diff --git a/erpnext/translations/bs.csv b/erpnext/translations/bs.csv
new file mode 100644
index 0000000..697f016
--- /dev/null
+++ b/erpnext/translations/bs.csv
@@ -0,0 +1,3331 @@
+ (Half Day),(Poludnevni)
+ and year: ,i godina:
+""" does not exists",""" Ne postoji"
+%  Delivered,Isporučena%
+% Amount Billed,% Iznos Naplaćeno
+% Billed,Naplaćeno%
+% Completed,Završen%
+% Delivered,% isporučeno
+% Installed,Instalirani%
+% Received,% Pozicija
+% of materials billed against this Purchase Order.,% Materijala naplaćeno protiv ove narudžbenice.
+% of materials billed against this Sales Order,% Materijala naplaćeno protiv ovog prodajnog naloga
+% of materials delivered against this Delivery Note,% Materijala dostavljenih protiv ove otpremnici
+% of materials delivered against this Sales Order,% Materijala dostavljenih od ovog prodajnog naloga
+% of materials ordered against this Material Request,% Materijala naredio protiv ovog materijala Zahtjeva
+% of materials received against this Purchase Order,% Materijala dobio protiv ove narudžbenice
+'Actual Start Date' can not be greater than 'Actual End Date',"' Stvarni datum početka ' ne može biti veći od stvarnih datuma završetka """
+'Based On' and 'Group By' can not be same,' Temelji se na' i 'Grupiranje po ' ne mogu biti isti
+'Days Since Last Order' must be greater than or equal to zero,' Dani od posljednjeg reda ' mora biti veći ili jednak nuli
+'Entries' cannot be empty,' Prijave ' ne može biti prazno
+'Expected Start Date' can not be greater than 'Expected End Date',""" Očekivani datum početka ' ne može biti veći od očekivanih datuma završetka"""
+'From Date' is required,' Od datuma ' je potrebno
+'From Date' must be after 'To Date',"' Od datuma ' mora biti poslije ' To Date """
+'Has Serial No' can not be 'Yes' for non-stock item,' Je rednim brojem ' ne može biti ' Da ' za ne - stock stavke
+'Notification Email Addresses' not specified for recurring invoice,"' Obavijest E-mail adrese "" nisu spomenuti za ponavljajuće fakture"
+'Profit and Loss' type account {0} not allowed in Opening Entry,' Račun dobiti i gubitka ' vrsta računa {0} nije dopuštena u otvor za
+'To Case No.' cannot be less than 'From Case No.',&#39;Za Predmet br&#39; ne može biti manja od &#39;Od Predmet br&#39;
+'To Date' is required,' To Date ' je potrebno
+'Update Stock' for Sales Invoice {0} must be set,' Update Stock ' za prodaje fakture {0} mora biti postavljen
+* Will be calculated in the transaction.,* Hoće li biti izračunata u transakciji.
+1 Currency = [?] FractionFor e.g. 1 USD = 100 Cent,1 valuta = [?] Frakcija  Za npr. 1 USD = 100 centi
+1. To maintain the customer wise item code and to make them searchable based on their code use this option,1. Za održavanje kupaca mudar Šifra i kako bi ih pretraživati ​​na temelju svog koda koristiti ovu opciju
+"<a href=""#Sales Browser/Customer Group"">Add / Edit</a>","<a href=""#Sales Browser/Customer Group""> Dodaj / Uredi < />"
+"<a href=""#Sales Browser/Item Group"">Add / Edit</a>","<a href=""#Sales Browser/Item Group""> Dodaj / Uredi < />"
+"<a href=""#Sales Browser/Territory"">Add / Edit</a>","<a href=""#Sales Browser/Territory""> Dodaj / Uredi < />"
+"<h4>Default Template</h4><p>Uses <a href=""http://jinja.pocoo.org/docs/templates/"">Jinja Templating</a> and all the fields of Address (including Custom Fields if any) will be available</p><pre><code>{{ address_line1 }}&lt;br&gt;{% if address_line2 %}{{ address_line2 }}&lt;br&gt;{% endif -%}{{ city }}&lt;br&gt;{% if state %}{{ state }}&lt;br&gt;{% endif -%}{% if pincode %} PIN:  {{ pincode }}&lt;br&gt;{% endif -%}{{ country }}&lt;br&gt;{% if phone %}Phone: {{ phone }}&lt;br&gt;{% endif -%}{% if fax %}Fax: {{ fax }}&lt;br&gt;{% endif -%}{% if email_id %}Email: {{ email_id }}&lt;br&gt;{% endif -%}</code></pre>","<h4> zadani predložak </ h4>  <p> Koristi <a href=""http://jinja.pocoo.org/docs/templates/""> Jinja templating </> i sva polja adresa ( uključujući Custom Fields ako postoje) će biti dostupan </ p>  <pre> <code> {{address_line1}} <br>  {% ako address_line2%} {{}} address_line2 <br> { endif% -%}  {{grad}} <br>  {% ako je državna%} {{}} Država <br> {% endif -%}  {% ako pincode%} PIN: {{pincode}} <br> {% endif -%}  {{country}} <br>  {% ako je telefon%} Telefon: {{telefonski}} <br> { endif% -%}  {% ako fax%} Fax: {{fax}} <br> {% endif -%}  {% ako email_id%} E: {{email_id}} <br> ; {% endif -%}  </ code> </ pre>"
+A Customer Group exists with same name please change the Customer name or rename the Customer Group,Grupa kupaca sa istim imenom postoji. Promijenite naziv kupca ili promijenite naziv grupe kupaca.
+A Customer exists with same name,Kupac sa istim imenom već postoji
+A Lead with this email id should exist,Kontakt sa ovim e-mailom bi trebao postojati
+A Product or Service,Proizvod ili usluga
+A Supplier exists with same name,Dobavljač sa istim imenom već postoji
+A symbol for this currency. For e.g. $,Simbol za ovu valutu. Kao npr. $
+AMC Expiry Date,AMC Datum isteka
+Abbr,Kratica
+Abbreviation cannot have more than 5 characters,Kratica ne može imati više od 5 znakova
+Above Value,Iznad vrijednosti
+Absent,Odsutan
+Acceptance Criteria,Kriterij prihvaćanja
+Accepted,Prihvaćeno
+Accepted + Rejected Qty must be equal to Received quantity for Item {0},Količina prihvaćeno + odbijeno mora biti jednaka zaprimljenoj količini artikla {0}
+Accepted Quantity,Prihvaćena količina
+Accepted Warehouse,Prihvaćeno skladište
+Account,Račun
+Account Balance,Bilanca računa
+Account Created: {0},Račun stvoren: {0}
+Account Details,Detalji računa
+Account Head,Zaglavlje računa
+Account Name,Naziv računa
+Account Type,Vrsta računa
+"Account balance already in Credit, you are not allowed to set 'Balance Must Be' as 'Debit'","Stanje računa već u kredit, što se ne smije postaviti 'ravnoteža se mora' kao 'zaduženje """
+"Account balance already in Debit, you are not allowed to set 'Balance Must Be' as 'Credit'","Stanje računa već u zaduženje, ne smiju postaviti 'ravnoteža se mora' kao 'kreditne'"
+Account for the warehouse (Perpetual Inventory) will be created under this Account.,Račun za skladište ( neprestani inventar) stvorit će se na temelju ovog računa .
+Account head {0} created,Zaglavlje računa {0} stvoreno
+Account must be a balance sheet account,Račun mora biti račun bilance
+Account with child nodes cannot be converted to ledger,Račun za dijete čvorova ne može pretvoriti u knjizi
+Account with existing transaction can not be converted to group.,Račun s postojećim transakcije ne može pretvoriti u skupinu .
+Account with existing transaction can not be deleted,Račun s postojećim transakcije ne može izbrisati
+Account with existing transaction cannot be converted to ledger,Račun s postojećim transakcije ne može pretvoriti u knjizi
+Account {0} cannot be a Group,Račun {0} ne može bitiGroup
+Account {0} does not belong to Company {1},Račun {0} ne pripada Društvu {1}
+Account {0} does not belong to company: {1},Račun {0} ne pripada tvrtki: {1}
+Account {0} does not exist,Račun {0} ne postoji
+Account {0} has been entered more than once for fiscal year {1},Račun {0} je ušao više od jednom za fiskalnu godinu {1}
+Account {0} is frozen,Račun {0} je zamrznuta
+Account {0} is inactive,Račun {0} nije aktivan
+Account {0} is not valid,Račun {0} nije ispravan
+Account {0} must be of type 'Fixed Asset' as Item {1} is an Asset Item,Račun {0} mora biti tipa ' Fixed Asset ' kao točka {1} jeAsset artikla
+Account {0}: Parent account {1} can not be a ledger,Račun {0}: Parent račun {1} Ne može biti knjiga
+Account {0}: Parent account {1} does not belong to company: {2},Račun {0}: Parent račun {1} ne pripadaju tvrtki: {2}
+Account {0}: Parent account {1} does not exist,Račun {0}: Parent račun {1} ne postoji
+Account {0}: You can not assign itself as parent account,Račun {0}: Ne može se dodijeliti roditeljskog računa
+Account: {0} can only be updated via \					Stock Transactions,Račun: {0} se može ažurirati samo putem \ Stock transakcije
+Accountant,računovođa
+Accounting,Računovodstvo
+"Accounting Entries can be made against leaf nodes, called","Računovodstvo Prijave se mogu podnijeti protiv lisnih čvorova , pozvao"
+"Accounting entry frozen up to this date, nobody can do / modify entry except role specified below.","Knjiženje zamrznuta do tog datuma, nitko ne može učiniti / mijenjati ulazak, osim uloge naveden u nastavku."
+Accounting journal entries.,Računovodstvo unosi u dnevnik.
+Accounts,Računi
+Accounts Browser,računi preglednik
+Accounts Frozen Upto,Računi Frozen Upto
+Accounts Payable,Računi naplativo
+Accounts Receivable,Potraživanja
+Accounts Settings,Računi Postavke
+Active,Aktivan
+Active: Will extract emails from ,Aktivno: Hoće li izdvojiti e-pošte iz
+Activity,Djelatnost
+Activity Log,Aktivnost Prijava
+Activity Log:,Aktivnost Prijavite:
+Activity Type,Aktivnost Tip
+Actual,Stvaran
+Actual Budget,Stvarni proračun
+Actual Completion Date,Stvarni datum dovršenja
+Actual Date,Stvarni datum
+Actual End Date,Stvarni Datum završetka
+Actual Invoice Date,Stvarni Datum fakture
+Actual Posting Date,Stvarni datum knjiženja
+Actual Qty,Stvarni Kol
+Actual Qty (at source/target),Stvarni Kol (na izvoru / ciljne)
+Actual Qty After Transaction,Stvarni Kol Nakon transakcije
+Actual Qty: Quantity available in the warehouse.,Stvarni Količina : Količina dostupni u skladištu .
+Actual Quantity,Stvarni Količina
+Actual Start Date,Stvarni datum početka
+Add,Dodati
+Add / Edit Taxes and Charges,Dodaj / Uredi poreza i pristojbi
+Add Child,Dodaj dijete
+Add Serial No,Dodaj rednim brojem
+Add Taxes,Dodaj Porezi
+Add Taxes and Charges,Dodaj poreze i troškove
+Add or Deduct,Dodavanje ili Oduzmite
+Add rows to set annual budgets on Accounts.,Dodavanje redaka postaviti godišnje proračune na računima.
+Add to Cart,Dodaj u košaricu
+Add to calendar on this date,Dodaj u kalendar ovog datuma
+Add/Remove Recipients,Dodaj / Ukloni primatelja
+Address,Adresa
+Address & Contact,Adresa i kontakt
+Address & Contacts,Adresa i kontakti
+Address Desc,Adresa Desc
+Address Details,Adresa - detalji
+Address HTML,Adresa HTML
+Address Line 1,Adresa Linija 1
+Address Line 2,Adresa Linija 2
+Address Template,Predložak adrese
+Address Title,Adresa - naslov
+Address Title is mandatory.,Adresa Naslov je obavezno .
+Address Type,Adresa Tip
+Address master.,Adresa master
+Administrative Expenses,Administrativni troškovi
+Administrative Officer,Administrativni službenik
+Advance Amount,Predujam Iznos
+Advance amount,Predujam iznos
+Advances,Napredak
+Advertisement,Reklama
+Advertising,oglašavanje
+Aerospace,zračno-kosmički prostor
+After Sale Installations,Nakon prodaje postrojenja
+Against,Protiv
+Against Account,Protiv računa
+Against Bill {0} dated {1},Protiv Bill {0} od {1}
+Against Docname,Protiv Docname
+Against Doctype,Protiv DOCTYPE
+Against Document Detail No,Protiv dokumenta Detalj No
+Against Document No,Protiv dokumentu nema
+Against Expense Account,Protiv Rashodi račun
+Against Income Account,Protiv računu dohotka
+Against Journal Voucher,Protiv Journal Voucheru
+Against Journal Voucher {0} does not have any unmatched {1} entry,Protiv Journal vaučer {0} nema premca {1} unos
+Against Purchase Invoice,Protiv Kupnja fakture
+Against Sales Invoice,Protiv prodaje fakture
+Against Sales Order,Protiv prodajnog naloga
+Against Voucher,Protiv Voucheru
+Against Voucher Type,Protiv voucher vrsti
+Ageing Based On,Starenje temelju On
+Ageing Date is mandatory for opening entry,Starenje Datum je obvezna za otvaranje unos
+Ageing date is mandatory for opening entry,Starenje datum je obavezno za otvaranje unos
+Agent,Agent
+Aging Date,Starenje Datum
+Aging Date is mandatory for opening entry,Starenje Datum je obvezna za otvaranje unos
+Agriculture,poljoprivreda
+Airline,aviokompanija
+All Addresses.,Sve adrese.
+All Contact,Sve Kontakt
+All Contacts.,Svi kontakti.
+All Customer Contact,Sve Kupac Kontakt
+All Customer Groups,Sve skupine kupaca
+All Day,All Day
+All Employee (Active),Sve zaposlenika (aktivna)
+All Item Groups,Svi Stavka Grupe
+All Lead (Open),Sve Olovo (Otvoreno)
+All Products or Services.,Svi proizvodi i usluge.
+All Sales Partner Contact,Sve Kontakt Prodaja partner
+All Sales Person,Sve Prodaje Osoba
+All Supplier Contact,Sve Dobavljač Kontakt
+All Supplier Types,Sve vrste Supplier
+All Territories,Svi Territories
+"All export related fields like currency, conversion rate, export total, export grand total etc are available in Delivery Note, POS, Quotation, Sales Invoice, Sales Order etc.","Sve izvoz srodnih područja poput valute , stopa pretvorbe , izvoz ukupno , izvoz sveukupnom itd su dostupni u Dostavnica, POS , ponude, prodaje fakture , prodajnog naloga i sl."
+"All import related fields like currency, conversion rate, import total, import grand total etc are available in Purchase Receipt, Supplier Quotation, Purchase Invoice, Purchase Order etc.","Svi uvoz srodnih područja poput valute , stopa pretvorbe , uvoz ukupno , uvoz sveukupnom itd su dostupni u Račun kupnje , dobavljač kotaciju , prilikom kupnje proizvoda, narudžbenice i sl."
+All items have already been invoiced,Svi predmeti su već fakturirano
+All these items have already been invoiced,Svi ovi predmeti su već fakturirano
+Allocate,Dodijeliti
+Allocate leaves for a period.,Dodijeliti lišće za razdoblje .
+Allocate leaves for the year.,Dodjela lišće za godinu dana.
+Allocated Amount,Dodijeljeni iznos
+Allocated Budget,Dodijeljeni proračuna
+Allocated amount,Dodijeljeni iznos
+Allocated amount can not be negative,Dodijeljeni iznos ne može biti negativna
+Allocated amount can not greater than unadusted amount,Dodijeljeni iznos ne može veći od iznosa unadusted
+Allow Bill of Materials,Dopustite Bill materijala
+Allow Bill of Materials should be 'Yes'. Because one or many active BOMs present for this item,Dopustite Bill materijala bi trebao biti ' Da ' . Budući da je jedan ili više aktivnih Sastavnice prisutne za ovu stavku
+Allow Children,dopustiti djeci
+Allow Dropbox Access,Dopusti pristup Dropbox
+Allow Google Drive Access,Dopusti pristup Google Drive
+Allow Negative Balance,Dopustite negativan saldo
+Allow Negative Stock,Dopustite negativnu Stock
+Allow Production Order,Dopustite proizvodnom nalogu
+Allow User,Dopusti korisnika
+Allow Users,Omogućiti korisnicima
+Allow the following users to approve Leave Applications for block days.,Dopusti sljedeći korisnici odobriti ostavite aplikacije za blok dana.
+Allow user to edit Price List Rate in transactions,Dopustite korisniku da uredite Ocijenite cjeniku u prometu
+Allowance Percent,Dodatak posto
+Allowance for over-{0} crossed for Item {1},Dodatak za prekomjerno {0} prešao za točku {1}
+Allowance for over-{0} crossed for Item {1}.,Dodatak za prekomjerno {0} prešao za točku {1}.
+Allowed Role to Edit Entries Before Frozen Date,Dopuštenih uloga za uređivanje upise Prije Frozen Datum
+Amended From,Izmijenjena Od
+Amount,Iznos
+Amount (Company Currency),Iznos (valuta tvrtke)
+Amount Paid,Plaćeni iznos
+Amount to Bill,Iznositi Billa
+An Customer exists with same name,Kupac postoji s istim imenom
+"An Item Group exists with same name, please change the item name or rename the item group","Stavka Grupa postoji s istim imenom , molimo promijenite ime stavku ili preimenovati stavku grupe"
+"An item exists with same name ({0}), please change the item group name or rename the item","Stavka postoji s istim imenom ( {0} ) , molimo promijenite ime stavku grupe ili preimenovati stavku"
+Analyst,analitičar
+Annual,godišnji
+Another Period Closing Entry {0} has been made after {1},Drugi period Zatvaranje Stupanje {0} je postignut nakon {1}
+Another Salary Structure {0} is active for employee {0}. Please make its status 'Inactive' to proceed.,Drugi Plaća Struktura {0} je aktivan za zaposlenika {0} . Molimo da svoj ​​status ' Neaktivan ' za nastavak .
+"Any other comments, noteworthy effort that should go in the records.","Svi ostali komentari, značajan napor da bi trebao ići u evidenciji."
+Apparel & Accessories,Odjeća i modni dodaci
+Applicability,Primjena
+Applicable For,primjenjivo za
+Applicable Holiday List,Primjenjivo odmor Popis
+Applicable Territory,primjenjivo teritorij
+Applicable To (Designation),Odnosi se na (Oznaka)
+Applicable To (Employee),Odnosi se na (Radnik)
+Applicable To (Role),Odnosi se na (uloga)
+Applicable To (User),Odnosi se na (Upute)
+Applicant Name,Podnositelj zahtjeva Ime
+Applicant for a Job.,Podnositelj prijave za posao.
+Application of Funds (Assets),Primjena sredstava ( aktiva )
+Applications for leave.,Prijave za odmor.
+Applies to Company,Odnosi se na Društvo
+Apply On,Nanesite na
+Appraisal,Procjena
+Appraisal Goal,Procjena gol
+Appraisal Goals,Ocjenjivanje Golovi
+Appraisal Template,Procjena Predložak
+Appraisal Template Goal,Procjena Predložak cilja
+Appraisal Template Title,Procjena Predložak Naslov
+Appraisal {0} created for Employee {1} in the given date range,Procjena {0} stvorena za zaposlenika {1} u određenom razdoblju
+Apprentice,šegrt
+Approval Status,Status odobrenja
+Approval Status must be 'Approved' or 'Rejected',"Status Odobrenje mora biti ""Odobreno"" ili "" Odbijeno """
+Approved,Odobren
+Approver,Odobritelj
+Approving Role,Odobravanje ulogu
+Approving Role cannot be same as role the rule is Applicable To,Odobravanje ulogu ne mogu biti isti kao i ulogepravilo odnosi se na
+Approving User,Odobravanje korisnika
+Approving User cannot be same as user the rule is Applicable To,Odobravanje korisnik ne može biti isto kao korisnikapravilo odnosi se na
+Are you sure you want to STOP ,Are you sure you want to STOP 
+Are you sure you want to UNSTOP ,Are you sure you want to UNSTOP 
+Arrear Amount,Iznos unatrag
+"As Production Order can be made for this item, it must be a stock item.","Kao Production Order može biti za tu stavku , to mora bitipredmet dionica ."
+As per Stock UOM,Kao po burzi UOM
+"As there are existing stock transactions for this item, you can not change the values of 'Has Serial No', 'Is Stock Item' and 'Valuation Method'","Kao što već postoje dionica transakcije za ovu stavku , ne možete mijenjati vrijednosti ' Je rednim brojem ' , ' Je Stock točka ""i"" Vrednovanje metoda'"
+Asset,Asset
+Assistant,asistent
+Associate,pomoćnik
+Atleast one of the Selling or Buying must be selected,Barem jedan od prodajete ili kupujete mora biti odabran
+Atleast one warehouse is mandatory,Atleast jednom skladištu je obavezno
+Attach Image,Pričvrstite slike
+Attach Letterhead,Pričvrstite zaglavljem
+Attach Logo,Pričvrstite Logo
+Attach Your Picture,Učvrstite svoju sliku
+Attendance,Pohađanje
+Attendance Date,Gledatelja Datum
+Attendance Details,Gledatelja Detalji
+Attendance From Date,Gledatelja Od datuma
+Attendance From Date and Attendance To Date is mandatory,Gledatelja Od datuma i posjećenost do sada je obvezno
+Attendance To Date,Gledatelja do danas
+Attendance can not be marked for future dates,Gledatelji ne može biti označena za budući datum
+Attendance for employee {0} is already marked,Gledatelja za zaposlenika {0} već označen
+Attendance record.,Gledatelja rekord.
+Authorization Control,Odobrenje kontrole
+Authorization Rule,Autorizacija Pravilo
+Auto Accounting For Stock Settings,Auto Računovodstvo za dionice Settings
+Auto Material Request,Auto Materijal Zahtjev
+Auto-raise Material Request if quantity goes below re-order level in a warehouse,Auto-podizanje Materijal zahtjev ako se količina ide ispod ponovno bi razinu u skladištu
+Automatically compose message on submission of transactions.,Automatski nova poruka na podnošenje transakcija .
+Automatically extract Job Applicants from a mail box ,Automatically extract Job Applicants from a mail box 
+Automatically extract Leads from a mail box e.g.,Automatski ekstrakt vodi iz mail box pr
+Automatically updated via Stock Entry of type Manufacture/Repack,Automatski ažurira putem burze Unos tipa Proizvodnja / prepakirati
+Automotive,automobilski
+Autoreply when a new mail is received,Automatski odgovori kad kada stigne nova pošta
+Available,Dostupno
+Available Qty at Warehouse,Dostupna količina na skladištu
+Available Stock for Packing Items,Raspoloživo stanje za pakirane artikle
+"Available in BOM, Delivery Note, Purchase Invoice, Production Order, Purchase Order, Purchase Receipt, Sales Invoice, Sales Order, Stock Entry, Timesheet","Dostupan u sastavnice , Dostavnica, prilikom kupnje proizvoda, proizvodnje narudžbi, narudžbenica , Račun kupnje , prodaje fakture , prodajnog naloga , Stock ulaska, timesheet"
+Average Age,Prosječna starost
+Average Commission Rate,Prosječna stopa komisija
+Average Discount,Prosječni popust
+Awesome Products,strašan Proizvodi
+Awesome Services,strašan Usluge
+BOM Detail No,BOM Detalj Ne
+BOM Explosion Item,BOM eksplozije artikla
+BOM Item,BOM artikla
+BOM No,BOM Ne
+BOM No. for a Finished Good Item,BOM broj za Gotovi Dobar točki
+BOM Operation,BOM Operacija
+BOM Operations,BOM operacije
+BOM Replace Tool,BOM Zamijenite alat
+BOM number is required for manufactured Item {0} in row {1},BOM broj potreban za proizvedenog artikla {0} je u redu {1}
+BOM number not allowed for non-manufactured Item {0} in row {1},BOM broj nisu dopušteni za ne - proizvedenog artikla {0} je u redu {1}
+BOM recursion: {0} cannot be parent or child of {2},BOM rekurzija : {0} ne može biti roditelj ili dijete od {2}
+BOM replaced,BOM zamijeniti
+BOM {0} for Item {1} in row {2} is inactive or not submitted,BOM {0} za točku {1} u redu {2} nije aktivan ili ne podnose
+BOM {0} is not active or not submitted,BOM {0} nije aktivan ili ne podnose
+BOM {0} is not submitted or inactive BOM for Item {1},BOM {0} nije podnesen ili neaktivne troškovnik za točku {1}
+Backup Manager,Backup Manager
+Backup Right Now,Backup Right Now
+Backups will be uploaded to,Sigurnosne kopije će biti učitane
+Balance Qty,Bilanca Kol
+Balance Sheet,završni račun
+Balance Value,Bilanca Vrijednost
+Balance for Account {0} must always be {1},Bilanca za račun {0} mora uvijek biti {1}
+Balance must be,Bilanca mora biti
+"Balances of Accounts of type ""Bank"" or ""Cash""","Stanja računa tipa "" Banka"" ili "" Cash """
+Bank,Banka
+Bank / Cash Account,Banka / Cash račun
+Bank A/C No.,Banka / C br
+Bank Account,Žiro račun
+Bank Account No.,Žiro račun broj
+Bank Accounts,bankovni računi
+Bank Clearance Summary,Razmak banka Sažetak
+Bank Draft,Bank Nacrt
+Bank Name,Ime banke
+Bank Overdraft Account,Bank Prekoračenje računa
+Bank Reconciliation,Banka pomirenje
+Bank Reconciliation Detail,Banka Pomirenje Detalj
+Bank Reconciliation Statement,Izjava banka pomirenja
+Bank Voucher,Banka bon
+Bank/Cash Balance,Banka / saldo
+Banking,bankarstvo
+Barcode,Barkod
+Barcode {0} already used in Item {1},Barkod {0} već koristi u točki {1}
+Based On,Na temelju
+Basic,osnovni
+Basic Info,Osnovne informacije
+Basic Information,Osnovne informacije
+Basic Rate,Osnovna stopa
+Basic Rate (Company Currency),Osnovna stopa (Društvo valuta)
+Batch,Serija
+Batch (lot) of an Item.,Hrpa (puno) od točke.
+Batch Finished Date,Hrpa Završio Datum
+Batch ID,Hrpa ID
+Batch No,Hrpa Ne
+Batch Started Date,Hrpa Autor Date
+Batch Time Logs for billing.,Hrpa Vrijeme Trupci za naplatu.
+Batch-Wise Balance History,Batch-Wise bilanca Povijest
+Batched for Billing,Izmiješane za naplatu
+Better Prospects,Bolji izgledi
+Bill Date,Bill Datum
+Bill No,Bill Ne
+Bill No {0} already booked in Purchase Invoice {1},Bill Ne {0} već rezervirani kupnje proizvoda {1}
+Bill of Material,Bill materijala
+Bill of Material to be considered for manufacturing,Bill of material treba uzeti u obzir za proizvodnju
+Bill of Materials (BOM),Bill materijala (BOM)
+Billable,Naplatu
+Billed,Naplaćeno
+Billed Amount,naplaćeno Iznos
+Billed Amt,Naplaćeno Amt
+Billing,Naplata
+Billing Address,Adresa za naplatu
+Billing Address Name,Adresa za naplatu Ime
+Billing Status,Naplata Status
+Bills raised by Suppliers.,Mjenice podigao dobavljače.
+Bills raised to Customers.,Mjenice podignuta na kupce.
+Bin,Kanta
+Bio,Bio
+Biotechnology,biotehnologija
+Birthday,rođendan
+Block Date,Blok Datum
+Block Days,Blok Dani
+Block leave applications by department.,Blok ostaviti aplikacija odjelu.
+Blog Post,Blog post
+Blog Subscriber,Blog Pretplatnik
+Blood Group,Krv Grupa
+Both Warehouse must belong to same Company,Oba Skladište mora pripadati istoj tvrtki
+Box,kutija
+Branch,Grana
+Brand,Marka
+Brand Name,Brand Name
+Brand master.,Marka majstor.
+Brands,Marke
+Breakdown,Slom
+Broadcasting,radiodifuzija
+Brokerage,posredništvo
+Budget,Budžet
+Budget Allocated,Proračun Dodijeljeni
+Budget Detail,Proračun Detalj
+Budget Details,Proračunski Detalji
+Budget Distribution,Proračun Distribucija
+Budget Distribution Detail,Proračun Distribucija Detalj
+Budget Distribution Details,Proračun raspodjele Detalji
+Budget Variance Report,Proračun varijance Prijavi
+Budget cannot be set for Group Cost Centers,Proračun ne može biti postavljen za grupe troška
+Build Report,Izgradite Prijavite
+Bundle items at time of sale.,Bala stavke na vrijeme prodaje.
+Business Development Manager,Business Development Manager
+Buying,Kupovina
+Buying & Selling,Kupnja i Prodaja
+Buying Amount,Kupnja Iznos
+Buying Settings,Kupnja postavki
+"Buying must be checked, if Applicable For is selected as {0}","Kupnja treba provjeriti, ako je primjenjivo za odabrano kao {0}"
+C-Form,C-Form
+C-Form Applicable,C-obrascu
+C-Form Invoice Detail,C-Obrazac Račun Detalj
+C-Form No,C-Obrazac br
+C-Form records,C - Form zapisi
+CENVAT Capital Goods,CENVAT Kapitalni proizvodi
+CENVAT Edu Cess,CENVAT Edu Posebni porez
+CENVAT SHE Cess,CENVAT ONA Posebni porez
+CENVAT Service Tax,CENVAT usluga Porezne
+CENVAT Service Tax Cess 1,CENVAT usluga Porezne Posebni porez na 1
+CENVAT Service Tax Cess 2,CENVAT usluga Porezne Posebni porez 2
+Calculate Based On,Izračunajte Na temelju
+Calculate Total Score,Izračunajte ukupni rezultat
+Calendar Events,Kalendar događanja
+Call,Nazvati
+Calls,pozivi
+Campaign,Kampanja
+Campaign Name,Naziv kampanje
+Campaign Name is required,Ime Kampanja je potrebno
+Campaign Naming By,Imenovanje Kampanja By
+Campaign-.####,Kampanje . # # # #
+Can be approved by {0},Može biti odobren od strane {0}
+"Can not filter based on Account, if grouped by Account","Ne možete filtrirati na temelju računa , ako grupirani po računu"
+"Can not filter based on Voucher No, if grouped by Voucher","Ne možete filtrirati na temelju vaučer No , ako grupirani po vaučer"
+Can refer row only if the charge type is 'On Previous Row Amount' or 'Previous Row Total',"Može se odnositi red samo akotip zadužen je "" Na prethodni red Iznos 'ili' prethodnog retka Total '"
+Cancel Material Visit {0} before cancelling this Customer Issue,Odustani Materijal Posjetite {0} prije poništenja ovog kupca Issue
+Cancel Material Visits {0} before cancelling this Maintenance Visit,Odustani Posjeta materijala {0} prije otkazivanja ovog održavanja pohod
+Cancelled,Otkazan
+Cancelling this Stock Reconciliation will nullify its effect.,Otkazivanje Ove obavijesti pomirenja će poništiti svoj ​​učinak .
+Cannot Cancel Opportunity as Quotation Exists,Ne mogu otkazati prilika kao kotacija Exist
+Cannot approve leave as you are not authorized to approve leaves on Block Dates,Ne može odobriti dopust kako niste ovlašteni za odobravanje lišće o skupnom datume
+Cannot cancel because Employee {0} is already approved for {1},"Ne mogu otkazati , jer zaposlenika {0} već je odobren za {1}"
+Cannot cancel because submitted Stock Entry {0} exists,"Ne mogu otkazati , jer podnijela Stock Stupanje {0} postoji"
+Cannot carry forward {0},Ne mogu prenositi {0}
+Cannot change Fiscal Year Start Date and Fiscal Year End Date once the Fiscal Year is saved.,Ne možete promijeniti fiskalnu godinu datum početka i datum završetka fiskalne godine kada Fiskalna godina se sprema.
+"Cannot change company's default currency, because there are existing transactions. Transactions must be cancelled to change the default currency.","Ne mogu promijeniti tvrtke zadanu valutu , jer postoje neki poslovi . Transakcije mora biti otkazana promijeniti zadanu valutu ."
+Cannot convert Cost Center to ledger as it has child nodes,"Ne može se pretvoriti troška za knjigu , kao da ima djece čvorova"
+Cannot covert to Group because Master Type or Account Type is selected.,"Ne može tajno da Grupe , jer je izabran Master Type ili račun Type ."
+Cannot deactive or cancle BOM as it is linked with other BOMs,Ne možete DEACTIVE ili cancle troškovnik jer je povezan s drugim sastavnicama
+"Cannot declare as lost, because Quotation has been made.","Ne može proglasiti izgubili , jer citat je napravio ."
+Cannot deduct when category is for 'Valuation' or 'Valuation and Total',"Ne mogu odbiti kada kategorija je "" vrednovanje "" ili "" Vrednovanje i Total '"
+"Cannot delete Serial No {0} in stock. First remove from stock, then delete.","Ne možete izbrisati rednim brojem {0} na lageru . Prvo izvadite iz zalihe , a zatim izbrisati ."
+"Cannot directly set amount. For 'Actual' charge type, use the rate field","Ne može se izravno postaviti iznos . Za stvarnu ' tipa naboja , koristiti polje rate"
+"Cannot overbill for Item {0} in row {0} more than {1}. To allow overbilling, please set in Stock Settings","Ne možete overbill za točku {0} u redu {0} više od {1}. Da bi se omogućilo overbilling, molimo vas postavljen u Stock Settings"
+Cannot produce more Item {0} than Sales Order quantity {1},Ne može proizvesti više predmeta {0} od prodajnog naloga količina {1}
+Cannot refer row number greater than or equal to current row number for this Charge type,Ne mogu se odnositi broj retka veći ili jednak trenutnom broju red za ovu vrstu Charge
+Cannot return more than {0} for Item {1},Ne može se vratiti više od {0} za točku {1}
+Cannot select charge type as 'On Previous Row Amount' or 'On Previous Row Total' for first row,"Ne možete odabrati vrstu naboja kao ' na prethodnim Row Iznos ""ili"" u odnosu na prethodnu Row Ukupno ""za prvi red"
+Cannot select charge type as 'On Previous Row Amount' or 'On Previous Row Total' for valuation. You can select only 'Total' option for previous row amount or previous row total,"Ne možete odabrati vrstu naboja kao ' na prethodnim Row Iznos ""ili"" u odnosu na prethodnu Row Total ' za vrednovanje . Možete odabrati samo ' Ukupno ' opciju za prethodni iznos red ili prethodne ukupno redu"
+Cannot set as Lost as Sales Order is made.,Ne mogu se postaviti kao izgubljen kao prodajnog naloga je napravio .
+Cannot set authorization on basis of Discount for {0},Ne mogu postaviti odobrenje na temelju popusta za {0}
+Capacity,Kapacitet
+Capacity Units,Kapacitet jedinice
+Capital Account,Kapitalni račun
+Capital Equipments,Kapitalni oprema
+Carry Forward,Prenijeti
+Carry Forwarded Leaves,Nosi proslijeđen lišće
+Case No(s) already in use. Try from Case No {0},Slučaj Ne ( i) je već u uporabi . Pokušajte s predmetu broj {0}
+Case No. cannot be 0,Slučaj broj ne može biti 0
+Cash,Gotovina
+Cash In Hand,Novac u blagajni
+Cash Voucher,Novac bon
+Cash or Bank Account is mandatory for making payment entry,Novac ili bankovni račun je obvezna za izradu ulazak plaćanje
+Cash/Bank Account,Novac / bankovni račun
+Casual Leave,Casual dopust
+Cell Number,Mobitel Broj
+Change UOM for an Item.,Promjena UOM za predmet.
+Change the starting / current sequence number of an existing series.,Promjena polaznu / tekući redni broj postojeće serije.
+Channel Partner,Channel Partner
+Charge of type 'Actual' in row {0} cannot be included in Item Rate,Punjenje tipa ' Stvarni ' u redu {0} ne mogu biti uključeni u točki Rate
+Chargeable,Naplativ
+Charity and Donations,Ljubav i donacije
+Chart Name,Ime grafikona
+Chart of Accounts,Kontnog
+Chart of Cost Centers,Grafikon troškovnih centara
+Check how the newsletter looks in an email by sending it to your email.,Pogledajte kako izgleda newsletter u e-mail tako da ga šalju na e-mail.
+"Check if recurring invoice, uncheck to stop recurring or put proper End Date","Provjerite je li ponavljajući fakture, poništite zaustaviti ponavljajući ili staviti odgovarajući datum završetka"
+"Check if you need automatic recurring invoices. After submitting any sales invoice, Recurring section will be visible.","Provjerite ako trebate automatske ponavljajuće fakture. Nakon odavanja prodaje fakturu, ponavljajućih sekcija će biti vidljiv."
+Check if you want to send salary slip in mail to each employee while submitting salary slip,"Provjerite ako želite poslati plaće slip u pošti svakom zaposleniku, dok podnošenje plaće slip"
+Check this if you want to force the user to select a series before saving. There will be no default if you check this.,Označite ovo ako želite prisiliti korisniku odabir seriju prije spremanja. Tu će biti zadana ako to provjerili.
+Check this if you want to show in website,Označite ovo ako želite pokazati u web
+Check this to disallow fractions. (for Nos),Provjerite to da ne dopušta frakcija. (Za br)
+Check this to pull emails from your mailbox,Provjerite to povući e-pošte iz poštanskog sandučića
+Check to activate,Provjerite za aktiviranje
+Check to make Shipping Address,Provjerite otprema adresu
+Check to make primary address,Provjerite primarnu adresu
+Chemical,kemijski
+Cheque,Ček
+Cheque Date,Ček Datum
+Cheque Number,Ček Broj
+Child account exists for this account. You can not delete this account.,Dijete računa postoji za taj račun . Ne možete izbrisati ovaj račun .
+City,Grad
+City/Town,Grad / Mjesto
+Claim Amount,Iznos štete
+Claims for company expense.,Potraživanja za tvrtke trošak.
+Class / Percentage,Klasa / Postotak
+Classic,Klasik
+Clear Table,Jasno Tablica
+Clearance Date,Razmak Datum
+Clearance Date not mentioned,Razmak Datum nije spomenuo
+Clearance date cannot be before check date in row {0},Datum rasprodaja ne može biti prije datuma check u redu {0}
+Click on 'Make Sales Invoice' button to create a new Sales Invoice.,Kliknite na &quot;Make prodaje Račun &#39;gumb za stvaranje nove prodaje fakture.
+Click on a link to get options to expand get options ,Click on a link to get options to expand get options 
+Client,Klijent
+Close Balance Sheet and book Profit or Loss.,Zatvori bilanca i knjiga dobit ili gubitak .
+Closed,Zatvoreno
+Closing (Cr),Zatvaranje (Cr)
+Closing (Dr),Zatvaranje (DR)
+Closing Account Head,Zatvaranje računa šefa
+Closing Account {0} must be of type 'Liability',Zatvaranje računa {0} mora biti tipa ' odgovornosti '
+Closing Date,Datum zatvaranja
+Closing Fiscal Year,Zatvaranje Fiskalna godina
+Closing Qty,zatvaranje Kol
+Closing Value,zatvaranje vrijednost
+CoA Help,CoA Pomoć
+Code,Šifra
+Cold Calling,Hladno pozivanje
+Color,Boja
+Column Break,Kolona Break
+Comma separated list of email addresses,Zarez odvojen popis e-mail adrese
+Comment,Komentirati
+Comments,Komentari
+Commercial,trgovački
+Commission,provizija
+Commission Rate,Komisija Stopa
+Commission Rate (%),Komisija stopa (%)
+Commission on Sales,Komisija za prodaju
+Commission rate cannot be greater than 100,Proviziju ne može biti veća od 100
+Communication,Komunikacija
+Communication HTML,Komunikacija HTML
+Communication History,Komunikacija Povijest
+Communication log.,Komunikacija dnevnik.
+Communications,Communications
+Company,Društvo
+Company (not Customer or Supplier) master.,Društvo ( ne kupaca i dobavljača ) majstor .
+Company Abbreviation,Kratica Društvo
+Company Details,Tvrtka Detalji
+Company Email,tvrtka E-mail
+"Company Email ID not found, hence mail not sent","Tvrtka E-mail ID nije pronađen , pa se ne mail poslan"
+Company Info,Podaci o tvrtki
+Company Name,Ime tvrtke
+Company Settings,Tvrtka Postavke
+Company is missing in warehouses {0},Tvrtka je nestalo u skladištima {0}
+Company is required,Tvrtka je potrebno
+Company registration numbers for your reference. Example: VAT Registration Numbers etc.,Tvrtka registracijski brojevi za svoju referencu. Primjer: PDV registracijski brojevi i sl.
+Company registration numbers for your reference. Tax numbers etc.,Tvrtka registracijski brojevi za svoju referencu. Porezni brojevi itd.
+"Company, Month and Fiscal Year is mandatory","Tvrtka , Mjesec i Fiskalna godina je obvezno"
+Compensatory Off,kompenzacijski Off
+Complete,Dovršiti
+Complete Setup,kompletan Setup
+Completed,Dovršen
+Completed Production Orders,Završeni Radni nalozi
+Completed Qty,Završen Kol
+Completion Date,Završetak Datum
+Completion Status,Završetak Status
+Computer,računalo
+Computers,Računala
+Confirmation Date,potvrda Datum
+Confirmed orders from Customers.,Potvrđeno narudžbe od kupaca.
+Consider Tax or Charge for,Razmislite poreza ili pristojbi za
+Considered as Opening Balance,Smatra početnog stanja
+Considered as an Opening Balance,Smatra se kao početno stanje
+Consultant,Konzultant
+Consulting,savjetodavni
+Consumable,potrošni
+Consumable Cost,potrošni cost
+Consumable cost per hour,Potrošni cijena po satu
+Consumed Qty,Potrošeno Kol
+Consumer Products,Consumer Products
+Contact,Kontakt
+Contact Control,Kontaktirajte kontrolu
+Contact Desc,Kontakt ukratko
+Contact Details,Kontakt podaci
+Contact Email,Kontakt email
+Contact HTML,Kontakt HTML
+Contact Info,Kontakt Informacije
+Contact Mobile No,Kontak GSM
+Contact Name,Kontakt ime
+Contact No.,Kontakt broj
+Contact Person,Kontakt osoba
+Contact Type,Vrsta kontakta
+Contact master.,Kontakt majstor .
+Contacts,Kontakti
+Content,Sadržaj
+Content Type,Vrsta sadržaja
+Contra Voucher,Contra bon
+Contract,ugovor
+Contract End Date,Ugovor Datum završetka
+Contract End Date must be greater than Date of Joining,Ugovor Datum završetka mora biti veći od dana ulaska u
+Contribution (%),Doprinos (%)
+Contribution to Net Total,Doprinos neto Ukupno
+Conversion Factor,Konverzijski faktor
+Conversion Factor is required,Faktor pretvorbe je potrebno
+Conversion factor cannot be in fractions,Faktor pretvorbe ne može biti u frakcijama
+Conversion factor for default Unit of Measure must be 1 in row {0},Faktor pretvorbe za zadani jedinica mjere mora biti jedan u nizu {0}
+Conversion rate cannot be 0 or 1,Stopa pretvorbe ne može biti 0 ili 1
+Convert into Recurring Invoice,Pretvori u Ponavljajući fakture
+Convert to Group,Pretvori u Grupi
+Convert to Ledger,Pretvori u knjizi
+Converted,Pretvoreno
+Copy From Item Group,Primjerak iz točke Group
+Cosmetics,kozmetika
+Cost Center,Troška
+Cost Center Details,Troška Detalji
+Cost Center Name,Troška Name
+Cost Center is required for 'Profit and Loss' account {0},Troška je potrebno za račun ' dobiti i gubitka ' {0}
+Cost Center is required in row {0} in Taxes table for type {1},Troška potrebno je u redu {0} poreza stolom za vrstu {1}
+Cost Center with existing transactions can not be converted to group,Troška s postojećim transakcija ne može se prevesti u skupini
+Cost Center with existing transactions can not be converted to ledger,Troška s postojećim transakcija ne može pretvoriti u knjizi
+Cost Center {0} does not belong to Company {1},Troška {0} ne pripada Tvrtka {1}
+Cost of Goods Sold,Troškovi prodane robe
+Costing,Koštanje
+Country,Zemlja
+Country Name,Država Ime
+Country wise default Address Templates,Država mudar zadana adresa predlošci
+"Country, Timezone and Currency","Država , vremenske zone i valute"
+Create Bank Voucher for the total salary paid for the above selected criteria,Stvaranje Bank bon za ukupne plaće isplaćene za gore odabranih kriterija
+Create Customer,izraditi korisnika
+Create Material Requests,Stvaranje materijalni zahtijevi
+Create New,Stvori novo
+Create Opportunity,Stvaranje prilika
+Create Production Orders,Stvaranje radne naloge
+Create Quotation,stvaranje citata
+Create Receiver List,Stvaranje Receiver popis
+Create Salary Slip,Stvaranje plaće Slip
+Create Stock Ledger Entries when you submit a Sales Invoice,Otvori Stock stavke knjige kada podnijeti prodaje fakture
+"Create and manage daily, weekly and monthly email digests.","Stvaranje i upravljanje dnevne , tjedne i mjesečne e razgradnju ."
+Create rules to restrict transactions based on values.,Stvaranje pravila za ograničavanje prometa na temelju vrijednosti .
+Created By,Stvorio
+Creates salary slip for above mentioned criteria.,Stvara plaće slip za gore navedene kriterije.
+Creation Date,Datum stvaranja
+Creation Document No,Stvaranje dokumenata nema
+Creation Document Type,Tip stvaranje dokumenata
+Creation Time,vrijeme kreiranja
+Credentials,Svjedodžba
+Credit,Kredit
+Credit Amt,Kreditne Amt
+Credit Card,kreditna kartica
+Credit Card Voucher,Kreditne kartice bon
+Credit Controller,Kreditne kontroler
+Credit Days,Kreditne Dani
+Credit Limit,Kreditni limit
+Credit Note,Kreditne Napomena
+Credit To,Kreditne Da
+Currency,Valuta
+Currency Exchange,Mjenjačnica
+Currency Name,Valuta Ime
+Currency Settings,Valuta Postavke
+Currency and Price List,Valuta i cjenik
+Currency exchange rate master.,Majstor valute .
+Current Address,Trenutna adresa
+Current Address Is,Trenutni Adresa je
+Current Assets,Dugotrajna imovina
+Current BOM,Trenutni BOM
+Current BOM and New BOM can not be same,Trenutni troškovnik i novi troškovnik ne mogu biti isti
+Current Fiscal Year,Tekuće fiskalne godine
+Current Liabilities,Kratkoročne obveze
+Current Stock,Trenutni Stock
+Current Stock UOM,Trenutni kataloški UOM
+Current Value,Trenutna vrijednost
+Custom,Običaj
+Custom Autoreply Message,Prilagođena Automatski Poruka
+Custom Message,Prilagođena poruka
+Customer,Kupac
+Customer (Receivable) Account,Kupac (Potraživanja) račun
+Customer / Item Name,Kupac / Stavka Ime
+Customer / Lead Address,Kupac / Olovo Adresa
+Customer / Lead Name,Kupac / Ime osobe
+Customer > Customer Group > Territory,Kupac> Korisnička Group> Regija
+Customer Account Head,Kupac račun Head
+Customer Acquisition and Loyalty,Stjecanje kupaca i lojalnost
+Customer Address,Kupac Adresa
+Customer Addresses And Contacts,Kupac adrese i kontakti
+Customer Addresses and Contacts,Kupca adrese i kontakti
+Customer Code,Kupac Šifra
+Customer Codes,Kupac Kodovi
+Customer Details,Korisnički podaci
+Customer Feedback,Kupac Ocjena
+Customer Group,Kupac Grupa
+Customer Group / Customer,Kupac Group / kupaca
+Customer Group Name,Kupac Grupa Ime
+Customer Intro,Kupac Uvod
+Customer Issue,Kupac Issue
+Customer Issue against Serial No.,Kupac izdavanja protiv serijski broj
+Customer Name,Naziv klijenta
+Customer Naming By,Kupac Imenovanje By
+Customer Service,Služba za korisnike
+Customer database.,Kupac baze.
+Customer is required,Kupac je dužan
+Customer master.,Majstor Korisnička .
+Customer required for 'Customerwise Discount',Kupac je potrebno za ' Customerwise Popust '
+Customer {0} does not belong to project {1},Korisnik {0} ne pripada projicirati {1}
+Customer {0} does not exist,Korisnik {0} ne postoji
+Customer's Item Code,Kupca Stavka Šifra
+Customer's Purchase Order Date,Kupca narudžbenice Datum
+Customer's Purchase Order No,Kupca Narudžbenica br
+Customer's Purchase Order Number,Kupac je broj narudžbenice
+Customer's Vendor,Kupca Prodavatelj
+Customers Not Buying Since Long Time,Kupci ne kupuju jer dugo vremena
+Customerwise Discount,Customerwise Popust
+Customize,Prilagodite
+Customize the Notification,Prilagodite Obavijest
+Customize the introductory text that goes as a part of that email. Each transaction has a separate introductory text.,Prilagodite uvodni tekst koji ide kao dio tog e-maila. Svaka transakcija ima zaseban uvodni tekst.
+DN Detail,DN detalj
+Daily,Svakodnevno
+Daily Time Log Summary,Dnevno vrijeme Log Profila
+Database Folder ID,Direktorij podatkovne baze ID
+Database of potential customers.,Baza potencijalnih kupaca.
+Date,Datum
+Date Format,Oblik datuma
+Date Of Retirement,Datum odlaska u mirovinu
+Date Of Retirement must be greater than Date of Joining,Datum umirovljenja mora biti veći od datuma pristupa
+Date is repeated,Datum se ponavlja
+Date of Birth,Datum rođenja
+Date of Issue,Datum izdavanja
+Date of Joining,Datum pristupa
+Date of Joining must be greater than Date of Birth,Datum pristupa mora biti veći od datuma rođenja
+Date on which lorry started from supplier warehouse,Datum kojeg je kamion krenuo sa dobavljačeva skladišta
+Date on which lorry started from your warehouse,Datum kojeg je kamion otišao sa Vašeg skladišta
+Dates,Datumi
+Days Since Last Order,Dana od posljednje narudžbe
+Days for which Holidays are blocked for this department.,Dani za koje su praznici blokirani za ovaj odjel.
+Dealer,Trgovac
+Debit,Zaduženje
+Debit Amt,Rashod Amt
+Debit Note,Rashodi - napomena
+Debit To,Rashodi za
+Debit and Credit not equal for this voucher. Difference is {0}.,Rashodi i kreditiranje nisu jednaki za ovog jamca. Razlika je {0} .
+Deduct,Odbiti
+Deduction,Odbitak
+Deduction Type,Tip odbitka
+Deduction1,Odbitak 1
+Deductions,Odbici
+Default,Zadano
+Default Account,Zadani račun
+Default Address Template cannot be deleted,Zadani predložak adrese ne može se izbrisati
+Default Amount,Zadani iznos
+Default BOM,Zadani BOM
+Default Bank / Cash account will be automatically updated in POS Invoice when this mode is selected.,"Zadana banka / novčani račun će se automatski ažurirati prema POS računu, kada je ovaj mod odabran."
+Default Bank Account,Zadani bankovni račun
+Default Buying Cost Center,Zadani trošak kupnje
+Default Buying Price List,Zadani cjenik kupnje
+Default Cash Account,Zadani novčani račun
+Default Company,Zadana tvrtka
+Default Currency,Zadana valuta
+Default Customer Group,Zadana grupa korisnika
+Default Expense Account,Zadani račun rashoda
+Default Income Account,Zadani račun prihoda
+Default Item Group,Zadana grupa artikala
+Default Price List,Zadani cjenik
+Default Purchase Account in which cost of the item will be debited.,Zadani račun kupnje - na koji će trošak artikla biti terećen.
+Default Selling Cost Center,Zadani trošak prodaje
+Default Settings,Zadane postavke
+Default Source Warehouse,Zadano izvorno skladište
+Default Stock UOM,Zadana kataloška mjerna jedinica
+Default Supplier,Glavni dobavljač
+Default Supplier Type,Zadani tip dobavljača
+Default Target Warehouse,Centralno skladište
+Default Territory,Zadani teritorij
+Default Unit of Measure,Zadana mjerna jedinica
+"Default Unit of Measure can not be changed directly because you have already made some transaction(s) with another UOM. To change default UOM, use 'UOM Replace Utility' tool under Stock module.","Zadana mjerna jedinica ne može se mijenjati izravno, jer ste već napravili neku transakciju sa drugom mjernom jedinicom. Za promjenu zadane mjerne jedinice, koristite 'Alat za mijenjanje mjernih jedinica' alat preko Stock modula."
+Default Valuation Method,Zadana metoda vrednovanja
+Default Warehouse,Glavno skladište
+Default Warehouse is mandatory for stock Item.,Glavno skladište je obvezno za zalihu artikala.
+Default settings for accounting transactions.,Zadane postavke za računovodstvene poslove.
+Default settings for buying transactions.,Zadane postavke za transakciju kupnje.
+Default settings for selling transactions.,Zadane postavke za transakciju prodaje.
+Default settings for stock transactions.,Zadane postavke za burzovne transakcije.
+Defense,Obrana
+"Define Budget for this Cost Center. To set budget action, see <a href=""#!List/Company"">Company Master</a>","Odredite proračun za ovu troška. Da biste postavili proračuna akciju, vidi <a href=""#!List/Company"">Tvrtka Master</a>"
+Del,Izbr
+Delete,Izbrisati
+Delete {0} {1}?,Izbrisati {0} {1} ?
+Delivered,Isporučeno
+Delivered Items To Be Billed,Isporučeni proizvodi za naplatiti
+Delivered Qty,Isporučena količina
+Delivered Serial No {0} cannot be deleted,Isporučeni serijski broj {0} se ne može izbrisati
+Delivery Date,Datum isporuke
+Delivery Details,Detalji isporuke
+Delivery Document No,Dokument isporuke br
+Delivery Document Type,Dokument isporuke - tip
+Delivery Note,Otpremnica
+Delivery Note Item,Otpremnica artikla
+Delivery Note Items,Otpremnica artikala
+Delivery Note Message,Otpremnica - poruka
+Delivery Note No,Otpremnica br
+Delivery Note Required,Potrebna je otpremnica
+Delivery Note Trends,Trendovi otpremnica
+Delivery Note {0} is not submitted,Otpremnica {0} nije potvrđena
+Delivery Note {0} must not be submitted,Otpremnica {0} ne smije biti potvrđena
+Delivery Notes {0} must be cancelled before cancelling this Sales Order,Otpremnica {0} mora biti otkazana prije poništenja ove narudžbenice
+Delivery Status,Status isporuke
+Delivery Time,Vrijeme isporuke
+Delivery To,Dostava za
+Department,Odjel
+Department Stores,Robne kuće
+Depends on LWP,Ovisi o LWP
+Depreciation,Amortizacija
+Description,Opis
+Description HTML,HTML opis
+Designation,Oznaka
+Designer,Imenovatelj
+Detailed Breakup of the totals,Detaljni raspada ukupnim
+Details,Detalji
+Difference (Dr - Cr),Razlika ( dr. - Cr )
+Difference Account,Račun razlike
+"Difference Account must be a 'Liability' type account, since this Stock Reconciliation is an Opening Entry","Razlika račun mora biti' odgovornosti ' vrsta računa , jer to Stock Pomirenje jeulazni otvor"
+Different UOM for items will lead to incorrect (Total) Net Weight value. Make sure that Net Weight of each item is in the same UOM.,Različite mjerne jedinice artikala će dovesti do ukupne pogrešne neto težine. Budite sigurni da je neto težina svakog artikla u istoj mjernoj jedinici.
+Direct Expenses,Izravni troškovi
+Direct Income,Izravni dohodak
+Disable,Ugasiti
+Disable Rounded Total,Ugasiti zaokruženi iznos
+Disabled,Ugašeno
+Discount  %,Popust%
+Discount %,Popust%
+Discount (%),Popust (%)
+Discount Amount,Iznos popusta
+"Discount Fields will be available in Purchase Order, Purchase Receipt, Purchase Invoice","Popust polja će biti dostupna u narudžbenici, primci i računu kupnje"
+Discount Percentage,Postotak popusta
+Discount Percentage can be applied either against a Price List or for all Price List.,Postotak popusta se može neovisno primijeniti prema jednom ili za više cjenika.
+Discount must be less than 100,Popust mora biti manji od 100
+Discount(%),Popust (%)
+Dispatch,Otpremanje
+Display all the individual items delivered with the main items,Prikaži sve pojedinačne artikle isporučene sa glavnim artiklima
+Distribute transport overhead across items.,Podijeliti cijenu prijevoza prema artiklima.
+Distribution,Distribucija
+Distribution Id,ID distribucije
+Distribution Name,Naziv distribucije
+Distributor,Distributer
+Divorced,Rastavljen
+Do Not Contact,Ne kontaktirati
+Do not show any symbol like $ etc next to currencies.,Ne pokazati nikakav simbol kao $ iza valute.
+Do really want to unstop production order: ,Želite li ponovno pokrenuti proizvodnju:
+Do you really want to STOP ,Želite li stvarno stati
+Do you really want to STOP this Material Request?,Želite li stvarno stopirati ovaj zahtjev za materijalom?
+Do you really want to Submit all Salary Slip for month {0} and year {1},Želite li zaista podnijeti sve klizne plaće za mjesec {0} i godinu {1}
+Do you really want to UNSTOP ,Želite li zaista pokrenuti
+Do you really want to UNSTOP this Material Request?,Želite li stvarno ponovno pokrenuti ovaj zahtjev za materijalom?
+Do you really want to stop production order: ,Želite li stvarno prekinuti proizvodnju:
+Doc Name,Doc ime
+Doc Type,Doc tip
+Document Description,Opis dokumenta
+Document Type,Tip dokumenta
+Documents,Dokumenti
+Domain,Domena
+Don't send Employee Birthday Reminders,Ne šaljite podsjetnik za rođendan zaposlenika
+Download Materials Required,Preuzmite - Potrebni materijali
+Download Reconcilation Data,Preuzmite Rekoncilijacijske podatke
+Download Template,Preuzmite predložak
+Download a report containing all raw materials with their latest inventory status,Preuzmite izvješće koje sadrži sve sirovine sa svojim najnovijim statusom inventara
+"Download the Template, fill appropriate data and attach the modified file.","Preuzmite predložak , ispunite odgovarajuće podatke i priložite izmijenjenu datoteku ."
+"Download the Template, fill appropriate data and attach the modified file.All dates and employee combination in the selected period will come in the template, with existing attendance records","Preuzmite predložak, ispunite odgovarajuće podatke i priložite izmijenjenu datoteku. Svi datumi i kombinacija zaposlenika u odabranom razdoblju će doći u predlošku, s postojećim izostancima"
+Draft,Nepotvrđeno
+Dropbox,Dropbox
+Dropbox Access Allowed,Dozvoljen pristup Dropboxu
+Dropbox Access Key,Dropbox pristupni ključ
+Dropbox Access Secret,Dropbox tajni pristup
+Due Date,Datum dospijeća
+Due Date cannot be after {0},Datum dospijeća ne može biti poslije {0}
+Due Date cannot be before Posting Date,Datum dospijeća ne može biti prije datuma objavljivanja
+Duplicate Entry. Please check Authorization Rule {0},Dupli unos. Provjerite pravila za autorizaciju {0}
+Duplicate Serial No entered for Item {0},Dupli serijski broj unešen za artikal {0}
+Duplicate entry,Dupli unos
+Duplicate row {0} with same {1},Dupli red {0} sa istim {1}
+Duties and Taxes,Carine i porezi
+ERPNext Setup,ERPNext Setup
+Earliest,Najstarije
+Earnest Money,kapara
+Earning,Zarada
+Earning & Deduction,Zarada &amp; Odbitak
+Earning Type,Zarada Vid
+Earning1,Earning1
+Edit,Uredi
+Edu. Cess on Excise,Edu. Posebni porez na trošarine
+Edu. Cess on Service Tax,Edu. Posebni porez na porez na uslugu
+Edu. Cess on TDS,Edu. Posebni porez na TDS
+Education,Obrazovanje
+Educational Qualification,Obrazovne kvalifikacije
+Educational Qualification Details,Obrazovni Pojedinosti kvalifikacije
+Eg. smsgateway.com/api/send_sms.cgi,Npr.. smsgateway.com / api / send_sms.cgi
+Either debit or credit amount is required for {0},Ili debitna ili kreditna iznos potreban za {0}
+Either target qty or target amount is mandatory,Ili meta Količina ili ciljani iznos je obvezna
+Either target qty or target amount is mandatory.,Ili meta Količina ili ciljani iznos je obavezna .
+Electrical,Električna
+Electricity Cost,Troškovi struje
+Electricity cost per hour,Troškovi struje po satu
+Electronics,Elektronika
+Email,E-mail
+Email Digest,E-pošta
+Email Digest Settings,E-pošta Postavke
+Email Digest: ,Email Digest: 
+Email Id,E-mail ID
+"Email Id where a job applicant will email e.g. ""jobs@example.com""",E-mail Id gdje posao zahtjeva će e-mail npr. &quot;jobs@example.com&quot;
+Email Notifications,E-mail obavijesti
+Email Sent?,Je li e-mail poslan?
+"Email id must be unique, already exists for {0}","Email ID mora biti jedinstven , već postoji za {0}"
+Email ids separated by commas.,E-mail ids odvojene zarezima.
+"Email settings to extract Leads from sales email id e.g. ""sales@example.com""",E-mail postavke za izdvajanje vodi od prodaje email id npr. &quot;sales@example.com&quot;
+Emergency Contact,Hitni kontakt
+Emergency Contact Details,Hitna Kontaktni podaci
+Emergency Phone,Hitna Telefon
+Employee,Zaposlenik
+Employee Birthday,Zaposlenik Rođendan
+Employee Details,Zaposlenih Detalji
+Employee Education,Zaposlenik Obrazovanje
+Employee External Work History,Zaposlenik Vanjski Rad Povijest
+Employee Information,Zaposlenik informacije
+Employee Internal Work History,Zaposlenik Unutarnji Rad Povijest
+Employee Internal Work Historys,Zaposlenih unutarnji rad Historys
+Employee Leave Approver,Zaposlenik dopust Odobritelj
+Employee Leave Balance,Zaposlenik napuste balans
+Employee Name,Zaposlenik Ime
+Employee Number,Zaposlenik Broj
+Employee Records to be created by,Zaposlenik Records bi se stvorili
+Employee Settings,Postavke zaposlenih
+Employee Type,Zaposlenik Tip
+"Employee designation (e.g. CEO, Director etc.).","Oznaka zaposlenika ( npr. CEO , direktor i sl. ) ."
+Employee master.,Majstor zaposlenika .
+Employee record is created using selected field. ,Zaposlenika rekord je stvorio pomoću odabranog polja.
+Employee records.,Zaposlenih evidencija.
+Employee relieved on {0} must be set as 'Left',Zaposlenik razriješen na {0} mora biti postavljen kao 'lijevo '
+Employee {0} has already applied for {1} between {2} and {3},Zaposlenik {0} već podnijela zahtjev za {1} od {2} i {3}
+Employee {0} is not active or does not exist,Zaposlenik {0} nije aktivan ili ne postoji
+Employee {0} was on leave on {1}. Cannot mark attendance.,Zaposlenik {0} je bio na odmoru na {1} . Ne možete označiti dolazak .
+Employees Email Id,Zaposlenici Email ID
+Employment Details,Zapošljavanje Detalji
+Employment Type,Zapošljavanje Tip
+Enable / disable currencies.,Omogućiti / onemogućiti valute .
+Enabled,Omogućeno
+Encashment Date,Encashment Datum
+End Date,Datum završetka
+End Date can not be less than Start Date,Datum završetka ne može biti manja od početnog datuma
+End date of current invoice's period,Kraj datum tekućeg razdoblja dostavnice
+End of Life,Kraj života
+Energy,energija
+Engineer,inženjer
+Enter Verification Code,Unesite kod za provjeru
+Enter campaign name if the source of lead is campaign.,Unesite naziv kampanje ukoliko izvor olova je kampanja.
+Enter department to which this Contact belongs,Unesite odjel na koji se ovaj Kontakt pripada
+Enter designation of this Contact,Upišite oznaku ove Kontakt
+"Enter email id separated by commas, invoice will be mailed automatically on particular date","Unesite e-mail ID odvojena zarezima, račun će automatski biti poslan na određeni datum"
+Enter items and planned qty for which you want to raise production orders or download raw materials for analysis.,Unesite stavke i planirani Količina za koje želite povećati proizvodne naloge ili preuzimanje sirovine za analizu.
+Enter name of campaign if source of enquiry is campaign,"Unesite naziv kampanje, ako je izvor upit je kampanja"
+"Enter static url parameters here (Eg. sender=ERPNext, username=ERPNext, password=1234 etc.)","Unesite statičke parametre URL ovdje (npr. pošiljatelj = ERPNext, username = ERPNext, lozinkom = 1234 itd.)"
+Enter the company name under which Account Head will be created for this Supplier,Unesite naziv tvrtke pod kojima računa Voditelj će biti stvoren za tu dobavljača
+Enter url parameter for message,Unesite URL parametar za poruke
+Enter url parameter for receiver nos,Unesite URL parametar za prijemnike br
+Entertainment & Leisure,Zabava i slobodno vrijeme
+Entertainment Expenses,Zabava Troškovi
+Entries,Prijave
+Entries against ,Entries against 
+Entries are not allowed against this Fiscal Year if the year is closed.,"Prijave nisu dozvoljeni protiv ove fiskalne godine, ako se godina zatvoren."
+Equity,pravičnost
+Error: {0} > {1},Pogreška : {0} > {1}
+Estimated Material Cost,Procjena troškova materijala
+"Even if there are multiple Pricing Rules with highest priority, then following internal priorities are applied:","Čak i ako postoji više Cijene pravila s najvišim prioritetom, onda sljedeći interni prioriteti primjenjuje se:"
+Everyone can read,Svatko može pročitati
+"Example: ABCD.#####If series is set and Serial No is not mentioned in transactions, then automatic serial number will be created based on this series. If you always want to explicitly mention Serial Nos for this item. leave this blank.",". Primjer: ABCD # # # # #  Ako serija je postavljena i Serial No ne spominje u transakcijama, a zatim automatski serijski broj će biti izrađen na temelju ove serije. Ako ste oduvijek željeli izrijekom spomenuti Serial brojeva za tu stavku. ostavite praznim."
+Exchange Rate,Tečaj
+Excise Duty 10,Trošarina 10
+Excise Duty 14,Trošarina 14
+Excise Duty 4,Trošarina 4
+Excise Duty 8,Trošarina 8
+Excise Duty @ 10,Trošarina @ 10.
+Excise Duty @ 14,Trošarina @ 14
+Excise Duty @ 4,Trošarina @ 4
+Excise Duty @ 8,Trošarina @ 8.
+Excise Duty Edu Cess 2,Trošarina Edu Posebni porez 2
+Excise Duty SHE Cess 1,Trošarina ONA Posebni porez na 1
+Excise Page Number,Trošarina Broj stranice
+Excise Voucher,Trošarina bon
+Execution,izvršenje
+Executive Search,Executive Search
+Exemption Limit,Izuzeće granica
+Exhibition,Izložba
+Existing Customer,Postojeći Kupac
+Exit,Izlaz
+Exit Interview Details,Izlaz Intervju Detalji
+Expected,Očekivana
+Expected Completion Date can not be less than Project Start Date,Očekivani datum dovršetka ne može biti manja od projekta Početni datum
+Expected Date cannot be before Material Request Date,Očekivani datum ne može biti prije Materijal Zahtjev Datum
+Expected Delivery Date,Očekivani rok isporuke
+Expected Delivery Date cannot be before Purchase Order Date,Očekuje se dostava Datum ne može biti prije narudžbenice Datum
+Expected Delivery Date cannot be before Sales Order Date,Očekuje se dostava Datum ne može biti prije prodajnog naloga Datum
+Expected End Date,Očekivani Datum završetka
+Expected Start Date,Očekivani datum početka
+Expense,rashod
+Expense / Difference account ({0}) must be a 'Profit or Loss' account,Rashodi / Razlika računa ({0}) mora biti račun 'dobit ili gubitak'
+Expense Account,Rashodi račun
+Expense Account is mandatory,Rashodi račun je obvezna
+Expense Claim,Rashodi polaganja
+Expense Claim Approved,Rashodi Zahtjev odobren
+Expense Claim Approved Message,Rashodi Zahtjev Odobren poruku
+Expense Claim Detail,Rashodi Zahtjev Detalj
+Expense Claim Details,Rashodi Pojedinosti o polaganju
+Expense Claim Rejected,Rashodi Zahtjev odbijen
+Expense Claim Rejected Message,Rashodi Zahtjev odbijen poruku
+Expense Claim Type,Rashodi Vrsta polaganja
+Expense Claim has been approved.,Rashodi Zahtjev je odobren .
+Expense Claim has been rejected.,Rashodi Zahtjev je odbijen .
+Expense Claim is pending approval. Only the Expense Approver can update status.,Rashodi Tužba se čeka odobrenje . SamoRashodi Odobritelj može ažurirati status .
+Expense Date,Rashodi Datum
+Expense Details,Rashodi Detalji
+Expense Head,Rashodi voditelj
+Expense account is mandatory for item {0},Rashodi račun je obvezna za predmet {0}
+Expense or Difference account is mandatory for Item {0} as it impacts overall stock value,Rashodi ili razlika račun je obvezna za točke {0} jer utječe na ukupnu vrijednost dionica
+Expenses,troškovi
+Expenses Booked,Rashodi Rezervirani
+Expenses Included In Valuation,Troškovi uključeni u vrednovanje
+Expenses booked for the digest period,Troškovi rezerviranih za razdoblje digest
+Expiry Date,Datum isteka
+Exports,Izvoz
+External,Vanjski
+Extract Emails,Ekstrakt e-pošte
+FCFS Rate,FCFS Stopa
+Failed: ,Nije uspjelo:
+Family Background,Obitelj Pozadina
+Fax,Fax
+Features Setup,Značajke konfiguracija
+Feed,Hraniti
+Feed Type,Pasi Vid
+Feedback,Povratna veza
+Female,Ženski
+Fetch exploded BOM (including sub-assemblies),Fetch eksplodirala BOM (uključujući i podsklopova )
+"Field available in Delivery Note, Quotation, Sales Invoice, Sales Order","Polje dostupan u otpremnicu, ponudu, prodaje fakture, prodaja reda"
+Files Folder ID,Files ID
+Fill the form and save it,Ispunite obrazac i spremite ga
+Filter based on customer,Filter temelji se na kupca
+Filter based on item,Filtrirati na temelju točki
+Financial / accounting year.,Financijska / obračunska godina .
+Financial Analytics,Financijski Analytics
+Financial Services,financijske usluge
+Financial Year End Date,Financijska godina End Date
+Financial Year Start Date,Financijska godina Start Date
+Finished Goods,gotovih proizvoda
+First Name,Ime
+First Responded On,Prvo Odgovorili Na
+Fiscal Year,Fiskalna godina
+Fiscal Year Start Date and Fiscal Year End Date are already set in Fiscal Year {0},Fiskalna godina Datum početka i datum završetka fiskalne godine već su postavljeni u fiskalnoj godini {0}
+Fiscal Year Start Date and Fiscal Year End Date cannot be more than a year apart.,Fiskalna godina Datum početka i datum završetka fiskalne godine ne može biti više od godine dana.
+Fiscal Year Start Date should not be greater than Fiscal Year End Date,Fiskalna godina Start Date ne bi trebao biti veći od Fiskalna godina End Date
+Fixed Asset,Dugotrajne imovine
+Fixed Assets,Dugotrajna imovina
+Follow via Email,Slijedite putem e-maila
+"Following table will show values if items are sub - contracted. These values will be fetched from the master of ""Bill of Materials"" of sub - contracted items.",Nakon stol će pokazati vrijednosti ako su stavke pod - ugovoreno. Ove vrijednosti će biti preuzeta od zapovjednika &quot;Bill of Materials&quot; pod - ugovoreni stavke.
+Food,hrana
+"Food, Beverage & Tobacco","Hrana , piće i duhan"
+"For 'Sales BOM' items, Warehouse, Serial No and Batch No will be considered from the 'Packing List' table. If Warehouse and Batch No are same for all packing items for any 'Sales BOM' item, those values can be entered in the main Item table, values will be copied to 'Packing List' table.","Za 'Prodaja BOM ""predmeta, skladište, rednim brojem i hrpa Ne smatrat će se iz' Popis pakiranja 'stolom. Ako Warehouse i šarže su isti za sve pakiranje predmeta za bilo 'Prodaja' sastavnice točke, te vrijednosti mogu se unijeti u glavni predmet stola, vrijednosti će se kopirati 'pakiranje popis' stolom."
+For Company,Za tvrtke
+For Employee,Za zaposlenom
+For Employee Name,Za ime zaposlenika
+For Price List,Za Cjeniku
+For Production,Za proizvodnju
+For Reference Only.,Samo za referencu.
+For Sales Invoice,Za prodaju fakture
+For Server Side Print Formats,Za Server formati stranom za ispis
+For Supplier,za Supplier
+For Warehouse,Za galeriju
+For Warehouse is required before Submit,Jer je potrebno Warehouse prije Podnijeti
+"For e.g. 2012, 2012-13","Za npr. 2012, 2012-13"
+For reference,Za referencu
+For reference only.,Za samo kao referenca.
+"For the convenience of customers, these codes can be used in print formats like Invoices and Delivery Notes","Za praktičnost kupaca, te kodovi mogu se koristiti u tiskanim formata kao što su fakture i otpremnice"
+Fraction,Frakcija
+Fraction Units,Frakcije Jedinice
+Freeze Stock Entries,Zamrzavanje Stock Unosi
+Freeze Stocks Older Than [Days],Freeze Dionice stariji od [ dana ]
+Freight and Forwarding Charges,Teretni i Forwarding Optužbe
+Friday,Petak
+From,Od
+From Bill of Materials,Od Bill of Materials
+From Company,Iz Društva
+From Currency,Od novca
+From Currency and To Currency cannot be same,Od valute i valuta ne mogu biti isti
+From Customer,Od kupca
+From Customer Issue,Od kupca Issue
+From Date,Od datuma
+From Date cannot be greater than To Date,Od datuma ne može biti veća od To Date
+From Date must be before To Date,Od datuma mora biti prije do danas
+From Date should be within the Fiscal Year. Assuming From Date = {0},Od datuma trebao biti u fiskalnoj godini. Uz pretpostavku Od datuma = {0}
+From Delivery Note,Od otpremnici
+From Employee,Od zaposlenika
+From Lead,Od Olovo
+From Maintenance Schedule,Od održavanje rasporeda
+From Material Request,Od materijala zahtjev
+From Opportunity,od Opportunity
+From Package No.,Iz paketa broj
+From Purchase Order,Od narudžbenice
+From Purchase Receipt,Od Račun kupnje
+From Quotation,od kotaciju
+From Sales Order,Od prodajnog naloga
+From Supplier Quotation,Od dobavljača kotaciju
+From Time,S vremena
+From Value,Od Vrijednost
+From and To dates required,Od i Do datuma zahtijevanih
+From value must be less than to value in row {0},Od vrijednosti mora biti manje nego vrijednosti u redu {0}
+Frozen,Zaleđeni
+Frozen Accounts Modifier,Blokiran Računi Modifikacijska
+Fulfilled,Ispunjena
+Full Name,Ime i prezime
+Full-time,Puno radno vrijeme
+Fully Billed,Potpuno Naplaćeno
+Fully Completed,Potpuno Završeni
+Fully Delivered,Potpuno Isporučeno
+Furniture and Fixture,Namještaj i susret
+Further accounts can be made under Groups but entries can be made against Ledger,"Daljnje računi mogu biti u skupinama , ali unose možete izvoditi protiv Ledgera"
+"Further accounts can be made under Groups, but entries can be made against Ledger","Daljnje računi mogu biti u skupinama , ali unose možete izvoditi protiv Ledgera"
+Further nodes can be only created under 'Group' type nodes,"Daljnje čvorovi mogu se samo stvorio pod ""Grupa"" tipa čvorova"
+GL Entry,GL Stupanje
+Gantt Chart,Gantogram
+Gantt chart of all tasks.,Gantogram svih zadataka.
+Gender,Rod
+General,Opći
+General Ledger,Glavna knjiga
+Generate Description HTML,Generiranje Opis HTML
+Generate Material Requests (MRP) and Production Orders.,Generirajte Materijal Upiti (MRP) i radne naloge.
+Generate Salary Slips,Generiranje plaće gaćice
+Generate Schedule,Generiranje Raspored
+Generates HTML to include selected image in the description,Stvara HTML uključuju odabrane slike u opisu
+Get Advances Paid,Nabavite plaćenim avansima
+Get Advances Received,Get Napredak pozicija
+Get Current Stock,Nabavite trenutne zalihe
+Get Items,Nabavite artikle
+Get Items From Sales Orders,Get artikle iz narudžbe
+Get Items from BOM,Se predmeti s troškovnikom
+Get Last Purchase Rate,Nabavite Zadnji Ocijeni Kupnja
+Get Outstanding Invoices,Nabavite neplaćene račune
+Get Relevant Entries,Dobiti relevantne objave
+Get Sales Orders,Nabavite narudžbe
+Get Specification Details,Nabavite Specifikacija Detalji
+Get Stock and Rate,Nabavite Stock i stopa
+Get Template,Nabavite predloška
+Get Terms and Conditions,Nabavite Uvjeti i pravila
+Get Unreconciled Entries,Nabavite nesaglašen objave
+Get Weekly Off Dates,Nabavite Tjedno Off datumi
+"Get valuation rate and available stock at source/target warehouse on mentioned posting date-time. If serialized item, please press this button after entering serial nos.","Nabavite stopa za vrednovanje i dostupni zaliha na izvor / cilj skladištu na spomenuti datum knjiženja radno vrijeme. Ako serijaliziranom stavku, molimo pritisnite ovu tipku nakon ulaska serijskih brojeva."
+Global Defaults,Globalni Zadano
+Global POS Setting {0} already created for company {1},Global POS Setting {0} već stvorene za tvrtke {1}
+Global Settings,globalne postavke
+"Go to the appropriate group (usually Application of Funds > Current Assets > Bank Accounts and create a new Account Ledger (by clicking on Add Child) of type ""Bank""","Idi na odgovarajuće skupine (obično Application fondova > tekuće imovine > bankovnim računima i stvoriti Ledger novog računa (klikom na Dodaj dijete) tipa : ""Banka"""
+"Go to the appropriate group (usually Source of Funds > Current Liabilities > Taxes and Duties and create a new Account Ledger (by clicking on Add Child) of type ""Tax"" and do mention the Tax rate.","Idi na odgovarajuće skupine (obično izvor sredstava > kratkoročne obveze > poreza i carina i stvoriti novi račun Ledger ( klikom na Dodaj dijete ) tipa "" porez"" i ne spominju se porezna stopa ."
+Goal,Cilj
+Goals,Golovi
+Goods received from Suppliers.,Roba dobio od dobavljače.
+Google Drive,Google Drive
+Google Drive Access Allowed,Google Drive Pristup dopuštenih
+Government,vlada
+Graduate,Diplomski
+Grand Total,Ukupno za platiti
+Grand Total (Company Currency),Sveukupno (valuta tvrtke)
+"Grid ""","Grid """
+Grocery,Trgovina
+Gross Margin %,Bruto marža %
+Gross Margin Value,Bruto marža vrijednost
+Gross Pay,Bruto plaće
+Gross Pay + Arrear Amount +Encashment Amount - Total Deduction,Bruto plaće + + zaostatak Iznos Iznos Encashment - Ukupno Odbitak
+Gross Profit,Ukupan profit
+Gross Profit (%),Bruto dobit (%)
+Gross Weight,Bruto težina
+Gross Weight UOM,Bruto težina UOM
+Group,Grupa
+Group by Account,Grupa po računu
+Group by Voucher,Grupa po vaučer
+Group or Ledger,Grupa ili knjiga
+Groups,Grupe
+HR Manager,HR Manager
+HR Settings,HR Postavke
+HTML / Banner that will show on the top of product list.,HTML / bannera koji će se prikazivati ​​na vrhu liste proizvoda.
+Half Day,Pola dana
+Half Yearly,Pola Godišnji
+Half-yearly,Polugodišnje
+Happy Birthday!,Sretan rođendan !
+Hardware,hardver
+Has Batch No,Je Hrpa Ne
+Has Child Node,Je li čvor dijete
+Has Serial No,Ima Serial Ne
+Head of Marketing and Sales,Voditelj marketinga i prodaje
+Header,Kombajn
+Health Care,Health Care
+Health Concerns,Zdravlje Zabrinutost
+Health Details,Zdravlje Detalji
+Held On,Održanoj
+Help HTML,Pomoć HTML
+"Help: To link to another record in the system, use ""#Form/Note/[Note Name]"" as the Link URL. (don't use ""http://"")","Pomoć: Za povezivanje na drugi zapis u sustavu, koristite &quot;# Forma / Napomena / [Napomena ime]&quot; kao URL veze. (Ne koristite &quot;http://&quot;)"
+"Here you can maintain family details like name and occupation of parent, spouse and children","Ovdje možete održavati obiteljske pojedinosti kao što su ime i okupacije roditelja, supružnika i djecu"
+"Here you can maintain height, weight, allergies, medical concerns etc","Ovdje možete održavati visina, težina, alergije, medicinske brige itd."
+Hide Currency Symbol,Sakrij simbol valute
+High,Visok
+History In Company,Povijest U Društvu
+Hold,Držati
+Holiday,Odmor
+Holiday List,Turistička Popis
+Holiday List Name,Turistička Popis Ime
+Holiday master.,Majstor za odmor .
+Holidays,Praznici
+Home,Dom
+Host,Domaćin
+"Host, Email and Password required if emails are to be pulled","Domaćin, e-mail i lozinka potrebni ako e-mailove su se izvukao"
+Hour,sat
+Hour Rate,Sat Ocijenite
+Hour Rate Labour,Sat Ocijenite rada
+Hours,Sati
+How Pricing Rule is applied?,Kako se primjenjuje cijena pravilo?
+How frequently?,Kako često?
+"How should this currency be formatted? If not set, will use system defaults","Kako bi se to valuta biti formatiran? Ako nije postavljeno, koristit će zadane postavke sustava"
+Human Resources,Ljudski resursi
+Identification of the package for the delivery (for print),Identifikacija paketa za dostavu (za tisak)
+If Income or Expense,Ako prihoda i rashoda
+If Monthly Budget Exceeded,Ako Mjesečni proračun Exceeded
+"If Sale BOM is defined, the actual BOM of the Pack is displayed as table. Available in Delivery Note and Sales Order","Ako Prodaja BOM definiran ,stvarni troškovnik od Pack prikazuje se kao stol . Dostupan u Dostavnica i prodajni nalog"
+"If Supplier Part Number exists for given Item, it gets stored here","Ako Dobavljač Broj dijela postoji za određeni predmet, to dobiva pohranjen ovdje"
+If Yearly Budget Exceeded,Ako Godišnji proračun Exceeded
+"If checked, BOM for sub-assembly items will be considered for getting raw materials. Otherwise, all sub-assembly items will be treated as a raw material.","Ako je označeno, BOM za pod-zbor stavke će biti uzeti u obzir za dobivanje sirovine. Inače, sve pod-montaža stavke će biti tretirani kao sirovinu."
+"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Ako je označeno, Ukupan broj. radnih dana će uključiti odmor, a to će smanjiti vrijednost plaća po danu"
+"If checked, the tax amount will be considered as already included in the Print Rate / Print Amount","Ako je označeno, iznos poreza će se smatrati već uključena u Print Rate / Ispis Iznos"
+If different than customer address,Ako se razlikuje od kupaca adresu
+"If disable, 'Rounded Total' field will not be visible in any transaction","Ako onemogućite, &#39;Ukupno&#39; Zaobljeni polje neće biti vidljiv u bilo kojoj transakciji"
+"If enabled, the system will post accounting entries for inventory automatically.","Ako je omogućeno, sustav će objaviti računovodstvene stavke za popis automatski."
+If more than one package of the same type (for print),Ako je više od jedan paket od iste vrste (za tisak)
+"If multiple Pricing Rules continue to prevail, users are asked to set Priority manually to resolve conflict.","Ako više Cijene pravila i dalje prevladavaju, korisnici su zamoljeni da postavite prioritet ručno riješiti sukob."
+"If no change in either Quantity or Valuation Rate, leave the cell blank.","Ako nema promjena u bilo Količina ili procjena stope , ostaviti prazno stanica ."
+If not applicable please enter: NA,Ako ne odnosi unesite: NA
+"If not checked, the list will have to be added to each Department where it has to be applied.","Ako nije označeno, popis će biti dodan u svakom odjela gdje se mora primjenjivati."
+"If selected Pricing Rule is made for 'Price', it will overwrite Price List. Pricing Rule price is the final price, so no further discount should be applied. Hence, in transactions like Sales Order, Purchase Order etc, it will be fetched in 'Rate' field, rather than 'Price List Rate' field.","Ako odabrani Cijene Pravilo je za 'Cijena', to će prebrisati cjenik. Cijene Pravilo cijena je konačna cijena, tako da nema dalje popusta treba primijeniti. Dakle, u prometu kao što su prodajni nalog, narudžbenica itd, to će biti preuzeta u 'stopi' polju, a ne 'cjenik' stopi polju."
+"If specified, send the newsletter using this email address","Ako je navedeno, pošaljite newsletter koristeći ovu e-mail adresu"
+"If the account is frozen, entries are allowed to restricted users.","Ako je račun zamrznut , unosi dopušteno ograničene korisnike ."
+"If this Account represents a Customer, Supplier or Employee, set it here.","Ako se to računa predstavlja kupac, dobavljač ili zaposlenik, postavite ga ovdje."
+"If two or more Pricing Rules are found based on the above conditions, Priority is applied. Priority is a number between 0 to 20 while default value is zero (blank). Higher number means it will take precedence if there are multiple Pricing Rules with same conditions.","Ako su dva ili više Cijene Pravila naći na temelju gore navedenih uvjeta, prednost se primjenjuju. Prioritet je broj od 0 do 20, a zadana vrijednost je nula (prazno). Veći broj znači da će imati prednost ako postoji više Cijene pravila s istim uvjetima."
+If you follow Quality Inspection. Enables Item QA Required and QA No in Purchase Receipt,Ako slijedite kvalitete . Omogućuje predmet QA potrebno i QA Ne u Račun kupnje
+If you have Sales Team and Sale Partners (Channel Partners)  they can be tagged and maintain their contribution in the sales activity,Ako imate prodajnog tima i prodaja partnerima (partneri) mogu biti označene i održavati svoj doprinos u prodajne aktivnosti
+"If you have created a standard template in Purchase Taxes and Charges Master, select one and click on the button below.","Ako ste stvorili standardni predložak za kupnju poreze i pristojbe magisterij, odaberite jednu i kliknite na gumb ispod."
+"If you have created a standard template in Sales Taxes and Charges Master, select one and click on the button below.","Ako ste stvorili standardni predložak u prodaji poreze i pristojbe magisterij, odaberite jednu i kliknite na gumb ispod."
+"If you have long print formats, this feature can be used to split the page to be printed on multiple pages with all headers and footers on each page","Ako ste dugo ispis formata, ova značajka može se koristiti za podijeliti stranicu na koju se ispisuje više stranica sa svim zaglavljima i podnožjima na svakoj stranici"
+If you involve in manufacturing activity. Enables Item 'Is Manufactured',Ako uključiti u proizvodnom djelatnošću . Omogućuje stavci je proizveden '
+Ignore,Ignorirati
+Ignore Pricing Rule,Ignorirajte Cijene pravilo
+Ignored: ,Zanemareni:
+Image,Slika
+Image View,Slika Pogledaj
+Implementation Partner,Provedba partner
+Import Attendance,Uvoz posjećenost
+Import Failed!,Uvoz nije uspio !
+Import Log,Uvoz Prijavite
+Import Successful!,Uvoz uspješna!
+Imports,Uvoz
+In Hours,U sati
+In Process,U procesu
+In Qty,u kol
+In Value,u vrijednosti
+In Words,Riječima
+In Words (Company Currency),Riječima (valuta tvrtke)
+In Words (Export) will be visible once you save the Delivery Note.,U riječi (izvoz) će biti vidljiv nakon što spremite otpremnici.
+In Words will be visible once you save the Delivery Note.,U riječi će biti vidljiv nakon što spremite otpremnici.
+In Words will be visible once you save the Purchase Invoice.,U riječi će biti vidljiv nakon što spremite ulazne fakture.
+In Words will be visible once you save the Purchase Order.,U riječi će biti vidljiv nakon što spremite narudžbenice.
+In Words will be visible once you save the Purchase Receipt.,U riječi će biti vidljiv nakon što spremite kupiti primitka.
+In Words will be visible once you save the Quotation.,U riječi će biti vidljiv nakon što spremite ponudu.
+In Words will be visible once you save the Sales Invoice.,U riječi će biti vidljiv nakon što spremite prodaje fakture.
+In Words will be visible once you save the Sales Order.,U riječi će biti vidljiv nakon što spremite prodajnog naloga.
+Incentives,Poticaji
+Include Reconciled Entries,Uključi pomirio objave
+Include holidays in Total no. of Working Days,Uključi odmor u ukupnom. radnih dana
+Income,prihod
+Income / Expense,Prihodi / rashodi
+Income Account,Prihodi račun
+Income Booked,Prihodi Rezervirani
+Income Tax,porezu na dohodak
+Income Year to Date,Prihodi godine do danas
+Income booked for the digest period,Prihodi rezervirano za razdoblje digest
+Incoming,Dolazni
+Incoming Rate,Dolazni Stopa
+Incoming quality inspection.,Dolazni kvalitete inspekcije.
+Incorrect number of General Ledger Entries found. You might have selected a wrong Account in the transaction.,Neispravan broj glavnu knjigu unose naći. Možda ste odabrali krivi račun u transakciji.
+Incorrect or Inactive BOM {0} for Item {1} at row {2},Pogrešne ili Neaktivno BOM {0} za točku {1} po redu {2}
+Indicates that the package is a part of this delivery (Only Draft),Ukazuje da je paket je dio ove isporuke (samo nacrti)
+Indirect Expenses,neizravni troškovi
+Indirect Income,Neizravno dohodak
+Individual,Pojedinac
+Industry,Industrija
+Industry Type,Industrija Tip
+Inspected By,Pregledati
+Inspection Criteria,Inspekcijski Kriteriji
+Inspection Required,Inspekcija Obvezno
+Inspection Type,Inspekcija Tip
+Installation Date,Instalacija Datum
+Installation Note,Instalacija Napomena
+Installation Note Item,Instalacija Napomena artikla
+Installation Note {0} has already been submitted,Instalacija Napomena {0} već je poslan
+Installation Status,Instalacija Status
+Installation Time,Instalacija Vrijeme
+Installation date cannot be before delivery date for Item {0},Datum Instalacija ne može biti prije datuma isporuke za točke {0}
+Installation record for a Serial No.,Instalacija rekord za serijski broj
+Installed Qty,Instalirani Kol
+Instructions,Instrukcije
+Integrate incoming support emails to Support Ticket,Integracija dolazne e-mailove podrške za podršku ulaznica
+Interested,Zainteresiran
+Intern,stažista
+Internal,Interni
+Internet Publishing,Internet Izdavaštvo
+Introduction,Uvod
+Invalid Barcode,Invalid Barcode
+Invalid Barcode or Serial No,Invalid Barcode ili Serial Ne
+Invalid Mail Server. Please rectify and try again.,Invalid Server Mail . Molimo ispraviti i pokušajte ponovno .
+Invalid Master Name,Invalid Master Ime
+Invalid User Name or Support Password. Please rectify and try again.,Neispravno korisničko ime ili podrška Lozinka . Molimo ispraviti i pokušajte ponovno .
+Invalid quantity specified for item {0}. Quantity should be greater than 0.,Pogrešna količina navedeno za predmet {0} . Količina treba biti veći od 0 .
+Inventory,Inventar
+Inventory & Support,Inventar i podrška
+Investment Banking,Investicijsko bankarstvo
+Investments,investicije
+Invoice Date,Račun Datum
+Invoice Details,Pojedinosti dostavnice
+Invoice No,Račun br
+Invoice Number,Račun broj
+Invoice Period From,Račun razdoblju od
+Invoice Period From and Invoice Period To dates mandatory for recurring invoice,Račun razdoblju od računa i period za datume obveznih za ponavljajuće fakture
+Invoice Period To,Račun Razdoblje Da
+Invoice Type,Tip fakture
+Invoice/Journal Voucher Details,Račun / Časopis bon Detalji
+Invoiced Amount (Exculsive Tax),Dostavljeni iznos ( Exculsive poreza )
+Is Active,Je aktivna
+Is Advance,Je Predujam
+Is Cancelled,Je Otkazan
+Is Carry Forward,Je Carry Naprijed
+Is Default,Je Default
+Is Encash,Je li unovčiti
+Is Fixed Asset Item,Je fiksne imovine stavku
+Is LWP,Je lwp
+Is Opening,Je Otvaranje
+Is Opening Entry,Je Otvaranje unos
+Is POS,Je POS
+Is Primary Contact,Je Primarna Kontakt
+Is Purchase Item,Je Kupnja artikla
+Is Sales Item,Je Prodaja artikla
+Is Service Item,Je li usluga artikla
+Is Stock Item,Je kataloški artikla
+Is Sub Contracted Item,Je Sub Ugovoreno artikla
+Is Subcontracted,Je podugovarati
+Is this Tax included in Basic Rate?,Je li ovo pristojba uključena u osnovne stope?
+Issue,Izdanje
+Issue Date,Datum izdavanja
+Issue Details,Issue Detalji
+Issued Items Against Production Order,Izdana Proizvodi prema proizvodnji Reda
+It can also be used to create opening stock entries and to fix stock value.,Također se može koristiti za stvaranje početne vrijednosti unose i popraviti stock vrijednost .
+Item,Artikl
+Item Advanced,Stavka Napredna
+Item Barcode,Stavka Barkod
+Item Batch Nos,Stavka Batch Nos
+Item Code,Stavka Šifra
+Item Code > Item Group > Brand,Kod Stavka> Stavka Group> Brand
+Item Code and Warehouse should already exist.,Šifra i skladišta trebao već postoje .
+Item Code cannot be changed for Serial No.,Kod stavka ne može se mijenjati za serijskog broja
+Item Code is mandatory because Item is not automatically numbered,Kod artikla je obvezno jer točka nije automatski numerirani
+Item Code required at Row No {0},Šifra potrebno na Row Zabranjeno {0}
+Item Customer Detail,Stavka Kupac Detalj
+Item Description,Stavka Opis
+Item Desription,Stavka Desription
+Item Details,Stavka Detalji
+Item Group,Stavka Grupa
+Item Group Name,Stavka Ime grupe
+Item Group Tree,Stavka Group Tree
+Item Group not mentioned in item master for item {0},Stavka Grupa ne spominje u točki majstora za predmet {0}
+Item Groups in Details,Stavka Grupe u detaljima
+Item Image (if not slideshow),Stavka slike (ako ne Slideshow)
+Item Name,Stavka Ime
+Item Naming By,Stavka nazivanje
+Item Price,Stavka Cijena
+Item Prices,Stavka Cijene
+Item Quality Inspection Parameter,Stavka Provera kvaliteta parametara
+Item Reorder,Stavka redoslijeda
+Item Serial No,Stavka rednim brojem
+Item Serial Nos,Stavka Serijski br
+Item Shortage Report,Stavka Nedostatak Izvješće
+Item Supplier,Stavka Dobavljač
+Item Supplier Details,Stavka Supplier Detalji
+Item Tax,Stavka poreza
+Item Tax Amount,Stavka Iznos poreza
+Item Tax Rate,Stavka Porezna stopa
+Item Tax Row {0} must have account of type Tax or Income or Expense or Chargeable,Stavka Porezna Row {0} mora imati račun tipa poreza ili prihoda i rashoda ili naplativ
+Item Tax1,Stavka Tax1
+Item To Manufacture,Stavka za proizvodnju
+Item UOM,Stavka UOM
+Item Website Specification,Stavka Web Specifikacija
+Item Website Specifications,Stavka Website Specifikacije
+Item Wise Tax Detail,Stavka Wise Porezna Detalj
+Item Wise Tax Detail ,Stavka Wise Porezna Detalj
+Item is required,Stavka je potrebno
+Item is updated,Stavka je obnovljeno
+Item master.,Majstor artikla .
+"Item must be a purchase item, as it is present in one or many Active BOMs","Stavka mora bitipredmet kupnje , kao što je to prisutno u jednom ili više aktivnih sastavnicama"
+Item or Warehouse for row {0} does not match Material Request,Stavka ili skladišta za redom {0} ne odgovara Material Zahtjev
+Item table can not be blank,Tablica predmet ne može biti prazan
+Item to be manufactured or repacked,Stavka biti proizvedeni ili prepakirani
+Item valuation updated,Vrednovanje Stavka izmijenjena
+Item will be saved by this name in the data base.,Stavka će biti spremljena pod ovim imenom u bazi podataka.
+Item {0} appears multiple times in Price List {1},Stavka {0} se pojavljuje više puta u Cjenika {1}
+Item {0} does not exist,Stavka {0} ne postoji
+Item {0} does not exist in the system or has expired,Stavka {0} ne postoji u sustavu ili je istekla
+Item {0} does not exist in {1} {2},Stavka {0} ne postoji u {1} {2}
+Item {0} has already been returned,Stavka {0} već je vraćeno
+Item {0} has been entered multiple times against same operation,Stavka {0} upisan je više puta protiv istog rada
+Item {0} has been entered multiple times with same description or date,Stavka {0} upisan je više puta s istim opisom ili datumu
+Item {0} has been entered multiple times with same description or date or warehouse,Stavka {0} upisan je više puta s istim opisom ili datum ili skladište
+Item {0} has been entered twice,Stavka {0} je ušao dva puta
+Item {0} has reached its end of life on {1},Stavka {0} je dosegla svoj kraj života na {1}
+Item {0} ignored since it is not a stock item,Stavka {0} ignorirala jer to nijepredmet dionica
+Item {0} is cancelled,Stavka {0} je otkazan
+Item {0} is not Purchase Item,Stavka {0} nije Kupnja predmeta
+Item {0} is not a serialized Item,Stavka {0} nijeserijaliziranom predmeta
+Item {0} is not a stock Item,Stavka {0} nijestock Stavka
+Item {0} is not active or end of life has been reached,Stavka {0} nije aktivan ili kraj života je postignut
+Item {0} is not setup for Serial Nos. Check Item master,"Stavka {0} nije dobro postavljen za gospodara , serijski brojevi Provjera"
+Item {0} is not setup for Serial Nos. Column must be blank,Stavka {0} nije setup za serijski brojevi Stupac mora biti prazan
+Item {0} must be Sales Item,Stavka {0} mora biti Prodaja artikla
+Item {0} must be Sales or Service Item in {1},Stavka {0} mora biti Prodaja ili usluga artikla u {1}
+Item {0} must be Service Item,Stavka {0} mora biti usluga Stavka
+Item {0} must be a Purchase Item,Stavka {0} mora bitikupnja artikla
+Item {0} must be a Sales Item,Stavka {0} mora bitiProdaja artikla
+Item {0} must be a Service Item.,Stavka {0} mora bitiusluga artikla .
+Item {0} must be a Sub-contracted Item,Stavka {0} mora bitisklopljen ugovor artikla
+Item {0} must be a stock Item,Stavka {0} mora bitistock Stavka
+Item {0} must be manufactured or sub-contracted,Stavka {0} mora biti proizvedeni ili pod-ugovori
+Item {0} not found,Stavka {0} nije pronađena
+Item {0} with Serial No {1} is already installed,Stavka {0} s rednim brojem {1} već instaliran
+Item {0} with same description entered twice,Stavka {0} sa istim opisom ušao dva puta
+"Item, Warranty, AMC (Annual Maintenance Contract) details will be automatically fetched when Serial Number is selected.","Stavka, jamstvo, AMC (Godišnje održavanje Ugovor) pojedinosti će biti automatski dohvatio kada serijski broj je odabran."
+Item-wise Price List Rate,Stavka - mudar Cjenovnik Ocijenite
+Item-wise Purchase History,Stavka-mudar Kupnja Povijest
+Item-wise Purchase Register,Stavka-mudar Kupnja Registracija
+Item-wise Sales History,Stavka-mudar Prodaja Povijest
+Item-wise Sales Register,Stavka-mudri prodaja registar
+"Item: {0} managed batch-wise, can not be reconciled using \					Stock Reconciliation, instead use Stock Entry","Stavka: {0} uspio turi, ne može se pomiriti korištenja \ Stock pomirenje, umjesto da koristite Stock stupanja"
+Item: {0} not found in the system,Stavka : {0} ne nalaze u sustavu
+Items,Proizvodi
+Items To Be Requested,Predmeti se zatražiti
+Items required,Stavke potrebne
+"Items to be requested which are ""Out of Stock"" considering all warehouses based on projected qty and minimum order qty",Proizvodi se traži što su &quot;Out of Stock&quot; s obzirom na sve skladišta na temelju projicirane Qty i minimalne narudžbe Kol
+Items which do not exist in Item master can also be entered on customer's request,Proizvodi koji ne postoje u artikla gospodara također može unijeti na zahtjev kupca
+Itemwise Discount,Itemwise Popust
+Itemwise Recommended Reorder Level,Itemwise Preporučio redoslijeda Level
+Job Applicant,Posao podnositelj
+Job Opening,Posao Otvaranje
+Job Profile,posao Profile
+Job Title,Titula
+"Job profile, qualifications required etc.","Profil posla , kvalifikacijama i sl."
+Jobs Email Settings,Poslovi Postavke e-pošte
+Journal Entries,Časopis upisi
+Journal Entry,Časopis Stupanje
+Journal Voucher,Časopis bon
+Journal Voucher Detail,Časopis bon Detalj
+Journal Voucher Detail No,Časopis bon Detalj Ne
+Journal Voucher {0} does not have account {1} or already matched,Časopis bon {0} nema račun {1} ili već usklađeni
+Journal Vouchers {0} are un-linked,Časopis bon {0} su UN -linked
+Keep a track of communication related to this enquiry which will help for future reference.,Držite pratiti komunikacije vezane uz ovaj upit koji će vam pomoći za buduću referencu.
+Keep it web friendly 900px (w) by 100px (h),Držite ga prijateljski web 900px ( w ) by 100px ( h )
+Key Performance Area,Key Performance Area
+Key Responsibility Area,Ključ Odgovornost Površina
+Kg,kg
+LR Date,LR Datum
+LR No,LR Ne
+Label,Oznaka
+Landed Cost Item,Sletio Troškovi artikla
+Landed Cost Items,Sletio troškova Proizvodi
+Landed Cost Purchase Receipt,Sletio Trošak Kupnja Potvrda
+Landed Cost Purchase Receipts,Sletio troškova kupnje Primici
+Landed Cost Wizard,Sletio Trošak Čarobnjak
+Landed Cost updated successfully,Sletio Troškovi uspješno ažurirana
+Language,Jezik
+Last Name,Prezime
+Last Purchase Rate,Zadnja Kupnja Ocijenite
+Latest,najnoviji
+Lead,Dovesti
+Lead Details,Olovo Detalji
+Lead Id,Olovo Id
+Lead Name,Olovo Ime
+Lead Owner,Olovo Vlasnik
+Lead Source,Olovo Source
+Lead Status,Olovo Status
+Lead Time Date,Olovo Time Date
+Lead Time Days,Olovo vrijeme Dane
+Lead Time days is number of days by which this item is expected in your warehouse. This days is fetched in Material Request when you select this item.,Olovo vrijeme dana je broj dana koji ovaj predmet se očekuje u skladištu. Ovih dana je preuzeta u Materijal Zahtjev kada odaberete ovu stavku.
+Lead Type,Olovo Vid
+Lead must be set if Opportunity is made from Lead,Olovo se mora postaviti ako prilika je izrađena od olova
+Leave Allocation,Ostavite Raspodjela
+Leave Allocation Tool,Ostavite raspodjele alat
+Leave Application,Ostavite aplikaciju
+Leave Approver,Ostavite odobravatelju
+Leave Approvers,Ostavite odobravateljima
+Leave Balance Before Application,Ostavite Balance Prije primjene
+Leave Block List,Ostavite Block List
+Leave Block List Allow,Ostavite Blok Popis Dopustite
+Leave Block List Allowed,Ostavite Block List dopuštenih
+Leave Block List Date,Ostavite Date Popis Block
+Leave Block List Dates,Ostavite datumi lista blokiranih
+Leave Block List Name,Ostavite popis imena Block
+Leave Blocked,Ostavite blokirani
+Leave Control Panel,Ostavite Upravljačka ploča
+Leave Encashed?,Ostavite Encashed?
+Leave Encashment Amount,Ostavite Encashment Iznos
+Leave Type,Ostavite Vid
+Leave Type Name,Ostavite ime tipa
+Leave Without Pay,Ostavite bez plaće
+Leave application has been approved.,Ostavite Zahtjev je odobren .
+Leave application has been rejected.,Ostavite Zahtjev je odbijen .
+Leave approver must be one of {0},Ostavite odobritelj mora biti jedan od {0}
+Leave blank if considered for all branches,Ostavite prazno ako smatra za sve grane
+Leave blank if considered for all departments,Ostavite prazno ako smatra za sve odjele
+Leave blank if considered for all designations,Ostavite prazno ako smatra za sve oznake
+Leave blank if considered for all employee types,Ostavite prazno ako smatra za sve tipove zaposlenika
+"Leave can be approved by users with Role, ""Leave Approver""","Ostavite može biti odobren od strane korisnika s uloge, &quot;Ostavite odobravatelju&quot;"
+Leave of type {0} cannot be longer than {1},Ostavite tipa {0} ne može biti duži od {1}
+Leaves Allocated Successfully for {0},Lišće Dodijeljeni uspješno za {0}
+Leaves for type {0} already allocated for Employee {1} for Fiscal Year {0},Ostavlja za vrstu {0} već dodijeljeno za zaposlenika {1} za fiskalnu godinu {0}
+Leaves must be allocated in multiples of 0.5,"Listovi moraju biti dodijeljeno u COMBI 0,5"
+Ledger,Glavna knjiga
+Ledgers,knjige
+Left,Lijevo
+Legal,pravni
+Legal Expenses,pravne Troškovi
+Letter Head,Pismo Head
+Letter Heads for print templates.,Pismo glave za ispis predložaka .
+Level,Nivo
+Lft,LFT
+Liability,odgovornost
+List a few of your customers. They could be organizations or individuals.,Naveditenekoliko svojih kupaca . Oni mogu biti organizacije ili pojedinci .
+List a few of your suppliers. They could be organizations or individuals.,Naveditenekoliko svojih dobavljača . Oni mogu biti organizacije ili pojedinci .
+List items that form the package.,Popis stavki koje čine paket.
+List this Item in multiple groups on the website.,Popis ovaj predmet u više grupa na web stranici.
+"List your products or services that you buy or sell. Make sure to check the Item Group, Unit of Measure and other properties when you start.",Popis svoje proizvode ili usluge koje kupuju ili prodaju .
+"List your tax heads (e.g. VAT, Excise; they should have unique names) and their standard rates. This will create a standard template, which you can edit and add more later.","Popis svoje porezne glave ( npr. PDV , trošarine , oni bi trebali imati jedinstvene nazive ) i njihove standardne stope ."
+Loading...,Loading ...
+Loans (Liabilities),Zajmovi ( pasiva)
+Loans and Advances (Assets),Zajmovi i predujmovi ( aktiva )
+Local,mjesni
+Login,prijava
+Login with your new User ID,Prijavite se s novim User ID
+Logo,Logo
+Logo and Letter Heads,Logo i pismo glave
+Lost,izgubljen
+Lost Reason,Izgubili Razlog
+Low,Nisko
+Lower Income,Donja Prihodi
+MTN Details,MTN Detalji
+Main,glavni
+Main Reports,Glavni Izvješća
+Maintain Same Rate Throughout Sales Cycle,Održavati ista stopa Tijekom cijele prodajni ciklus
+Maintain same rate throughout purchase cycle,Održavanje istu stopu tijekom kupnje ciklusa
+Maintenance,Održavanje
+Maintenance Date,Održavanje Datum
+Maintenance Details,Održavanje Detalji
+Maintenance Schedule,Održavanje Raspored
+Maintenance Schedule Detail,Održavanje Raspored Detalj
+Maintenance Schedule Item,Održavanje Raspored predmeta
+Maintenance Schedule is not generated for all the items. Please click on 'Generate Schedule',"Raspored održavanja ne stvara za sve stavke . Molimo kliknite na ""Generiraj raspored '"
+Maintenance Schedule {0} exists against {0},Raspored održavanja {0} postoji od {0}
+Maintenance Schedule {0} must be cancelled before cancelling this Sales Order,Raspored održavanja {0} mora biti otkazana prije poništenja ovu prodajnog naloga
+Maintenance Schedules,Održavanje Raspored
+Maintenance Status,Održavanje statusa
+Maintenance Time,Održavanje Vrijeme
+Maintenance Type,Održavanje Tip
+Maintenance Visit,Održavanje Posjetite
+Maintenance Visit Purpose,Održavanje Posjetite Namjena
+Maintenance Visit {0} must be cancelled before cancelling this Sales Order,Održavanje Posjetite {0} mora biti otkazana prije poništenja ovu prodajnog naloga
+Maintenance start date can not be before delivery date for Serial No {0},Održavanje datum početka ne može biti prije datuma isporuke za rednim brojem {0}
+Major/Optional Subjects,Glavni / Izborni predmeti
+Make ,Make 
+Make Accounting Entry For Every Stock Movement,Provjerite knjiženje za svaki burzi pokreta
+Make Bank Voucher,Napravite Bank bon
+Make Credit Note,Provjerite Credit Note
+Make Debit Note,Provjerite terećenju
+Make Delivery,bi isporuka
+Make Difference Entry,Čine razliku Entry
+Make Excise Invoice,Provjerite trošarinske fakturu
+Make Installation Note,Provjerite Installation napomenu
+Make Invoice,Napravite fakturu
+Make Maint. Schedule,Napravite Maint . raspored
+Make Maint. Visit,Napravite Maint . posjet
+Make Maintenance Visit,Provjerite održavanja Posjetite
+Make Packing Slip,Napravite popis zapakiranih
+Make Payment,Uplati
+Make Payment Entry,Napravite unos Plaćanje
+Make Purchase Invoice,Napravite kupnje proizvoda
+Make Purchase Order,Provjerite narudžbenice
+Make Purchase Receipt,Napravite Račun kupnje
+Make Salary Slip,Provjerite plaće slip
+Make Salary Structure,Provjerite Plaća Struktura
+Make Sales Invoice,Ostvariti prodaju fakturu
+Make Sales Order,Provjerite prodajnog naloga
+Make Supplier Quotation,Provjerite Supplier kotaciji
+Make Time Log Batch,Nađite vremena Prijavite Hrpa
+Male,Muški
+Manage Customer Group Tree.,Upravljanje grupi kupaca stablo .
+Manage Sales Partners.,Upravljanje prodajnih partnera.
+Manage Sales Person Tree.,Upravljanje prodavač stablo .
+Manage Territory Tree.,Upravljanje teritorij stablo .
+Manage cost of operations,Upravljanje troškove poslovanja
+Management,upravljanje
+Manager,menadžer
+"Mandatory if Stock Item is ""Yes"". Also the default warehouse where reserved quantity is set from Sales Order.",Obvezni ako Stock Stavka je &quot;Da&quot;. Također zadano skladište gdje je zadržana količina se postaviti od prodajnog naloga.
+Manufacture against Sales Order,Proizvodnja protiv prodaje Reda
+Manufacture/Repack,Proizvodnja / Ponovno pakiranje
+Manufactured Qty,Proizvedeno Kol
+Manufactured quantity will be updated in this warehouse,Proizvedeno količina će biti ažurirana u ovom skladištu
+Manufactured quantity {0} cannot be greater than planned quanitity {1} in Production Order {2},Proizvedeno Količina {0} ne može biti veći od planiranog quanitity {1} u proizvodnom nalogu {2}
+Manufacturer,Proizvođač
+Manufacturer Part Number,Proizvođač Broj dijela
+Manufacturing,Proizvodnja
+Manufacturing Quantity,Proizvodnja Količina
+Manufacturing Quantity is mandatory,Proizvodnja Količina je obvezno
+Margin,Marža
+Marital Status,Bračni status
+Market Segment,Tržišni segment
+Marketing,marketing
+Marketing Expenses,Troškovi marketinga
+Married,Oženjen
+Mass Mailing,Misa mailing
+Master Name,Učitelj Ime
+Master Name is mandatory if account type is Warehouse,Master Ime je obavezno ako je vrsta račun Skladište
+Master Type,Majstor Tip
+Masters,Majstori
+Match non-linked Invoices and Payments.,Klađenje na ne-povezane faktura i plaćanja.
+Material Issue,Materijal Issue
+Material Receipt,Materijal Potvrda
+Material Request,Materijal zahtjev
+Material Request Detail No,Materijal Zahtjev Detalj Ne
+Material Request For Warehouse,Materijal Zahtjev za galeriju
+Material Request Item,Materijal Zahtjev artikla
+Material Request Items,Materijalni Zahtjev Proizvodi
+Material Request No,Materijal Zahtjev Ne
+Material Request Type,Materijal Zahtjev Tip
+Material Request of maximum {0} can be made for Item {1} against Sales Order {2},Materijal Zahtjev maksimalno {0} može biti za točku {1} od prodajnog naloga {2}
+Material Request used to make this Stock Entry,Materijal Zahtjev se koristi da bi se ova Stock unos
+Material Request {0} is cancelled or stopped,Materijal Zahtjev {0} je otkazan ili zaustavljen
+Material Requests for which Supplier Quotations are not created,Materijalni Zahtjevi za koje Supplier Citati nisu stvorene
+Material Requests {0} created,Materijalni Zahtjevi {0} stvorio
+Material Requirement,Materijal Zahtjev
+Material Transfer,Materijal transfera
+Materials,Materijali
+Materials Required (Exploded),Materijali Obavezno (eksplodirala)
+Max 5 characters,Max 5 znakova
+Max Days Leave Allowed,Max Dani Ostavite dopuštenih
+Max Discount (%),Maks Popust (%)
+Max Qty,Max Kol
+Max discount allowed for item: {0} is {1}%,Maksimalni popust dopušteno za predmet: {0} je {1}%
+Maximum Amount,Maksimalni iznos
+Maximum allowed credit is {0} days after posting date,Najveća dopuštena kredit je {0} dana nakon objavljivanja datuma
+Maximum {0} rows allowed,Maksimalne {0} redovi dopušteno
+Maxiumm discount for Item {0} is {1}%,Maxiumm popusta za točke {0} je {1} %
+Medical,liječnički
+Medium,Srednji
+"Merging is only possible if following properties are same in both records. Group or Ledger, Root Type, Company",Spajanje je moguće samo ako sljedeća svojstva su jednaka u obje evidencije .
+Message,Poruka
+Message Parameter,Poruka parametra
+Message Sent,Poruka je poslana
+Message updated,Poruka izmijenjena
+Messages,Poruke
+Messages greater than 160 characters will be split into multiple messages,Poruka veća od 160 karaktera će biti split u više mesage
+Middle Income,Srednji Prihodi
+Milestone,Prekretnica
+Milestone Date,Prekretnica Datum
+Milestones,Dostignuća
+Milestones will be added as Events in the Calendar,Dostignuća će biti dodan kao Događanja u kalendaru
+Min Order Qty,Min Red Kol
+Min Qty,min Kol
+Min Qty can not be greater than Max Qty,Min Kol ne može biti veći od Max Kol
+Minimum Amount,Minimalni iznos
+Minimum Order Qty,Minimalna narudžba Količina
+Minute,minuta
+Misc Details,Razni podaci
+Miscellaneous Expenses,Razni troškovi
+Miscelleneous,Miscelleneous
+Mobile No,Mobitel Nema
+Mobile No.,Mobitel broj
+Mode of Payment,Način plaćanja
+Modern,Moderna
+Monday,Ponedjeljak
+Month,Mjesec
+Monthly,Mjesečno
+Monthly Attendance Sheet,Mjesečna posjećenost list
+Monthly Earning & Deduction,Mjesečna zarada &amp; Odbitak
+Monthly Salary Register,Mjesečna plaća Registracija
+Monthly salary statement.,Mjesečna plaća izjava.
+More Details,Više pojedinosti
+More Info,Više informacija
+Motion Picture & Video,Motion Picture & Video
+Moving Average,Moving Average
+Moving Average Rate,Premještanje prosječna stopa
+Mr,G.
+Ms,Gospođa
+Multiple Item prices.,Više cijene stavke.
+"Multiple Price Rule exists with same criteria, please resolve \			conflict by assigning priority. Price Rules: {0}","Višestruki Cijena Pravilo postoji sa istim kriterijima, molimo riješiti \ Sukob dodjeljivanjem prioritet. Cijena pravila: {0}"
+Music,glazba
+Must be Whole Number,Mora biti cijeli broj
+Name,Ime
+Name and Description,Ime i opis
+Name and Employee ID,Ime i ID zaposlenika
+"Name of new Account. Note: Please don't create accounts for Customers and Suppliers, they are created automatically from the Customer and Supplier master","Ime novog računa. Napomena: Molimo Vas da ne stvarate račune za kupce i dobavljače, oni se automatski stvaraju od postojećih klijenata i dobavljača"
+Name of person or organization that this address belongs to.,Ime osobe ili organizacije kojoj ova adresa pripada.
+Name of the Budget Distribution,Ime distribucije proračuna
+Naming Series,Imenovanje serije
+Negative Quantity is not allowed,Negativna količina nije dopuštena
+Negative Stock Error ({6}) for Item {0} in Warehouse {1} on {2} {3} in {4} {5},Negativna Stock Error ( {6} ) za točke {0} u skladište {1} na {2} {3} u {4} {5}
+Negative Valuation Rate is not allowed,Negativna stopa vrijednovanja nije dopuštena
+Negative balance in Batch {0} for Item {1} at Warehouse {2} on {3} {4},Negativna bilanca u batch {0} za artikl {1} na skladište {2} na {3} {4}
+Net Pay,Neto plaća
+Net Pay (in words) will be visible once you save the Salary Slip.,Neto plaća (riječima) će biti vidljiva nakon što spremite klizne plaće.
+Net Profit / Loss,Neto dobit / gubitak
+Net Total,Osnovica
+Net Total (Company Currency),Neto Ukupno (Društvo valuta)
+Net Weight,Neto težina
+Net Weight UOM,Težina mjerna jedinica
+Net Weight of each Item,Težina svakog artikla
+Net pay cannot be negative,Neto plaća ne može biti negativna
+Never,Nikad
+New ,Novi
+New Account,Novi račun
+New Account Name,Naziv novog računa
+New BOM,Novi BOM
+New Communications,Novi komunikacije
+New Company,Nova tvrtka
+New Cost Center,Novi trošak
+New Cost Center Name,Novi troška Naziv
+New Delivery Notes,Nove otpremnice
+New Enquiries,Novi upiti
+New Leads,Novi potencijalni kupci
+New Leave Application,Novi dopust Primjena
+New Leaves Allocated,Novi Leaves Dodijeljeni
+New Leaves Allocated (In Days),Novi Lišće alociran (u danima)
+New Material Requests,Novi materijal Zahtjevi
+New Projects,Novi projekti
+New Purchase Orders,Novi narudžbenice kupnje
+New Purchase Receipts,Novi primke kupnje
+New Quotations,Nove ponude
+New Sales Orders,Nove narudžbenice
+New Serial No cannot have Warehouse. Warehouse must be set by Stock Entry or Purchase Receipt,Novi serijski broj ne može imati skladište. Skladište mora biti postavljen od strane burze upisu ili kupiti primitka
+New Stock Entries,Novi Stock upisi
+New Stock UOM,Novi kataloški UOM
+New Stock UOM is required,Novi Stock UOM je potrebno
+New Stock UOM must be different from current stock UOM,Novi Stock UOM mora biti različita od trenutne zalihe UOM
+New Supplier Quotations,Novi dobavljač Citati
+New Support Tickets,Novi Podrška Ulaznice
+New UOM must NOT be of type Whole Number,Novi UOM ne mora biti tipa cijeli broj
+New Workplace,Novi radnom mjestu
+Newsletter,Bilten
+Newsletter Content,Newsletter Sadržaj
+Newsletter Status,Newsletter Status
+Newsletter has already been sent,Newsletter je već poslana
+"Newsletters to contacts, leads.","Brošure za kontakte, vodi."
+Newspaper Publishers,novinski izdavači
+Next,sljedeći
+Next Contact By,Sljedeća Kontakt Do
+Next Contact Date,Sljedeća Kontakt Datum
+Next Date,Sljedeća Datum
+Next email will be sent on:,Sljedeća e-mail će biti poslan na:
+No,Ne
+No Customer Accounts found.,Nema kupaca Računi pronađena .
+No Customer or Supplier Accounts found,Nema kupaca i dobavljača Računi naći
+No Expense Approvers. Please assign 'Expense Approver' Role to atleast one user,Nema Rashodi approvers . Molimo dodijeliti ' Rashodi odobravatelju ' Uloga da atleast jednom korisniku
+No Item with Barcode {0},No Stavka s Barcode {0}
+No Item with Serial No {0},No Stavka s rednim brojem {0}
+No Items to pack,Nema stavki za omot
+No Leave Approvers. Please assign 'Leave Approver' Role to atleast one user,Nema dopusta approvers . Molimo dodijeliti ' ostavite odobravatelju ' Uloga da atleast jednom korisniku
+No Permission,Bez dozvole
+No Production Orders created,Nema Radni nalozi stvoreni
+No Supplier Accounts found. Supplier Accounts are identified based on 'Master Type' value in account record.,"Nema Supplier Računi pronađena . Supplier Računi su identificirani na temelju ' Master vrstu "" vrijednosti u računu rekord ."
+No accounting entries for the following warehouses,Nema računovodstvene unosi za sljedeće skladišta
+No addresses created,Nema adrese stvoreni
+No contacts created,Nema kontakata stvoreni
+No default Address Template found. Please create a new one from Setup > Printing and Branding > Address Template.,Ne zadana adresa Predložak pronađena. Molimo stvoriti novu s Setup> Tisak i Branding> adresu predložak.
+No default BOM exists for Item {0},Ne default BOM postoji točke {0}
+No description given,Nema opisa dano
+No employee found,Niti jedan zaposlenik pronađena
+No employee found!,Niti jedan zaposlenik našao !
+No of Requested SMS,Nema traženih SMS
+No of Sent SMS,Ne poslanih SMS
+No of Visits,Bez pregleda
+No permission,nema dozvole
+No record found,Ne rekord naći
+No records found in the Invoice table,Nisu pronađeni u tablici fakturu
+No records found in the Payment table,Nisu pronađeni u tablici plaćanja
+No salary slip found for month: ,Bez plaće slip naći za mjesec dana:
+Non Profit,Neprofitne
+Nos,Nos
+Not Active,Ne aktivna
+Not Applicable,Nije primjenjivo
+Not Available,nije dostupno
+Not Billed,Ne Naplaćeno
+Not Delivered,Ne Isporučeno
+Not Set,ne Set
+Not allowed to update stock transactions older than {0},Nije dopušteno osvježavanje burzovnih transakcija stariji od {0}
+Not authorized to edit frozen Account {0},Nije ovlašten za uređivanje smrznute račun {0}
+Not authroized since {0} exceeds limits,Ne authroized od {0} prelazi granice
+Not permitted,nije dopušteno
+Note,Primijetiti
+Note User,Napomena Upute
+"Note: Backups and files are not deleted from Dropbox, you will have to delete them manually.","Napomena: Backup i datoteke se ne brišu na Dropbox, morat ćete ih izbrisati ručno."
+"Note: Backups and files are not deleted from Google Drive, you will have to delete them manually.","Napomena: Backup i datoteke se ne brišu na Google Drive, morat ćete ih izbrisati ručno."
+Note: Due Date exceeds the allowed credit days by {0} day(s),Napomena : Zbog Datum prelazi dopuštene kreditne dane od strane {0} dan (a)
+Note: Email will not be sent to disabled users,Napomena: E-mail neće biti poslan invalide
+Note: Item {0} entered multiple times,Napomena : Stavka {0} upisan je više puta
+Note: Payment Entry will not be created since 'Cash or Bank Account' was not specified,Napomena : Stupanje Plaćanje neće biti izrađen od ' Gotovina ili bankovni račun ' nije naveden
+Note: System will not check over-delivery and over-booking for Item {0} as quantity or amount is 0,Napomena : Sustav neće provjeravati pretjerano isporuke i više - booking za točku {0} kao količinu ili vrijednost je 0
+Note: There is not enough leave balance for Leave Type {0},Napomena : Nema dovoljno ravnotežu dopust za dozvolu tipa {0}
+Note: This Cost Center is a Group. Cannot make accounting entries against groups.,Napomena : Ovaj troška jegrupa . Ne mogu napraviti računovodstvenih unosa protiv skupine .
+Note: {0},Napomena : {0}
+Notes,Bilješke
+Notes:,Bilješke :
+Nothing to request,Ništa se zatražiti
+Notice (days),Obavijest (dani )
+Notification Control,Obavijest kontrola
+Notification Email Address,Obavijest E-mail adresa
+Notify by Email on creation of automatic Material Request,Obavijesti putem e-pošte na stvaranje automatskog Materijal Zahtjeva
+Number Format,Broj Format
+Offer Date,ponuda Datum
+Office,Ured
+Office Equipments,uredske opreme
+Office Maintenance Expenses,Troškovi održavanja ureda
+Office Rent,najam ureda
+Old Parent,Stari Roditelj
+On Net Total,Na Net Total
+On Previous Row Amount,Na prethodnu Row visini
+On Previous Row Total,Na prethodni redak Ukupno
+Online Auctions,online aukcije
+Only Leave Applications with status 'Approved' can be submitted,"Ostavite samo one prijave sa statusom "" Odobreno"" može se podnijeti"
+"Only Serial Nos with status ""Available"" can be delivered.","Samo Serial Nos sa statusom "" dostupan "" može biti isporučena ."
+Only leaf nodes are allowed in transaction,Samo leaf čvorovi su dozvoljeni u transakciji
+Only the selected Leave Approver can submit this Leave Application,Samoodabrani Ostavite Odobritelj može podnijeti ovo ostaviti aplikacija
+Open,Otvoreno
+Open Production Orders,Otvoren Radni nalozi
+Open Tickets,Otvoreni Ulaznice
+Opening (Cr),Otvaranje ( Cr )
+Opening (Dr),Otvaranje ( DR)
+Opening Date,Otvaranje Datum
+Opening Entry,Otvaranje unos
+Opening Qty,Otvaranje Kol
+Opening Time,Radno vrijeme
+Opening Value,Otvaranje vrijednost
+Opening for a Job.,Otvaranje za posao.
+Operating Cost,Operativni troškovi
+Operation Description,Operacija Opis
+Operation No,Operacija Ne
+Operation Time (mins),Operacija Vrijeme (min)
+Operation {0} is repeated in Operations Table,Operacija {0} se ponavlja u operacijama tablici
+Operation {0} not present in Operations Table,Operacija {0} nije prisutan u operacijama tablici
+Operations,Operacije
+Opportunity,Prilika
+Opportunity Date,Prilika Datum
+Opportunity From,Prilika Od
+Opportunity Item,Prilika artikla
+Opportunity Items,Prilika Proizvodi
+Opportunity Lost,Prilika Izgubili
+Opportunity Type,Prilika Tip
+Optional. This setting will be used to filter in various transactions.,Izborni . Ova postavka će se koristiti za filtriranje u raznim transakcijama .
+Order Type,Vrsta narudžbe
+Order Type must be one of {0},Vrsta narudžbe mora biti jedan od {0}
+Ordered,A do Ž
+Ordered Items To Be Billed,Naručeni Stavke biti naplaćeno
+Ordered Items To Be Delivered,Naručeni Proizvodi se dostavljaju
+Ordered Qty,naredio Kol
+"Ordered Qty: Quantity ordered for purchase, but not received.","Ž Kol : Količina naručiti za kupnju , ali nije dobila ."
+Ordered Quantity,Količina Ž
+Orders released for production.,Narudžbe objavljen za proizvodnju.
+Organization Name,Naziv organizacije
+Organization Profile,Organizacija Profil
+Organization branch master.,Organizacija grana majstor .
+Organization unit (department) master.,Organizacija jedinica ( odjela ) majstor .
+Other,Drugi
+Other Details,Ostali podaci
+Others,drugi
+Out Qty,Od kol
+Out Value,Od vrijednosti
+Out of AMC,Od AMC
+Out of Warranty,Od jamstvo
+Outgoing,Društven
+Outstanding Amount,Izvanredna Iznos
+Outstanding for {0} cannot be less than zero ({1}),Izvanredna za {0} ne može biti manji od nule ( {1} )
+Overhead,Dometnut
+Overheads,opći troškovi
+Overlapping conditions found between:,Preklapanje uvjeti nalaze između :
+Overview,pregled
+Owned,U vlasništvu
+Owner,vlasnik
+P L A - Cess Portion,PLA - Posebni porez porcija
+PL or BS,PL ili BS
+PO Date,PO Datum
+PO No,PO Nema
+POP3 Mail Server,POP3 Mail Server
+POP3 Mail Settings,POP3 Mail Postavke
+POP3 mail server (e.g. pop.gmail.com),POP3 mail server (npr. pop.gmail.com)
+POP3 server e.g. (pop.gmail.com),POP3 poslužitelj npr. (pop.gmail.com)
+POS Setting,POS Podešavanje
+POS Setting required to make POS Entry,POS postavke potrebne da bi POS stupanja
+POS Setting {0} already created for user: {1} and company {2},POS Setting {0} već stvorena za korisnika : {1} i tvrtka {2}
+POS View,POS Pogledaj
+PR Detail,PR Detalj
+Package Item Details,Paket Stavka Detalji
+Package Items,Paket Proizvodi
+Package Weight Details,Težina paketa - detalji
+Packed Item,Dostava Napomena Pakiranje artikla
+Packed quantity must equal quantity for Item {0} in row {1},Prepuna količina mora biti jednaka količina za točku {0} je u redu {1}
+Packing Details,Detalji pakiranja
+Packing List,Popis pakiranja
+Packing Slip,Odreskom
+Packing Slip Item,Odreskom predmet
+Packing Slip Items,Odreskom artikle
+Packing Slip(s) cancelled,Pakiranje proklizavanja ( s) otkazan
+Page Break,Prijelom stranice
+Page Name,Ime stranice
+Paid Amount,Plaćeni iznos
+Paid amount + Write Off Amount can not be greater than Grand Total,Uplaćeni iznos + otpis iznos ne može biti veći od SVEUKUPNO
+Pair,Par
+Parameter,Parametar
+Parent Account,Roditelj račun
+Parent Cost Center,Roditelj troška
+Parent Customer Group,Roditelj Kupac Grupa
+Parent Detail docname,Roditelj Detalj docname
+Parent Item,Roditelj artikla
+Parent Item Group,Roditelj artikla Grupa
+Parent Item {0} must be not Stock Item and must be a Sales Item,Parent Item {0} mora biti ne Stock točka i mora bitiProdaja artikla
+Parent Party Type,Matične stranke Tip
+Parent Sales Person,Roditelj Prodaja Osoba
+Parent Territory,Roditelj Regija
+Parent Website Page,Roditelj Web Stranica
+Parent Website Route,Roditelj Web Route
+Parenttype,Parenttype
+Part-time,Part - time
+Partially Completed,Djelomično Završeni
+Partly Billed,Djelomično Naplaćeno
+Partly Delivered,Djelomično Isporučeno
+Partner Target Detail,Partner Ciljana Detalj
+Partner Type,Partner Tip
+Partner's Website,Web stranica partnera
+Party,Stranka
+Party Account,Party račun
+Party Type,Party Tip
+Party Type Name,Party Vrsta Naziv
+Passive,Pasiva
+Passport Number,Putovnica Broj
+Password,Zaporka
+Pay To / Recd From,Platiti Da / RecD Od
+Payable,Plativ
+Payables,Obveze
+Payables Group,Obveze Grupa
+Payment Days,Plaćanja Dana
+Payment Due Date,Plaćanje Due Date
+Payment Period Based On Invoice Date,Razdoblje za naplatu po Datum fakture
+Payment Reconciliation,Pomirenje plaćanja
+Payment Reconciliation Invoice,Pomirenje Plaćanje fakture
+Payment Reconciliation Invoices,Pomirenje Plaćanje računa
+Payment Reconciliation Payment,Pomirenje Plaćanje Plaćanje
+Payment Reconciliation Payments,Pomirenje Plaćanje Plaćanja
+Payment Type,Vrsta plaćanja
+Payment cannot be made for empty cart,Plaćanje ne može biti za prazan košaricu
+Payment of salary for the month {0} and year {1},Isplata plaće za mjesec {0} i godina {1}
+Payments,Plaćanja
+Payments Made,Uplate Izrađen
+Payments Received,Uplate primljeni
+Payments made during the digest period,Plaćanja tijekom razdoblja digest
+Payments received during the digest period,Uplate primljene tijekom razdoblja digest
+Payroll Settings,Postavke plaće
+Pending,Čekanju
+Pending Amount,Iznos na čekanju
+Pending Items {0} updated,Tijeku stvari {0} ažurirana
+Pending Review,U tijeku pregled
+Pending SO Items For Purchase Request,Otvorena SO Proizvodi za zahtjev za kupnju
+Pension Funds,mirovinskim fondovima
+Percent Complete,Postotak Cijela
+Percentage Allocation,Postotak Raspodjela
+Percentage Allocation should be equal to 100%,Postotak izdvajanja trebala bi biti jednaka 100 %
+Percentage variation in quantity to be allowed while receiving or delivering this item.,Postotak varijacije u količini biti dopušteno dok prima ili isporuku ovu stavku.
+Percentage you are allowed to receive or deliver more against the quantity ordered. For example: If you have ordered 100 units. and your Allowance is 10% then you are allowed to receive 110 units.,Postotak koju smiju primiti ili isporučiti više od naručene količine. Na primjer: Ako ste naručili 100 jedinica. i tvoj ispravak je 10% onda se smiju primati 110 jedinica.
+Performance appraisal.,Ocjenjivanje.
+Period,razdoblje
+Period Closing Voucher,Razdoblje Zatvaranje bon
+Periodicity,Periodičnost
+Permanent Address,Stalna adresa
+Permanent Address Is,Stalna adresa je
+Permission,Dopuštenje
+Personal,Osobno
+Personal Details,Osobni podaci
+Personal Email,Osobni e
+Pharmaceutical,farmaceutski
+Pharmaceuticals,Lijekovi
+Phone,Telefon
+Phone No,Telefonski broj
+Piecework,rad plaćen na akord
+Pincode,Poštanski broj
+Place of Issue,Mjesto izdavanja
+Plan for maintenance visits.,Plan održavanja posjeta.
+Planned Qty,Planirani Kol
+"Planned Qty: Quantity, for which, Production Order has been raised, but is pending to be manufactured.","Planirano Količina : Količina , za koje , proizvodnja Red je podigao , ali je u tijeku kako bi se proizvoditi ."
+Planned Quantity,Planirana količina
+Planning,planiranje
+Plant,Biljka
+Plant and Machinery,Postrojenja i strojevi
+Please Enter Abbreviation or Short Name properly as it will be added as Suffix to all Account Heads.,Molimo unesite Skraćenica ili skraćeni naziv ispravno jer će biti dodan kao sufiks na sve računa šefova.
+Please Update SMS Settings,Obnovite SMS Settings
+Please add expense voucher details,Molimo dodati trošak bon pojedinosti
+Please add to Modes of Payment from Setup.,Molimo dodati načina plaćanja iz programa za postavljanje.
+Please check 'Is Advance' against Account {0} if this is an advance entry.,Molimo provjerite ' Je Advance ' protiv računu {0} ako je tounaprijed ulaz .
+Please click on 'Generate Schedule',"Molimo kliknite na ""Generiraj raspored '"
+Please click on 'Generate Schedule' to fetch Serial No added for Item {0},"Molimo kliknite na ""Generiraj raspored ' dohvatiti Serial No dodao je za točku {0}"
+Please click on 'Generate Schedule' to get schedule,"Molimo kliknite na ""Generiraj raspored ' kako bi dobili raspored"
+Please create Customer from Lead {0},Molimo stvoriti kupac iz Olovo {0}
+Please create Salary Structure for employee {0},Molimo stvoriti Plaća Struktura za zaposlenika {0}
+Please create new account from Chart of Accounts.,Molimo stvoriti novi račun iz kontnog plana .
+Please do NOT create Account (Ledgers) for Customers and Suppliers. They are created directly from the Customer / Supplier masters.,Molimo vas da ne stvaraju račun ( knjigama ) za kupce i dobavljače . Oni su stvorili izravno iz Kupac / Dobavljač majstora .
+Please enter 'Expected Delivery Date',Unesite ' Očekivani datum isporuke '
+Please enter 'Is Subcontracted' as Yes or No,Unesite ' Je podugovoren ' kao da ili ne
+Please enter 'Repeat on Day of Month' field value,Unesite ' ponovite na dan u mjesecu ' na terenu vrijednosti
+Please enter Account Receivable/Payable group in company master,Unesite račun potraživanja / naplativo skupinu u društvu gospodara
+Please enter Approving Role or Approving User,Unesite Odobravanje ulogu ili Odobravanje korisnike
+Please enter BOM for Item {0} at row {1},Unesite BOM za točku {0} na redu {1}
+Please enter Company,Unesite tvrtke
+Please enter Cost Center,Unesite troška
+Please enter Delivery Note No or Sales Invoice No to proceed,Unesite otpremnica br ili prodaja Račun br postupiti
+Please enter Employee Id of this sales parson,Unesite Id zaposlenika ovog prodajnog župnika
+Please enter Expense Account,Unesite trošak računa
+Please enter Item Code to get batch no,Unesite kod Predmeta da se hrpa nema
+Please enter Item Code.,Unesite kod artikal .
+Please enter Item first,Unesite predmeta prvi
+Please enter Maintaince Details first,Unesite prva Maintaince Detalji
+Please enter Master Name once the account is created.,Unesite Master ime jednomračunu je stvorio .
+Please enter Planned Qty for Item {0} at row {1},Unesite Planirano Qty za točku {0} na redu {1}
+Please enter Production Item first,Unesite Proizvodnja predmeta prvi
+Please enter Purchase Receipt No to proceed,Unesite kupiti primitka No za nastavak
+Please enter Reference date,Unesite Referentni datum
+Please enter Warehouse for which Material Request will be raised,Unesite skladište za koje Materijal Zahtjev će biti podignuta
+Please enter Write Off Account,Unesite otpis račun
+Please enter atleast 1 invoice in the table,Unesite atleast jedan račun u tablici
+Please enter company first,Unesite tvrtka prva
+Please enter company name first,Unesite ime tvrtke prvi
+Please enter default Unit of Measure,Unesite zadanu jedinicu mjere
+Please enter default currency in Company Master,Unesite zadanu valutu u tvrtki Master
+Please enter email address,Molimo unesite e-mail adresu
+Please enter item details,Unesite Detalji
+Please enter message before sending,Unesite poruku prije slanja
+Please enter parent account group for warehouse account,Unesite skupinu roditeljskog računa za skladišta obzir
+Please enter parent cost center,Unesite roditelj troška
+Please enter quantity for Item {0},Molimo unesite količinu za točku {0}
+Please enter relieving date.,Unesite olakšavanja datum .
+Please enter sales order in the above table,Unesite prodajnog naloga u gornjoj tablici
+Please enter valid Company Email,Unesite ispravnu tvrtke E-mail
+Please enter valid Email Id,Unesite ispravnu e-mail ID
+Please enter valid Personal Email,Unesite važeću osobnu e-mail
+Please enter valid mobile nos,Unesite valjane mobilne br
+Please find attached Sales Invoice #{0},U prilogu Prodaja Račun # {0}
+Please install dropbox python module,Molimo instalirajte Dropbox piton modul
+Please mention no of visits required,Molimo spomenuti nema posjeta potrebnih
+Please pull items from Delivery Note,Molimo povucite stavke iz Dostavnica
+Please save the Newsletter before sending,Molimo spremite Newsletter prije slanja
+Please save the document before generating maintenance schedule,Molimo spremite dokument prije stvaranja raspored za održavanje
+Please see attachment,Pogledajte prilog
+Please select Bank Account,Odaberite bankovni račun
+Please select Carry Forward if you also want to include previous fiscal year's balance leaves to this fiscal year,Molimo odaberite prenositi ako želite uključiti prethodnoj fiskalnoj godini je ravnoteža ostavlja na ovoj fiskalnoj godini
+Please select Category first,Molimo odaberite kategoriju prvi
+Please select Charge Type first,Odaberite Naknada za prvi
+Please select Fiscal Year,Odaberite Fiskalna godina
+Please select Group or Ledger value,Odaberite vrijednost grupi ili Ledger
+Please select Incharge Person's name,Odaberite incharge ime osobe
+Please select Invoice Type and Invoice Number in atleast one row,Odaberite fakture Vid i broj računa u atleast jednom redu
+"Please select Item where ""Is Stock Item"" is ""No"" and ""Is Sales Item"" is ""Yes"" and there is no other Sales BOM","Odaberite stavku u kojoj "" Je Stock Stavka "" je ""ne "" i "" Je Prodaja Stavka "" je "" Da "" i ne postoji drugi Prodaja BOM"
+Please select Price List,Molimo odaberite Cjenik
+Please select Start Date and End Date for Item {0},Molimo odaberite datum početka i datum završetka za točke {0}
+Please select Time Logs.,Odaberite vrijeme Evidencije.
+Please select a csv file,Odaberite CSV datoteku
+Please select a valid csv file with data,Odaberite valjanu CSV datoteku s podacima
+Please select a value for {0} quotation_to {1},Molimo odabir vrijednosti za {0} quotation_to {1}
+"Please select an ""Image"" first","Molimo odaberite ""Slika"" Prvi"
+Please select charge type first,Odaberite vrstu naboja prvi
+Please select company first,Odaberite tvrtku prvi
+Please select company first.,Odaberite tvrtku prvi.
+Please select item code,Odaberite Šifra
+Please select month and year,Molimo odaberite mjesec i godinu
+Please select prefix first,Odaberite prefiks prvi
+Please select the document type first,Molimo odaberite vrstu dokumenta prvi
+Please select weekly off day,Odaberite tjednik off dan
+Please select {0},Odaberite {0}
+Please select {0} first,Odaberite {0} Prvi
+Please select {0} first.,Odaberite {0} na prvom mjestu.
+Please set Dropbox access keys in your site config,Molimo postaviti Dropbox pristupnih tipki u vašem web config
+Please set Google Drive access keys in {0},Molimo postaviti Google Drive pristupnih tipki u {0}
+Please set default Cash or Bank account in Mode of Payment {0},Molimo postavite zadanu gotovinom ili banka računa u načinu plaćanja {0}
+Please set default value {0} in Company {0},Molimo postavite zadanu vrijednost {0} u Društvu {0}
+Please set {0},Molimo postavite {0}
+Please setup Employee Naming System in Human Resource > HR Settings,Molimo postavljanje zaposlenika sustav imenovanja u ljudskim resursima&gt; HR Postavke
+Please setup numbering series for Attendance via Setup > Numbering Series,Molimo postava numeriranje serija za sudjelovanje putem Podešavanje> numeriranja serije
+Please setup your chart of accounts before you start Accounting Entries,Molim postaviti svoj kontni plan prije nego što počnete računovodstvenih unosa
+Please specify,Navedite
+Please specify Company,Navedite tvrtke
+Please specify Company to proceed,Navedite Tvrtka postupiti
+Please specify Default Currency in Company Master and Global Defaults,Navedite zadanu valutu u tvrtki Global Master i zadane
+Please specify a,Navedite
+Please specify a valid 'From Case No.',Navedite važeću &#39;iz Predmet br&#39;
+Please specify a valid Row ID for {0} in row {1},Navedite valjanu Row ID za {0} je u redu {1}
+Please specify either Quantity or Valuation Rate or both,Navedite ili količini ili vrednovanja Ocijenite ili oboje
+Please submit to update Leave Balance.,Molimo dostaviti ažurirati napuste balans .
+Plot,zemljište
+Plot By,zemljište By
+Point of Sale,Point of Sale
+Point-of-Sale Setting,Point-of-Sale Podešavanje
+Post Graduate,Post diplomski
+Postal,Poštanski
+Postal Expenses,Poštanski troškovi
+Posting Date,Objavljivanje Datum
+Posting Time,Objavljivanje Vrijeme
+Posting date and posting time is mandatory,Datum knjiženja i knjiženje vrijeme je obvezna
+Posting timestamp must be after {0},Objavljivanje timestamp mora biti poslije {0}
+Potential opportunities for selling.,Potencijalni mogućnosti za prodaju.
+Preferred Billing Address,Željena adresa za naplatu
+Preferred Shipping Address,Željena Dostava Adresa
+Prefix,Prefiks
+Present,Sadašnje
+Prevdoc DocType,Prevdoc DOCTYPE
+Prevdoc Doctype,Prevdoc DOCTYPE
+Preview,Pregled
+Previous,prijašnji
+Previous Work Experience,Radnog iskustva
+Price,Cijena
+Price / Discount,Cijena / Popust
+Price List,Cjenik
+Price List Currency,Cjenik valuta
+Price List Currency not selected,Cjenik valuta ne bira
+Price List Exchange Rate,Cjenik tečajna
+Price List Name,Cjenik Ime
+Price List Rate,Cjenik Stopa
+Price List Rate (Company Currency),Cjenik stopa (Društvo valuta)
+Price List master.,Cjenik majstor .
+Price List must be applicable for Buying or Selling,Cjenik mora biti primjenjiv za kupnju ili prodaju
+Price List not selected,Popis Cijena ne bira
+Price List {0} is disabled,Cjenik {0} je onemogućen
+Price or Discount,Cijena i popust
+Pricing Rule,cijene Pravilo
+Pricing Rule Help,Cijene Pravilo Pomoć
+"Pricing Rule is first selected based on 'Apply On' field, which can be Item, Item Group or Brand.","Cijene Pravilo prvo se bira na temelju 'Nanesite na' terenu, koji može biti točka, točka Grupa ili Brand."
+"Pricing Rule is made to overwrite Price List / define discount percentage, based on some criteria.","Cijene Pravilo je napravljen prebrisati Cjenik / definirati postotak popusta, na temelju nekih kriterija."
+Pricing Rules are further filtered based on quantity.,Pravilnik o određivanju cijena dodatno se filtrira na temelju količine.
+Print Format Style,Print Format Style
+Print Heading,Ispis Naslov
+Print Without Amount,Ispis Bez visini
+Print and Stationary,Ispis i stacionarnih
+Printing and Branding,Tiskanje i Branding
+Priority,Prioritet
+Private Equity,Private Equity
+Privilege Leave,Privilege dopust
+Probation,probni rad
+Process Payroll,Proces plaće
+Produced,izrađen
+Produced Quantity,Proizveden Količina
+Product Enquiry,Na upit
+Production,proizvodnja
+Production Order,Proizvodnja Red
+Production Order status is {0},Status radnog naloga je {0}
+Production Order {0} must be cancelled before cancelling this Sales Order,Proizvodnja Red {0} mora biti otkazana prije poništenja ovu prodajnog naloga
+Production Order {0} must be submitted,Proizvodnja Red {0} mora biti podnesen
+Production Orders,Nalozi
+Production Orders in Progress,Radni nalozi u tijeku
+Production Plan Item,Proizvodnja plan artikla
+Production Plan Items,Plan proizvodnje Proizvodi
+Production Plan Sales Order,Proizvodnja plan prodajnog naloga
+Production Plan Sales Orders,Plan proizvodnje narudžbe
+Production Planning Tool,Planiranje proizvodnje alat
+Products,Proizvodi
+"Products will be sorted by weight-age in default searches. More the weight-age, higher the product will appear in the list.","Proizvodi će biti razvrstani po težine dobi u zadane pretraživanja. Više težina-dob, veća proizvod će se pojaviti na popisu."
+Professional Tax,Stručni Porezni
+Profit and Loss,Račun dobiti i gubitka
+Profit and Loss Statement,Račun dobiti i gubitka
+Project,Projekt
+Project Costing,Projekt Costing
+Project Details,Projekt Detalji
+Project Manager,Voditelj projekta
+Project Milestone,Projekt Prekretnica
+Project Milestones,Projekt Dostignuća
+Project Name,Naziv projekta
+Project Start Date,Projekt datum početka
+Project Type,Vrsta projekta
+Project Value,Projekt Vrijednost
+Project activity / task.,Projekt aktivnost / zadatak.
+Project master.,Projekt majstor.
+Project will get saved and will be searchable with project name given,Projekt će biti spašen i da će se moći pretraživati ​​s projektom ime dano
+Project wise Stock Tracking,Projekt mudar Stock Praćenje
+Project-wise data is not available for Quotation,Projekt - mudar podaci nisu dostupni za ponudu
+Projected,projektiran
+Projected Qty,Predviđen Kol
+Projects,Projekti
+Projects & System,Projekti i sustav
+Prompt for Email on Submission of,Pitaj za e-poštu na podnošenje
+Proposal Writing,Pisanje prijedlog
+Provide email id registered in company,Osigurati e id registriran u tvrtki
+Provisional Profit / Loss (Credit),Privremeni dobit / gubitak (Credit)
+Public,Javni
+Published on website at: {0},Objavljeni na web stranici: {0}
+Publishing,objavljivanje
+Pull sales orders (pending to deliver) based on the above criteria,Povucite prodajne naloge (na čekanju za isporuku) na temelju navedenih kriterija
+Purchase,Kupiti
+Purchase / Manufacture Details,Kupnja / Proizvodnja Detalji
+Purchase Analytics,Kupnja Analytics
+Purchase Common,Kupnja Zajednička
+Purchase Details,Kupnja Detalji
+Purchase Discounts,Kupnja Popusti
+Purchase Invoice,Kupnja fakture
+Purchase Invoice Advance,Kupnja fakture Predujam
+Purchase Invoice Advances,Kupnja fakture Napredak
+Purchase Invoice Item,Kupnja fakture predmet
+Purchase Invoice Trends,Trendovi kupnje proizvoda
+Purchase Invoice {0} is already submitted,Kupnja Račun {0} već je podnijela
+Purchase Order,Narudžbenica
+Purchase Order Item,Narudžbenica predmet
+Purchase Order Item No,Narudžbenica Br.
+Purchase Order Item Supplied,Narudžbenica artikla Isporuka
+Purchase Order Items,Narudžbenica artikle
+Purchase Order Items Supplied,Narudžbenica Proizvodi Isporuka
+Purchase Order Items To Be Billed,Narudžbenica Proizvodi se naplaćuje
+Purchase Order Items To Be Received,Narudžbenica Proizvodi treba primiti
+Purchase Order Message,Narudžbenica poruku
+Purchase Order Required,Narudžbenica Obvezno
+Purchase Order Trends,Narudžbenica trendovi
+Purchase Order number required for Item {0},Broj narudžbenice potrebne za točku {0}
+Purchase Order {0} is 'Stopped',Narudžbenica {0} je ' Zaustavljen '
+Purchase Order {0} is not submitted,Narudžbenicu {0} nije podnesen
+Purchase Orders given to Suppliers.,Kupnja naloge koje je dao dobavljače.
+Purchase Receipt,Račun kupnje
+Purchase Receipt Item,Kupnja Potvrda predmet
+Purchase Receipt Item Supplied,Kupnja Prijem artikla Isporuka
+Purchase Receipt Item Supplieds,Kupnja Supplieds Stavka primitka
+Purchase Receipt Items,Kupnja primitka artikle
+Purchase Receipt Message,Kupnja Potvrda poruku
+Purchase Receipt No,Račun kupnje Ne
+Purchase Receipt Required,Kupnja Potvrda Obvezno
+Purchase Receipt Trends,Račun kupnje trendovi
+Purchase Receipt number required for Item {0},Račun kupnje broj potreban za točku {0}
+Purchase Receipt {0} is not submitted,Račun kupnje {0} nije podnesen
+Purchase Register,Kupnja Registracija
+Purchase Return,Kupnja Povratak
+Purchase Returned,Kupnja Vraćeno
+Purchase Taxes and Charges,Kupnja Porezi i naknade
+Purchase Taxes and Charges Master,Kupnja Porezi i naknade Master
+Purchse Order number required for Item {0},Broj Purchse Order potrebno za točke {0}
+Purpose,Svrha
+Purpose must be one of {0},Svrha mora biti jedan od {0}
+QA Inspection,QA Inspekcija
+Qty,Kol
+Qty Consumed Per Unit,Kol Potrošeno po jedinici
+Qty To Manufacture,Količina za proizvodnju
+Qty as per Stock UOM,Količina po burzi UOM
+Qty to Deliver,Količina za dovođenje
+Qty to Order,Količina za narudžbu
+Qty to Receive,Količina za primanje
+Qty to Transfer,Količina za prijenos
+Qualification,Kvalifikacija
+Quality,Kvaliteta
+Quality Inspection,Provjera kvalitete
+Quality Inspection Parameters,Inspekcija kvalitete Parametri
+Quality Inspection Reading,Kvaliteta Inspekcija čitanje
+Quality Inspection Readings,Inspekcija kvalitete Čitanja
+Quality Inspection required for Item {0},Provera kvaliteta potrebna za točke {0}
+Quality Management,upravljanja kvalitetom
+Quantity,Količina
+Quantity Requested for Purchase,Količina Traženi za kupnju
+Quantity and Rate,Količina i stopa
+Quantity and Warehouse,Količina i skladišta
+Quantity cannot be a fraction in row {0},Količina ne može bitidio u redu {0}
+Quantity for Item {0} must be less than {1},Količina za točku {0} mora biti manji od {1}
+Quantity in row {0} ({1}) must be same as manufactured quantity {2},Količina u redu {0} ( {1} ) mora biti isti kao proizvedena količina {2}
+Quantity of item obtained after manufacturing / repacking from given quantities of raw materials,Količina predmeta dobije nakon proizvodnju / pakiranje od navedenih količina sirovina
+Quantity required for Item {0} in row {1},Količina potrebna za točke {0} je u redu {1}
+Quarter,Četvrtina
+Quarterly,Tromjesečni
+Quick Help,Brza pomoć
+Quotation,Ponuda
+Quotation Item,Artikl iz ponude
+Quotation Items,Artikli iz ponude
+Quotation Lost Reason,Razlog nerealizirane ponude
+Quotation Message,Ponuda - poruka
+Quotation To,Ponuda za
+Quotation Trends,Trendovi ponude
+Quotation {0} is cancelled,Ponuda {0} je otkazana
+Quotation {0} not of type {1},Ponuda {0} nije tip {1}
+Quotations received from Suppliers.,Ponude dobivene od dobavljača.
+Quotes to Leads or Customers.,Citati na vodi ili kupaca.
+Raise Material Request when stock reaches re-order level,Podignite Materijal Zahtjev kad dionica dosegne ponovno poredak razinu
+Raised By,Povišena Do
+Raised By (Email),Povišena Do (e)
+Random,Slučajan
+Range,Domet
+Rate,VPC
+Rate ,Stopa
+Rate (%),Stopa ( % )
+Rate (Company Currency),Ocijeni (Društvo valuta)
+Rate Of Materials Based On,Stopa materijali na temelju
+Rate and Amount,Kamatna stopa i iznos
+Rate at which Customer Currency is converted to customer's base currency,Stopa po kojoj Kupac valuta se pretvaraju u kupca osnovne valute
+Rate at which Price list currency is converted to company's base currency,Stopa po kojoj Cjenik valute se pretvaraju u tvrtke bazne valute
+Rate at which Price list currency is converted to customer's base currency,Stopa po kojoj Cjenik valute se pretvaraju u kupca osnovne valute
+Rate at which customer's currency is converted to company's base currency,Stopa po kojoj se valuta klijenta se pretvaraju u tvrtke bazne valute
+Rate at which supplier's currency is converted to company's base currency,Stopa po kojoj supplier valuta se pretvaraju u tvrtke bazne valute
+Rate at which this tax is applied,Stopa po kojoj je taj porez se primjenjuje
+Raw Material,sirovine
+Raw Material Item Code,Sirovine Stavka Šifra
+Raw Materials Supplied,Sirovine nabavlja
+Raw Materials Supplied Cost,Sirovine Isporuka Troškovi
+Raw material cannot be same as main Item,Sirovina ne mogu biti isti kao glavni predmet
+Re-Order Level,Re-Order Razina
+Re-Order Qty,Re-Order Kol
+Re-order,Ponovno bi
+Re-order Level,Ponovno bi Razina
+Re-order Qty,Ponovno bi Kol
+Read,Čitati
+Reading 1,Čitanje 1
+Reading 10,Čitanje 10
+Reading 2,Čitanje 2
+Reading 3,Čitanje 3
+Reading 4,Čitanje 4
+Reading 5,Čitanje 5
+Reading 6,Čitanje 6
+Reading 7,Čitanje 7
+Reading 8,Čitanje 8
+Reading 9,Čitanje 9
+Real Estate,Nekretnine
+Reason,Razlog
+Reason for Leaving,Razlog za odlazak
+Reason for Resignation,Razlog za ostavku
+Reason for losing,Razlog za gubljenje
+Recd Quantity,RecD Količina
+Receivable,potraživanja
+Receivable / Payable account will be identified based on the field Master Type,Potraživanja / obveze prema dobavljačima račun će se utvrditi na temelju vrsti terenu Master
+Receivables,Potraživanja
+Receivables / Payables,Potraživanja / obveze
+Receivables Group,Potraživanja Grupa
+Received Date,Datum pozicija
+Received Items To Be Billed,Primljeni Proizvodi se naplaćuje
+Received Qty,Pozicija Kol
+Received and Accepted,Primljeni i prihvaćeni
+Receiver List,Prijemnik Popis
+Receiver List is empty. Please create Receiver List,Receiver Lista je prazna . Molimo stvoriti Receiver Popis
+Receiver Parameter,Prijemnik parametra
+Recipients,Primatelji
+Reconcile,pomiriti
+Reconciliation Data,Pomirenje podataka
+Reconciliation HTML,Pomirenje HTML
+Reconciliation JSON,Pomirenje JSON
+Record item movement.,Zabilježite stavku pokret.
+Recurring Id,Ponavljajući Id
+Recurring Invoice,Ponavljajući Račun
+Recurring Type,Ponavljajući Tip
+Reduce Deduction for Leave Without Pay (LWP),Smanjite odbitak za ostaviti bez plaća (lwp)
+Reduce Earning for Leave Without Pay (LWP),Smanjenje plaća za ostaviti bez plaće (lwp)
+Ref,Ref.
+Ref Code,Ref. Šifra
+Ref SQ,Ref. SQ
+Reference,Upućivanje
+Reference #{0} dated {1},Reference # {0} od {1}
+Reference Date,Referentni datum
+Reference Name,Referenca Ime
+Reference No & Reference Date is required for {0},Reference Nema & Reference Datum je potrebno za {0}
+Reference No is mandatory if you entered Reference Date,Reference Ne obvezno ako ušao referentnog datuma
+Reference Number,Referentni broj
+Reference Row #,Reference Row #
+Refresh,Osvježiti
+Registration Details,Registracija Brodu
+Registration Info,Registracija Info
+Rejected,Odbijen
+Rejected Quantity,Odbijen Količina
+Rejected Serial No,Odbijen Serijski br
+Rejected Warehouse,Odbijen galerija
+Rejected Warehouse is mandatory against regected item,Odbijen Skladište je obavezno protiv regected stavku
+Relation,Odnos
+Relieving Date,Rasterećenje Datum
+Relieving Date must be greater than Date of Joining,Olakšavanja Datum mora biti veći od dana ulaska u
+Remark,Primjedba
+Remarks,Primjedbe
+Remarks Custom,Primjedbe Custom
+Rename,preimenovati
+Rename Log,Preimenovanje Prijavite
+Rename Tool,Preimenovanje alat
+Rent Cost,Rent cost
+Rent per hour,Najam po satu
+Rented,Iznajmljuje
+Repeat on Day of Month,Ponovite na dan u mjesecu
+Replace,Zamijeniti
+Replace Item / BOM in all BOMs,Zamijenite predmet / BOM u svim sastavnicama
+Replied,Odgovorio
+Report Date,Prijavi Datum
+Report Type,Prijavi Vid
+Report Type is mandatory,Vrsta izvješća je obvezno
+Reports to,Izvješća
+Reqd By Date,Reqd Po datumu
+Reqd by Date,Reqd po datumu
+Request Type,Zahtjev Tip
+Request for Information,Zahtjev za informacije
+Request for purchase.,Zahtjev za kupnju.
+Requested,Tražena
+Requested For,Traženi Za
+Requested Items To Be Ordered,Traženi Proizvodi se mogu naručiti
+Requested Items To Be Transferred,Traženi stavki za prijenos
+Requested Qty,Traženi Kol
+"Requested Qty: Quantity requested for purchase, but not ordered.","Tražena količina : Količina zatražio za kupnju , ali ne i naređeno ."
+Requests for items.,Zahtjevi za stavke.
+Required By,Potrebna Do
+Required Date,Potrebna Datum
+Required Qty,Potrebna Kol
+Required only for sample item.,Potrebna je samo za primjer stavke.
+Required raw materials issued to the supplier for producing a sub - contracted item.,Potrebna sirovina izdane dobavljač za proizvodnju pod - ugovoreni predmet.
+Research,istraživanje
+Research & Development,Istraživanje i razvoj
+Researcher,istraživač
+Reseller,Prodavač
+Reserved,Rezervirano
+Reserved Qty,Rezervirano Kol
+"Reserved Qty: Quantity ordered for sale, but not delivered.","Rezervirano Količina : Količina naručiti za prodaju , ali nije dostavljena ."
+Reserved Quantity,Rezervirano Količina
+Reserved Warehouse,Rezervirano galerija
+Reserved Warehouse in Sales Order / Finished Goods Warehouse,Rezervirano Warehouse u prodajni nalog / skladišta gotovih proizvoda
+Reserved Warehouse is missing in Sales Order,Rezervirano Warehouse nedostaje u prodajni nalog
+Reserved Warehouse required for stock Item {0} in row {1},Rezervirana Skladište potrebno za dionice točke {0} u redu {1}
+Reserved warehouse required for stock item {0},Rezervirana skladište potrebno za dionice predmet {0}
+Reserves and Surplus,Pričuve i višak
+Reset Filters,Reset Filteri
+Resignation Letter Date,Ostavka Pismo Datum
+Resolution,Rezolucija
+Resolution Date,Rezolucija Datum
+Resolution Details,Rezolucija o Brodu
+Resolved By,Riješen Do
+Rest Of The World,Ostatak svijeta
+Retail,Maloprodaja
+Retail & Wholesale,Trgovina na veliko i
+Retailer,Prodavač na malo
+Review Date,Recenzija Datum
+Rgt,Ustaša
+Role Allowed to edit frozen stock,Uloga dopuštenih urediti smrznute zalihe
+Role that is allowed to submit transactions that exceed credit limits set.,Uloga koja je dopušteno podnijeti transakcije koje premašuju kreditnih ograničenja postavljena.
+Root Type,korijen Tip
+Root Type is mandatory,Korijen Tip je obvezno
+Root account can not be deleted,Korijen račun ne može biti izbrisan
+Root cannot be edited.,Korijen ne može se mijenjati .
+Root cannot have a parent cost center,Korijen ne mogu imati središte troškova roditelj
+Rounded Off,zaokružen
+Rounded Total,Zaokruženi iznos
+Rounded Total (Company Currency),Zaobljeni Ukupno (Društvo valuta)
+Row # ,Redak #
+Row # {0}: ,Row # {0}: 
+Row #{0}: Ordered qty can not less than item's minimum order qty (defined in item master).,Row # {0}: Ž Količina ne može manje od stavke minimalne narudžbe kom (definiranom u točki gospodara).
+Row #{0}: Please specify Serial No for Item {1},Row # {0}: Navedite rednim brojem predmeta za {1}
+Row {0}: Account does not match with \						Purchase Invoice Credit To account,Red {0}: račun ne odgovara \ Kupnja Račun kredit za račun
+Row {0}: Account does not match with \						Sales Invoice Debit To account,Red {0}: račun ne odgovara \ Prodaja Račun terećenja na računu
+Row {0}: Conversion Factor is mandatory,Red {0}: pretvorbe Factor je obvezno
+Row {0}: Credit entry can not be linked with a Purchase Invoice,Red {0} : Kreditni unos ne može biti povezan s kupnje proizvoda
+Row {0}: Debit entry can not be linked with a Sales Invoice,Red {0} : debitne unos ne može biti povezan s prodaje fakture
+Row {0}: Payment amount must be less than or equals to invoice outstanding amount. Please refer Note below.,Red {0}: Iznos uplate mora biti manji ili jednak da računa preostali iznos. Pogledajte Napomena nastavku.
+Row {0}: Qty is mandatory,Red {0}: Količina je obvezno
+"Row {0}: Qty not avalable in warehouse {1} on {2} {3}.					Available Qty: {4}, Transfer Qty: {5}","Red {0}: Kol ne stavi na raspolaganje u skladištu {1} na {2} {3}. Dostupan Količina: {4}, prijenos Kol: {5}"
+"Row {0}: To set {1} periodicity, difference between from and to date \						must be greater than or equal to {2}","Red {0}: Za postavljanje {1} periodičnost, razlika između od i do sada \ mora biti veći ili jednak {2}"
+Row {0}:Start Date must be before End Date,Red {0} : Datum početka mora biti prije datuma završetka
+Rules for adding shipping costs.,Pravila za dodavanjem troškove prijevoza .
+Rules for applying pricing and discount.,Pravila za primjenu cijene i popust .
+Rules to calculate shipping amount for a sale,Pravila za izračun shipping iznos za prodaju
+S.O. No.,S.O. Ne.
+SHE Cess on Excise,ONA procesni o akcizama
+SHE Cess on Service Tax,ONA procesni na usluga poreza
+SHE Cess on TDS,ONA procesni na TDS
+SMS Center,SMS centar
+SMS Gateway URL,SMS Gateway URL
+SMS Log,SMS Prijava
+SMS Parameter,SMS parametra
+SMS Sender Name,SMS Sender Ime
+SMS Settings,Postavke SMS
+SO Date,SO Datum
+SO Pending Qty,SO čekanju Kol
+SO Qty,SO Kol
+Salary,Plaća
+Salary Information,Plaća informacije
+Salary Manager,Plaća Manager
+Salary Mode,Plaća način
+Salary Slip,Plaća proklizavanja
+Salary Slip Deduction,Plaća proklizavanja Odbitak
+Salary Slip Earning,Plaća proklizavanja Zarada
+Salary Slip of employee {0} already created for this month,Plaća Slip zaposlenika {0} već stvorena za ovaj mjesec
+Salary Structure,Plaća Struktura
+Salary Structure Deduction,Plaća Struktura Odbitak
+Salary Structure Earning,Plaća Struktura Zarada
+Salary Structure Earnings,Plaća Struktura Zarada
+Salary breakup based on Earning and Deduction.,Plaća raspada temelju zarađivati ​​i odbitka.
+Salary components.,Plaća komponente.
+Salary template master.,Plaća predložak majstor .
+Sales,Prodaja
+Sales Analytics,Prodajna analitika
+Sales BOM,Prodaja BOM
+Sales BOM Help,Prodaja BOM Pomoć
+Sales BOM Item,Prodaja BOM artikla
+Sales BOM Items,Prodaja BOM Proizvodi
+Sales Browser,prodaja preglednik
+Sales Details,Prodajni detalji
+Sales Discounts,Prodajni popusti
+Sales Email Settings,Prodajne email postavke
+Sales Expenses,Prodajni troškovi
+Sales Extras,Prodajni dodaci
+Sales Funnel,prodaja dimnjak
+Sales Invoice,Prodajni račun
+Sales Invoice Advance,Predujam prodajnog računa
+Sales Invoice Item,Prodajni artikal
+Sales Invoice Items,Prodajni artikli
+Sales Invoice Message,Poruka prodajnog  računa
+Sales Invoice No,Prodajni račun br
+Sales Invoice Trends,Trendovi prodajnih računa
+Sales Invoice {0} has already been submitted,Prodajni računi {0} su već potvrđeni
+Sales Invoice {0} must be cancelled before cancelling this Sales Order,Prodaja Račun {0} mora biti otkazana prije poništenja ovu prodajnog naloga
+Sales Order,Narudžba kupca
+Sales Order Date,Datum narudžbe (kupca)
+Sales Order Item,Naručeni artikal - prodaja
+Sales Order Items,Naručeni artikli - prodaja
+Sales Order Message,Poruka narudžbe kupca
+Sales Order No,Broj narudžbe kupca
+Sales Order Required,Prodajnog naloga Obvezno
+Sales Order Trends,Prodajnog naloga trendovi
+Sales Order required for Item {0},Prodajnog naloga potrebna za točke {0}
+Sales Order {0} is not submitted,Prodajnog naloga {0} nije podnesen
+Sales Order {0} is not valid,Prodajnog naloga {0} nije ispravan
+Sales Order {0} is stopped,Prodajnog naloga {0} je zaustavljen
+Sales Partner,Prodajni partner
+Sales Partner Name,Prodaja Ime partnera
+Sales Partner Target,Prodaja partner Target
+Sales Partners Commission,Prodaja Partneri komisija
+Sales Person,Prodajna osoba
+Sales Person Name,Ime prodajne osobe
+Sales Person Target Variance Item Group-Wise,Prodaja Osoba Target varijance artikla Group - Wise
+Sales Person Targets,Prodaje osobi Mete
+Sales Person-wise Transaction Summary,Prodaja Osobne mudar Transakcija Sažetak
+Sales Register,Prodaja Registracija
+Sales Return,Povrat robe
+Sales Returned,prodaja Vraćeno
+Sales Taxes and Charges,Prodaja Porezi i naknade
+Sales Taxes and Charges Master,Prodaja Porezi i naknade Master
+Sales Team,Prodaja Team
+Sales Team Details,Prodaja Team Detalji
+Sales Team1,Prodaja Team1
+Sales and Purchase,Prodaje i kupnje
+Sales campaigns.,Prodajne kampanje.
+Salutation,Pozdrav
+Sample Size,Veličina uzorka
+Sanctioned Amount,Iznos kažnjeni
+Saturday,Subota
+Schedule,Raspored
+Schedule Date,Raspored Datum
+Schedule Details,Raspored Detalji
+Scheduled,Planiran
+Scheduled Date,Planirano Datum
+Scheduled to send to {0},Planirano za slanje na {0}
+Scheduled to send to {0} recipients,Planirano za slanje na {0} primatelja
+Scheduler Failed Events,Raspored događanja Neuspjeli
+School/University,Škola / Sveučilište
+Score (0-5),Ocjena (0-5)
+Score Earned,Ocjena Zarađeni
+Score must be less than or equal to 5,Rezultat mora biti manja od ili jednaka 5
+Scrap %,Otpad%
+Seasonality for setting budgets.,Sezonalnost za postavljanje proračuna.
+Secretary,tajnica
+Secured Loans,osigurani krediti
+Securities & Commodity Exchanges,Vrijednosni papiri i robne razmjene
+Securities and Deposits,Vrijednosni papiri i depoziti
+"See ""Rate Of Materials Based On"" in Costing Section",Pogledajte &quot;stopa materijali na temelju troškova&quot; u odjeljak
+"Select ""Yes"" for sub - contracting items",Odaberite &quot;Da&quot; za pod - ugovorne stavke
+"Select ""Yes"" if this item is used for some internal purpose in your company.",Odaberite &quot;Da&quot; ako ova stavka se koristi za neke unutarnje potrebe u vašoj tvrtki.
+"Select ""Yes"" if this item represents some work like training, designing, consulting etc.","Odaberite &quot;Da&quot; ako ova stavka predstavlja neki posao poput treninga, projektiranje, konzalting i sl."
+"Select ""Yes"" if you are maintaining stock of this item in your Inventory.",Odaberite &quot;Da&quot; ako ste održavanju zaliha ove točke u vašem inventaru.
+"Select ""Yes"" if you supply raw materials to your supplier to manufacture this item.",Odaberite &quot;Da&quot; ako opskrbu sirovina na svoj dobavljača za proizvodnju ovu stavku.
+Select Brand...,Odaberite brend ...
+Select Budget Distribution to unevenly distribute targets across months.,Odaberite Budget distribuciju neravnomjerno raspodijeliti ciljeve diljem mjeseci.
+"Select Budget Distribution, if you want to track based on seasonality.","Odaberite Budget Distribution, ako želite pratiti na temelju sezonalnosti."
+Select Company...,Odaberite tvrtku ...
+Select DocType,Odaberite DOCTYPE
+Select Fiscal Year...,Odaberite fiskalnu godinu ...
+Select Items,Odaberite artikle
+Select Project...,Odaberite projekt ...
+Select Purchase Receipts,Odaberite primku
+Select Sales Orders,Odaberite narudžbe kupca
+Select Sales Orders from which you want to create Production Orders.,Odaberite narudžbe iz kojih želite stvoriti radne naloge.
+Select Time Logs and Submit to create a new Sales Invoice.,Odaberite vrijeme Evidencije i slanje stvoriti novi prodajni fakture.
+Select Transaction,Odaberite transakciju
+Select Warehouse...,Odaberite skladište ...
+Select Your Language,Odaberite jezik
+Select account head of the bank where cheque was deposited.,Odaberite račun šefa banke gdje je ček bio pohranjen.
+Select company name first.,Prvo odaberite naziv tvrtke.
+Select template from which you want to get the Goals,Odaberite predložak s kojeg želite dobiti ciljeva
+Select the Employee for whom you are creating the Appraisal.,Odaberite zaposlenika za koga se stvara procjene.
+Select the period when the invoice will be generated automatically,Odaberite razdoblje kada faktura će biti generiran automatski
+Select the relevant company name if you have multiple companies,Odaberite odgovarajući naziv tvrtke ako imate više tvrtki
+Select the relevant company name if you have multiple companies.,Odaberite odgovarajući naziv tvrtke ako imate više tvrtki.
+Select who you want to send this newsletter to,Odaberite kome želite poslati ovaj bilten
+Select your home country and check the timezone and currency.,Odaberite zemlju i provjerite zonu i valutu.
+"Selecting ""Yes"" will allow this item to appear in Purchase Order , Purchase Receipt.","Odabir &quot;Da&quot; omogućit će ovu stavku da se pojavi u narudžbenice, Otkup primitka."
+"Selecting ""Yes"" will allow this item to figure in Sales Order, Delivery Note","Odabir &quot;Da&quot; omogućit će ovaj predmet shvatiti u prodajni nalog, otpremnici"
+"Selecting ""Yes"" will allow you to create Bill of Material showing raw material and operational costs incurred to manufacture this item.",Odabir &quot;Da&quot; će vam omogućiti da stvorite Bill materijala pokazuje sirovina i operativne troškove nastale za proizvodnju ovu stavku.
+"Selecting ""Yes"" will allow you to make a Production Order for this item.",Odabir &quot;Da&quot; će vam omogućiti da napravite proizvodnom nalogu za tu stavku.
+"Selecting ""Yes"" will give a unique identity to each entity of this item which can be viewed in the Serial No master.",Odabir &quot;Da&quot; će dati jedinstveni identitet svakog entiteta ove točke koja se može vidjeti u rednim brojem učitelja.
+Selling,Prodaja
+Selling Settings,Postavke prodaje
+"Selling must be checked, if Applicable For is selected as {0}","Prodaje se mora provjeriti, ako je primjenjivo za odabrano kao {0}"
+Send,Poslati
+Send Autoreply,Pošalji Automatski
+Send Email,Pošaljite e-poštu
+Send From,Pošalji Iz
+Send Notifications To,Slanje obavijesti
+Send Now,Pošalji odmah
+Send SMS,Pošalji SMS
+Send To,Pošalji
+Send To Type,Pošalji Upišite
+Send mass SMS to your contacts,Pošalji masovne SMS svojim kontaktima
+Send to this list,Pošalji na ovom popisu
+Sender Name,Pošiljatelj Ime
+Sent On,Poslan Na
+Separate production order will be created for each finished good item.,Poseban proizvodnja kako će biti izrađen za svakog gotovog dobrom stavke.
+Serial No,Serijski br
+Serial No / Batch,Serijski Ne / Batch
+Serial No Details,Serijski nema podataka
+Serial No Service Contract Expiry,Serijski Bez isteka Ugovor o pružanju usluga
+Serial No Status,Serijski Bez Status
+Serial No Warranty Expiry,Serijski Nema jamstva isteka
+Serial No is mandatory for Item {0},Serijski Nema je obvezna za točke {0}
+Serial No {0} created,Serijski Ne {0} stvorio
+Serial No {0} does not belong to Delivery Note {1},Serijski Ne {0} ne pripada isporuke Napomena {1}
+Serial No {0} does not belong to Item {1},Serijski Ne {0} ne pripada točki {1}
+Serial No {0} does not belong to Warehouse {1},Serijski Ne {0} ne pripada Warehouse {1}
+Serial No {0} does not exist,Serijski Ne {0} ne postoji
+Serial No {0} has already been received,Serijski Ne {0} već je primila
+Serial No {0} is under maintenance contract upto {1},Serijski Ne {0} je pod ugovorom za održavanje upto {1}
+Serial No {0} is under warranty upto {1},Serijski Ne {0} je pod jamstvom upto {1}
+Serial No {0} not in stock,Serijski Ne {0} nije u dioničko
+Serial No {0} quantity {1} cannot be a fraction,Serijski Ne {0} {1} količina ne može bitidio
+Serial No {0} status must be 'Available' to Deliver,Serijski Ne {0} status mora biti ' dostupna' za dovođenje
+Serial Nos Required for Serialized Item {0},Serijski Nos potrebna za serijaliziranom točke {0}
+Serial Number Series,Serijski broj serije
+Serial number {0} entered more than once,Serijski broj {0} ušao više puta
+Serialized Item {0} cannot be updated \					using Stock Reconciliation,Serijaliziranom Stavka {0} ne može biti obnovljeno \ korištenjem Stock pomirenja
+Series,serija
+Series List for this Transaction,Serija Popis za ovu transakciju
+Series Updated,Serija Updated
+Series Updated Successfully,Serija Updated uspješno
+Series is mandatory,Serija je obvezno
+Series {0} already used in {1},Serija {0} već koristi u {1}
+Service,usluga
+Service Address,Usluga Adresa
+Service Tax,Usluga Porezne
+Services,Usluge
+Set,set
+"Set Default Values like Company, Currency, Current Fiscal Year, etc.","Zadane vrijednosti kao što su tvrtke , valute , tekuće fiskalne godine , itd."
+Set Item Group-wise budgets on this Territory. You can also include seasonality by setting the Distribution.,Postavite Stavka Grupa-mudre proračune na ovom području. Također možete uključiti sezonalnost postavljanjem Distribution.
+Set Status as Available,Postavi kao Status Available
+Set as Default,Postavi kao zadano
+Set as Lost,Postavi kao Lost
+Set prefix for numbering series on your transactions,Postavite prefiks za numeriranje niza na svoje transakcije
+Set targets Item Group-wise for this Sales Person.,Set cilja predmet Grupa-mudar za ovaj prodavač.
+Setting Account Type helps in selecting this Account in transactions.,Postavljanje Vrsta računa pomaže u odabiru ovaj račun u prometu.
+Setting this Address Template as default as there is no other default,"Postavljanje Ova adresa predloška kao zadano, jer nema drugog zadano"
+Setting up...,Postavljanje ...
+Settings,Postavke
+Settings for HR Module,Postavke za HR modula
+"Settings to extract Job Applicants from a mailbox e.g. ""jobs@example.com""",Postavke za izdvajanje posao zahtjeva iz spremnika npr. &quot;jobs@example.com&quot;
+Setup,Postavljanje
+Setup Already Complete!!,Postavljanje Već Kompletan !
+Setup Complete,postavljanje dovršeno
+Setup SMS gateway settings,Postavke Setup SMS gateway
+Setup Series,Postavljanje Serija
+Setup Wizard,Čarobnjak za postavljanje
+Setup incoming server for jobs email id. (e.g. jobs@example.com),Postavljanje dolazni poslužitelj za poslove e-ID . ( npr. jobs@example.com )
+Setup incoming server for sales email id. (e.g. sales@example.com),Postavljanje dolazni poslužitelj za id prodaja e-mail . ( npr. sales@example.com )
+Setup incoming server for support email id. (e.g. support@example.com),Postavljanje dolazni poslužitelj za podršku e-mail ID . ( npr. support@example.com )
+Share,Udio
+Share With,Podijelite s
+Shareholders Funds,Dioničari fondovi
+Shipments to customers.,Isporuke kupcima.
+Shipping,Utovar
+Shipping Account,Dostava račun
+Shipping Address,Dostava Adresa
+Shipping Amount,Dostava Iznos
+Shipping Rule,Dostava Pravilo
+Shipping Rule Condition,Dostava Pravilo Stanje
+Shipping Rule Conditions,Dostava Koje uvjete
+Shipping Rule Label,Dostava Pravilo Label
+Shop,Dućan
+Shopping Cart,Košarica
+Short biography for website and other publications.,Kratka biografija za web stranice i drugih publikacija.
+"Show ""In Stock"" or ""Not in Stock"" based on stock available in this warehouse.",Show &quot;na lageru&quot; ili &quot;Nije u skladištu&quot; temelji se na skladištu dostupna u tom skladištu.
+"Show / Hide features like Serial Nos, POS etc.","Show / Hide značajke kao što su serijski brojevima , POS i sl."
+Show In Website,Pokaži Na web stranice
+Show a slideshow at the top of the page,Prikaži slideshow na vrhu stranice
+Show in Website,Prikaži u web
+Show rows with zero values,Prikaži retke s nula vrijednosti
+Show this slideshow at the top of the page,Prikaži ovaj slideshow na vrhu stranice
+Sick Leave,bolovanje
+Signature,Potpis
+Signature to be appended at the end of every email,Potpis se dodaje na kraju svakog e
+Single,Singl
+Single unit of an Item.,Jedna jedinica stavku.
+Sit tight while your system is being setup. This may take a few moments.,"Sjedi čvrsto , dok je vaš sustav se postava . To može potrajati nekoliko trenutaka ."
+Slideshow,Slideshow
+Soap & Detergent,Sapun i deterdžent
+Software,softver
+Software Developer,Software Developer
+"Sorry, Serial Nos cannot be merged","Žao nam je , Serial Nos ne mogu spojiti"
+"Sorry, companies cannot be merged","Žao nam je , tvrtke ne mogu spojiti"
+Source,Izvor
+Source File,izvor File
+Source Warehouse,Izvor galerija
+Source and target warehouse cannot be same for row {0},Izvor i ciljna skladište ne može biti isti za redom {0}
+Source of Funds (Liabilities),Izvor sredstava ( pasiva)
+Source warehouse is mandatory for row {0},Izvor skladište je obvezno za redom {0}
+Spartan,Spartanski
+"Special Characters except ""-"" and ""/"" not allowed in naming series","Posebne znakove osim "" - "" i "" / "" nisu dopušteni u imenovanja seriju"
+Specification Details,Specifikacija Detalji
+Specifications,tehnički podaci
+"Specify a list of Territories, for which, this Price List is valid","Navedite popis teritorijima, za koje, ovom cjeniku vrijedi"
+"Specify a list of Territories, for which, this Shipping Rule is valid","Navedite popis teritorijima, za koje, to Dostava Pravilo vrijedi"
+"Specify a list of Territories, for which, this Taxes Master is valid","Navedite popis teritorijima, za koje, to Porezi Master vrijedi"
+"Specify the operations, operating cost and give a unique Operation no to your operations.","Navedite operacija, operativni troškovi i dati jedinstven radom najkasnije do svojih operacija ."
+Split Delivery Note into packages.,Split otpremnici u paketima.
+Sports,sportovi
+Sr,Br
+Standard,Standard
+Standard Buying,Standardna kupnju
+Standard Reports,Standardni Izvješća
+Standard Selling,Standardna prodaja
+Standard contract terms for Sales or Purchase.,Standardni uvjeti ugovora za prodaju ili kupnju.
+Start,početak
+Start Date,Datum početka
+Start date of current invoice's period,Početak datum tekućeg razdoblja dostavnice
+Start date should be less than end date for Item {0},Početak bi trebao biti manji od krajnjeg datuma za točke {0}
+State,Država
+Statement of Account,Izjava o računu
+Static Parameters,Statički parametri
+Status,Status
+Status must be one of {0},Status mora biti jedan od {0}
+Status of {0} {1} is now {2},Status {0} {1} je sada {2}
+Status updated to {0},Status obnovljeno za {0}
+Statutory info and other general information about your Supplier,Zakonska info i druge opće informacije o vašem Dobavljaču
+Stay Updated,Budite u tijeku
+Stock,Zaliha
+Stock Adjustment,Stock Podešavanje
+Stock Adjustment Account,Stock Adjustment račun
+Stock Ageing,Kataloški Starenje
+Stock Analytics,Stock Analytics
+Stock Assets,dionicama u vrijednosti
+Stock Balance,Kataloški bilanca
+Stock Entries already created for Production Order ,Stock Entries already created for Production Order 
+Stock Entry,Kataloški Stupanje
+Stock Entry Detail,Kataloški Stupanje Detalj
+Stock Expenses,Stock Troškovi
+Stock Frozen Upto,Kataloški Frozen Upto
+Stock Ledger,Stock Ledger
+Stock Ledger Entry,Stock Ledger Stupanje
+Stock Ledger entries balances updated,Stock unose u knjigu salda ažurirane
+Stock Level,Kataloški Razina
+Stock Liabilities,Stock Obveze
+Stock Projected Qty,Stock Projekcija Kol
+Stock Queue (FIFO),Kataloški red (FIFO)
+Stock Received But Not Billed,Stock primljeni Ali ne Naplaćeno
+Stock Reconcilation Data,Stock Reconcilation podataka
+Stock Reconcilation Template,Stock Reconcilation Predložak
+Stock Reconciliation,Kataloški pomirenje
+"Stock Reconciliation can be used to update the stock on a particular date, usually as per physical inventory.","Stock Pomirenje može se koristiti za ažuriranje zaliha na određeni datum , najčešće po fizičke inventure ."
+Stock Settings,Stock Postavke
+Stock UOM,Kataloški UOM
+Stock UOM Replace Utility,Kataloški UOM Zamjena Utility
+Stock UOM updatd for Item {0},Stock UOM updatd za točku {0}
+Stock Uom,Kataloški Uom
+Stock Value,Stock vrijednost
+Stock Value Difference,Stock Vrijednost razlika
+Stock balances updated,Stock stanja izmijenjena
+Stock cannot be updated against Delivery Note {0},Dionica ne može biti obnovljeno protiv isporuke Napomena {0}
+Stock entries exist against warehouse {0} cannot re-assign or modify 'Master Name',Stock navodi koji postoje protiv skladište {0} se ne može ponovno zauzeti ili mijenjati ' Master Ime '
+Stock transactions before {0} are frozen,Stock transakcije prije {0} se zamrznut
+Stop,Stop
+Stop Birthday Reminders,Zaustavi Rođendan Podsjetnici
+Stop Material Request,Zaustavi Materijal Zahtjev
+Stop users from making Leave Applications on following days.,Prestani korisnike od izrade ostaviti aplikacija na sljedećim danima.
+Stop!,Stop!
+Stopped,Zaustavljen
+Stopped order cannot be cancelled. Unstop to cancel.,Zaustavljen nalog ne može prekinuti. Otpušiti otkazati .
+Stores,prodavaonice
+Stub,iskrčiti
+Sub Assemblies,pod skupštine
+"Sub-currency. For e.g. ""Cent""",Sub-valuta. Za npr. &quot;centi&quot;
+Subcontract,Podugovor
+Subject,Predmet
+Submit Salary Slip,Slanje plaće Slip
+Submit all salary slips for the above selected criteria,Slanje sve plaće gaćice za gore odabranih kriterija
+Submit this Production Order for further processing.,Pošaljite ovaj radnog naloga za daljnju obradu .
+Submitted,Prijavljen
+Subsidiary,Podružnica
+Successful: ,Uspješna:
+Successfully Reconciled,Uspješno Pomirio
+Suggestions,Prijedlozi
+Sunday,Nedjelja
+Supplier,Dobavljač
+Supplier (Payable) Account,Dobavljač (Plaća) račun
+Supplier (vendor) name as entered in supplier master,Dobavljač (prodavatelja) ime kao ušao u dobavljača gospodara
+Supplier > Supplier Type,Dobavljač> proizvođač tip
+Supplier Account Head,Dobavljač račun Head
+Supplier Address,Dobavljač Adresa
+Supplier Addresses and Contacts,Supplier Adrese i kontakti
+Supplier Details,Dobavljač Detalji
+Supplier Intro,Dobavljač Uvod
+Supplier Invoice Date,Dobavljač Datum fakture
+Supplier Invoice No,Dobavljač Račun br
+Supplier Name,Dobavljač Ime
+Supplier Naming By,Dobavljač nazivanje
+Supplier Part Number,Dobavljač Broj dijela
+Supplier Quotation,Dobavljač Ponuda
+Supplier Quotation Item,Dobavljač ponudu artikla
+Supplier Reference,Dobavljač Referenca
+Supplier Type,Dobavljač Tip
+Supplier Type / Supplier,Dobavljač Tip / Supplier
+Supplier Type master.,Dobavljač Vrsta majstor .
+Supplier Warehouse,Dobavljač galerija
+Supplier Warehouse mandatory for sub-contracted Purchase Receipt,Dobavljač skladišta obvezan je za sub - ugovoreni kupiti primitka
+Supplier database.,Dobavljač baza podataka.
+Supplier master.,Dobavljač majstor .
+Supplier warehouse where you have issued raw materials for sub - contracting,Dobavljač skladište gdje ste izdali sirovine za pod - ugovaranje
+Supplier-Wise Sales Analytics,Supplier -mudar prodaje Analytics
+Support,Podržati
+Support Analtyics,Podrška Analtyics
+Support Analytics,Podrška Analytics
+Support Email,Podrška e
+Support Email Settings,E-mail Settings Podrška
+Support Password,Podrška Lozinka
+Support Ticket,Podrška karata
+Support queries from customers.,Podrška upite od kupaca.
+Symbol,Simbol
+Sync Support Mails,Sinkronizacija Podrška mailova
+Sync with Dropbox,Sinkronizacija s Dropbox
+Sync with Google Drive,Sinkronizacija s Google Drive
+System,Sistem
+System Settings,Postavke sustava
+"System User (login) ID. If set, it will become default for all HR forms.","Sustav Korisničko (login) ID. Ako je postavljen, to će postati zadana za sve HR oblicima."
+TDS (Advertisement),TDS (Reklama)
+TDS (Commission),TDS (komisija)
+TDS (Contractor),TDS (Izvođač)
+TDS (Interest),TDS (kamate)
+TDS (Rent),TDS (Rent)
+TDS (Salary),TDS (plaće)
+Target  Amount,Ciljani iznos
+Target Detail,Ciljana Detalj
+Target Details,Ciljane Detalji
+Target Details1,Ciljana Details1
+Target Distribution,Ciljana Distribucija
+Target On,Target Na
+Target Qty,Ciljana Kol
+Target Warehouse,Ciljana galerija
+Target warehouse in row {0} must be same as Production Order,Target skladište u redu {0} mora biti ista kao Production Order
+Target warehouse is mandatory for row {0},Target skladište je obvezno za redom {0}
+Task,Zadatak
+Task Details,Zadatak Detalji
+Tasks,zadaci
+Tax,Porez
+Tax Amount After Discount Amount,Iznos poreza Nakon iznosa popusta
+Tax Assets,porezna imovina
+Tax Category can not be 'Valuation' or 'Valuation and Total' as all items are non-stock items,Porezna Kategorija ne može biti ' Procjena ' ili ' Procjena i Total ' kao i svi proizvodi bez zaliha predmeta
+Tax Rate,Porezna stopa
+Tax and other salary deductions.,Porez i drugih isplata plaća.
+Tax detail table fetched from item master as a string and stored in this field.Used for Taxes and Charges,Porezna detalj stol preuzeta iz točke majstora kao string i pohranjene u ovom području. Koristi se za poreze i troškove
+Tax template for buying transactions.,Porezna Predložak za kupnju transakcije .
+Tax template for selling transactions.,Porezna predložak za prodaju transakcije .
+Taxable,Oporezivo
+Taxes,Porezi
+Taxes and Charges,Porezi i naknade
+Taxes and Charges Added,Porezi i naknade Dodano
+Taxes and Charges Added (Company Currency),Porezi i naknade uvrštenja (Društvo valuta)
+Taxes and Charges Calculation,Porezi i naknade Proračun
+Taxes and Charges Deducted,Porezi i naknade oduzeti
+Taxes and Charges Deducted (Company Currency),Porezi i naknade Umanjenja (Društvo valuta)
+Taxes and Charges Total,Porezi i naknade Ukupno
+Taxes and Charges Total (Company Currency),Porezi i naknade Ukupno (Društvo valuta)
+Technology,tehnologija
+Telecommunications,telekomunikacija
+Telephone Expenses,Telefonski troškovi
+Television,Televizija
+Template,Predložak
+Template for performance appraisals.,Predložak za ocjene rada .
+Template of terms or contract.,Predložak termina ili ugovor.
+Temporary Accounts (Assets),Privremene banke ( aktiva )
+Temporary Accounts (Liabilities),Privremene banke ( pasiva)
+Temporary Assets,Privremena Imovina
+Temporary Liabilities,Privremena Obveze
+Term Details,Oročeni Detalji
+Terms,Uvjeti
+Terms and Conditions,Odredbe i uvjeti
+Terms and Conditions Content,Uvjeti sadržaj
+Terms and Conditions Details,Uvjeti Detalji
+Terms and Conditions Template,Uvjeti predloška
+Terms and Conditions1,Odredbe i Conditions1
+Terretory,Terretory
+Territory,Teritorija
+Territory / Customer,Teritorij / Customer
+Territory Manager,Teritorij Manager
+Territory Name,Regija Ime
+Territory Target Variance Item Group-Wise,Teritorij Target varijance artikla Group - Wise
+Territory Targets,Teritorij Mete
+Test,Test
+Test Email Id,Test E-mail ID
+Test the Newsletter,Test Newsletter
+The BOM which will be replaced,BOM koji će biti zamijenjen
+The First User: You,Prvo Korisnik : Vi
+"The Item that represents the Package. This Item must have ""Is Stock Item"" as ""No"" and ""Is Sales Item"" as ""Yes""",Stavka koja predstavlja paket. Ova stavka mora imati &quot;Je kataloški Stavka&quot; kao &quot;Ne&quot; i &quot;Je li prodaja artikla&quot; kao &quot;Da&quot;
+The Organization,Organizacija
+"The account head under Liability, in which Profit/Loss will be booked","Glava računa pod odgovornosti , u kojoj dobit / gubitak će biti rezerviran"
+The date on which next invoice will be generated. It is generated on submit.,Datum na koji pored faktura će biti generiran. To je izrađen podnose.
+The date on which recurring invoice will be stop,Datum na koji se ponavlja faktura će se zaustaviti
+"The day of the month on which auto invoice will be generated e.g. 05, 28 etc ","Dan u mjesecu na koji se automatski faktura će biti generiran npr. 05, 28 itd."
+The day(s) on which you are applying for leave are holiday. You need not apply for leave.,Dan (a ) na koji se prijavljujete za dopust su odmor . Ne trebaju podnijeti zahtjev za dopust .
+The first Leave Approver in the list will be set as the default Leave Approver,Prvi dopust Odobritelj na popisu će se postaviti kao zadani Odobritelj dopust
+The first user will become the System Manager (you can change that later).,Prvi korisnik će postatiSystem Manager ( možete promijeniti kasnije ) .
+The gross weight of the package. Usually net weight + packaging material weight. (for print),Bruto težina paketa. Obično neto težina + ambalaža težina. (Za tisak)
+The name of your company for which you are setting up this system.,Ime vaše tvrtke za koje ste postavljanje ovog sustava .
+The net weight of this package. (calculated automatically as sum of net weight of items),Neto težina tog paketa. (Automatski izračunava kao zbroj neto težini predmeta)
+The new BOM after replacement,Novi BOM nakon zamjene
+The rate at which Bill Currency is converted into company's base currency,Stopa po kojoj Bill valuta pretvara u tvrtke bazne valute
+The unique id for tracking all recurring invoices. It is generated on submit.,Jedinstveni ID za praćenje svih ponavljajući fakture. To je izrađen podnijeti.
+"Then Pricing Rules are filtered out based on Customer, Customer Group, Territory, Supplier, Supplier Type, Campaign, Sales Partner etc.","Zatim Cjenovna Pravila filtriraju se temelji na Kupca, Kupac Group, Teritorij, dobavljač, proizvođač tip, Kampanja, prodajni partner i sl."
+There are more holidays than working days this month.,Postoji više odmor nego radnih dana ovog mjeseca .
+"There can only be one Shipping Rule Condition with 0 or blank value for ""To Value""","Tu može biti samo jedan Dostava Pravilo Stanje sa 0 ili prazni vrijednost za "" Da Value """
+There is not enough leave balance for Leave Type {0},Nema dovoljno ravnotežu dopust za dozvolu tipa {0}
+There is nothing to edit.,Ne postoji ništa za uređivanje .
+There was an error. One probable reason could be that you haven't saved the form. Please contact support@erpnext.com if the problem persists.,Došlo je do pogreške . Jedan vjerojatan razlog bi mogao biti da niste spremili obrazac. Molimo kontaktirajte support@erpnext.com ako se problem ne riješi .
+There were errors.,Bilo je grešaka .
+This Currency is disabled. Enable to use in transactions,Ova valuta je onemogućen . Moći koristiti u transakcijama
+This Leave Application is pending approval. Only the Leave Apporver can update status.,To Leave Aplikacija se čeka odobrenje . SamoOstavite Apporver može ažurirati status .
+This Time Log Batch has been billed.,Ovo Batch Vrijeme Log je naplaćeno.
+This Time Log Batch has been cancelled.,Ovo Batch Vrijeme Log je otkazan.
+This Time Log conflicts with {0},Ovaj put Prijavite se kosi s {0}
+This format is used if country specific format is not found,Ovaj format se koristi ako država specifičan format nije pronađena
+This is a root account and cannot be edited.,To jekorijen račun i ne može se mijenjati .
+This is a root customer group and cannot be edited.,To jekorijen skupini kupaca i ne može se mijenjati .
+This is a root item group and cannot be edited.,To jekorijen stavka grupa i ne može se mijenjati .
+This is a root sales person and cannot be edited.,To jekorijen prodavač i ne može se mijenjati .
+This is a root territory and cannot be edited.,To jekorijen teritorij i ne može se mijenjati .
+This is an example website auto-generated from ERPNext,Ovo je primjer web stranica automatski generira iz ERPNext
+This is the number of the last created transaction with this prefix,To je broj zadnjeg stvorio transakcije s ovim prefiksom
+This will be used for setting rule in HR module,To će se koristiti za postavljanje pravilu u HR modula
+Thread HTML,Temu HTML
+Thursday,Četvrtak
+Time Log,Vrijeme Log
+Time Log Batch,Vrijeme Log Hrpa
+Time Log Batch Detail,Vrijeme Log Batch Detalj
+Time Log Batch Details,Time Log Hrpa Brodu
+Time Log Batch {0} must be 'Submitted',"Vrijeme Log Batch {0} mora biti "" Postavio '"
+Time Log Status must be Submitted.,Vrijeme Log Status moraju biti dostavljeni.
+Time Log for tasks.,Vrijeme Prijava za zadatke.
+Time Log is not billable,Vrijeme Log nije naplatnih
+Time Log {0} must be 'Submitted',"Vrijeme Log {0} mora biti "" Postavio '"
+Time Zone,Time Zone
+Time Zones,Vremenske zone
+Time and Budget,Vrijeme i proračun
+Time at which items were delivered from warehouse,Vrijeme na stavke koje su isporučena iz skladišta
+Time at which materials were received,Vrijeme u kojem su materijali primili
+Title,Naslov
+Titles for print templates e.g. Proforma Invoice.,Naslovi za ispis predložaka pr Predračuna.
+To,Na
+To Currency,Valutno
+To Date,Za datum
+To Date should be same as From Date for Half Day leave,Za datum bi trebao biti isti kao i od datuma za poludnevni dopust
+To Date should be within the Fiscal Year. Assuming To Date = {0},Za datum mora biti unutar fiskalne godine. Pod pretpostavkom da bi datum = {0}
+To Discuss,Za Raspravljajte
+To Do List,Da li popis
+To Package No.,Za Paket br
+To Produce,proizvoditi
+To Time,Za vrijeme
+To Value,Za vrijednost
+To Warehouse,Za galeriju
+"To add child nodes, explore tree and click on the node under which you want to add more nodes.","Da biste dodali djece čvorova , istražiti stablo i kliknite na čvoru pod kojima želite dodati više čvorova ."
+"To assign this issue, use the ""Assign"" button in the sidebar.","Za dodjelu taj problem, koristite &quot;dodijeliti&quot; gumb u sidebar."
+To create a Bank Account,Za stvaranje bankovni račun
+To create a Tax Account,Za stvaranje porezno
+"To create an Account Head under a different company, select the company and save customer.","Za stvaranje računa glavu pod drugom tvrtkom, odaberite tvrtku i spasiti kupca."
+To date cannot be before from date,Do danas ne može biti prije od datuma
+To enable <b>Point of Sale</b> features,Da biste omogućili <b>Point of Sale</b> značajke
+To enable <b>Point of Sale</b> view,Da biste omogućili <b> prodajnom </ b> pogledom
+To get Item Group in details table,Da biste dobili predmeta Group u tablici pojedinosti
+"To include tax in row {0} in Item rate, taxes in rows {1} must also be included","To uključuje porez u redu {0} u stopu točke , porezi u redovima {1} također moraju biti uključeni"
+"To merge, following properties must be same for both items","Spojiti , ova svojstva moraju biti isti za obje stavke"
+"To not apply Pricing Rule in a particular transaction, all applicable Pricing Rules should be disabled.","Da se ne primjenjuje pravilo Cijene u određenoj transakciji, svim primjenjivim pravilima cijena bi trebala biti onemogućen."
+"To set this Fiscal Year as Default, click on 'Set as Default'","Za postavljanje ove fiskalne godine kao zadano , kliknite na "" Set as Default '"
+To track any installation or commissioning related work after sales,Za praćenje bilo koju instalaciju ili puštanje vezane raditi nakon prodaje
+"To track brand name in the following documents Delivery Note, Opportunity, Material Request, Item, Purchase Order, Purchase Voucher, Purchaser Receipt, Quotation, Sales Invoice, Sales BOM, Sales Order, Serial No","Za praćenje branda u sljedećim dokumentima Dostavnica, Opportunity , materijal zahtjev, predmet, narudžbenice , kupnju vouchera Kupac prijemu, ponude, prodaje fakture , prodaje sastavnice , prodajnog naloga , rednim brojem"
+To track item in sales and purchase documents based on their serial nos. This is can also used to track warranty details of the product.,Za praćenje stavke u prodaji i kupnji dokumenata na temelju njihovih serijskih br. To je također može koristiti za praćenje jamstvene podatke o proizvodu.
+To track items in sales and purchase documents with batch nos<br><b>Preferred Industry: Chemicals etc</b>,Za praćenje stavke u prodaji i kupnji dokumenata s batch br <br> <b>Prošle Industrija: Kemikalije itd</b>
+To track items using barcode. You will be able to enter items in Delivery Note and Sales Invoice by scanning barcode of item.,Za praćenje stavki pomoću barkod. Vi ćete biti u mogućnosti da unesete stavke u otpremnici i prodaje Računa skeniranjem barkod stavke.
+Too many columns. Export the report and print it using a spreadsheet application.,Previše stupovi. Izvesti izvješće i ispisati pomoću aplikacije za proračunske tablice.
+Tools,Alat
+Total,Ukupan
+Total ({0}),Ukupno ({0})
+Total Advance,Ukupno Predujam
+Total Amount,Ukupan iznos
+Total Amount To Pay,Ukupan iznos platiti
+Total Amount in Words,Ukupan iznos u riječi
+Total Billing This Year: ,Ukupno naplate Ova godina:
+Total Characters,Ukupno Likovi
+Total Claimed Amount,Ukupno Zatražio Iznos
+Total Commission,Ukupno komisija
+Total Cost,Ukupan trošak
+Total Credit,Ukupna kreditna
+Total Debit,Ukupno zaduženje
+Total Debit must be equal to Total Credit. The difference is {0},Ukupno zaduženje mora biti jednak ukupnom kreditnom .
+Total Deduction,Ukupno Odbitak
+Total Earning,Ukupna zarada
+Total Experience,Ukupno Iskustvo
+Total Hours,Ukupno vrijeme
+Total Hours (Expected),Ukupno vrijeme (Očekivani)
+Total Invoiced Amount,Ukupno Iznos dostavnice
+Total Leave Days,Ukupno Ostavite Dani
+Total Leaves Allocated,Ukupno Lišće Dodijeljeni
+Total Message(s),Ukupno poruka ( i)
+Total Operating Cost,Ukupni trošak
+Total Points,Ukupno bodova
+Total Raw Material Cost,Ukupno troškova sirovine
+Total Sanctioned Amount,Ukupno kažnjeni Iznos
+Total Score (Out of 5),Ukupna ocjena (od 5)
+Total Tax (Company Currency),Ukupno poreza (Društvo valuta)
+Total Taxes and Charges,Ukupno Porezi i naknade
+Total Taxes and Charges (Company Currency),Ukupno Porezi i naknade (Društvo valuta)
+Total allocated percentage for sales team should be 100,Ukupno dodijeljeno postotak za prodajni tim bi trebao biti 100
+Total amount of invoices received from suppliers during the digest period,Ukupan iznos primljenih računa od dobavljača tijekom razdoblja digest
+Total amount of invoices sent to the customer during the digest period,Ukupan iznos računa šalje kupcu tijekom razdoblja digest
+Total cannot be zero,Ukupna ne može biti nula
+Total in words,Ukupno je u riječima
+Total points for all goals should be 100. It is {0},Ukupni broj bodova za sve ciljeve trebao biti 100 . To je {0}
+Total valuation for manufactured or repacked item(s) can not be less than total valuation of raw materials,Ukupna procjena za proizvodnu ili prepakirani točke (a) ne može biti manja od ukupnog vrednovanja sirovina
+Total weightage assigned should be 100%. It is {0},Ukupno bi trebalo biti dodijeljena weightage 100 % . To je {0}
+Totals,Ukupan rezultat
+Track Leads by Industry Type.,Trag vodi prema tip industrije .
+Track this Delivery Note against any Project,Prati ovu napomenu isporuke protiv bilo Projekta
+Track this Sales Order against any Project,Prati ovu prodajni nalog protiv bilo Projekta
+Transaction,Transakcija
+Transaction Date,Transakcija Datum
+Transaction not allowed against stopped Production Order {0},Transakcija nije dopuštena protiv zaustavljena proizvodnja Reda {0}
+Transfer,Prijenos
+Transfer Material,Prijenos materijala
+Transfer Raw Materials,Prijenos sirovine
+Transferred Qty,prebačen Kol
+Transportation,promet
+Transporter Info,Transporter Info
+Transporter Name,Transporter Ime
+Transporter lorry number,Transporter kamion broj
+Travel,putovanje
+Travel Expenses,putni troškovi
+Tree Type,Tree Type
+Tree of Item Groups.,Tree stavke skupina .
+Tree of finanial Cost Centers.,Drvo finanial troška .
+Tree of finanial accounts.,Drvo finanial račune .
+Trial Balance,Pretresno bilanca
+Tuesday,Utorak
+Type,Vrsta
+Type of document to rename.,Vrsta dokumenta za promjenu naziva.
+"Type of leaves like casual, sick etc.","Tip lišća poput casual, bolovanja i sl."
+Types of Expense Claim.,Vrste Rashodi zahtjevu.
+Types of activities for Time Sheets,Vrste aktivnosti za vrijeme listova
+"Types of employment (permanent, contract, intern etc.).","Vrste zapošljavanja ( trajni ugovor , pripravnik i sl. ) ."
+UOM Conversion Detail,UOM pretvorbe Detalj
+UOM Conversion Details,UOM pretvorbe Detalji
+UOM Conversion Factor,UOM konverzijski faktor
+UOM Conversion factor is required in row {0},Faktor UOM pretvorbe je potrebno u redu {0}
+UOM Name,UOM Ime
+UOM coversion factor required for UOM: {0} in Item: {1},UOM faktor coversion potrebna za UOM: {0} u točki: {1}
+Under AMC,Pod AMC
+Under Graduate,Pod diplomski
+Under Warranty,Pod jamstvo
+Unit,jedinica
+Unit of Measure,Jedinica mjere
+Unit of Measure {0} has been entered more than once in Conversion Factor Table,Jedinica mjere {0} je ušao više od jednom u konverzije Factor tablici
+"Unit of measurement of this item (e.g. Kg, Unit, No, Pair).","Jedinica za mjerenje ove točke (npr. kg, Jedinica Ne, Par)."
+Units/Hour,Jedinice / sat
+Units/Shifts,Jedinice / smjene
+Unpaid,Neplaćen
+Unreconciled Payment Details,Nesaglašen Detalji plaćanja
+Unscheduled,Neplanski
+Unsecured Loans,unsecured krediti
+Unstop,otpušiti
+Unstop Material Request,Otpušiti Materijal Zahtjev
+Unstop Purchase Order,Otpušiti narudžbenice
+Unsubscribed,Pretplatu
+Update,Ažurirati
+Update Clearance Date,Ažurirajte provjeri datum
+Update Cost,Update cost
+Update Finished Goods,Update gotovih proizvoda
+Update Landed Cost,Update Sletio trošak
+Update Series,Update serija
+Update Series Number,Update serije Broj
+Update Stock,Ažurirajte Stock
+Update bank payment dates with journals.,Update banka datum plaćanja s časopisima.
+Update clearance date of Journal Entries marked as 'Bank Vouchers',"Datum Update klirens navoda označene kao ""Banka bon '"
+Updated,Obnovljeno
+Updated Birthday Reminders,Obnovljeno Rođendan Podsjetnici
+Upload Attendance,Upload Attendance
+Upload Backups to Dropbox,Upload sigurnosne kopije za ispuštanje
+Upload Backups to Google Drive,Upload sigurnosne kopije na Google Drive
+Upload HTML,Prenesi HTML
+Upload a .csv file with two columns: the old name and the new name. Max 500 rows.,Učitajte CSV datoteku s dva stupca.: Stari naziv i novi naziv. Max 500 redaka.
+Upload attendance from a .csv file,Prenesi dolazak iz. Csv datoteku
+Upload stock balance via csv.,Prenesi dionica ravnotežu putem CSV.
+Upload your letter head and logo - you can edit them later.,Pošalji svoje pismo glavu i logo - možete ih urediti kasnije .
+Upper Income,Gornja Prihodi
+Urgent,Hitan
+Use Multi-Level BOM,Koristite multi-level BOM
+Use SSL,Koristite SSL
+Used for Production Plan,Koristi se za plan proizvodnje
+User,Korisnik
+User ID,Korisnički ID
+User ID not set for Employee {0},Korisnik ID nije postavljen za zaposlenika {0}
+User Name,Korisničko ime
+User Name or Support Password missing. Please enter and try again.,Korisničko ime ili podrška Lozinka nedostaje . Unesite i pokušajte ponovno .
+User Remark,Upute Zabilješka
+User Remark will be added to Auto Remark,Upute Napomena će biti dodan Auto Napomena
+User Remarks is mandatory,Korisničko Primjedbe je obvezno
+User Specific,Korisnik Specifična
+User must always select,Korisničko uvijek mora odabrati
+User {0} is already assigned to Employee {1},Korisnik {0} već dodijeljena zaposlenika {1}
+User {0} is disabled,Korisnik {0} je onemogućen
+Username,Korisničko ime
+Users with this role are allowed to create / modify accounting entry before frozen date,Korisnici koji imaju tu ulogu mogu kreirati / modificirati knjiženje prije zamrznute dana
+Users with this role are allowed to set frozen accounts and create / modify accounting entries against frozen accounts,Korisnici s ovom ulogom smiju postaviti zamrznute račune i izradu / izmjenu računovodstvenih unosa protiv zamrznutih računa
+Utilities,Komunalne usluge
+Utility Expenses,komunalna Troškovi
+Valid For Territories,Vrijedi za teritorijima
+Valid From,vrijedi od
+Valid Upto,Vrijedi Upto
+Valid for Territories,Vrijedi za teritorijima
+Validate,Potvrditi
+Valuation,Procjena
+Valuation Method,Vrednovanje metoda
+Valuation Rate,Vrednovanje Stopa
+Valuation Rate required for Item {0},Vrednovanje stopa potrebna za točke {0}
+Valuation and Total,Vrednovanje i Total
+Value,Vrijednost
+Value or Qty,"Vrijednost, ili Kol"
+Vehicle Dispatch Date,Vozilo Dispatch Datum
+Vehicle No,Ne vozila
+Venture Capital,venture Capital
+Verified By,Ovjeren od strane
+View Ledger,Pogledaj Ledger
+View Now,Pregled Sada
+Visit report for maintenance call.,Posjetite izvješće za održavanje razgovora.
+Voucher #,bon #
+Voucher Detail No,Bon Detalj Ne
+Voucher Detail Number,Bon Detalj broj
+Voucher ID,Bon ID
+Voucher No,Bon Ne
+Voucher Type,Bon Tip
+Voucher Type and Date,Tip bon i datum
+Walk In,Šetnja u
+Warehouse,skladište
+Warehouse Contact Info,Skladište Kontakt Info
+Warehouse Detail,Skladište Detalj
+Warehouse Name,Skladište Ime
+Warehouse and Reference,Skladište i upute
+Warehouse can not be deleted as stock ledger entry exists for this warehouse.,"Skladište se ne može izbrisati , kao entry stock knjiga postoji za to skladište ."
+Warehouse can only be changed via Stock Entry / Delivery Note / Purchase Receipt,Skladište se može mijenjati samo preko Stock Stupanje / Dostavnica / kupiti primitka
+Warehouse cannot be changed for Serial No.,Skladište se ne može promijeniti za serijskog broja
+Warehouse is mandatory for stock Item {0} in row {1},Skladište je obvezna za dionice točke {0} je u redu {1}
+Warehouse is missing in Purchase Order,Skladište nedostaje u narudžbenice
+Warehouse not found in the system,Skladište se ne nalaze u sustavu
+Warehouse required for stock Item {0},Skladište potreban dionica točke {0}
+Warehouse where you are maintaining stock of rejected items,Skladište gdje ste održavanju zaliha odbijenih stavki
+Warehouse {0} can not be deleted as quantity exists for Item {1},Skladište {0} ne može biti izbrisan kao količina postoji točka {1}
+Warehouse {0} does not belong to company {1},Skladište {0} ne pripada tvrtka {1}
+Warehouse {0} does not exist,Skladište {0} ne postoji
+Warehouse {0}: Company is mandatory,Skladište {0}: Društvo je obvezno
+Warehouse {0}: Parent account {1} does not bolong to the company {2},Skladište {0}: Parent račun {1} ne Bolong tvrtki {2}
+Warehouse-Wise Stock Balance,Skladište-Wise Stock Balance
+Warehouse-wise Item Reorder,Warehouse-mudar Stavka redoslijeda
+Warehouses,Skladišta
+Warehouses.,Skladišta.
+Warn,Upozoriti
+Warning: Leave application contains following block dates,Upozorenje: Ostavite program sadrži sljedeće blok datume
+Warning: Material Requested Qty is less than Minimum Order Qty,Upozorenje : Materijal Tražena količina manja nego minimalna narudžba kol
+Warning: Sales Order {0} already exists against same Purchase Order number,Upozorenje : prodajnog naloga {0} već postoji od broja ista narudžbenice
+Warning: System will not check overbilling since amount for Item {0} in {1} is zero,Upozorenje : Sustav neće provjeravati overbilling od iznosa za točku {0} u {1} je nula
+Warranty / AMC Details,Jamstveni / AMC Brodu
+Warranty / AMC Status,Jamstveni / AMC Status
+Warranty Expiry Date,Jamstvo Datum isteka
+Warranty Period (Days),Jamstveno razdoblje (dani)
+Warranty Period (in days),Jamstveno razdoblje (u danima)
+We buy this Item,Mi smo kupiti ovu stavku
+We sell this Item,Prodajemo ovu stavku
+Website,Website
+Website Description,Web stranica Opis
+Website Item Group,Web stranica artikla Grupa
+Website Item Groups,Website Stavka Grupe
+Website Settings,Website Postavke
+Website Warehouse,Web stranica galerije
+Wednesday,Srijeda
+Weekly,Tjedni
+Weekly Off,Tjedni Off
+Weight UOM,Težina UOM
+"Weight is mentioned,\nPlease mention ""Weight UOM"" too","Težina je spomenuto , \ nDa spominjem "" Težina UOM "" previše"
+Weightage,Weightage
+Weightage (%),Weightage (%)
+Welcome,dobrodošli
+Welcome to ERPNext. Over the next few minutes we will help you setup your ERPNext account. Try and fill in as much information as you have even if it takes a bit longer. It will save you a lot of time later. Good Luck!,"Dobrodošli na ERPNext . Tijekom sljedećih nekoliko minuta, mi ćemo vam pomoći postava tvoj ERPNext računa . Pokušajte i ispunite što više informacija kao što su , čak i ako to trajemalo duže . To će vam uštedjeti puno vremena kasnije . Sretno !"
+Welcome to ERPNext. Please select your language to begin the Setup Wizard.,Dobrodošli na ERPNext . Molimo odaberite svoj jezik kako bi početak čarobnjaka za postavljanje .
+What does it do?,Što učiniti ?
+"When any of the checked transactions are ""Submitted"", an email pop-up automatically opened to send an email to the associated ""Contact"" in that transaction, with the transaction as an attachment. The user may or may not send the email.","Kada bilo koji od provjerenih transakcija &quot;Postavio&quot;, e-mail pop-up automatski otvorio poslati e-mail na povezane &quot;Kontakt&quot; u toj transakciji, s transakcijom u privitku. Korisnik može ili ne može poslati e-mail."
+"When submitted, the system creates difference entries to set the given stock and valuation on this date.","Kada se podnosi ,sustav stvara razlika unose postaviti zadani zaliha i procjenu vrijednosti tog datuma ."
+Where items are stored.,Gdje predmeti su pohranjeni.
+Where manufacturing operations are carried out.,Gdje proizvodni postupci provode.
+Widowed,Udovički
+Will be calculated automatically when you enter the details,Hoće li biti izračunata automatski kada unesete podatke
+Will be updated after Sales Invoice is Submitted.,Hoće li se obnavljaju nakon prodaje fakture je Prijavljen.
+Will be updated when batched.,Hoće li biti ažurirani kada izmiješane.
+Will be updated when billed.,Hoće li biti promjena kada je naplaćeno.
+Wire Transfer,Wire Transfer
+With Operations,Uz operacije
+With Period Closing Entry,S Zatvaranje razdoblja upisa
+Work Details,Radni Brodu
+Work Done,Rad Done
+Work In Progress,Radovi u tijeku
+Work-in-Progress Warehouse,Rad u tijeku Warehouse
+Work-in-Progress Warehouse is required before Submit,Rad u tijeku Warehouse je potrebno prije Podnijeti
+Working,Rad
+Working Days,Radnih dana
+Workstation,Workstation
+Workstation Name,Ime Workstation
+Write Off Account,Napišite Off račun
+Write Off Amount,Napišite paušalni iznos
+Write Off Amount <=,Otpis Iznos &lt;=
+Write Off Based On,Otpis na temelju
+Write Off Cost Center,Otpis troška
+Write Off Outstanding Amount,Otpisati preostali iznos
+Write Off Voucher,Napišite Off bon
+Wrong Template: Unable to find head row.,Pogrešna Predložak: Nije moguće pronaći glave red.
+Year,Godina
+Year Closed,Godina Zatvoreno
+Year End Date,Godina Datum završetka
+Year Name,Godina Ime
+Year Start Date,Godina Datum početka
+Year of Passing,Godina Prolazeći
+Yearly,Godišnje
+Yes,Da
+You are not authorized to add or update entries before {0},Niste ovlašteni za dodati ili ažurirati unose prije {0}
+You are not authorized to set Frozen value,Niste ovlašteni za postavljanje Frozen vrijednost
+You are the Expense Approver for this record. Please Update the 'Status' and Save,"Vi steRashodi Odobritelj za ovaj rekord . Molimo Ažuriranje "" status"" i Save"
+You are the Leave Approver for this record. Please Update the 'Status' and Save,"Vi steOstavite Odobritelj za ovaj rekord . Molimo Ažuriranje "" status"" i Save"
+You can enter any date manually,Možete unijeti bilo koji datum ručno
+You can enter the minimum quantity of this item to be ordered.,Možete unijeti minimalnu količinu ove točke biti naređeno.
+You can not change rate if BOM mentioned agianst any item,Ne možete promijeniti brzinu ako BOM spomenuo agianst bilo predmet
+You can not enter both Delivery Note No and Sales Invoice No. Please enter any one.,Vi ne možete unositi oba isporuke Napomena Ne i prodaje Račun br Unesite bilo jedno .
+You can not enter current voucher in 'Against Journal Voucher' column,Ne možete unijeti trenutni voucher u ' Protiv Journal vaučer ' kolonu
+You can set Default Bank Account in Company master,Možete postaviti Default bankovni račun u gospodara tvrtke
+You can start by selecting backup frequency and granting access for sync,Možete početi odabirom sigurnosnu frekvenciju i davanje pristupa za sinkronizaciju
+You can submit this Stock Reconciliation.,Možete poslati ovu zaliha pomirenja .
+You can update either Quantity or Valuation Rate or both.,Možete ažurirati ili količini ili vrednovanja Ocijenite ili oboje .
+You cannot credit and debit same account at the same time,Ne možete kreditnim i debitnim isti račun u isto vrijeme
+You have entered duplicate items. Please rectify and try again.,Unijeli duple stavke . Molimo ispraviti i pokušajte ponovno .
+You may need to update: {0},Možda ćete morati ažurirati : {0}
+You must Save the form before proceeding,Morate spremiti obrazac prije nastavka
+Your Customer's TAX registration numbers (if applicable) or any general information,Vaš klijent je poreznoj registraciji brojevi (ako je primjenjivo) ili bilo opće informacije
+Your Customers,vaši klijenti
+Your Login Id,Vaš Id Prijava
+Your Products or Services,Svoje proizvode ili usluge
+Your Suppliers,vaši Dobavljači
+Your email address,Vaša e-mail adresa
+Your financial year begins on,Vaša financijska godina počinje
+Your financial year ends on,Vaš Financijska godina završava
+Your sales person who will contact the customer in future,Vaš prodaje osobi koja će kontaktirati kupca u budućnosti
+Your sales person will get a reminder on this date to contact the customer,Vaš prodavač će dobiti podsjetnik na taj datum kontaktirati kupca
+Your setup is complete. Refreshing...,Vaš postava je potpuni . Osvježavajući ...
+Your support email id - must be a valid email - this is where your emails will come!,Vaša podrška e-mail id - mora biti valjana e-mail - ovo je mjesto gdje svoje e-mailove će doći!
+[Error],[Error]
+[Select],[ Select ]
+`Freeze Stocks Older Than` should be smaller than %d days.,` Freeze Dionice starije od ` bi trebao biti manji od % d dana .
+and,i
+are not allowed.,nisu dopušteni.
+assigned by,dodjeljuje
+cannot be greater than 100,ne može biti veća od 100
+"e.g. ""Build tools for builders""","na primjer "" Izgraditi alate za graditelje """
+"e.g. ""MC""","na primjer ""MC"""
+"e.g. ""My Company LLC""","na primjer ""Moja tvrtka LLC"""
+e.g. 5,na primjer 5
+"e.g. Bank, Cash, Credit Card","npr. banka, gotovina, kreditne kartice"
+"e.g. Kg, Unit, Nos, m","npr. kg, Jedinica, br, m"
+e.g. VAT,na primjer PDV
+eg. Cheque Number,npr.. Ček Broj
+example: Next Day Shipping,Primjer: Sljedeći dan Dostava
+lft,LFT
+old_parent,old_parent
+rgt,ustaša
+subject,subjekt
+to,na
+website page link,web stranica vode
+{0} '{1}' not in Fiscal Year {2},{0} ' {1} ' nije u fiskalnoj godini {2}
+{0} Credit limit {0} crossed,{0} Kreditni limit {0} prešao
+{0} Serial Numbers required for Item {0}. Only {0} provided.,{0} serijski brojevi potrebni za točke {0} . Samo {0} uvjetom .
+{0} budget for Account {1} against Cost Center {2} will exceed by {3},{0} proračun za račun {1} od troška {2} premašit će po {3}
+{0} can not be negative,{0} ne može biti negativna
+{0} created,{0} stvorio
+{0} does not belong to Company {1},{0} ne pripada Društvu {1}
+{0} entered twice in Item Tax,{0} dva puta ušao u točki poreza
+{0} is an invalid email address in 'Notification Email Address',"{0} jenevažeća e-mail adresu u "" obavijesti e-mail adresa '"
+{0} is mandatory,{0} je obavezno
+{0} is mandatory for Item {1},{0} je obavezno za točku {1}
+{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2}.,{0} je obavezno. Možda Mjenjačnica zapis nije stvoren za {1} na {2}.
+{0} is not a stock Item,{0} nijestock Stavka
+{0} is not a valid Batch Number for Item {1},{0} nije ispravan broj serije za točku {1}
+{0} is not a valid Leave Approver. Removing row #{1}.,{0} nije ispravan Leave Odobritelj. Uklanjanje red # {1}.
+{0} is not a valid email id,{0} nije ispravan id e-mail
+{0} is now the default Fiscal Year. Please refresh your browser for the change to take effect.,{0} je sadazadana Fiskalna godina . Osvježite svoj preglednik za promjene stupiti na snagu.
+{0} is required,{0} je potrebno
+{0} must be a Purchased or Sub-Contracted Item in row {1},{0} mora bitikupljen ili pod-ugovori stavka u nizu {1}
+{0} must be reduced by {1} or you should increase overflow tolerance,{0} mora biti smanjena za {1} ili bi trebali povećati overflow toleranciju
+{0} must have role 'Leave Approver',{0} mora imati ulogu ' Leave odobravatelju '
+{0} valid serial nos for Item {1},{0} valjani serijski nos za Stavka {1}
+{0} {1} against Bill {2} dated {3},{0} {1} od {2} Billa od {3}
+{0} {1} against Invoice {2},{0} {1} protiv fakture {2}
+{0} {1} has already been submitted,{0} {1} je već poslan
+{0} {1} has been modified. Please refresh.,{0} {1} je izmijenjen . Osvježite.
+{0} {1} is not submitted,{0} {1} nije podnesen
+{0} {1} must be submitted,{0} {1} mora biti podnesen
+{0} {1} not in any Fiscal Year,{0} {1} nije u poslovnu godinu
+{0} {1} status is 'Stopped',{0} {1} status ' Zaustavljen '
+{0} {1} status is Stopped,{0} {1} status zaustavljen
+{0} {1} status is Unstopped,{0} {1} status Unstopped
+{0} {1}: Cost Center is mandatory for Item {2},{0} {1}: troška je obvezno za točku {2}
+{0}: {1} not found in Invoice Details table,{0}: {1} nije pronađen u Pojedinosti dostavnice stolu
diff --git a/erpnext/translations/ca.csv b/erpnext/translations/ca.csv
new file mode 100644
index 0000000..4e9690c
--- /dev/null
+++ b/erpnext/translations/ca.csv
@@ -0,0 +1,3677 @@
+ (Half Day),
+ and year: ,
+""" does not exists","""No existeix"
+%  Delivered,
+% Amount Billed,% Import facturat
+% Billed,% Facturat
+% Completed,
+% Delivered,% Lliurat
+% Installed,% Instal·lat
+% Milestones Achieved,% Fites assolides
+% Milestones Completed,% Assoliments aconseguits
+% Received,% Rebut
+% Tasks Completed,
+% of materials billed against this Purchase Order.,% de materials facturats d'aquesta ordre de compra.
+% of materials billed against this Sales Order,% De materials facturats d'aquesta Ordre de Venda
+% of materials delivered against this Delivery Note,% Dels materials lliurats d'aquesta nota de lliurament
+% of materials delivered against this Sales Order,
+% of materials ordered against this Material Request,% De materials demanats per aquesta sol·licitud de materials
+% of materials received against this Purchase Order,% Dels materials rebuts d'aquesta ordre de compra
+'Actual Start Date' can not be greater than 'Actual End Date',
+'Based On' and 'Group By' can not be same,
+'Days Since Last Order' must be greater than or equal to zero,
+'Entries' cannot be empty,
+'Expected Start Date' can not be greater than 'Expected End Date',
+'From Date' is required,
+'From Date' must be after 'To Date',
+'From Time' cannot be later than 'To Time',
+'Has Serial No' can not be 'Yes' for non-stock item,
+'Notification Email Addresses' not specified for recurring %s,
+'Profit and Loss' type account {0} not allowed in Opening Entry,
+'To Case No.' cannot be less than 'From Case No.',
+'To Date' is required,
+'Update Stock' for Sales Invoice {0} must be set,
+* Will be calculated in the transaction.,
+"**Budget Distribution** helps you distribute your budget across months if you have seasonality in your business.
+
+To distribute a budget using this distribution, set this **Budget Distribution** in the **Cost Center**",
+**Currency** Master,** Moneda ** MestreDivisa
+**Fiscal Year** represents a Financial Year. All accounting entries and other major transactions are tracked against **Fiscal Year**.,
+"1 Currency = [?] Fraction
+For e.g. 1 USD = 100 Cent",
+1. To maintain the customer wise item code and to make them searchable based on their code use this option,1. Utilitza aquesta opció per mantenir el codi de l'article del client i incloure'l en les cerques en base al seu codi
+90-Above,
+"<a href=""#Sales Browser/Customer Group"">Add / Edit</a>","<a href=""#Sales Browser/Customer Group"">Add / Edit</a>"
+"<a href=""#Sales Browser/Item Group"">Add / Edit</a>","<a href=""#Sales Browser/Item Group"">Add / Edit</a>"
+"<a href=""#Sales Browser/Territory"">Add / Edit</a>","<a href=""#Sales Browser/Territory"">Add / Edit</a>"
+"<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>",
+A Customer Group exists with same name please change the Customer name or rename the Customer Group,"Hi ha un grup de clients amb el mateix nom, si us plau canvia el nom del client o del nom del Grup de Clients"
+A Customer exists with same name,
+A Lead with this email id should exist,Hauria d'haver-hi un client potencial amb aquest correu electrònic
+A Product or Service,Un producte o servei
+"A Product or a Service that is bought, sold or kept in stock.",
+A Supplier exists with same name,
+A condition for a Shipping Rule,
+A logical Warehouse against which stock entries are made.,
+A symbol for this currency. For e.g. $,
+A third party distributor / dealer / commission agent / affiliate / reseller who sells the companies products for a commission.,
+"A user with ""Expense Approver"" role","Un usuari amb rol de ""Aprovador de despeses"""
+AMC Expiry Date,
+Abbr,Abbr
+Abbreviation cannot have more than 5 characters,
+Above Value,
+Absent,
+Acceptance Criteria,Criteris d'acceptació
+Accepted,Acceptat
+Accepted + Rejected Qty must be equal to Received quantity for Item {0},
+Accepted Quantity,Quantitat Acceptada
+Accepted Warehouse,
+Account,Compte
+Account Balance,Saldo del compte
+Account Created: {0},Compte Creat: {0}
+Account Details,Detalls del compte
+Account Group,
+Account Head,
+Account Name,Nom del Compte
+Account Type,Tipus de compte
+"Account balance already in Credit, you are not allowed to set 'Balance Must Be' as 'Debit'","El saldo del compte ja està en crèdit, no tens permisos per establir-lo com 'El balanç ha de ser ""com ""Dèbit """
+"Account balance already in Debit, you are not allowed to set 'Balance Must Be' as 'Credit'",
+Account for the warehouse (Perpetual Inventory) will be created under this Account.,Es crearà un Compte per al magatzem (Inventari Permanent) en aquest Compte
+Account head {0} created,
+Account must be a balance sheet account,
+Account with child nodes cannot be converted to ledger,
+Account with existing transaction can not be converted to group.,
+Account with existing transaction can not be deleted,Un compte amb transaccions no es pot eliminar
+Account with existing transaction cannot be converted to ledger,El Compte de la transacció existent no es pot convertir en llibre major
+Account {0} cannot be a Group,El Compte {0} no pot ser un grup
+Account {0} does not belong to Company {1},El compte {0} no pertany a l'empresa {1}
+Account {0} does not belong to company: {1},
+Account {0} does not exist,El compte {0} no existeix
+Account {0} does not exists,
+Account {0} has been entered more than once for fiscal year {1},Compte {0} s'ha introduït més d'una vegada per a l'any fiscal {1}
+Account {0} is frozen,El compte {0} està bloquejat
+Account {0} is inactive,
+Account {0} is not valid,EL compte {0} no és vàlid
+Account {0} must be of type 'Fixed Asset' as Item {1} is an Asset Item,El compte {0} ha de ser del tipus 'd'actius fixos' perquè l'article {1} és un element d'actiu
+Account {0}: Parent account {1} can not be a ledger,Compte {0}: compte pare {1} no pot ser un llibre de comptabilitat
+Account {0}: Parent account {1} does not belong to company: {2},Compte {0}: el compte Pare {1} no pertany a la companyia: {2}
+Account {0}: Parent account {1} does not exist,Compte {0}: el compte superior {1} no existeix
+Account {0}: You can not assign itself as parent account,
+Account: {0} can only be updated via Stock Transactions,El compte: {0} només pot ser actualitzat a través de transaccions d'estoc
+Accountant,Accountant
+Accounting,Comptabilitat
+"Accounting Entries can be made against leaf nodes, called","Accounting Entries can be made against leaf nodes, called"
+Accounting Entry for Stock,
+"Accounting entry frozen up to this date, nobody can do / modify entry except role specified below.",
+Accounting journal entries.,Entrades de diari de Comptabilitat.
+Accounts,Comptes
+Accounts Browser,
+Accounts Frozen Upto,Comptes bloquejats fins a
+Accounts Manager,Gerent de Comptes
+Accounts Payable,
+Accounts Receivable,Comptes Per Cobrar
+Accounts Settings,Ajustaments de comptabilitat
+Accounts User,
+Achieved,
+Active,
+Active: Will extract emails from ,
+Activity,
+Activity Log,Registre d'activitat
+Activity Log:,Registre d'activitat:
+Activity Type,
+Actual,
+Actual Budget,Pressupost Actual
+Actual Completion Date,
+Actual Date,Data actual
+Actual End Date,Data de finalització actual
+Actual Invoice Date,Data de la factura
+Actual Posting Date,Data de comptabilització actual
+Actual Qty,
+Actual Qty (at source/target),
+Actual Qty After Transaction,
+Actual Qty is mandatory,La quantitat actual és obligatòria
+Actual Qty: Quantity available in the warehouse.,
+Actual Quantity,Quantitat real
+Actual Start Date,Data d'inici real
+Add,Afegir
+Add / Edit Prices,Afegeix / Edita Preus
+Add / Edit Taxes and Charges,Afegeix / Edita les taxes i càrrecs
+Add Child,
+Add Serial No,Afegir Número de sèrie
+Add Taxes,Afegir Impostos
+Add or Deduct,Afegir o Deduir
+Add rows to set annual budgets on Accounts.,Afegir files per establir els pressupostos anuals de Comptes.
+Add to Cart,
+Add to calendar on this date,Afegir al calendari en aquesta data
+Add/Remove Recipients,
+Address,Adreça
+Address & Contact,
+Address & Contacts,
+Address Desc,Descripció de direcció
+Address Details,Detall de l'adreça
+Address HTML,Adreça HTML
+Address Line 1,Adreça Línia 1
+Address Line 2,Adreça Línia 2
+Address Template,
+Address Title,
+Address Title is mandatory.,Títol d'adreça obligatori.
+Address Type,Tipus d'adreça
+Address master.,
+Administrative Expenses,
+Administrative Officer,Oficial Administratiu
+Administrator,Administrador
+Advance Amount,
+Advance Paid,Bestreta pagada
+Advance amount,
+"Advance paid against {0} {1} cannot be greater \
+					than Grand Total {2}",
+Advances,Advances
+Advertisement,Anunci
+Advertising,
+Aerospace,
+After Sale Installations,Instal·lacions després de venda
+Against,Contra
+Against Account,Contra Compte
+Against Docname,
+Against Doctype,
+Against Document Detail No,Contra Detall del document núm
+Against Document No,
+Against Expense Account,Contra el Compte de Despeses
+Against Income Account,
+Against Invoice,Contra Factura
+Against Invoice Posting Date,Against Invoice Posting Date
+Against Journal Voucher,Contra Assentament de Diari
+Against Journal Voucher {0} does not have any unmatched {1} entry,
+Against Journal Voucher {0} is already adjusted against some other voucher,
+Against Purchase Invoice,
+Against Purchase Order,Per l'Ordre de Compra
+Against Sales Invoice,Contra la factura de venda
+Against Sales Order,Contra l'Ordre de Venda
+Against Supplier Invoice {0} dated {1},Contra Proveïdor Factura {0} {1} datat
+Against Voucher,Contra justificant
+Against Voucher No,Contra el comprovant número
+Against Voucher Type,Contra el val tipus
+"Against Voucher Type must be one of Purchase Order, Purchase Invoice or Journal Voucher","Against Voucher Type must be one of Purchase Order, Purchase Invoice or Journal Voucher"
+"Against Voucher Type must be one of Sales Order, Sales Invoice or Journal Voucher",
+Age,
+Ageing Based On,Envelliment basat en
+Ageing Date is mandatory for opening entry,La data d'envelliment és obligatòria per a l'entrada d'obertura
+Ageing date is mandatory for opening entry,Data d'envelliment és obligatori per a l'entrada d'obertura
+Agent,Agent
+"Aggregate group of **Items** into another **Item**. This is useful if you are bundling a certain **Items** into a package and you maintain stock of the packed **Items** and not the aggregate **Item**. 
+
+The package **Item** will have ""Is Stock Item"" as ""No"" and ""Is Sales Item"" as ""Yes"".
+
+For Example: If you are selling Laptops and Backpacks separately and have a special price if the customer buys both, then the Laptop + Backpack will be a new Sales BOM Item.
+
+Note: BOM = Bill of Materials",
+Aging Date,Data Envelliment
+Aging Date is mandatory for opening entry,
+Agriculture,Agricultura
+Airline,Aerolínia
+All,Tots
+All Addresses.,
+All Contact,All Contact
+All Contacts.,
+All Customer Contact,Contacte tot client
+All Customer Groups,
+All Day,Tot el dia
+All Employee (Active),
+All Item Groups,Tots els grups d'articles
+All Lead (Open),Tots els clients potencials (Obert)
+All Products or Services.,Tots els Productes o Serveis.
+All Sales Partner Contact,
+All Sales Person,Tot el personal de vendes
+All Sales Transactions can be tagged against multiple **Sales Persons** so that you can set and monitor targets.,
+All Supplier Contact,Contacte de Tot el Proveïdor
+All Supplier Types,Tots els tipus de proveïdors
+All Territories,Tots els territoris
+"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.","Tots els camps relacionats amb l'exportació, com la moneda, taxa de conversió, el total de les exportacions, els totals de les exportacions etc estan disponibles a notes de lliurament, TPV, ofertes, factura de venda, ordre de venda, etc."
+"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.","Tots els camps relacionats amb la importació com la divisa, taxa de conversió, el total de l'import, els imports acumulats, etc estan disponibles en el rebut de compra, oferta de compra, factura de compra, ordres de compra, etc."
+All items have already been invoiced,S'han facturat tots els articles
+All these items have already been invoiced,Tots aquests elements ja s'han facturat
+Allocate,Assignar
+Allocate leaves for a period.,Assignar absències per un període.
+Allocate leaves for the year.,
+Allocated,Situat
+Allocated Amount,
+Allocated Budget,Pressupost assignat
+Allocated amount,Quantitat assignada
+Allocated amount can not be negative,Suma assignat no pot ser negatiu
+Allocated amount can not greater than unadusted amount,
+Allow Bill of Materials,
+Allow Bill of Materials should be 'Yes'. Because one or many active BOMs present for this item,Permetre llista de materials ha de ser 'Sí'. Perquè hi ha una o vàries llistes de materials actives per aquest article
+Allow Children,Permetre descendents a l'arbre
+Allow Dropbox Access,Allow Dropbox Access
+Allow Google Drive Access,Permetre l'accés de Google Drive
+Allow Negative Balance,Permetre balanç negatiu
+Allow Negative Stock,Permetre existències negatives
+Allow Production Order,
+Allow User,Permetre a l'usuari
+Allow Users,
+Allow the following users to approve Leave Applications for block days.,
+Allow user to edit Price List Rate in transactions,Permetre a l'usuari editar la Llista de Preus de Tarifa en transaccions
+Allowance Percent,
+Allowance for over-{0} crossed for Item {1},Permissió de superació {0} superat per l'article {1}
+Allowance for over-{0} crossed for Item {1}.,
+Allowed Role to Edit Entries Before Frozen Date,
+Amended From,Modificada Des de
+Amount,
+Amount (Company Currency),Import (Companyia moneda)
+Amount Paid,Quantitat pagada
+Amount to Bill,
+Amounts not reflected in bank,Les quantitats no es reflecteixen en el banc
+Amounts not reflected in system,
+Amt,
+An Customer exists with same name,
+"An Item Group exists with same name, please change the item name or rename the item group","Hi ha un grup d'articles amb el mateix nom, si us plau, canvieu el nom de l'article o del grup d'articles"
+"An item exists with same name ({0}), please change the item group name or rename the item",
+Analyst,Analista
+Annual,Anual
+Another Period Closing Entry {0} has been made after {1},
+Another Salary Structure {0} is active for employee {1}. Please make its status 'Inactive' to proceed.,"Una altra estructura salarial {0} està activa per l'empleat {1}. Si us plau, passeu el seu estat a 'inactiu' per seguir."
+"Any other comments, noteworthy effort that should go in the records.",
+Apparel & Accessories,
+Applicability,
+Applicable Charges,Càrrecs aplicables
+Applicable For,Aplicable per
+Applicable Holiday List,Llista de vacances aplicable
+Applicable Territory,
+Applicable To (Designation),Aplicable a (Designació)
+Applicable To (Employee),Aplicable a (Empleat)
+Applicable To (Role),Aplicable a (Rol)
+Applicable To (User),Aplicable a (Usuari)
+Applicant Name,Nom del sol·licitant
+Applicant for a Job,Sol·licitant d'ocupació
+Applicant for a Job.,
+Application of Funds (Assets),
+Applications for leave.,
+Applies to Company,S'aplica a l'empresa
+Apply / Approve Leaves,
+Apply On,Aplicar a
+Appraisal,Avaluació
+Appraisal Goal,Avaluació Meta
+Appraisal Goals,Valoració d'Objectius
+Appraisal Template,Plantilla d'Avaluació
+Appraisal Template Goal,
+Appraisal Template Title,Títol de plantilla d'avaluació
+Appraisal {0} created for Employee {1} in the given date range,
+Apprentice,
+Approval Status,
+Approval Status must be 'Approved' or 'Rejected',"Estat d'aprovació ha de ser ""Aprovat"" o ""Rebutjat"""
+Approved,
+Approver,
+Approving Role,Aprovar Rol
+Approving Role cannot be same as role the rule is Applicable To,El rol d'aprovador no pot ser el mateix que el rol al que la regla s'ha d'aplicar
+Approving User,Usuari aprovador
+Approving User cannot be same as user the rule is Applicable To,Approving User cannot be same as user the rule is Applicable To
+Are you sure you want to STOP ,
+Are you sure you want to UNSTOP ,
+Arrear Amount,Arrear Amount
+"As Production Order can be made for this item, it must be a stock item.",Per a poder fer aquest article Ordre de Producció cal designar-lo com a article d'estoc
+As per Stock UOM,Segons Stock UDM
+"As there are existing stock transactions for this item, you can not change the values of 'Has Serial No', 'Has Batch No', 'Is Stock Item' and 'Valuation Method'",
+Asset,
+Assistant,
+Associate,
+Atleast one of the Selling or Buying must be selected,Has de marcar compra o venda
+Atleast one warehouse is mandatory,Almenys un magatzem és obligatori
+Attach Image,
+Attach Letterhead,Afegir capçalera de carta
+Attach Logo,
+Attach Your Picture,Adjunta la teva imatge
+Attendance,Assistència
+Attendance Date,
+Attendance Details,
+Attendance From Date,Assistència des de data
+Attendance From Date and Attendance To Date is mandatory,Assistència Des de la data i Assistència a la data és obligatori
+Attendance To Date,Assistència fins a la Data
+Attendance can not be marked for future dates,No es poden entrar assistències per dates futures
+Attendance for employee {0} is already marked,Assistència per a l'empleat {0} ja està marcat
+Attendance record.,
+Auditor,Auditor
+Authorization Control,Control d'Autorització
+Authorization Rule,
+Auto Accounting For Stock Settings,
+Auto Material Request,Sol·licitud de material automàtica
+Auto-raise Material Request if quantity goes below re-order level in a warehouse,Puja automàticament la quantitat de material a demanar si la quantitat està per sota de nivell de re-ordre en un magatzem
+Automatically compose message on submission of transactions.,Compondre automàticament el missatge en la presentació de les transaccions.
+Automatically updated via Stock Entry of type Manufacture or Repack,
+Automotive,Automòbil
+Autoreply when a new mail is received,
+Available,
+Available Qty at Warehouse,
+Available Stock for Packing Items,Estoc disponible per articles d'embalatge
+"Available in BOM, Delivery Note, Purchase Invoice, Production Order, Purchase Order, Purchase Receipt, Sales Invoice, Sales Order, Stock Entry, Timesheet","Disponible a la llista de materials, nota de lliurament, factura de compra, ordre de producció, ordres de compra, rebut de compra, factura de venda, ordres de venda, entrada d'estoc, fulla d'hores"
+Average Age,
+Average Commission Rate,Comissió de Tarifes mitjana
+Average Discount,Descompte Mig
+Avg Daily Outgoing,
+Avg. Buying Rate,Quota de compra mitja
+Awesome Products,
+Awesome Services,
+BOM Detail No,Detall del BOM No
+BOM Explosion Item,Explosió de BOM d'article
+BOM Item,Article BOM
+BOM No,
+BOM No. for a Finished Good Item,
+BOM Operation,
+BOM Operations,Operacions BOM
+BOM Rate,BOM Rate
+BOM Replace Tool,
+BOM number is required for manufactured Item {0} in row {1},
+BOM number not allowed for non-manufactured Item {0} in row {1},Número de BOM (llista de materials) no permès per l'article no-manufacturat {0} a la fila {1}
+BOM recursion: {0} cannot be parent or child of {2},BOM recursiu: {0} no pot ser pare o fill de {2}
+BOM replaced,
+BOM {0} for Item {1} in row {2} is inactive or not submitted,
+BOM {0} is not active or not submitted,
+BOM {0} is not submitted or inactive BOM for Item {1},El BOM {0} no esta Presentat o està inactiu per l'article {1}
+Backup Manager,
+Backup Right Now,
+Backups will be uploaded to,Les còpies de seguretat es pujaran a
+Balance,
+Balance Qty,Saldo Quantitat
+Balance Sheet,Balanç
+Balance Value,
+Balance for Account {0} must always be {1},Balanç per compte {0} ha de ser sempre {1}
+Balance must be,El balanç ha de ser
+"Balances of Accounts of type ""Bank"" or ""Cash""",
+Bank,Banc
+Bank / Cash Account,
+Bank A/C No.,Número de Compte Corrent
+Bank Account,Compte Bancari
+Bank Account No.,Compte Bancari No.
+Bank Accounts,Comptes bancaris
+Bank Clearance Summary,
+Bank Draft,
+Bank Name,Nom del banc
+Bank Overdraft Account,Bank Overdraft Account
+Bank Reconciliation,Conciliació bancària
+Bank Reconciliation Detail,
+Bank Reconciliation Statement,Declaració de Conciliació Bancària
+Bank Voucher,
+Bank/Cash Balance,Banc / Balanç de Caixa
+Banking,Banca
+Barcode,Codi de barres
+Barcode {0} already used in Item {1},
+Based On,Basat en
+Basic,Bàsic
+Basic Info,
+Basic Information,Informació bàsica
+Basic Rate,Tarifa Bàsica
+Basic Rate (Company Currency),Tarifa Bàsica (En la divisa de la companyia)
+Batch,
+Batch (lot) of an Item.,
+Batch Finished Date,
+Batch ID,Identificació de lots
+Batch No,Lot número
+Batch Started Date,
+Batch Time Logs for Billing.,
+Batch Time Logs for billing.,
+Batch-Wise Balance History,Batch-Wise Balance History
+Batched for Billing,Agrupat per a la Facturació
+Better Prospects,
+Bill Date,Data de la factura
+Bill No,Factura Número
+Bill of Material,Llista de materials (BOM)
+Bill of Material to be considered for manufacturing,
+Bill of Materials (BOM),Llista de materials (BOM)
+Billable,
+Billed,Facturat
+Billed Amount,Quantitat facturada
+Billed Amt,Quantitat facturada
+Billing,
+Billing (Sales Invoice),
+Billing Address,
+Billing Address Name,Nom de l'adressa de facturació
+Billing Status,Estat de facturació
+Bills raised by Suppliers.,
+Bills raised to Customers.,Factures enviades als clients.
+Bin,Paperera
+Bio,Bio
+Biotechnology,
+Birthday,
+Block Date,Bloquejar Data
+Block Days,Bloc de Dies
+Block Holidays on important days.,
+Block leave applications by department.,Bloquejar sol·licituds d'absències per departament.
+Blog Post,Post Blog
+Blog Subscriber,
+Blood Group,
+Both Warehouse must belong to same Company,
+Box,
+Branch,Branca
+Brand,Marca comercial
+Brand Name,
+Brand master.,
+Brands,
+Breakdown,Breakdown
+Broadcasting,
+Brokerage,
+Budget,Pressupost
+Budget Allocated,Pressupost assignat
+Budget Detail,Detall del Pressupost
+Budget Details,Detalls del Pressupost
+Budget Distribution,Distribució del Pressupost
+Budget Distribution Detail,
+Budget Distribution Details,Budget Distribution Details
+Budget Variance Report,
+Budget cannot be set for Group Cost Centers,
+Build Report,Redactar Informe
+Bundle items at time of sale.,Articles agrupats en el moment de la venda.
+Business Development Manager,
+Buyer of Goods and Services.,Compradors de Productes i Serveis.
+Buying,
+Buying & Selling,
+Buying Amount,
+Buying Settings,
+"Buying must be checked, if Applicable For is selected as {0}",
+C-Form,C-Form
+C-Form Applicable,C-Form Applicable
+C-Form Invoice Detail,C-Form Invoice Detail
+C-Form No,
+C-Form records,
+CENVAT Capital Goods,
+CENVAT Edu Cess,
+CENVAT SHE Cess,
+CENVAT Service Tax,CENVAT Service Tax
+CENVAT Service Tax Cess 1,
+CENVAT Service Tax Cess 2,CENVAT Service Tax Cess 2
+Calculate Based On,
+Calculate Total Score,Calcular Puntuació total
+Calendar Events,
+Call,Truca
+Calls,Trucades
+Campaign,Campanya
+Campaign Name,
+Campaign Name is required,Cal un nom de Campanya
+Campaign Naming By,Naming de Campanya Per
+Campaign-.####,Campanya-.####
+Can be approved by {0},Pot ser aprovat per {0}
+"Can not filter based on Account, if grouped by Account",
+"Can not filter based on Voucher No, if grouped by Voucher","Can not filter based on Voucher No, if grouped by Voucher"
+Can refer row only if the charge type is 'On Previous Row Amount' or 'Previous Row Total',
+Cancel Material Visit {0} before cancelling this Customer Issue,Cancel·la la visita de material {0} abans de cancel·lar aquesta incidència de client
+Cancel Material Visits {0} before cancelling this Maintenance Visit,Cancel·la Visites Materials {0} abans de cancel·lar aquesta visita de manteniment
+Cancelled,
+Cancelling this Stock Reconciliation will nullify its effect.,Cancel·lant aquesta reconciliació d'estocs anul·larà el seu efecte.
+Cannot Cancel Opportunity as Quotation Exists,No es pot Cancel·lar Oportunitat perquè hi ha ofertes
+Cannot approve leave as you are not authorized to approve leaves on Block Dates,No es pot aprovar l'absència perquè no estàs autoritzat per aprovar-les en dates bloquejades
+Cannot cancel because Employee {0} is already approved for {1},No es pot cancel·lar perquè Empleat {0} ja està aprovat per {1}
+Cannot cancel because submitted Stock Entry {0} exists,No es pot cancel·lar perquè l'entrada d'estoc {0} ja ha estat Presentada
+Cannot carry forward {0},No es pot tirar endavant {0}
+Cannot change Fiscal Year Start Date and Fiscal Year End Date once the Fiscal Year is saved.,No es poden canviar les dates de l'any finscal (inici i fi) una vegada ha estat desat
+"Cannot change company's default currency, because there are existing transactions. Transactions must be cancelled to change the default currency.",
+Cannot convert Cost Center to ledger as it has child nodes,"No es pot convertir de centres de cost per al llibre major, ja que té nodes secundaris"
+Cannot covert to Group because Master Type or Account Type is selected.,No es pot convertir en Grup perquè està seleccionat Type Master o Tipus de Compte.
+Cannot deactive or cancle BOM as it is linked with other BOMs,No es pot Desactivar o cancelar el BOM ja que està vinculat a d'altres llistes de materials
+"Cannot declare as lost, because Quotation has been made.","No es pot declarar com perdut, perquè s'han fet ofertes"
+Cannot deduct when category is for 'Valuation' or 'Valuation and Total',
+"Cannot delete Serial No {0} in stock. First remove from stock, then delete.",
+"Cannot directly set amount. For 'Actual' charge type, use the rate field","No es pot establir directament quantitat. Per l'""Actual"" tipus de càrrec utilitzeu el camp de canvi"
+"Cannot overbill for Item {0} in row {1} more than {2}. To allow overbilling, please set in Stock Settings","No es pot sobrefacturar l'element {0} a la fila {1} més de {2}. Per permetre la sobrefacturació, configura-ho a configuració d'existències"
+Cannot produce more Item {0} than Sales Order quantity {1},
+Cannot refer row number greater than or equal to current row number for this Charge type,No es pot fer referència número de la fila superior o igual al nombre de fila actual d'aquest tipus de càrrega
+Cannot return more than {0} for Item {1},
+Cannot select charge type as 'On Previous Row Amount' or 'On Previous Row Total' for first row,No es pot seleccionar el tipus de càrrega com 'Suma de la fila anterior' o 'Total de la fila anterior' per la primera fila
+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,"No es pot seleccionar el tipus de càrrega com 'On Anterior Suma Fila ""o"" L'anterior Fila Total ""per a la valoració. Només podeu seleccionar l'opció ""Total"" per la quantitat fila anterior o següent total de la fila"
+Cannot set as Lost as Sales Order is made.,
+Cannot set authorization on basis of Discount for {0},No es pot establir l'autorització sobre la base de Descompte per {0}
+Capacity,Capacitat
+Capacity Units,Unitats de Capacitat
+Capital Account,Capital Account
+Capital Equipments,Capital Equipments
+Carry Forward,
+Carry Forwarded Leaves,
+Case No(s) already in use. Try from Case No {0},
+Case No. cannot be 0,
+Cash,
+Cash In Hand,Efectiu disponible
+Cash Voucher,Tiquet de caixa
+Cash or Bank Account is mandatory for making payment entry,
+Cash/Bank Account,Compte de Caixa / Banc
+Casual Leave,
+Cell Number,Número de cel·la
+Change Abbreviation,
+Change UOM for an Item.,Canviar la UDM d'un article
+Change the starting / current sequence number of an existing series.,Canviar el número de seqüència inicial/actual d'una sèrie existent.
+Channel Partner,Partner de Canal
+Charge of type 'Actual' in row {0} cannot be included in Item Rate,Càrrec del tipus 'real' a la fila {0} no pot ser inclòs en la partida Rate
+Chargeable,Facturable
+Charges are updated in Purchase Receipt against each item,Els càrrecs s'actualitzen amb els rebuts de compra contra cada un dels articles
+"Charges will be distributed proportionately based on item qty or amount, as per your selection","Els càrrecs es distribuiran proporcionalment basen en Quantitat o import de l'article, segons la teva selecció"
+Charity and Donations,Caritat i Donacions
+Chart Name,Nom del diagrama
+Chart of Accounts,Pla General de Comptabilitat
+Chart of Cost Centers,Gràfic de centres de cost
+Check how the newsletter looks in an email by sending it to your email.,Comprova com es veu el butlletí en un correu electrònic enviant-lo al teu correu electrònic.
+"Check if recurring invoice, uncheck to stop recurring or put proper End Date",
+"Check if recurring order, uncheck to stop recurring or put proper End Date","Marca-ho si és una ordre recurrent, desmarca per aturar recurrents o posa la data final"
+"Check if you need automatic recurring invoices. After submitting any sales invoice, Recurring section will be visible.","Comproveu si necessita factures recurrents automàtiques. Després de Presentar qualsevol factura de venda, la secció recurrent serà visible."
+Check if you want to send salary slip in mail to each employee while submitting salary 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.,Seleccioneu aquesta opció si voleu obligar l'usuari a seleccionar una sèrie abans de desar. No hi haurà cap valor per defecte si marca aquesta.
+Check this if you want to show in website,Seleccioneu aquesta opció si voleu que aparegui en el lloc web
+Check this to disallow fractions. (for Nos),Habiliteu aquesta opció per no permetre fraccions. (Per números)
+Check this to pull emails from your mailbox,Selecciona perenviar correus electrònics de la seva bústia de correu
+Check to activate,Marca per activar
+Check to make Shipping Address,
+Check to make primary address,Comproveu que hi hagi la direcció principal
+Chemical,
+Cheque,
+Cheque Date,Data Xec
+Cheque Number,Número de Xec
+Child account exists for this account. You can not delete this account.,
+City,
+City/Town,Ciutat / Poble
+Claim Amount,Reclamació Import
+Claims for company expense.,
+Class / Percentage,
+Classic,
+Classification of Customers by region,Classificació dels clients per regió
+Clear Table,Taula en blanc
+Clearance Date,Data Liquidació
+Clearance Date not mentioned,No s'esmenta l'espai de dates
+Clearance date cannot be before check date in row {0},La data de liquidació no pot ser anterior a la data de verificació a la fila {0}
+Click on 'Make Sales Invoice' button to create a new Sales Invoice.,
+Click on a link to get options to expand get options ,
+Client,Client
+Close,Close
+Close Balance Sheet and book Profit or Loss.,
+Closed,Tancat
+Closing (Cr),Tancament (Cr)
+Closing (Dr),Tancament (Dr)
+Closing Account Head,Tancant el Compte principal
+Closing Account {0} must be of type 'Liability',El Compte de tancament {0} ha de ser del tipus 'responsabilitat'
+Closing Date,Data de tancament
+Closing Fiscal Year,Tancant l'Any Fiscal
+CoA Help,CoA Help
+Code,Codi
+Cold Calling,Trucades en fred
+Color,Color
+Column Break,
+Column Break 1,Column Break 1
+Comma separated list of email addresses,
+Comment,
+Comments,Comentaris
+Commercial,Comercial
+Commission,Comissió
+Commission Rate,Percentatge de comissió
+Commission Rate (%),Comissió (%)
+Commission on Sales,Comissió de Vendes
+Commission rate cannot be greater than 100,La Comissió no pot ser major que 100
+Communication,Comunicació
+Communication HTML,Comunicació HTML
+Communication History,
+Communication log.,Registre de Comunicació.
+Communications,Comunicacions
+Company,Empresa
+Company (not Customer or Supplier) master.,Companyia (no client o proveïdor) mestre.
+Company Abbreviation,Abreviatura de l'empresa
+Company Details,
+Company Email,Email de l'empresa
+"Company Email ID not found, hence mail not sent","ID de correu electrònic de l'empresa no trobat, per tant, no s'ha enviat el correu"
+Company Info,
+Company Name,Nom de l'Empresa
+Company Settings,
+Company is missing in warehouses {0},Falta Empresa als magatzems {0}
+Company is required,
+Company registration numbers for your reference. Example: VAT Registration Numbers etc.,Els números de registre de l'empresa per la teva referència. Per exemple: Els números de registre d'IVA etc
+Company registration numbers for your reference. Tax numbers etc.,
+"Company, Month and Fiscal Year is mandatory","Empresa, mes i de l'any fiscal és obligatòri"
+Compensatory Off,Compensatori
+Complete,Complet
+Complete Setup,
+Completed,Acabat
+Completed Production Orders,
+Completed Qty,Quantitat completada
+Completion Date,Data d'acabament
+Completion Status,Estat de finalització
+Computer,Ordinador
+Computers,Ordinadors
+Confirmation Date,Data de confirmació
+Confirmed orders from Customers.,Comandes en ferm dels clients.
+Consider Tax or Charge for,Consider Tax or Charge for
+Considered as Opening Balance,Considerat com a saldo d'obertura
+Considered as an Opening Balance,Considerat com un saldo d'obertura
+Consultant,Consultor
+Consulting,Consulting
+Consumable,
+Consumable Cost,Cost de consumibles
+Consumable cost per hour,Cost de consumibles per hora
+Consumed,
+Consumed Amount,
+Consumed Qty,Quantitat utilitzada
+Consumer Products,
+Contact,Contacte
+Contact Desc,Descripció del Contacte
+Contact Details,
+Contact Email,
+Contact HTML,Contacte HTML
+Contact Info,Informació de Contacte
+Contact Mobile No,
+Contact Name,Nom de Contacte
+Contact No.,Número de Contacte
+Contact Person,Persona De Contacte
+Contact Type,Tipus de contacte
+Contact master.,
+Contacts,
+Content,Contingut
+Content Type,
+Contra Voucher,
+Contract,
+Contract End Date,Data de finalització de contracte
+Contract End Date must be greater than Date of Joining,La Data de finalització del contracte ha de ser major que la data d'inici
+Contribution %,
+Contribution (%),
+Contribution Amount,Quantitat aportada
+Contribution to Net Total,Contribució neta total
+Conversion Factor,Factor de conversió
+Conversion Factor is required,
+Conversion factor cannot be in fractions,Factor de conversió no pot estar en fraccions
+Conversion factor for default Unit of Measure must be 1 in row {0},
+Conversion rate cannot be 0 or 1,La taxa de conversió no pot ser 0 o 1
+Convert to Group,
+Convert to Ledger,Convertir a llibre major
+Converted,Convertit
+Copy From Item Group,Copiar del Grup d'Articles
+Cosmetics,Productes cosmètics
+Cost Center,Centre de Cost
+Cost Center Details,Detalls del centre de cost
+Cost Center For Item with Item Code ',Centre de cost per l'article amb Codi d'article '
+Cost Center Name,Nom del centre de cost
+Cost Center is required for 'Profit and Loss' account {0},
+Cost Center is required in row {0} in Taxes table for type {1},
+Cost Center with existing transactions can not be converted to group,Un Centre de costos amb transaccions existents no es pot convertir en grup
+Cost Center with existing transactions can not be converted to ledger,Centre de costos de les transaccions existents no es pot convertir en llibre major
+Cost Center {0} does not belong to Company {1},El Centre de cost {0} no pertany a l'empresa {1}
+Cost of Delivered Items,Cost dels articles lliurats
+Cost of Goods Sold,Cost de Vendes
+Cost of Issued Items,
+Cost of Purchased Items,El cost d'articles comprats
+Costing,
+Country,
+Country Name,Nom del país
+Country wise default Address Templates,
+"Country, Timezone and Currency","País, Zona horària i moneda"
+Cr,Cr
+Create Bank Voucher for the total salary paid for the above selected criteria,Create Bank Voucher for the total salary paid for the above selected criteria
+Create Customer,
+Create Material Requests,
+Create New,Crear nou
+Create Opportunity,Crear Oportunitats
+Create Payment Entries against Orders or Invoices.,
+Create Production Orders,Crear ordres de producció
+Create Quotation,
+Create Receiver List,Crear Llista de receptors
+Create Salary Slip,Crear fulla de nòmina
+Create Stock Ledger Entries when you submit a Sales Invoice,Crear moviments d'estoc quan es presenta una factura de venda
+Create and Send Newsletters,
+"Create and manage daily, weekly and monthly email digests.",
+Create rules to restrict transactions based on values.,Crear regles per restringir les transaccions basades en valors.
+Created By,Creat per
+Creates salary slip for above mentioned criteria.,Crea nòmina per als criteris abans esmentats.
+Creation Date,
+Creation Document No,Creació document nº
+Creation Document Type,Creació de tipus de document
+Creation Time,
+Credentials,
+Credit,
+Credit Amt,Credit Amt
+Credit Card,Targeta De Crèdit
+Credit Card Voucher,Tiquet de targeta de crèdit
+Credit Controller,
+Credit Days,
+Credit Limit,Límit de Crèdit
+Credit Note,
+Credit To,Crèdit Per
+Cross Listing of Item in multiple groups,Creu Fitxa d'article en diversos grups
+Currency,
+Currency Exchange,Valor de Canvi de divisa
+Currency Name,
+Currency Settings,Ajustaments de divises
+Currency and Price List,
+Currency exchange rate master.,Tipus de canvi principal.
+Current Address,Adreça actual
+Current Address Is,L'adreça actual és
+Current Assets,
+Current BOM,BOM actual
+Current BOM and New BOM can not be same,El BOM actual i el nou no poden ser el mateix
+Current Fiscal Year,Any fiscal actual
+Current Liabilities,
+Current Stock,Estoc actual
+Current Stock UOM,
+Current Value,
+Custom,A mida
+Custom Autoreply Message,
+Custom Message,Missatge personalitzat
+Customer,Client
+Customer (Receivable) Account,Compte de Clients (per cobrar)
+Customer / Item Name,
+Customer / Lead Address,
+Customer / Lead Name,nom del Client/Client Potencial
+Customer > Customer Group > Territory,Client> Grup de Clients> Territori
+Customer Account,
+Customer Account Head,
+Customer Acquisition and Loyalty,Captació i Fidelització
+Customer Address,
+Customer Addresses And Contacts,Adreces de clients i contactes
+Customer Addresses and Contacts,Adreces de clients i contactes
+Customer Code,Codi de Client
+Customer Codes,Codis de clients
+Customer Details,
+Customer Feedback,Comentaris del client
+Customer Group,Grup de Clients
+Customer Group / Customer,
+Customer Group Name,
+Customer Id,ID del client
+Customer Issue,Incidència de Client
+Customer Issue against Serial No.,Incidència de client amb l'article amb número de sèrie
+Customer Name,Nom del client
+Customer Naming By,Customer Naming By
+Customer Service,Servei Al Client
+Customer database.,Base de dades de clients.
+Customer is required,Es requereix client
+Customer master.,
+Customer required for 'Customerwise Discount',
+Customer {0} does not belong to project {1},
+Customer {0} does not exist,El client {0} no existeix
+Customer's Item Code,
+Customer's Purchase Order Date,Data de l'ordre de compra del client
+Customer's Purchase Order No,
+Customer's Purchase Order Number,Número de Comanda del Client
+Customer's Vendor,Venedor del Client
+Customers Not Buying Since Long Time,
+Customers Not Buying Since Long Time ,
+Customerwise Discount,
+Customize,Personalitza
+Customize the Notification,
+Customize the introductory text that goes as a part of that email. Each transaction has a separate introductory text.,Personalitza el text d'introducció que va com una part d'aquest correu electrònic. Cada transacció té un text introductori independent.
+DN Detail,Detall DN
+Daily,Diari
+Daily Time Log Summary,Resum diari del registre de temps
+Database Folder ID,Database Folder ID
+Database of potential customers.,Base de dades de clients potencials.
+Date,Data
+Date Format,Format de data
+Date Of Retirement,Data de la jubilació
+Date Of Retirement must be greater than Date of Joining,Data de la jubilació ha de ser major que la data del contracte
+Date is repeated,Data repetida
+Date of Birth,Data de naixement
+Date of Issue,
+Date of Joining,Data d'ingrés
+Date of Joining must be greater than Date of Birth,Data d'ingrés ha de ser major que la data de naixement
+Date on which lorry started from supplier warehouse,
+Date on which lorry started from your warehouse,Data en què el camió va sortir del teu magatzem
+Dates,Dates
+Days Since Last Order,
+Days for which Holidays are blocked for this department.,Dies de festa que estan bloquejats per aquest departament.
+Dealer,
+Debit,
+Debit Amt,Dèbit
+Debit Note,Nota de Dèbit
+Debit To,
+Debit and Credit not equal for this voucher. Difference is {0}.,Dèbit i credit diferent per aquest comprovant. La diferència és {0}.
+Deduct,
+Deduction,Deducció
+Deduction Type,
+Deduction1,Deducció 1
+Deductions,Deduccions
+Default,Defecte
+Default Account,Compte predeterminat
+Default Address Template cannot be deleted,La Plantilla de la direcció predeterminada no es pot eliminar
+Default Amount,Default Amount
+Default BOM,BOM predeterminat
+Default Bank / Cash account will be automatically updated in POS Invoice when this mode is selected.,El compte bancs/efectiu predeterminat s'actualitzarà automàticament a les factures de TPV quan es selecciona aquest.
+Default Bank Account,
+Default Buying Cost Center,Centres de cost de compres predeterminat
+Default Buying Price List,Llista de preus per defecte
+Default Cash Account,Compte de Tresoreria predeterminat
+Default Company,
+Default Cost Center,Centre de cost predeterminat
+Default Currency,
+Default Customer Group,
+Default Expense Account,Compte de Despeses predeterminat
+Default Income Account,Compte d'Ingressos predeterminat
+Default Item Group,Grup d'articles predeterminat
+Default Price List,Llista de preus per defecte
+Default Purchase Account in which cost of the item will be debited.,Compte de Compra predeterminat en la qual es carregarà el cost de l'article.
+Default Selling Cost Center,
+Default Settings,
+Default Source Warehouse,Magatzem d'origen predeterminat
+Default Stock UOM,UDM d'estoc predeterminat
+Default Supplier,
+Default Supplier Type,Tipus predeterminat de Proveïdor
+Default Target Warehouse,Magatzem de destí predeterminat
+Default Territory,Territori per defecte
+Default Unit of Measure,Unitat de mesura per defecte
+"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.",
+Default Valuation Method,Mètode de valoració predeterminat
+Default Warehouse,Magatzem predeterminat
+Default Warehouse is mandatory for stock Item.,El magatzem predeterminat és obligatòria pels articles d'estoc
+Default settings for accounting transactions.,Ajustos predeterminats per a les operacions comptables.
+Default settings for buying transactions.,Ajustos predeterminats per a transaccions de compra.
+Default settings for selling transactions.,Ajustos predeterminats per a les transaccions de venda
+Default settings for stock transactions.,
+Defense,
+"Define Budget for this Cost Center. To set budget action, see <a href=""#!List/Company"">Company Master</a>","Definir Pressupost per a aquest centre de cost. Per configurar l'acció de pressupost, consulteu <a href=""#!List/Company"">Company Master</a>"
+Del,Esborra
+Delete,Esborrar
+Delivered,
+Delivered Amount,
+Delivered Items To Be Billed,Articles lliurats pendents de facturar
+Delivered Qty,Quantitat lliurada
+Delivered Serial No {0} cannot be deleted,
+Delivery Date,Data De Lliurament
+Delivery Details,
+Delivery Document No,
+Delivery Document Type,Tipus de document de lliurament
+Delivery Note,Nota de lliurament
+Delivery Note Item,
+Delivery Note Items,
+Delivery Note Message,Missatge de la Nota de lliurament
+Delivery Note No,Número d'albarà de lliurament
+Delivery Note Required,Nota de lliurament Obligatòria
+Delivery Note Trends,Nota de lliurament Trends
+Delivery Note {0} is not submitted,La Nota de lliurament {0} no està presentada
+Delivery Note {0} must not be submitted,La Nota de lliurament {0} no es pot presentar
+Delivery Note/Sales Invoice,Nota de lliurament / Factura
+Delivery Notes {0} must be cancelled before cancelling this Sales Order,
+Delivery Status,Estat de l'enviament
+Delivery Time,Temps de Lliurament
+Delivery To,Lliurar a
+Department,Departament
+Department Stores,Grans Magatzems
+Depends on LWP,
+Depreciation,
+Description,Descripció
+Description HTML,Descripció HTML
+Description of a Job Opening,
+Designation,Designació
+Designer,
+Detailed Breakup of the totals,
+Details,
+Difference (Dr - Cr),Diferència (Dr - Cr)
+Difference Account,Compte de diferències
+"Difference Account must be a 'Liability' type account, since this Stock Reconciliation is an Opening Entry","El compte de diferències ha de ser un compte de tipus 'responsabilitat', ja que aquest ajust d'estocs és una entrada d'Obertura"
+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.,UDMs diferents per als articles provocarà pesos nets (Total) erronis. Assegureu-vos que pes net de cada article és de la mateixa UDM.
+Direct Expenses,
+Direct Income,
+Disable,
+Disable Rounded Total,Desactivar total arrodonit
+Disabled,Deshabilitat
+Discount,
+Discount  %,
+Discount %,% Descompte
+Discount (%),Descompte (%)
+Discount Amount,
+Discount Amount (Company Currency),
+"Discount Fields will be available in Purchase Order, Purchase Receipt, Purchase Invoice","Els camps de descompte estaran disponible a l'ordre de compra, rebut de compra, factura de compra"
+Discount Percentage,%Descompte
+Discount Percentage can be applied either against a Price List or for all Price List.,El percentatge de descompte es pot aplicar ja sigui contra una llista de preus o per a tot Llista de Preus.
+Discount must be less than 100,Descompte ha de ser inferior a 100
+Discount(%),
+Dispatch,
+Display all the individual items delivered with the main items,
+Distinct unit of an Item,
+Distribute Charges Based On,Distribuir els càrrecs en base a
+Distribution,Distribució
+Distribution Id,ID de Distribució
+Distribution Name,Distribution Name
+Distributor,Distribuïdor
+Divorced,Divorciat
+Do Not Contact,
+Do not show any symbol like $ etc next to currencies.,
+Do really want to unstop production order: ,
+Do you really want to STOP ,
+Do you really want to STOP this Material Request?,
+Do you really want to Submit all Salary Slip for month {0} and year {1},Realment vols presentar totes les nòmines del mes {0} i any {1}
+Do you really want to UNSTOP ,
+Do you really want to UNSTOP this Material Request?,
+Do you really want to stop production order: ,
+Doc Name,Nom del document
+Doc Type,
+Document Description,Descripció Document
+Document Type,Tipus de document
+Documents,
+Domain,
+Don't send Employee Birthday Reminders,
+Download Materials Required,Es requereix descàrrega de materials
+Download Reconcilation Data,
+Download Template,Descarregar plantilla
+Download a report containing all raw materials with their latest inventory status,Descarrega un informe amb totes les matèries primeres amb el seu estat últim inventari
+"Download the Template, fill appropriate data and attach the modified file.","Descarregueu la plantilla, omplir les dades adequades i adjuntar l'arxiu modificat."
+"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","Descarregueu la plantilla, ompliu les dades i adjuntar l'arxiu modificat.
+ Apareixeran tots els registres de presència del treballador en el període marcat"
+Dr,Dr
+Draft,Esborrany
+Dropbox,
+Dropbox Access Allowed,Dropbox Access Allowed
+Dropbox Access Key,Dropbox Access Key
+Dropbox Access Secret,Dropbox Access Secret
+Due Date,
+Due Date cannot be before Posting Date,Data de venciment no pot ser anterior Data de comptabilització
+Duplicate Entry. Please check Authorization Rule {0},"Entrada duplicada. Si us plau, consulteu Regla d'autorització {0}"
+Duplicate Serial No entered for Item {0},Número de sèrie duplicat per l'article {0}
+Duplicate entry,Entrada duplicada
+Duplicate row {0} with same {1},
+Duties and Taxes,Taxes i impostos
+ERPNext Setup,Configuració ERPNext
+Earliest,Earliest
+Earnest Money,
+Earning,Guany
+Earning & Deduction,Guanyar i Deducció
+Earning Type,
+Earning1,Benefici 1
+Edit,Edita
+Edu. Cess on Excise,
+Edu. Cess on Service Tax,Edu. Cess on Service Tax
+Edu. Cess on TDS,
+Education,Educació
+Educational Qualification,
+Educational Qualification Details,Detalls de les qualificacions de formació
+Eg. smsgateway.com/api/send_sms.cgi,
+Either debit or credit amount is required for {0},Es requereix ja sigui quantitat de dèbit o crèdit per {0}
+Either target qty or target amount is mandatory,Cal la Quantitat destí i la origen
+Either target qty or target amount is mandatory.,Tan quantitat destí com Quantitat són obligatoris.
+Electrical,
+Electricity Cost,Cost d'electricitat
+Electricity cost per hour,
+Electronics,
+Email,
+Email Digest,
+Email Digest Settings,Ajustos del processador d'emails
+Email Digest: ,
+Email ID,ID de correu electrònic
+Email Id,Identificació de l'email
+"Email Id where a job applicant will email e.g. ""jobs@example.com""","Email Id where a job applicant will email e.g. ""jobs@example.com"""
+Email Notifications,Notificacions per correu electrònic
+Email Sent?,
+Email Settings for Outgoing and Incoming Emails.,
+"Email id must be unique, already exists for {0}","L'adreça de correu electrònic ha de ser única, ja existeix per {0}"
+Email ids separated by commas.,Correus electrònics separats per comes.
+"Email settings for jobs email id ""jobs@example.com""",
+"Email settings to extract Leads from sales email id e.g. ""sales@example.com""","Configuració de l'adreça de correu electrònic per a clients potencials amb correus electrònic comercials. Per exemple ""sales@example.com"""
+Emergency Contact,Contacte d'Emergència
+Emergency Contact Details,
+Emergency Phone,Telèfon d'Emergència
+Employee,Empleat
+Employee Birthday,Aniversari d'Empleat
+Employee Details,
+Employee Education,Formació Empleat
+Employee External Work History,Historial de treball d'Empleat extern
+Employee Information,
+Employee Internal Work History,Historial de treball intern de l'empleat
+Employee Internal Work Historys,
+Employee Leave Approver,
+Employee Leave Balance,Balanç d'absències d'empleat
+Employee Name,Nom de l'Empleat
+Employee Number,Número d'empleat
+Employee Records to be created by,Registres d'empleats a ser creats per
+Employee Settings,Configuració dels empleats
+Employee Type,
+Employee can not be changed,
+"Employee designation (e.g. CEO, Director etc.).","Designació de l'empleat (per exemple, director general, director, etc.)."
+Employee master.,Taula Mestre d'Empleats.
+Employee record is created using selected field. ,
+Employee records.,
+Employee relieved on {0} must be set as 'Left',Empleat rellevat en {0} ha de ser establert com 'Esquerra'
+Employee {0} has already applied for {1} between {2} and {3},L'Empleat {0} ja ha sol·licitat {1} entre {2} i {3}
+Employee {0} is not active or does not exist,L'Empleat {0} no està actiu o no existeix
+Employee {0} was on leave on {1}. Cannot mark attendance.,
+Employees Email Id,
+Employment Details,Detalls d'Ocupació
+Employment Type,Tipus d'Ocupació
+Enable / disable currencies.,Activar / desactivar les divises.
+Enabled,Activat
+Encashment Date,Data Cobrament
+End Date,
+End Date can not be less than Start Date,
+End date of current invoice's period,Data de finalització del període de facturació actual
+End date of current order's period,Data de finalització del període de l'ordre actual
+End of Life,Final de la Vida
+Energy,Energia
+Engineer,
+Enter Verification Code,Introduïu el codi de verificació
+Enter campaign name if the source of lead is campaign.,Introduïu nom de la campanya si la font de clients potencials és una campanya.
+Enter department to which this Contact belongs,Introduïu departament al qual pertany aquest contacte
+Enter designation of this Contact,
+"Enter email id separated by commas, invoice will be mailed automatically on particular date",
+"Enter email id separated by commas, order will be mailed automatically on particular date",
+Enter items and planned qty for which you want to raise production orders or download raw materials for analysis.,
+Enter name of campaign if source of enquiry is campaign,
+"Enter static url parameters here (Eg. sender=ERPNext, username=ERPNext, password=1234 etc.)",
+Enter the company name under which Account Head will be created for this Supplier,Introduïu el nom de l'empresa per la que es crearà el compte principal per aquest proveïdor
+Enter url parameter for message,
+Enter url parameter for receiver nos,Introdueix els paràmetres URL per als receptors
+Entertainment & Leisure,Entreteniment i Oci
+Entertainment Expenses,Despeses d'Entreteniment
+Entries,
+Entries against ,
+Entries are not allowed against this Fiscal Year if the year is closed.,
+Equity,
+Error: {0} > {1},Error: {0}> {1}
+Estimated Material Cost,Cost estimat del material
+"Even if there are multiple Pricing Rules with highest priority, then following internal priorities are applied:","Fins i tot si hi ha diverses regles de preus amb major prioritat, s'apliquen prioritats internes:"
+Everyone can read,
+"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.","Exemple :. ABCD ##### 
+ Si la sèrie s'estableix i Número de sèrie no s'esmenta en les transaccions, llavors es crearà un número de sèrie automàticament basat en aquesta sèrie. Si sempre vol indicar explícitament els números de sèrie per a aquest article. deixeu en blanc."
+Exchange Rate,Tipus De Canvi
+Excise Duty 10,
+Excise Duty 14,
+Excise Duty 4,Impostos Especials 4
+Excise Duty 8,Impostos Especials 8
+Excise Duty @ 10,
+Excise Duty @ 14,
+Excise Duty @ 4,Excise Duty @ 4
+Excise Duty @ 8,
+Excise Duty Edu Cess 2,Excise Duty Edu Cess 2
+Excise Duty SHE Cess 1,Excise Duty SHE Cess 1
+Excise Page Number,Excise Page Number
+Excise Voucher,Excise Voucher
+Execution,
+Executive Search,
+Exhibition,Exposició
+Existing Customer,Client existent
+Exit,
+Exit Interview Details,Detalls de l'entrevista final
+Expected,Esperat
+Expected Completion Date can not be less than Project Start Date,
+Expected Date cannot be before Material Request Date,
+Expected Delivery Date,Data de lliurament esperada
+Expected Delivery Date cannot be before Purchase Order Date,Data prevista de lliurament no pot ser anterior a l'Ordre de Compra
+Expected Delivery Date cannot be before Sales Order Date,Data prevista de lliurament no pot ser abans de la data de l'ordres de venda
+Expected End Date,Esperat Data de finalització
+Expected Start Date,Data prevista d'inici
+Expected balance as per bank,Import pendent de rebre com per banc
+Expense,
+Expense / Difference account ({0}) must be a 'Profit or Loss' account,"El compte de despeses / diferències ({0}) ha de ser un compte ""Guany o Pèrdua '"
+Expense Account,Compte de Despeses
+Expense Account is mandatory,
+Expense Approver,Aprovador de despeses
+Expense Claim,Compte de despeses
+Expense Claim Approved,
+Expense Claim Approved Message,Missatge Reclamació d'aprovació de Despeses
+Expense Claim Detail,Reclamació de detall de despesa
+Expense Claim Details,
+Expense Claim Rejected,Compte de despeses Rebutjat
+Expense Claim Rejected Message,Missatge de rebuig de petició de despeses
+Expense Claim Type,Expense Claim Type
+Expense Claim has been approved.,El compte de despeses s'ha aprovat.
+Expense Claim has been rejected.,Compte de despeses rebutjada.
+Expense Claim is pending approval. Only the Expense Approver can update status.,El compte de despeses està pendent d'aprovació. Només l'aprovador de despeses pot actualitzar l'estat.
+Expense Date,Data de la Despesa
+Expense Details,
+Expense Head,
+Expense account is mandatory for item {0},El compte de despeses és obligatòria per a cada element {0}
+Expense or Difference account is mandatory for Item {0} as it impacts overall stock value,
+Expenses,
+Expenses Booked,
+Expenses Included In Valuation,Despeses incloses en la valoració
+Expenses booked for the digest period,Despeses reservades pel període
+Expired,Caducat
+Expiry,
+Expiry Date,Data De Caducitat
+Exports,Exportacions
+External,Extern
+Extract Emails,Extracte dels correus electrònics
+FCFS Rate,FCFS Rate
+Failed: ,
+Family Background,Antecedents de família
+Fax,
+Features Setup,Característiques del programa d'instal·lació
+Feed,
+Feed Type,
+Feedback,Resposta
+Female,Dona
+Fetch exploded BOM (including sub-assemblies),Fetch exploded BOM (including sub-assemblies)
+"Field available in Delivery Note, Quotation, Sales Invoice, Sales Order","El camp disponible a la nota de lliurament, oferta, factura de venda, ordres de venda"
+Files Folder ID,ID Carpeta d'arxius
+Fill the form and save it,Ompliu el formulari i deseu
+Filter based on customer,Filtre basat en el client
+Filter based on item,
+Financial / accounting year.,
+Financial Analytics,Comptabilitat analítica
+Financial Chart of Accounts. Imported from file.,
+Financial Services,
+Financial Year End Date,Data de finalització de l'exercici fiscal
+Financial Year Start Date,Data d'Inici de l'Exercici fiscal
+Finished Goods,Béns Acabats
+First Name,
+First Responded On,Primer respost el
+Fiscal Year,Any Fiscal
+Fiscal Year Start Date and Fiscal Year End Date are already set in Fiscal Year {0},
+Fiscal Year Start Date and Fiscal Year End Date cannot be more than a year apart.,
+Fiscal Year Start Date should not be greater than Fiscal Year End Date,
+Fiscal Year {0} not found.,
+Fixed Asset,Actius Fixos
+Fixed Assets,Actius Fixos
+Fixed Cycle Cost,
+Fold,Plegar
+Follow via Email,
+"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.",
+Food,Menjar
+"Food, Beverage & Tobacco",
+"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.","Per als articles 'BOM Vendes', magatzem, Número de sèrie i de lot No es tindran en compte en el quadre ""Packing List '.Si Magatzems i Números de lot són els mateixos per a tots els articles d'embalatge per a qualsevol article 'BOM de vendes', aquests valors es poden introduir a la taula principal d'articles, els valors es copiaran a la taula ""Packing List '."
+For Company,Per a l'empresa
+For Employee,Per als Empleats
+For Employee Name,Per Nom de l'Empleat
+For Price List,
+For Production,Per Producció
+For Reference Only.,
+For Sales Invoice,Per Factura Vendes
+For Server Side Print Formats,
+For Supplier,
+For Warehouse,
+For Warehouse is required before Submit,Cal informar del magatzem destí abans de presentar
+"For e.g. 2012, 2012-13","Per exemple, 2012, 2012-13"
+For reference,
+For reference only.,Només per referència.
+"For the convenience of customers, these codes can be used in print formats like Invoices and Delivery Notes","Per comoditat dels clients, aquests codis es poden utilitzar en formats d'impressió, com factures i albarans"
+"For {0}, only credit entries can be linked against another debit entry","Per {0}, només les entrades de crèdit poden vincular-se amb un altre assentament de dèbit"
+"For {0}, only debit entries can be linked against another credit entry",
+Fraction,Fracció
+Fraction Units,Fraction Units
+Freeze Stock Entries,
+Freeze Stocks Older Than [Days],Congela els estocs més vells de [dies]
+Freight and Forwarding Charges,Freight and Forwarding Charges
+Friday,
+From,
+From Bill of Materials,A partir de la llista de materials
+From Company,Des de l'empresa
+From Currency,De la divisa
+From Currency and To Currency cannot be same,
+From Customer,De Client
+From Customer Issue,De Incidència de Client
+From Date,
+From Date cannot be greater than To Date,
+From Date must be before To Date,
+From Date should be within the Fiscal Year. Assuming From Date = {0},
+From Datetime,
+From Delivery Note,De la nota de lliurament
+From Employee,
+From Lead,De client potencial
+From Maintenance Schedule,
+From Material Request,De Sol·licituds de materials
+From Opportunity,De Oportunitat
+From Package No.,Del paquet número
+From Purchase Order,De l'Ordre de Compra
+From Purchase Receipt,
+From Quotation,Des de l'oferta
+From Sales Order,
+From Supplier Quotation,Oferta de Proveïdor
+From Time,From Time
+From Value,
+From and To dates required,
+From value must be less than to value in row {0},De valor ha de ser inferior al valor de la fila {0}
+Frozen,Bloquejat
+Frozen Accounts Modifier,Modificador de Comptes bloquejats
+Fulfilled,Complert
+Full Name,Nom complet
+Full-time,Temps complet
+Fully Billed,
+Fully Completed,
+Fully Delivered,Totalment Lliurat
+Furniture and Fixture,Mobles
+Further accounts can be made under Groups but entries can be made against Ledger,"Es poden fer més comptes amb grups, però les entrades es poden fer contra Ledger"
+"Further accounts can be made under Groups, but entries can be made against Ledger",
+Further nodes can be only created under 'Group' type nodes,Només es poden crear més nodes amb el tipus 'Grup'
+GL Entry,Entrada GL
+Gantt Chart,Diagrama de Gantt
+Gantt chart of all tasks.,
+Gender,
+General,General
+General Ledger,
+General Settings,Configuració general
+Generate Description HTML,
+Generate Material Requests (MRP) and Production Orders.,
+Generate Salary Slips,
+Generate Schedule,Generar Calendari
+"Generate packing slips for packages to be delivered. Used to notify package number, package contents and its weight.",
+Generates HTML to include selected image in the description,
+Get Advances Paid,Obtenir bestretes pagades
+Get Advances Received,Obtenir les bestretes rebudes
+Get Current Stock,
+Get Items,
+Get Items From Purchase Receipts,Obtenir els articles des dels rebuts de compra
+Get Items From Sales Orders,Obtenir els articles des de les comandes de client
+Get Items from BOM,
+Get Last Purchase Rate,
+Get Outstanding Invoices,Rep les factures pendents
+Get Outstanding Vouchers,Get Outstanding Vouchers
+Get Relevant Entries,Obtenir assentaments corresponents
+Get Sales Orders,Rep ordres de venda
+Get Specification Details,Obtenir Detalls d'Especificacions
+Get Stock and Rate,Obtenir Estoc i tarifa
+Get Template,Aconsegueix Plantilla
+Get Terms and Conditions,Obtenir Termes i Condicions
+Get Unreconciled Entries,
+Get Weekly Off Dates,Get Weekly Off Dates
+"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.","Obtenir la tarifa de valorització i l'estoc disponible als magatzems origen/destí en la data esmentada. Si és un article amb número de sèrie, si us plau premeu aquest botó després d'introduir els números de sèrie."
+Global Defaults,Valors per defecte globals
+Global POS Setting {0} already created for company {1},L'ajust general del TPV {0} ja està creat per la companyia {1}
+Global Settings,Configuració global
+"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""","Salta al grup apropiat (generalment Aplicació de Fons> Actius Corrents> Comptes Bancàries i crea un nou compte de major (fent clic a Afegeix fill) de tipus ""Banc"""
+"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.","Salta al grup apropiat (en general Font dels fons> Passius actuals> Impostos i drets i crear un nou compte de major (fent clic a Afegeix Fill) de tipus ""impostos"" i fer parlar de la taxa d'impostos."
+Goal,Meta
+Goals,
+Goods received from Suppliers.,
+Google Drive,Google Drive
+Google Drive Access Allowed,Accés permès a Google Drive
+Government,
+Graduate,Graduat
+Grand Total,
+Grand Total (Company Currency),Total (En la moneda de la companyia)
+"Grid ""","Grid """
+Grocery,Botiga
+Gross Margin %,Marge Brut%
+Gross Margin Value,Valor Marge Brut
+Gross Pay,Sou brut
+Gross Pay + Arrear Amount +Encashment Amount - Total Deduction,
+Gross Profit,Benefici Brut
+Gross Profit %,Benefici Brut%
+Gross Weight,Pes Brut
+Gross Weight UOM,Pes brut UDM
+Group,Grup
+Group Node,Group Node
+Group by Account,Agrupa Per Comptes
+Group by Voucher,Agrupa per comprovants
+Group or Ledger,Group or Ledger
+Groups,Grups
+Guest,Convidat
+HR Manager,Gerent de Recursos Humans
+HR Settings,Configuració de recursos humans
+HR User,HR User
+HTML / Banner that will show on the top of product list.,HTML / Banner que apareixerà a la part superior de la llista de productes.
+Half Day,
+Half Yearly,Semestrals
+Half-yearly,
+Happy Birthday!,
+Hardware,Maquinari
+Has Batch No,Té número de lot
+Has Child Node,
+Has Serial No,
+Head of Marketing and Sales,
+Heads (or groups) against which Accounting Entries are made and balances are maintained.,Capçaleres (o grups) contra els quals es mantenen els assentaments comptables i els saldos
+Health Care,Sanitari
+Health Concerns,Problemes de Salut
+Health Details,Detalls de la Salut
+Held On,Held On
+Help HTML,
+"Help: To link to another record in the system, use ""#Form/Note/[Note Name]"" as the Link URL. (don't use ""http://"")","Ajuda: Per enllaçar a un altre registre en el sistema, utilitzeu ""#Form/Note/[Note Name]"" com a URL. (no utilitzis ""http://"")"
+"Here you can maintain family details like name and occupation of parent, spouse and children",
+"Here you can maintain height, weight, allergies, medical concerns etc","Aquí pot actualitzar l'alçada, el pes, al·lèrgies, problemes mèdics, etc."
+Hide Currency Symbol,
+High,
+History In Company,Història a la Companyia
+Hold,Mantenir
+Holiday,Festiu
+Holiday List,
+Holiday List Name,Nom de la Llista de vacances
+Holiday master.,
+Holidays,Vacances
+Home,Casa
+Host,Amfitrió
+"Host, Email and Password required if emails are to be pulled","Host, correu electrònic i la contrasenya necessaris si els correus electrònics han de ser enviats"
+Hour,Hora
+Hour Rate,Hour Rate
+Hour Rate Labour,
+Hours,Hores
+How Pricing Rule is applied?,Com s'aplica la regla de preus?
+How frequently?,Amb quina freqüència?
+"How should this currency be formatted? If not set, will use system defaults",
+Human Resources,Recursos Humans
+Identification of the package for the delivery (for print),La identificació del paquet per al lliurament (per imprimir)
+If Income or Expense,Si ingressos o despeses
+If Monthly Budget Exceeded,
+"If Supplier Part Number exists for given Item, it gets stored here","Si existeix el Part Number de proveïdor per un determinat article, s'emmagatzema aquí"
+If Yearly Budget Exceeded,Si s'exedeix el pressupost anual
+"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.","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."
+"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Si es marca, número total. de dies de treball s'inclouran els festius, i això reduirà el valor de Salari per dia"
+"If checked, the tax amount will be considered as already included in the Print Rate / Print Amount","If checked, the tax amount will be considered as already included in the Print Rate / Print Amount"
+If different than customer address,Si és diferent de la direcció del client
+"If disable, 'Rounded Total' field will not be visible in any transaction","Si ho desactives, el camp 'Arrodonir Total' no serà visible a cap transacció"
+"If enabled, the system will post accounting entries for inventory automatically.","Si està activat, el sistema comptabilitza els assentaments comptables per a l'inventari automàticament."
+If more than one package of the same type (for print),Si més d'un paquet del mateix tipus (per impressió)
+"If multiple Pricing Rules continue to prevail, users are asked to set Priority manually to resolve conflict.","Si hi ha diverses regles de preus vàlides, es demanarà als usuaris que estableixin la prioritat manualment per resoldre el conflicte."
+"If no change in either Quantity or Valuation Rate, leave the cell blank.",
+"If not checked, the list will have to be added to each Department where it has to be applied.","Si no està habilitada, la llista haurà de ser afegit a cada departament en què s'ha d'aplicar."
+"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.","Si la Regla de preus seleccionada està fet per a 'Preu', sobreescriurà Llista de Preus. El preu de la Regla de preus és el preu final, així que no s'hi aplicarà cap descompte addicional. Per tant, en les transaccions com comandes de venda, ordres de compra, etc,s'anirà a buscar al camp ""Quota"", en lloc de camp 'Quota de llista de preus'."
+"If specified, send the newsletter using this email address",
+"If the account is frozen, entries are allowed to restricted users.","Si el compte està bloquejat, només es permeten entrades alguns usuaris."
+"If this Account represents a Customer, Supplier or Employee, set it here.","Si aquest compte representa un client, proveïdor o empleat, establir aquí."
+"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.",
+If you follow Quality Inspection. Enables Item QA Required and QA No in Purchase Receipt,
+If you have Sales Team and Sale Partners (Channel Partners)  they can be tagged and maintain their contribution in the sales activity,
+"If you have created a standard template in Purchase Taxes and Charges Master, select one and click on the button below.",
+"If you have created a standard template in Sales Taxes and Charges Master, select one and click on the button below.","Si heu creat una plantilla estàndard en la configuració dels impostos de vendes i càrrecs, escolliu-ne un i feu clic al botó de sota."
+"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",
+If you involve in manufacturing activity. Enables Item 'Is Manufactured',Si s'involucra en alguna fabricació. Activa 'es fabrica'
+Ignore,Ignorar
+Ignore Pricing Rule,
+Ignored: ,
+Image,Imatge
+Image View,Veure imatges
+Implementation Partner,Soci d'Aplicació
+Import Attendance,Importa Assistència
+Import Failed!,
+Import Log,Importa registre
+Import Successful!,Importació correcta!
+Imports,Importacions
+In Hours,En Hores
+In Process,
+In Qty,En Quantitat
+In Stock,En estoc
+In Words,En Paraules
+In Words (Company Currency),En paraules (Divisa de la Companyia)
+In Words (Export) will be visible once you save the Delivery Note.,En paraules (exportació) seran visibles quan es desi l'albarà de lliurament.
+In Words will be visible once you save the Delivery Note.,
+In Words will be visible once you save the Purchase Invoice.,En paraules seran visibles un cop que guardi la factura de compra.
+In Words will be visible once you save the Purchase Order.,En paraules seran visibles un cop que es guardi l'ordre de compra.
+In Words will be visible once you save the Purchase Receipt.,En paraules seran visibles un cop guardi el rebut de compra.
+In Words will be visible once you save the Quotation.,En paraules seran visibles un cop que es guarda la Cotització.
+In Words will be visible once you save the Sales Invoice.,
+In Words will be visible once you save the Sales Order.,
+Incentives,Incentius
+Include Reconciled Entries,Inclogui els comentaris conciliades
+Include holidays in Total no. of Working Days,Inclou vacances en el número total de dies laborables
+Income,Ingressos
+Income / Expense,
+Income Account,Compte d'ingressos
+Income Booked,
+Income Tax,Impost sobre els guanys
+Income Year to Date,Ingressos de l'any fins a la data
+Income booked for the digest period,
+Incoming,
+Incoming Rate,
+Incoming quality inspection.,Inspecció de qualitat entrant.
+Incorrect number of General Ledger Entries found. You might have selected a wrong Account in the transaction.,Nombre incorrecte d'entrades del llibre major. És possible que hi hagi seleccionat un compte erroni en la transacció.
+Incorrect or Inactive BOM {0} for Item {1} at row {2},BOM incorrecte o Inactiu {0} per a l'article {1} a la fila {2}
+Indicates that the package is a part of this delivery (Only Draft),
+Indirect Expenses,
+Indirect Income,Ingressos Indirectes
+Individual,Individual
+Industry,Indústria
+Industry Type,Tipus d'Indústria
+Inspected By,Inspeccionat per
+Inspection Criteria,Criteris d'Inspecció
+Inspection Required,Inspecció requerida
+Inspection Type,Tipus d'Inspecció
+Installation Date,
+Installation Note,Nota d'instal·lació
+Installation Note Item,Nota d'instal·lació de l'article
+Installation Note {0} has already been submitted,La Nota d'Instal·lació {0} ja s'ha presentat
+Installation Status,
+Installation Time,Temps d'instal·lació
+Installation date cannot be before delivery date for Item {0},Data d'instal·lació no pot ser abans de la data de lliurament d'article {0}
+Installation record for a Serial No.,Registre d'instal·lació per a un nº de sèrie
+Installed Qty,Quantitat instal·lada
+Instructions,Instruccions
+Interested,Interessat
+Intern,Intern
+Internal,Interna
+Internet Publishing,Publicant a Internet
+Introduction,Introducció
+Invalid Barcode,Codi de barres no vàlid
+Invalid Barcode or Serial No,
+Invalid Mail Server. Please rectify and try again.,
+Invalid Master Name,Invalid Master Name
+Invalid User Name or Support Password. Please rectify and try again.,"Nom d'usuari o contrassenya de suport no vàlids. Si us plau, rectifica i torna a intentar-ho."
+Invalid quantity specified for item {0}. Quantity should be greater than 0.,Quantitat no vàlid per a l'aricle {0}. Quantitat ha de ser major que 0.
+Inventory,Inventari
+Inventory & Support,Inventory & Support
+Investment Banking,Banca d'Inversió
+Investments,Inversions
+Invoice,Factura
+Invoice Date,
+Invoice Details,
+Invoice No,Número de Factura
+Invoice Number,Número de factura
+Invoice Type,Tipus de Factura
+Invoice/Journal Voucher Details,Detalls de l'assentament de Diari o factura
+Invoiced Amount,Quantitat facturada
+Invoiced Amount (Exculsive Tax),
+Is Active,Està actiu
+Is Advance,És Avanç
+Is Cancelled,Està cancel·lat
+Is Carry Forward,Is Carry Forward
+Is Default,
+Is Encash,
+Is Fixed Asset Item,És la partida de l'actiu fix
+Is LWP,
+Is Opening,
+Is Opening Entry,
+Is POS,És TPV
+Is Primary Contact,És Contacte principal
+Is Purchase Item,
+Is Recurring,És recurrent
+Is Sales Item,És article de venda
+Is Service Item,És un servei
+Is Stock Item,És un article d'estoc
+Is Sub Contracted Item,Es subcontracta
+Is Subcontracted,Es subcontracta
+Is this Tax included in Basic Rate?,Aqeust impost està inclòs a la tarifa bàsica?
+Issue,Incidència
+Issue Date,
+Issue Details,Detalls de la incidència
+Issued Items Against Production Order,
+It can also be used to create opening stock entries and to fix stock value.,També es pot utilitzar per crear entrades en existències d'obertura i fixar valor de les accions.
+Item,Article
+Item #{0}: Ordered qty can not less than item's minimum order qty (defined in item master).,Article # {0}: La quantitat ordenada no pot ser menor que la quantitat mínima de comanda d'article (definit a la configuració d'articles).
+Item Advanced,Article Avançat
+Item Barcode,Codi de barres d'article
+Item Batch Nos,Números de Lot d'articles
+Item Classification,
+Item Code,Codi de l'article
+Item Code > Item Group > Brand,Codi de l'article> Grup Element> Marca
+Item Code and Warehouse should already exist.,
+Item Code cannot be changed for Serial No.,El Codi de l'article no es pot canviar de número de sèrie
+Item Code is mandatory because Item is not automatically numbered,El codi de l'article és obligatori perquè no s'havia numerat automàticament
+Item Code required at Row No {0},
+Item Customer Detail,Item Customer Detail
+Item Description,
+Item Desription,Desription de l'article
+Item Details,Detalls de l'article
+Item Group,Grup d'articles
+Item Group Name,Nom del Grup d'Articles
+Item Group Tree,Arbre de grups d'article
+Item Group not mentioned in item master for item {0},
+Item Groups in Details,Els grups d'articles en detalls
+Item Image (if not slideshow),
+Item Name,
+Item Naming By,
+Item Price,Preu d'article
+Item Prices,Preus de l'article
+Item Quality Inspection Parameter,
+Item Reorder,
+Item Row {0}: Purchase Receipt {1} does not exist in above 'Purchase Receipts' table,Article Fila {0}: Compra de Recepció {1} no existeix a la taulat 'Rebuts de compra'
+Item Serial No,Número de sèrie d'article
+Item Serial Nos,
+Item Shortage Report,Informe d'escassetat d'articles
+Item Supplier,
+Item Supplier Details,Detalls d'article Proveïdor
+Item Tax,Impost d'article
+Item Tax Amount,Suma d'impostos d'articles
+Item Tax Rate,
+Item Tax Row {0} must have account of type Tax or Income or Expense or Chargeable,La fila de l'impost d'article {0} ha de tenir en compte el tipus d'impostos o ingressos o despeses o imposable
+Item Tax1,Impost d'article 1
+Item To Manufacture,Article a fabricar
+Item UOM,
+Item Website Specification,Especificacions d'article al Web
+Item Website Specifications,Especificacions del web d'articles
+Item Wise Tax Detail,Detall d'impostos de tots els articles
+Item Wise Tax Detail ,
+Item is required,Es requereix un article
+Item is updated,L'article s'ha actualitzat
+Item master.,Mestre d'articles.
+"Item must be a purchase item, as it is present in one or many Active BOMs",
+Item must be added using 'Get Items from Purchase Receipts' button,
+Item or Warehouse for row {0} does not match Material Request,
+Item table can not be blank,
+Item to be manufactured or repacked,Article que es fabricarà o embalarà de nou
+Item valuation rate is recalculated considering landed cost voucher amount,La taxa de valorització de l'article es torna a calcular tenint en compte landed cost voucher amount
+Item valuation updated,
+Item will be saved by this name in the data base.,
+Item {0} appears multiple times in Price List {1},
+Item {0} does not exist,
+Item {0} does not exist in the system or has expired,L'Article {0} no existeix en el sistema o ha caducat
+Item {0} does not exist in {1} {2},
+Item {0} has already been returned,
+Item {0} has been entered multiple times against same operation,
+Item {0} has been entered multiple times with same description or date,Article {0} s'ha introduït diverses vegades amb la mateixa descripció o data
+Item {0} has been entered multiple times with same description or date or warehouse,
+Item {0} has been entered twice,L'Article {0} ha estat entrat dues vegades
+Item {0} has reached its end of life on {1},
+Item {0} ignored since it is not a stock item,Article {0} ignorat ja que no és un article d'estoc
+Item {0} is cancelled,L'article {0} està cancel·lat
+Item {0} is not Purchase Item,Article {0} no és article de Compra
+Item {0} is not a serialized Item,Article {0} no és un article serialitzat
+Item {0} is not a stock Item,Article {0} no és un article d'estoc
+Item {0} is not active or end of life has been reached,L'article {0} no està actiu o ha arribat al final de la seva vida
+Item {0} is not setup for Serial Nos. Check Item master,L'Article {0} no està configurat per a números de sèrie. Comprova la configuració d'articles
+Item {0} is not setup for Serial Nos. Column must be blank,L'Article {0} no està configurat per números de sèrie. La columna ha d'estar en blanc
+Item {0} must be Sales Item,L'Article {0} ha de ser article de Vendes
+Item {0} must be Sales or Service Item in {1},
+Item {0} must be Service Item,
+Item {0} must be a Purchase Item,L'Article {0} ha de ser un article de compra
+Item {0} must be a Sales Item,L'Article {0} ha de ser un article de Vendes
+Item {0} must be a Service Item.,Article {0} ha de ser un element de servei.
+Item {0} must be a Sub-contracted Item,
+Item {0} must be a stock Item,Article {0} ha de ser un d'article de l'estoc
+Item {0} must be manufactured or sub-contracted,L'Article {0} s'ha de fabricar o subcontractar
+Item {0} not found,Article {0} no trobat
+Item {0} with Serial No {1} is already installed,L'article {0} amb número de sèrie {1} ja està instal·lat
+Item {0} with same description entered twice,Article {0} amb mateixa descripció entrar dues vegades
+"Item, Warranty, AMC (Annual Maintenance Contract) details will be automatically fetched when Serial Number is selected.","Els detalls d'Article, garantia, AMC (Contracte de Manteniment Anual) es recuperaran automàticament quan es selecciona el Número de sèrie."
+Item-wise Price List Rate,Llista de Preus de tarifa d'article
+Item-wise Purchase History,Historial de compres d'articles
+Item-wise Purchase Register,Registre de compra d'articles
+Item-wise Sales History,
+Item-wise Sales Register,
+Item: {0} does not exist in the system,Article: {0} no existeix en el sistema
+"Item: {0} managed batch-wise, can not be reconciled using \
+					Stock Reconciliation, instead use Stock Entry",
+Item: {0} not found in the system,Article: {0} no es troba en el sistema
+Items,Articles
+Items To Be Requested,Articles que s'han de demanar
+Items required,
+"Items to be requested which are ""Out of Stock"" considering all warehouses based on projected qty and minimum order qty","Els productes que es sol·licitaran i que estan ""Esgotat"", considerant tots els magatzems basat en Quantitat projectada i quantitat mínima de comanda"
+Items which do not exist in Item master can also be entered on customer's request,
+Itemwise Discount,Descompte d'articles
+Itemwise Recommended Reorder Level,Nivell d'articles recomanat per a tornar a passar comanda
+Job Applicant,Job Applicant
+Job Opening,Obertura de treball
+Job Profile,Perfil Laboral
+Job Title,
+"Job profile, qualifications required etc.","Perfil del lloc, formació necessària, etc."
+Jobs Email Settings,Configuració de les tasques de correu electrònic
+Journal Entries,Entrades de diari
+Journal Entry,Entrada de diari
+Journal Voucher,Assentament de Diari
+Journal Voucher Detail,Detall d'assentament de diari
+Journal Voucher Detail No,
+Journal Voucher {0} does not have account {1} or already matched against other voucher,L'assentament de Diari {0} no té compte {1} o coincideix amb un altre assentament
+"Journal Voucher {0} is linked against Order {1}, check if it should be pulled as advance in this invoice.","L'assentament de Diari {0} està enllaçat amb l'Ordre {1}, comproveu si s'ha de llençar com a avançament en aquesta factura."
+Journal Vouchers {0} are un-linked,
+"Keep Track of Sales Campaigns. Keep track of Leads, Quotations, Sales Order etc from Campaigns to gauge Return on Investment. ",
+Keep a track of communication related to this enquiry which will help for future reference.,
+Keep it web friendly 900px (w) by 100px (h),
+Key Performance Area,
+Key Responsibility Area,Àrea de Responsabilitat clau
+Kg,
+LR Date,LR Date
+LR No,LR No
+Label,Etiqueta
+Landed Cost Help,
+Landed Cost Item,
+Landed Cost Purchase Receipt,
+Landed Cost Taxes and Charges,
+Landed Cost Voucher,
+Landed Cost Voucher Amount,
+Language,Idioma
+Last Name,Cognoms
+Last Order Amount,
+Last Purchase Rate,
+Last Sales Order Date,
+Latest,Més recent
+Lead,Client potencial
+Lead Details,Detalls del client potencial
+Lead Id,Identificació de l'enviament
+Lead Name,
+Lead Owner,Responsable del client potencial
+Lead Source,Origen de clients potencials
+Lead Status,Estat de l'enviament
+Lead Time Date,
+Lead Time Days,
+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.,El temps d'arribada és el nombre de dies en què s'espera que aquest article al vostre magatzem. Aquest dia s'informa a Sol·licitud de material quan se selecciona aquest article.
+Lead Type,Tipus de client potencial
+Lead must be set if Opportunity is made from Lead,S'ha d'indicar el client potencial si la oportunitat té el seu origen en un client potencial
+Leave Allocation,Assignació d'absència
+Leave Allocation Tool,
+Leave Application,
+Leave Approver,Aprovador d'absències
+Leave Approver Name,Nom de l'aprovador d'absències
+Leave Approvers,Aprovadors d'absències
+Leave Balance Before Application,Leave Balance Before Application
+Leave Block List,
+Leave Block List Allow,Leave Block List Allow
+Leave Block List Allowed,Llista d'absències permeses bloquejades
+Leave Block List Date,
+Leave Block List Dates,
+Leave Block List Name,
+Leave Blocked,Absència bloquejada
+Leave Control Panel,
+Leave Encashed?,Leave Encashed?
+Leave Encashment Amount,
+Leave Type,
+Leave Type Name,
+Leave Without Pay,Absències sense sou
+Leave application has been approved.,La sol·licitud d'autorització d'absència ha estat aprovada.
+Leave application has been rejected.,
+Leave approver must be one of {0},L'aprovador d'absències ha de ser un de {0}
+Leave blank if considered for all branches,Deixar en blanc si es considera per a totes les branques
+Leave blank if considered for all departments,Deixar en blanc si es considera per a tots els departaments
+Leave blank if considered for all designations,Deixar en blanc si es considera per a totes les designacions
+Leave blank if considered for all employee types,Deixar en blanc si es considera per a tot tipus d'empleats
+"Leave can be approved by users with Role, ""Leave Approver""","L'absència només la pot aprovar un usuari amb rol, ""Revisador d'absències"""
+Leave of type {0} cannot be longer than {1},Una absència del tipus {0} no pot ser de més de {1}
+Leaves Allocated Successfully for {0},
+Leaves for type {0} already allocated for Employee {1} for Fiscal Year {0},Les absències per al tipus {0} ja han estat assignades per Empleat {1} per a l'Any Fiscal {0}
+Leaves must be allocated in multiples of 0.5,
+Ledger,
+Ledgers,Llibres majors
+Left,Esquerra
+Legal,Legal
+Legal Entity / Subsidiary with a separate Chart of Accounts belonging to the Organization.,
+Legal Expenses,
+Letter Head,Capçalera de la carta
+Letter Heads for print templates.,
+Level,Nivell
+Lft,Lft
+Liability,Responsabilitat
+Link,
+List a few of your customers. They could be organizations or individuals.,
+List a few of your suppliers. They could be organizations or individuals.,Enumera alguns de les teves proveïdors. Poden ser les organitzacions o individuals.
+List items that form the package.,Llista d'articles que formen el paquet.
+List of users who can edit a particular Note,Llista d'usuaris que poden editar una nota en particular
+List this Item in multiple groups on the website.,Fes una llista d'articles en diversos grups en el lloc web.
+"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.","Publica els teus productes o serveis de compra o venda Assegura't de revisar el Grup d'articles, unitat de mesura i altres propietats quan comencis"
+"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.","Enumereu els seus impostos principals (per exemple, IVA, impostos especials: han de tenir noms únics) i les seves quotes estàndard. Això crearà una plantilla estàndard, que pot editar i afegir més tard."
+Loading...,Carregant ...
+Loans (Liabilities),Préstecs (passius)
+Loans and Advances (Assets),Préstecs i bestretes (Actius)
+Local,
+"Log of Activities performed by users against Tasks that can be used for tracking time, billing.","Bloc d'activitats realitzades pels usuaris durant les feines que es poden utilitzar per al seguiment del temps, facturació."
+Login,Iniciar Sessió
+Login with your new User ID,
+Logo,Logo
+Logo and Letter Heads,
+Lost,
+Lost Reason,
+Low,
+Lower Income,Lower Income
+MTN Details,MTN Details
+Main,
+Main Reports,Informes principals
+Maintain Same Rate Throughout Sales Cycle,Mantenir la mateixa tarifa durant tot el cicle de vendes
+Maintain same rate throughout purchase cycle,
+Maintenance,Manteniment
+Maintenance Date,
+Maintenance Details,Detalls de Manteniment
+Maintenance Manager,Gerent de Manteniment
+Maintenance Schedule,
+Maintenance Schedule Detail,Detall del Programa de manteniment
+Maintenance Schedule Item,Programa de manteniment d'articles
+Maintenance Schedule is not generated for all the items. Please click on 'Generate Schedule',"El programa de manteniment no es genera per a tots els articles Si us plau, feu clic a ""Generar Planificació"""
+Maintenance Schedule {0} exists against {0},
+Maintenance Schedule {0} must be cancelled before cancelling this Sales Order,Programa de manteniment {0} ha de ser cancel·lat abans de cancel·lar aquesta comanda de vendes
+Maintenance Schedules,Programes de manteniment
+Maintenance Status,
+Maintenance Time,Temps de manteniment
+Maintenance Type,Tipus de Manteniment
+Maintenance User,Usuari de Manteniment
+Maintenance Visit,
+Maintenance Visit Purpose,Manteniment Motiu de visita
+Maintenance Visit {0} must be cancelled before cancelling this Sales Order,
+Maintenance start date can not be before delivery date for Serial No {0},Data d'inici de manteniment no pot ser abans de la data de lliurament pel número de sèrie {0}
+Major/Optional Subjects,Major/Optional Subjects
+Make ,
+Make Accounting Entry For Every Stock Movement,Feu Entrada Comptabilitat Per Cada moviment d'estoc
+Make Bank Voucher,Fer justificant bancari
+Make Credit Note,
+Make Debit Note,Fer Nota de Dèbit
+Make Delivery,Feu Lliurament
+Make Difference Entry,
+Make Excise Invoice,Feu Factura impostos especials
+Make Installation Note,Fer nota s'instal·lació
+Make Invoice,Fer Factura
+Make Journal Voucher,
+Make Maint. Schedule,Fer Planificació de Manteniment
+Make Maint. Visit,Make Maint. Visita
+Make Maintenance Visit,
+Make Packing Slip,
+Make Payment,Realitzar Pagament
+Make Payment Entry,Feu Entrada Pagament
+Make Purchase Invoice,
+Make Purchase Order,
+Make Purchase Receipt,Fes el rebut de compra
+Make Salary Slip,
+Make Salary Structure,
+Make Sales Invoice,Fer Factura Vendes
+Make Sales Order,
+Make Supplier Quotation,Fer Oferta de Proveïdor
+Make Time Log Batch,Fer un registre de temps
+Make new POS Setting,
+Male,Home
+Manage Customer Group Tree.,
+Manage Sales Partners.,Administrar Punts de vendes.
+Manage Sales Person Tree.,Organigrama de vendes
+Manage Territory Tree.,
+Manage cost of operations,
+Management,
+Manager,Gerent
+"Mandatory if Stock Item is ""Yes"". Also the default warehouse where reserved quantity is set from Sales Order.","Obligatori si Article d'estoc és ""Sí"". També el magatzem predeterminat en què la quantitat reservada s'estableix a partir d'ordres de venda."
+Manufacture,
+Manufacture against Sales Order,Fabricació contra ordre de vendes
+Manufactured Item,
+Manufactured Qty,Quantitat fabricada
+Manufactured quantity will be updated in this warehouse,
+Manufactured quantity {0} cannot be greater than planned quanitity {1} in Production Order {2},La quantitat fabricada {0} no pot ser més gran que la quantitat planificada {1} a l'ordre de producció {2}
+Manufacturer,Fabricant
+Manufacturer Part Number,PartNumber del fabricant
+Manufacturing,
+Manufacturing Manager,Gerent de Fàbrica
+Manufacturing Quantity,Quantitat a fabricar
+Manufacturing Quantity is mandatory,Quantitat de fabricació és obligatori
+Manufacturing User,Usuari de fabricació
+Margin,
+Marital Status,Estat Civil
+Market Segment,
+Marketing,Màrqueting
+Marketing Expenses,Despeses de Màrqueting
+Married,
+Mass Mailing,Mass Mailing
+Master Name,Nom Mestre
+Master Name is mandatory if account type is Warehouse,El Nom principal és obligatori si el tipus de compte és Magatzem
+Master Type,
+Masters,Màsters
+Match non-linked Invoices and Payments.,
+Material Issue,
+Material Manager,
+Material Master Manager,Material Master Manager
+Material Receipt,
+Material Request,Sol·licitud de materials
+Material Request Detail No,Número de detall de petició de material
+Material Request For Warehouse,Sol·licitud de material per al magatzem
+Material Request Item,Material Request Item
+Material Request Items,
+Material Request No,Número de sol·licitud de Material
+Material Request Type,
+Material Request of maximum {0} can be made for Item {1} against Sales Order {2},Per l'article {1} es poden fer un màxim de {0} sol·licituds de materials destinats a l'ordre de venda {2}
+Material Request used to make this Stock Entry,
+Material Request {0} is cancelled or stopped,Material de Sol·licitud {0} es cancel·la o s'atura
+Material Requests for which Supplier Quotations are not created,Les sol·licituds de material per als quals no es creen Ofertes de Proveïdor
+Material Requests {0} created,Sol·licituds de material {0} creats
+Material Requirement,Requirement de Material
+Material Transfer,
+Material User,Material User
+Materials,
+Materials Required (Exploded),Materials necessaris (explotat)
+Max 5 characters,Max 5 caràcters
+Max Days Leave Allowed,Màxim de dies d'absència permesos
+Max Discount (%),Descompte màxim (%)
+Max Qty,Quantitat màxima
+Max discount allowed for item: {0} is {1}%,Descompte màxim permès per l'article: {0} és {1}%
+Maximum Amount,
+Maximum {0} rows allowed,Màxim {0} files permeses
+Maxiumm discount for Item {0} is {1}%,Maxim descompte per article {0} és {1}%
+Medical,
+Medium,Medium
+"Merging is only possible if following properties are same in both records. Group or Ledger, Root Type, Company",
+Message,Missatge
+Message Parameter,Paràmetre del Missatge
+Message Sent,Missatge enviat
+Message updated,Missatge actualitzat
+Messages,Missatges
+Messages greater than 160 characters will be split into multiple messages,
+Middle Income,Ingrés Mig
+Milestone,Fita
+Milestone Date,Data de la fita
+Milestones,Fites
+Milestones will be added as Events in the Calendar,S'afegiran les fites com esdeveniments en el calendari
+Min Order Qty,
+Min Qty,Quantitat mínima
+Min Qty can not be greater than Max Qty,Quantitat mínima no pot ser major que Quantitat màxima
+Minimum Amount,Quantitat mínima
+Minimum Inventory Level,
+Minimum Order Qty,Quantitat de comanda mínima
+Minute,
+Misc Details,Detalls diversos
+Miscellaneous Expenses,
+Miscelleneous,
+Mobile No,Número de Mòbil
+Mobile No.,
+Mode of Payment,
+Modern,Modern
+Monday,Dilluns
+Month,Mes
+Monthly,
+Monthly Attendance Sheet,Full d'Assistència Mensual
+Monthly Earning & Deduction,Ingressos mensuals i Deducció
+Monthly Salary Register,Registre de Salari mensual
+Monthly salary statement.,
+More Details,Més detalls
+More Info,Més Info
+Motion Picture & Video,Cinema i vídeo
+Moving Average,
+Moving Average Rate,Moving Average Rate
+Mr,Sr
+Ms,Sra
+Multiple Item prices.,Múltiples Preus d'articles
+"Multiple Price Rule exists with same criteria, please resolve \
+			conflict by assigning priority. Price Rules: {0}",
+Music,
+Must be Whole Number,Ha de ser nombre enter
+Name,Nom
+Name and Description,Nom i descripció
+Name and Employee ID,
+"Name of new Account. Note: Please don't create accounts for Customers and Suppliers, they are created automatically from the Customer and Supplier master",
+Name of person or organization that this address belongs to.,Nom de la persona o organització a la que pertany aquesta direcció.
+Name of the Budget Distribution,Name of the Budget Distribution
+Naming Series,
+Negative Quantity is not allowed,No s'admenten quantitats negatives
+Negative Stock Error ({6}) for Item {0} in Warehouse {1} on {2} {3} in {4} {5},
+Negative Valuation Rate is not allowed,No es permeten els ràtios de valoració negatius
+Net Pay,Pay Net
+Net Pay (in words) will be visible once you save the Salary Slip.,El sou net (en paraules) serà visible un cop que es guardi la nòmina.
+Net Profit / Loss,Guany/Pèrdua neta
+Net Total,Total Net
+Net Total (Company Currency),Net Total (En la moneda de la Companyia)
+Net Weight,Pes Net
+Net Weight UOM,
+Net Weight of each Item,Pes net de cada article
+Net pay cannot be negative,Salari net no pot ser negatiu
+Never,Mai
+New Account,
+New Account Name,
+New BOM,
+New Communications,Noves Comunicacions
+New Company,Nova Empresa
+New Cost Center,Nou Centre de Cost
+New Cost Center Name,Nou nom de centres de cost
+New Customer Revenue,
+New Customers,Clients Nous
+New Delivery Notes,Noves notes de lliurament
+New Enquiries,Noves consultes
+New Leads,
+New Leave Application,
+New Leaves Allocated,Noves absències Assignades
+New Leaves Allocated (In Days),
+New Material Requests,Noves peticions de material
+New Projects,Nous Projectes
+New Purchase Orders,Noves ordres de compra
+New Purchase Receipts,Nous rebuts de compra
+New Quotations,
+New Sales Orders,
+New Serial No cannot have Warehouse. Warehouse must be set by Stock Entry or Purchase Receipt,
+New Stock Entries,
+New Stock UOM,Nova UDM d'existències
+New Stock UOM is required,
+New Stock UOM must be different from current stock UOM,
+New Supplier Quotations,
+New Support Tickets,Nous Tiquets de Suport
+New UOM must NOT be of type Whole Number,La nova UDM no pot ser de tipus Número sencer
+New Workplace,Nou lloc de treball
+New {0},Nova {0}
+New {0} Name,Nou {0} Nom
+New {0}: #{1},
+Newsletter,Newsletter
+Newsletter Content,Contingut del Newsletter
+Newsletter Status,Estat de la Newsletter
+Newsletter has already been sent,El Newsletter ja s'ha enviat
+"Newsletters to contacts, leads.","Newsletters a contactes, clients potencials."
+Newspaper Publishers,Editors de Newspapers
+Next,
+Next Contact By,Següent Contactar Per
+Next Contact Date,Data del següent contacte
+Next Date,
+Next Recurring {0} will be created on {1},Següent Recurrent {0} es crearà a {1}
+Next email will be sent on:,El següent correu electrònic s'enviarà a:
+No,No
+No Customer Accounts found.,
+No Customer or Supplier Accounts found,No s'han trobat comptes de clients ni proveïdors
+No Data,No hi ha dades
+No Item with Barcode {0},Número d'article amb Codi de barres {0}
+No Item with Serial No {0},
+No Items to pack,No hi ha articles per embalar
+No Permission,Sense Permís
+No Production Orders created,
+No Remarks,Sense Observacions
+No Supplier Accounts found. Supplier Accounts are identified based on 'Master Type' value in account record.,No s'han trobat comptes de Proveïdor. Els Comptes de Proveïdor s'identifiquen amb base en el valor de 'Type Master' en registre de compte.
+No Updates For,
+No accounting entries for the following warehouses,No hi ha assentaments comptables per als següents magatzems
+No address added yet.,
+No contacts added yet.,Encara no hi ha contactes.
+No default Address Template found. Please create a new one from Setup > Printing and Branding > Address Template.,"No hi ha adreça predeterminada. Si us plau, crea'n una de nova a Configuració> Premsa i Branding> plantilla d'adreça."
+No default BOM exists for Item {0},
+No description given,
+No employee found,No s'ha trobat cap empeat
+No employee found!,No s'ha trobat cap empleat!
+No of Requested SMS,No de SMS sol·licitada
+No of Sent SMS,No d'SMS enviats
+No of Visits,Número de Visites
+No permission,No permission
+No permission to use Payment Tool,
+No record found,No s'ha trobat registre
+No records found in the Invoice table,
+No records found in the Payment table,No hi ha registres a la taula de Pagaments
+No salary slip found for month: ,
+Non Profit,Sense ànim de lucre
+Nos,
+Not Active,No Actiu
+Not Applicable,No Aplicable
+Not Available,No Disponible
+Not Billed,
+Not Delivered,
+Not In Stock,No disponible
+Not Sent,No Enviat
+Not Set,
+Not allowed to update stock transactions older than {0},No es permet actualitzar les transaccions de valors més grans de {0}
+Not authorized to edit frozen Account {0},No autoritzat per editar el compte bloquejat {0}
+Not authroized since {0} exceeds limits,
+Not permitted,No permès
+Note,Nota
+Note User,
+Note is a free page where users can share documents / notes,Note és una pàgina gratuïta on els usuaris poden compartir documents/notes
+"Note: Backups and files are not deleted from Dropbox, you will have to delete them manually.","Nota: Les còpies de seguretat i arxius no s'eliminen de Dropbox, hauràs de fer-ho manualment."
+"Note: Backups and files are not deleted from Google Drive, you will have to delete them manually.",
+Note: Due Date exceeds the allowed credit days by {0} day(s),Nota: Data de venciment és superior als dies de crèdit permesos en {0} dia(es)
+Note: Email will not be sent to disabled users,
+"Note: If payment is not made against any reference, make Journal Voucher manually.","Nota: Si el pagament no es fa per una referència concreta, fes l'assentament de Diari manualment."
+Note: Item {0} entered multiple times,Nota: L'article {0} entrat diverses vegades
+Note: Payment Entry will not be created since 'Cash or Bank Account' was not specified,"Nota: L'entrada de pagament no es crearà perquè no s'ha especificat 'Caixa o compte bancari"""
+Note: Reference Date {0} is after invoice due date {1},
+Note: System will not check over-delivery and over-booking for Item {0} as quantity or amount is 0,
+Note: There is not enough leave balance for Leave Type {0},Note: There is not enough leave balance for Leave Type {0}
+Note: This Cost Center is a Group. Cannot make accounting entries against groups.,
+Note: {0},
+Notes,Notes
+Notes:,Notes:
+Nothing to request,Res per sol·licitar
+Notice (days),
+Notification Control,
+Notification Email Address,Dir Adreça de correu electrònic per notificacions
+Notify by Email on creation of automatic Material Request,
+Number Format,
+Number of Order,Número d'ordre
+Offer Date,Data d'Oferta
+Office,
+Office Equipments,Material d'oficina
+Office Maintenance Expenses,Despeses de manteniment d'oficines
+Office Rent,lloguer de l'oficina
+Old Parent,Antic Pare
+On Net Total,En total net
+On Previous Row Amount,A limport de la fila anterior
+On Previous Row Total,Total fila anterior
+Online Auctions,Subhastes en línia
+Only Leave Applications with status 'Approved' can be submitted,"Només es poden presentar les Aplicacions d'absència amb estat ""Aprovat"""
+"Only Serial Nos with status ""Available"" can be delivered.","Només es poden lliurar els números de Sèrie amb l'estat ""disponible"""
+Only leaf nodes are allowed in transaction,Només els nodes fulla es permet l'entrada de transaccions
+Only the selected Leave Approver can submit this Leave Application,Només l'aprovador d'absències seleccionat pot presentar aquesta sol·licitud
+Open,Obert
+Open Production Orders,
+Open Tickets,
+Opening (Cr),
+Opening (Dr),Obertura (Dr)
+Opening Date,Data d'obertura
+Opening Entry,Entrada Obertura
+Opening Qty,Quantitat d'obertura
+Opening Time,Temps d'obertura
+Opening for a Job.,
+Operating Cost,Cost de funcionament
+Operation Description,Descripció de la operació
+Operation No,Número d'Operació
+Operation Time (mins),Temps de l'Operació (minuts)
+Operation {0} is repeated in Operations Table,Operació {0} es repeteix a la Taula d'Operacions
+Operation {0} not present in Operations Table,
+Operations,Operacions
+Opportunity,
+Opportunity Date,Data oportunitat
+Opportunity From,Oportunitat De
+Opportunity Item,Opportunity Item
+Opportunity Items,Articles d'oferta
+Opportunity Lost,
+Opportunity Type,Tipus d'Oportunitats
+Optional. This setting will be used to filter in various transactions.,
+Order Type,Tipus d'ordre
+Order Type must be one of {0},Tipus d'ordre ha de ser un de {0}
+Ordered,
+Ordered Items To Be Billed,
+Ordered Items To Be Delivered,
+Ordered Qty,Quantitat demanada
+"Ordered Qty: Quantity ordered for purchase, but not received.",
+Ordered Quantity,Quantitat demanada
+Orders released for production.,Comandes llançades per a la producció.
+Organization Name,
+Organization Profile,
+Organization branch master.,Organization branch master.
+Organization unit (department) master.,Unitat d'Organització (departament) mestre.
+Other,Un altre
+Other Details,Altres detalls
+Others,Altres
+Out Qty,Quantitat de sortida
+Out of AMC,Fora d'AMC
+Out of Warranty,
+Outgoing,
+Outstanding Amount,Quantitat Pendent
+Outstanding for {0} cannot be less than zero ({1}),Excedent per {0} no pot ser menor que zero ({1})
+Overdue,Endarrerit
+Overdue: ,
+Overhead,
+Overheads,Overheads
+Overlapping conditions found between:,La superposició de les condicions trobades entre:
+Overview,Visió de conjunt
+Owned,Propietat de
+Owner,Propietari
+P L A - Cess Portion,
+PL or BS,PL o BS
+PO Date,PO Date
+PO No,
+POP3 Mail Server,POP3 Mail Server
+POP3 Mail Settings,
+POP3 mail server (e.g. pop.gmail.com),Servidor de correu POP3 (per exemple pop.gmail.com)
+POP3 server e.g. (pop.gmail.com),
+POS,TPV
+POS Setting,Ajustos TPV
+POS Setting required to make POS Entry,Ajust TPV requereix fer l'entrada TPV
+POS Setting {0} already created for user: {1} and company {2},Ajust TPV {0} ja creat per a l'usuari: {1} i companyia {2}
+POS View,
+PR Detail,
+Package Item Details,Detalls d'embalatge d'articles
+Package Items,Articles d'embalatge
+Package Weight Details,
+Packed Item,Article amb embalatge
+Packed quantity must equal quantity for Item {0} in row {1},Quantitat embalada ha de ser igual a la quantitat d'articles per {0} a la fila {1}
+Packing Details,Detalls del embalatge
+Packing List,Llista De Embalatge
+Packing Slip,
+Packing Slip Item,Albarà d'article
+Packing Slip Items,Fulla d'embalatge d'articles
+Packing Slip(s) cancelled,Fulla(s) d'embalatge cancel·lat
+Page Break,Salt de pàgina
+Page Name,Nom de pàgina
+Paid,Pagat
+Paid Amount,Quantitat pagada
+Paid amount + Write Off Amount can not be greater than Grand Total,
+Pair,Parell
+Parameter,
+Parent Account,
+Parent Cost Center,
+Parent Customer Group,
+Parent Detail docname,
+Parent Item,
+Parent Item Group,Grup d'articles pare
+Parent Item {0} must be not Stock Item and must be a Sales Item,Pares d'article {0} no pot de ser article d'estoc i ha de ser un article de Vendes
+Parent Party Type,Parent Party Type
+Parent Sales Person,Parent Sales Person
+Parent Territory,Parent Territory
+Parent Website Route,Parent Website Route
+Parenttype,
+Part-time,Temps parcial
+Partially Completed,
+Partly Billed,Parcialment Facturat
+Partly Delivered,Parcialment Lliurat
+Partner Target Detail,
+Partner Type,Tipus de Partner
+Partner's Website,Lloc Web dels Partners
+Party,Party
+Party Account,
+Party Details,Party Details
+Party Type,Tipus Partit
+Party Type Name,Party Type Name
+Passive,Passiu
+Passport Number,Nombre de Passaport
+Password,
+Pay To / Recd From,Pagar a/Rebut de
+Payable,
+Payables,Comptes per Pagar
+Payables Group,
+Payment Account,
+Payment Amount,Quantitat de pagament
+Payment Days,Dies de pagament
+Payment Due Date,Data de pagament
+Payment Mode,Mètode de pagament
+Payment Pending,
+Payment Period Based On Invoice Date,Període de pagament basat en Data de la factura
+Payment Received,Pagament rebut
+Payment Reconciliation,Reconciliació de Pagaments
+Payment Reconciliation Invoice,Factura de Pagament de Reconciliació
+Payment Reconciliation Invoices,Factures de conciliació de pagaments
+Payment Reconciliation Payment,Payment Reconciliation Payment
+Payment Reconciliation Payments,Payment Reconciliation Payments
+Payment Tool,Eina de Pagament
+Payment Tool Detail,Detall mitjà de Pagament
+Payment Tool Details,Detalls eina de pagament
+Payment Type,Tipus de Pagament
+"Payment against {0} {1} cannot be greater \
+					than Outstanding Amount {2}",
+Payment cannot be made for empty cart,El pagament no es pot fer per al carro buit
+Payment of salary for the month {0} and year {1},
+Payments,Pagaments
+Payments Made,
+Payments Received,Pagaments rebuts
+Payments made during the digest period,
+Payments received during the digest period,Els pagaments rebuts durant el període
+Payroll Settings,Ajustaments de Nòmines
+Pending,
+Pending Amount,A l'espera de l'Import
+Pending Items {0} updated,Articles pendents {0} actualitzats
+Pending Review,
+Pending SO Items For Purchase Request,A l'espera dels Articles de la SO per la sol·licitud de compra
+Pension Funds,
+Percentage Allocation,Percentatge d'Assignació
+Percentage Allocation should be equal to 100%,Percentatge d'assignació ha de ser igual a 100%
+Percentage variation in quantity to be allowed while receiving or delivering this item.,Variació percentual tolerable en la quantitat al rebre o lliurar aquest article.
+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.,
+Performance appraisal.,
+Period,
+Period Closing Entry,Entrada de Tancament de Període
+Period Closing Voucher,Comprovant de tancament de període
+Period From and Period To dates mandatory for recurring %s,Període Des de i Període Fins a obligatoris per recurrent %s
+Periodicity,
+Permanent Address,Adreça Permanent
+Permanent Address Is,Adreça permanent
+Permission,Permís
+Personal,Personal
+Personal Details,
+Personal Email,Email Personal
+Pharmaceutical,
+Pharmaceuticals,Farmacèutics
+Phone,
+Phone No,
+Piecework,Treball a preu fet
+Pincode,Codi PIN
+Place of Issue,Lloc de la incidència
+Plan for maintenance visits.,Pla de visites de manteniment.
+Planned Qty,
+"Planned Qty: Quantity, for which, Production Order has been raised, but is pending to be manufactured.","Planificada Quantitat: Quantitat, per a això, ordre de la producció s'ha elevat, però està a l'espera de ser fabricats."
+Planned Quantity,Quantitat planificada
+Planning,Planificació
+Plant,Planta
+Plant and Machinery,Instal·lacions tècniques i maquinària
+Please Enter Abbreviation or Short Name properly as it will be added as Suffix to all Account Heads.,Si us plau entra una abreviació o Nom curt correctament perquè s'afegirà com sufix a tots Comptes principals
+Please Update SMS Settings,
+Please add expense voucher details,"Si us plau, afegeix els detalls del comprovant de despeses"
+Please add to Modes of Payment from Setup.,
+Please click on 'Generate Schedule',"Si us plau, feu clic a ""Generar Planificació"""
+Please click on 'Generate Schedule' to fetch Serial No added for Item {0},"Si us plau, feu clic a ""Generar Planificació 'per reservar números de sèrie per l'article {0}"
+Please click on 'Generate Schedule' to get schedule,
+Please create Customer from Lead {0},"Si us plau, crea Client a partir del client potencial {0}"
+Please create Salary Structure for employee {0},
+Please create new account from Chart of Accounts.,"Si us plau, creu un nou compte de Pla de Comptes."
+Please do NOT create Account (Ledgers) for Customers and Suppliers. They are created directly from the Customer / Supplier masters.,Please do NOT create Account (Ledgers) for Customers and Suppliers. Es creen directament dels mestres client / proveïdor.
+Please enter 'Expected Delivery Date',"Si us plau, introdueixi 'la data prevista de lliurament'"
+Please enter 'Is Subcontracted' as Yes or No,
+Please enter 'Repeat on Day of Month' field value,
+Please enter Account Receivable/Payable group in company master,
+Please enter Approving Role or Approving User,Si us plau entra el rol d'aprovació o l'usuari aprovador
+Please enter BOM for Item {0} at row {1},"Si us plau, introduïu la llista de materials per a l'article {0} a la fila {1}"
+Please enter Company,Si us plau entra l'Empresa
+Please enter Cost Center,Si us plau entra el centre de cost
+Please enter Delivery Note No or Sales Invoice No to proceed,
+Please enter Employee Id of this sales parson,Si us plau ingressi l'Id d'Empleat d'aquest venedor
+Please enter Expense Account,
+Please enter Item Code to get batch no,
+Please enter Item Code.,"Si us plau, introduïu el codi d'article."
+Please enter Item first,Si us plau entra primer l'article
+Please enter Maintaince Details first,Si us plau entra primer els detalls de manteniment
+Please enter Master Name once the account is created.,"Si us plau, introduïu el nom un cop creat el compte."
+Please enter Payment Amount in atleast one row,
+Please enter Planned Qty for Item {0} at row {1},Si us plau entra la quantitat Planificada per l'article {0} a la fila {1}
+Please enter Production Item first,Si us plau indica primer l'Article a Producció
+Please enter Purchase Receipt No to proceed,Si us plau entra el número de rebut de compra per a continuar
+Please enter Purchase Receipt first,Si us plau primer entra el rebut de compra
+Please enter Purchase Receipts,Si us plau ingressi rebuts de compra
+Please enter Reference date,"Si us plau, introduïu la data de referència"
+Please enter Taxes and Charges,Entra les taxes i càrrecs
+Please enter Warehouse for which Material Request will be raised,Si us plau indica el Magatzem en què es faràa la Sol·licitud de materials
+Please enter Write Off Account,Si us plau indica el Compte d'annotació
+Please enter atleast 1 invoice in the table,"Si us plau, introdueixi almenys 1 factura a la taula"
+Please enter company first,
+Please enter company name first,Si us plau introdueix el nom de l'empresa primer
+Please enter default Unit of Measure,
+Please enter default currency in Company Master,
+Please enter email address,Introduïu l'adreça de correu electrònic
+Please enter item details,
+Please enter message before sending,
+Please enter parent account group for warehouse {0},
+Please enter parent cost center,
+Please enter quantity for Item {0},Introduïu la quantitat d'articles per {0}
+Please enter relieving date.,Please enter relieving date.
+Please enter sales order in the above table,
+Please enter the Against Vouchers manually,Introduïu manualment la partida dels comprovants
+Please enter valid Company Email,Si us plau entra un correu electrònic d'empresa vàlid
+Please enter valid Email Id,Si us plau introdueixi un correu electrònic vàlid
+Please enter valid Personal Email,Si us plau entreu un correu electrònic personal vàlid
+Please enter valid mobile nos,Entra números de mòbil vàlids
+Please find attached {0} #{1},Troba adjunt {0} #{1}
+Please install dropbox python module,
+Please mention no of visits required,
+Please pull items from Delivery Note,
+Please remove this Invoice {0} from C-Form {1},
+Please save the Newsletter before sending,
+Please save the document before generating maintenance schedule,"Si us plau, guardi el document abans de generar el programa de manteniment"
+Please see attachment,
+"Please select Allocated Amount, Invoice Type and Invoice Number in atleast one row",
+Please select Bank Account,
+Please select Carry Forward if you also want to include previous fiscal year's balance leaves to this fiscal year,
+Please select Category first,"Si us plau, Selecciona primer la Categoria"
+Please select Charge Type first,Seleccioneu Tipus de Càrrec primer
+Please select Fiscal Year,
+Please select Group or Ledger value,Seleccioneu valor de Grup o Llibre major
+Please select Incharge Person's name,"Si us plau, seleccioneu el nom de la persona al càrrec"
+"Please select Item where ""Is Stock Item"" is ""No"" and ""Is Sales Item"" is ""Yes"" and there is no other Sales BOM",
+Please select Price List,Seleccionla llista de preus
+Please select Start Date and End Date for Item {0},Seleccioneu data d'inici i data de finalització per a l'article {0}
+Please select Time Logs.,Seleccioneu registres de temps
+Please select a csv file,Seleccioneu un arxiu csv
+Please select a valid csv file with data,
+Please select a value for {0} quotation_to {1},Please select a value for {0} quotation_to {1}
+"Please select an ""Image"" first","Seleccioneu una ""imatge"" primer"
+Please select charge type first,
+Please select company first,Si us plau primer seleccioneu l'empresa
+Please select company first.,Si us plau seleccioneu l'empresa en primer lloc.
+Please select item code,Seleccioneu el codi de l'article
+Please select month and year,Selecciona el mes i l'any
+Please select prefix first,Seleccioneu el prefix primer
+Please select the document type first,Si us plau. Primer seleccioneu el tipus de document
+Please select weekly off day,Si us plau seleccioni el dia lliure setmanal
+Please select {0},
+Please select {0} first,Seleccioneu {0} primer
+Please select {0} first.,
+Please set Dropbox access keys in your site config,Please set Dropbox access keys in your site config
+Please set Google Drive access keys in {0},Please set Google Drive access keys in {0}
+Please set User ID field in an Employee record to set Employee Role,
+Please set default Cash or Bank account in Mode of Payment {0},"Si us plau, estableix pagament en efectiu o Compte bancari predeterminat a la Forma de pagament {0}"
+Please set default value {0} in Company {0},"Si us plau, estableix el valor per defecte {0} a l'empresa {0}"
+Please set {0},"Si us plau, estableix {0}"
+Please setup Employee Naming System in Human Resource > HR Settings,Please setup Employee Naming System in Human Resource > HR Settings
+Please setup numbering series for Attendance via Setup > Numbering Series,"Si us plau, configureu sèries de numeració per a l'assistència a través de Configuració> Sèries de numeració"
+Please setup your POS Preferences,
+Please setup your chart of accounts before you start Accounting Entries,"Si us plau, configura el teu pla de comptes abans de començar els assentaments comptables"
+Please specify,
+Please specify Company,
+Please specify Company to proceed,
+Please specify Default Currency in Company Master and Global Defaults,
+Please specify a,"Si us plau, especifiqueu un"
+Please specify a valid 'From Case No.',"Si us plau, especifica un 'Des del Cas Número' vàlid"
+Please specify a valid Row ID for {0} in row {1},"Si us plau, especifiqueu un ID de fila vàlid per {0} a la fila {1}"
+Please specify either Quantity or Valuation Rate or both,
+Please submit to update Leave Balance.,Presenta per actualitzar el balanç d'absències
+Plot,Plot
+Point of Sale,Punt de Venda
+Point-of-Sale Setting,Ajustos de Punt de Venda
+Post Graduate,Postgrau
+Postal,Postal
+Postal Expenses,Despeses postals
+Posting Date,Data de publicació
+Posting Time,Temps d'enviament
+Posting date and posting time is mandatory,
+Posting timestamp must be after {0},Data i hora d'enviament ha de ser posterior a {0}
+Potential Sales Deal,
+Potential opportunities for selling.,
+Preferred Billing Address,
+Preferred Shipping Address,Adreça d'enviament preferida
+Prefix,Prefix
+Present,Present
+Prevdoc DocType,Prevdoc DocType
+Prevdoc Doctype,Prevdoc Doctype
+Preview,
+Previous,
+Previous Work Experience,Experiència laboral anterior
+Price,Preu
+Price / Discount,
+Price List,
+Price List Currency,Price List Currency
+Price List Currency not selected,No s'ha escollit una divisa per la llista de preus
+Price List Exchange Rate,Tipus de canvi per a la llista de preus
+Price List Master,Llista de preus Mestre
+Price List Name,nom de la llista de preus
+Price List Rate,
+Price List Rate (Company Currency),Tarifa de preus (en la moneda de la companyia)
+Price List master.,
+Price List must be applicable for Buying or Selling,
+Price List not found or disabled,La llista de preus no existeix o està deshabilitada
+Price List not selected,
+Price List {0} is disabled,La llista de preus {0} està deshabilitada
+Price or Discount,
+Pricing Rule,Regla preus
+Pricing Rule Help,Ajuda de la Regla de preus
+"Pricing Rule is first selected based on 'Apply On' field, which can be Item, Item Group or Brand.",
+"Pricing Rule is made to overwrite Price List / define discount percentage, based on some criteria.","Regla de preus està feta per a sobreescriure la llista de preus/defineix percentatge de descompte, en base a algun criteri."
+Pricing Rules are further filtered based on quantity.,
+Primary,Primari
+Print Format Style,
+Print Heading,Imprimir Capçalera
+Print Without Amount,
+Print and Stationary,
+Printing and Branding,Printing and Branding
+Priority,Prioritat
+Private,
+Private Equity,Private Equity
+Privilege Leave,Privilege Leave
+Probation,Probation
+Process Payroll,Process Payroll
+Produced,Produït
+Produced Quantity,Quantitat produïda
+Product Enquiry,Consulta de producte
+Production,
+Production Order,Ordre de Producció
+Production Order status is {0},
+Production Order {0} must be cancelled before cancelling this Sales Order,
+Production Order {0} must be submitted,L'Ordre de Producció {0} ha d'estar Presentada
+Production Orders,Ordres de Producció
+Production Orders in Progress,
+Production Plan Item,Pla de Producció d'articles
+Production Plan Items,Articles del Pla de Producció
+Production Plan Sales Order,
+Production Plan Sales Orders,
+Production Planning Tool,
+Production order number is mandatory for stock entry purpose manufacture,El Número d'ordre de producció és obligatori per a les entrades d'estoc de fabricació
+Products,
+"Products will be sorted by weight-age in default searches. More the weight-age, higher the product will appear in the list.","Els productes s'ordenaran per pes-antiguitat en les recerques predeterminades. A més del pes-antiguitat, el producte apareixerà més amunt a la llista."
+Professional Tax,Impost Professionals
+Profit and Loss,Pèrdues i Guanys
+Profit and Loss Statement,Guanys i Pèrdues
+Project,
+Project Costing,Costos del projecte
+Project Details,Detalls del projecte
+Project Id,Identificació del projecte
+Project Manager,Gerent De Projecte
+Project Milestone,
+Project Milestones,
+Project Name,Nom del projecte
+Project Start Date,
+Project Status,Estat del Projecte
+Project Type,Tipus de Projecte
+Project Value,Valor de Projecte
+Project activity / task.,
+Project master.,
+Project will get saved and will be searchable with project name given,Es desarà el projecte i es podrà buscar amb el nom assignat
+Project wise Stock Tracking,
+Project wise Stock Tracking ,
+Project-wise data is not available for Quotation,
+Projected,Projectat
+Projected Qty,Quantitat projectada
+Projects,
+Projects & System,Projectes i Sistema
+Projects Manager,
+Projects User,Usuari de Projectes
+Prompt for Email on Submission of,Demana el correu electrònic al Presentar
+Proposal Writing,Redacció de propostes
+Provide email id registered in company,Provide email id registered in company
+Provisional Profit / Loss (Credit),Compte de guanys / pèrdues provisional (Crèdit)
+Public,
+Published on website at: {0},
+Publishing,Publicant
+Pull sales orders (pending to deliver) based on the above criteria,
+Purchase,
+Purchase / Manufacture Details,
+Purchase Analytics,Anàlisi de Compres
+Purchase Common,Purchase Common
+Purchase Details,
+Purchase Discounts,
+Purchase Invoice,Factura de Compra
+Purchase Invoice Advance,Factura de compra anticipada
+Purchase Invoice Advances,Anticips de Factura de Compra
+Purchase Invoice Item,
+Purchase Invoice Trends,Tendències de les Factures de Compra
+Purchase Invoice {0} is already submitted,La Factura de compra {0} ja està Presentada
+Purchase Item,
+Purchase Manager,Gerent de Compres
+Purchase Master Manager,Administraodr principal de compres
+Purchase Order,
+Purchase Order Item,Ordre de compra d'articles
+Purchase Order Item No,Ordre de Compra No. l'article
+Purchase Order Item Supplied,Article de l'ordre de compra Subministrat
+Purchase Order Items,Ordre de Compra d'articles
+Purchase Order Items Supplied,Articles de l'ordre de compra lliurats
+Purchase Order Items To Be Billed,Ordre de Compra articles a facturar
+Purchase Order Items To Be Received,Articles a rebre de l'ordre de compra
+Purchase Order Message,Missatge de les Ordres de Compra
+Purchase Order Required,
+Purchase Order Trends,
+Purchase Order number required for Item {0},Número d'ordre de Compra per {0}
+Purchase Order {0} is 'Stopped',
+Purchase Order {0} is not submitted,
+Purchase Orders given to Suppliers.,Ordres de compra donades a Proveïdors.
+Purchase Price List,Llista de preus de Compra
+Purchase Receipt,Albarà de compra
+Purchase Receipt Item,
+Purchase Receipt Item Supplied,Rebut de compra dels articles subministrats
+Purchase Receipt Item Supplieds,
+Purchase Receipt Items,Rebut de compra d'articles
+Purchase Receipt Message,
+Purchase Receipt No,Número de rebut de compra
+Purchase Receipt Required,Es requereix rebut de compra
+Purchase Receipt Trends,Purchase Receipt Trends
+Purchase Receipt must be submitted,
+Purchase Receipt number required for Item {0},
+Purchase Receipt {0} is not submitted,El rebut de compra {0} no està presentat
+Purchase Receipts,Rebut de compra
+Purchase Register,
+Purchase Return,Devolució de Compra
+Purchase Returned,Compra retornada
+Purchase Taxes and Charges,
+Purchase Taxes and Charges Master,Purchase Taxes and Charges Master
+Purchase User,Usuari de compres
+"Purchase rate for item: {0} not found, which is required to book accounting entry (expense). Please mention item price against a buying price list.",
+Purchse Order number required for Item {0},
+Purpose,Propòsit
+Purpose must be one of {0},Propòsit ha de ser un de {0}
+QA Inspection,Inspecció de qualitat
+Qty,Quantitat
+Qty Consumed Per Unit,
+Qty To Manufacture,Quantitat a fabricar
+Qty as per Stock UOM,La quantitat d'existències ha d'estar expresada en la UDM
+Qty to Deliver,Quantitat a lliurar
+Qty to Order,
+Qty to Receive,
+Qty to Transfer,Quantitat a Transferir
+Qualification,Qualificació
+Quality,Qualitat
+Quality Inspection,Inspecció de Qualitat
+Quality Inspection Parameters,
+Quality Inspection Reading,
+Quality Inspection Readings,Lectures d'inspecció de qualitat
+Quality Inspection required for Item {0},Inspecció de qualitat requerida per a l'article {0}
+Quality Management,Gestió de la Qualitat
+Quality Manager,Gerent de Qualitat
+Quantity,
+Quantity Requested for Purchase,
+Quantity and Rate,
+Quantity and Warehouse,Quantitat i Magatzem
+Quantity cannot be a fraction in row {0},La quantitat no pot ser una fracció a la fila {0}
+Quantity for Item {0} must be less than {1},
+Quantity in row {0} ({1}) must be same as manufactured quantity {2},
+Quantity of item obtained after manufacturing / repacking from given quantities of raw materials,
+Quantity required for Item {0} in row {1},
+Quarter,Trimestre
+Quarterly,Trimestral
+Quick Help,Ajuda Ràpida
+Quotation,Oferta
+Quotation Item,
+Quotation Items,
+Quotation Lost Reason,
+Quotation Message,
+Quotation To,Oferta per
+Quotation Trends,Quotation Trends
+Quotation {0} is cancelled,L'annotació {0} està cancel·lada
+Quotation {0} not of type {1},
+Quotations received from Suppliers.,Ofertes rebudes dels proveïdors.
+Quotes to Leads or Customers.,Cotitzacions a clients potencials o a clients.
+Raise Material Request when stock reaches re-order level,
+Raised By,Raised By
+Raised By (Email),Raised By (Email)
+Random,
+Range,
+Rate,Tarifa
+Rate ,
+Rate (%),Tarifa (%)
+Rate (Company Currency),
+Rate Of Materials Based On,Tarifa de materials basats en
+Rate and Amount,
+Rate at which Customer Currency is converted to customer's base currency,Canvi al qual la divisa del client es converteix la moneda base del client
+Rate at which Price list currency is converted to company's base currency,Valor pel qual la divisa de la llista de preus es converteix a la moneda base de la companyia
+Rate at which Price list currency is converted to customer's base currency,
+Rate at which customer's currency is converted to company's base currency,Rati a la qual es converteix la divisa del client es converteix en la moneda base de la companyia
+Rate at which supplier's currency is converted to company's base currency,Equivalència a la qual la divisa del proveïdor es converteixen a la moneda base de la companyia
+Rate at which this tax is applied,Rati a la qual s'aplica aquest impost
+Raw Material,Matèria Primera
+Raw Material Item Code,
+Raw Materials Supplied,Matèries primeres subministrades
+Raw Materials Supplied Cost,
+Raw material cannot be same as main Item,
+Re-Open Ticket,Reobrir tiquet
+Re-Order Level,
+Re-Order Qty,
+Re-order,
+Re-order Level,Reordenar Nivell
+Re-order Qty,Quantitat per comanda de manteniment de mínims
+Read,Llegir
+Reading 1,Lectura 1
+Reading 10,Reading 10
+Reading 2,
+Reading 3,Lectura 3
+Reading 4,Reading 4
+Reading 5,Lectura 5
+Reading 6,
+Reading 7,
+Reading 8,Lectura 8
+Reading 9,Lectura 9
+Real Estate,Real Estate
+Reason,
+Reason for Leaving,
+Reason for Resignation,Motiu del cessament
+Reason for losing,Motiu de pèrdua
+Recd Quantity,Recd Quantitat
+Receivable,Compte per cobrar
+Receivable / Payable account will be identified based on the field Master Type,Receivable / Payable account will be identified based on the field Master Type
+Receivables,Cobrables
+Receivables / Payables,
+Receivables Group,
+Received,Rebut
+Received Date,Data de recepció
+Received Items To Be Billed,Articles rebuts per a facturar
+Received Or Paid,
+Received Qty,Quantitat rebuda
+Received and Accepted,Rebut i acceptat
+Receiver List,
+Receiver List is empty. Please create Receiver List,"La llista de receptors és buida. Si us plau, crea la Llista de receptors"
+Receiver Parameter,Paràmetre de Receptor
+Recipients,Destinataris
+Reconcile,Conciliar
+Reconciliation Data,Reconciliation Data
+Reconciliation HTML,
+Reconciliation JSON,
+Record item movement.,Desa el Moviment d'article
+Recurring Id,
+Recurring Invoice,Factura Recurrent
+Recurring Order,Ordre Recurrent
+Recurring Type,Tipus Recurrent
+Reduce Deduction for Leave Without Pay (LWP),Reduir Deducció per absències sense sou (LWP)
+Reduce Earning for Leave Without Pay (LWP),Reduir el guany per absències sense sou (LWP)
+Ref,
+Ref Code,Codi de Referència
+Ref Date,
+Ref SQ,
+Reference,Referència
+Reference #{0} dated {1},Referència #{0} amb data {1}
+Reference Date,Data de Referència
+Reference Name,Referència Nom
+Reference No,Referència número
+Reference No & Reference Date is required for {0},
+Reference No is mandatory if you entered Reference Date,
+Reference Number,
+Reference Row #,Referència Fila #
+Refresh,Refrescar
+Registration Details,Detalls de registre
+Registration Info,
+Rejected,Rebutjat
+Rejected Quantity,Quantitat Rebutjada
+Rejected Serial No,Número de sèrie Rebutjat
+Rejected Warehouse,Magatzem no conformitats
+Rejected Warehouse is mandatory against regected item,Cal indicar el magatzem de no conformitats per la partida rebutjada
+Relation,Relació
+Relieving Date,
+Relieving Date must be greater than Date of Joining,
+Remark,
+Remarks,Observacions
+Remove item if charges is not applicable to that item,Treure article si els càrrecs no és aplicable a aquest
+Rename,Canviar el nom
+Rename Log,Canviar el nom de registre
+Rename Tool,Eina de canvi de nom
+Rent Cost,Cost de lloguer
+Rent per hour,Lloguer per hores
+Rented,Llogat
+Reorder Level,
+Reorder Qty,Quantitat per a generar comanda
+Repack,Torneu a embalar
+Repeat Customer Revenue,
+Repeat Customers,
+Repeat on Day of Month,
+Replace,Reemplaçar
+Replace Item / BOM in all BOMs,
+"Replace a particular BOM in all other BOMs where it is used. It will replace the old BOM link, update cost and regenerate ""BOM Explosion Item"" table as per new BOM","Reemplaçar una llista de materials(BOM) a totes les altres llistes de materials(BOM) on s'utilitza. Substituirà l'antic enllaç de llista de materials(BOM), s'actualitzarà el cost i es regenerarà la taula ""BOM Explosionat"", segons la nova llista de materials"
+Replied,Respost
+Report Date,Data de l'informe
+Report Type,
+Report Type is mandatory,
+Reports to,Informes a
+Reqd By Date,Reqd By Date
+Reqd by Date,Reqd per data
+Request Type,
+Request for Information,Sol·licitud d'Informació
+Request for purchase.,Sol·licitud de venda.
+Requested,
+Requested For,Requerida Per
+Requested Items To Be Ordered,
+Requested Items To Be Transferred,Articles sol·licitats per a ser transferits
+Requested Qty,
+"Requested Qty: Quantity requested for purchase, but not ordered.","Quantitat Sol·licitada: Quantitat sol·licitada per a la compra, però sense demanar."
+Requests for items.,Sol·licituds d'articles.
+Required By,Requerit per
+Required Date,
+Required Qty,Quantitat necessària
+Required only for sample item.,Només és necessari per l'article de mostra.
+Required raw materials issued to the supplier for producing a sub - contracted item.,Matèries primeres necessàries emeses al proveïdor per a la producció d'un sub - element contractat.
+Research,Recerca
+Research & Development,
+Researcher,Investigador
+Reseller,Revenedor
+Reserved,
+Reserved Qty,
+"Reserved Qty: Quantity ordered for sale, but not delivered.",
+Reserved Quantity,Quantitat reservades
+Reserved Warehouse,Magatzem Reservat
+Reserved Warehouse in Sales Order / Finished Goods Warehouse,Magatzem Reservat a Ordres de venda / Magatzem de productes acabats
+Reserved Warehouse is missing in Sales Order,Falta la reserva de magatzem a ordres de venda
+Reserved Warehouse required for stock Item {0} in row {1},
+Reserved warehouse required for stock item {0},
+Reserves and Surplus,Reserves i Superàvit
+Reset Filters,
+Resignation Letter Date,
+Resolution,
+Resolution Date,
+Resolution Details,
+Resolved By,Resolta Per
+Rest Of The World,Resta del món
+Retail,Venda al detall
+Retail & Wholesale,Al detall i a l'engròs
+Retailer,
+Review Date,Data de revisió
+Rgt,Rgt
+Role Allowed to edit frozen stock,
+Role that is allowed to submit transactions that exceed credit limits set.,Rol al que es permet presentar les transaccions que excedeixin els límits de crèdit establerts.
+Root Type,
+Root Type is mandatory,Root Type is mandatory
+Root account can not be deleted,
+Root cannot be edited.,Root no es pot editar.
+Root cannot have a parent cost center,
+Rounded Off,
+Rounded Total,Total Arrodonit
+Rounded Total (Company Currency),Total arrodonit (en la divisa de la companyia)
+Row # ,
+Row # {0}: ,
+Row #{0}: Please specify Serial No for Item {1},Fila #{0}: Si us plau especifica el número de sèrie per l'article {1}
+Row {0}: Account {1} does not match with {2} {3} Name,
+Row {0}: Account {1} does not match with {2} {3} account,Fila {0}: Compte {1} no coincideix amb el compte {2} {3}
+Row {0}: Allocated amount {1} must be less than or equals to JV amount {2},Fila {0}: quantitat assignada {1} ha de ser menor o igual a l'import JV {2}
+Row {0}: Allocated amount {1} must be less than or equals to invoice outstanding amount {2},Fila {0}: quantitat assignada {1} ha de ser menor o igual a quantitat pendent de facturar {2}
+Row {0}: Conversion Factor is mandatory,Fila {0}: el factor de conversió és obligatori
+Row {0}: Credit entry can not be linked with a {1},
+Row {0}: Debit entry can not be linked with a {1},
+Row {0}: Payment Amount cannot be greater than Outstanding Amount,Fila {0}: Quantitat de pagament no pot ser superior a quantitat lliurada
+Row {0}: Payment against Sales/Purchase Order should always be marked as advance,Fila {0}: El pagament contra Vendes / Ordre de Compra sempre ha d'estar marcat com a pagamet anticipat (bestreta)
+Row {0}: Payment amount can not be negative,
+Row {0}: Please check 'Is Advance' against Account {1} if this is an advance entry.,"Fila {0}: Si us plau, vegeu ""És Avanç 'contra el Compte {1} si es tracta d'una entrada amb antelació."
+Row {0}: Qty is mandatory,Fila {0}: Quantitat és obligatori
+"Row {0}: Qty not avalable in warehouse {1} on {2} {3}.
+					Available Qty: {4}, Transfer Qty: {5}",
+"Row {0}: To set {1} periodicity, difference between from and to date \
+						must be greater than or equal to {2}",
+Row {0}: {1} is not a valid {2},La fila {0}: {1} no és vàlida per {2}
+Row {0}:Start Date must be before End Date,
+Rules for adding shipping costs.,Regles per afegir les despeses d'enviament.
+Rules for applying pricing and discount.,
+Rules to calculate shipping amount for a sale,
+S.O. No.,S.O. No.
+SHE Cess on Excise,SHE Cess on Excise
+SHE Cess on Service Tax,SHE Cess on Service Tax
+SHE Cess on TDS,SHE Cess on TDS
+SMS Center,Centre d'SMS
+SMS Gateway URL,SMS Gateway URL
+SMS Log,
+SMS Parameter,Paràmetre SMS
+SMS Sender Name,
+SMS Settings,Ajustaments de SMS
+SO Date,SO Date
+SO Pending Qty,
+SO Qty,SO Qty
+Salary,
+Salary Information,Informació sobre sous
+Salary Manager,
+Salary Mode,Salary Mode
+Salary Slip,
+Salary Slip Deduction,Deducció de la fulla de nòmina
+Salary Slip Earning,Salary Slip Earning
+Salary Slip of employee {0} already created for this month,
+Salary Structure,Estructura salarial
+Salary Structure Deduction,Salary Structure Deduction
+Salary Structure Earning,Salary Structure Earning
+Salary Structure Earnings,
+Salary breakup based on Earning and Deduction.,Salary breakup based on Earning and Deduction.
+Salary components.,Components salarials.
+Salary template master.,Salary template master.
+Sales,
+Sales Analytics,
+Sales BOM,
+Sales BOM Help,
+Sales BOM Item,BOM d'article de venda
+Sales BOM Items,BOM d'articles de venda
+Sales Browser,Analista de Vendes
+Sales Details,
+Sales Discounts,Descomptes de venda
+Sales Email Settings,Ajustos dels correus electrònics de vendes
+Sales Expenses,Despeses de venda
+Sales Extras,
+Sales Funnel,Sales Funnel
+Sales Invoice,Factura de vendes
+Sales Invoice Advance,Factura proforma
+Sales Invoice Item,
+Sales Invoice Items,
+Sales Invoice Message,Missatge de Factura de vendes
+Sales Invoice No,Factura No
+Sales Invoice Trends,Tendències de Factures de Vendes
+Sales Invoice {0} has already been submitted,
+Sales Invoice {0} must be cancelled before cancelling this Sales Order,La factura {0} ha de ser cancel·lada abans de cancel·lar aquesta comanda de vendes
+Sales Item,Article de venda
+Sales Manager,Gerent De Vendes
+Sales Master Manager,Gerent de vendes
+Sales Order,Ordre de Venda
+Sales Order Date,
+Sales Order Item,
+Sales Order Items,
+Sales Order Message,
+Sales Order No,Ordre de Venda No
+Sales Order Required,
+Sales Order Trends,Sales Order Trends
+Sales Order required for Item {0},Ordres de venda requerides per l'article {0}
+Sales Order {0} is not submitted,
+Sales Order {0} is not valid,
+Sales Order {0} is stopped,
+Sales Partner,
+Sales Partner Name,Nom del revenedor
+Sales Partner Target,Sales Partner Target
+Sales Partners Commission,Comissió dels revenedors
+Sales Person,
+Sales Person Name,Nom del venedor
+Sales Person Target Variance Item Group-Wise,Sales Person Target Variance Item Group-Wise
+Sales Person Targets,
+Sales Person-wise Transaction Summary,Resum de transaccions de vendes Persona-savi
+Sales Price List,Llista de preus de venda
+Sales Register,Registre de vendes
+Sales Return,Devolucions de vendes
+Sales Returned,
+Sales Taxes and Charges,Els impostos i càrrecs de venda
+Sales Taxes and Charges Master,Configuració d'Impostos i càrregues
+Sales Team,Equip de vendes
+Sales Team Details,
+Sales Team1,Equip de Vendes 1
+Sales User,Usuari de vendes
+Sales and Purchase,Compra i Venda
+Sales campaigns.,Campanyes de venda.
+Salutation,Salutació
+Sample Size,Mida de la mostra
+Sanctioned Amount,Sanctioned Amount
+Saturday,
+Schedule,
+Schedule Date,
+Schedule Details,
+Scheduled,
+Scheduled Date,Data Prevista
+Scheduled to send to {0},Programat per enviar a {0}
+Scheduled to send to {0} recipients,
+Scheduler Failed Events,Scheduler Failed Events
+School/University,
+Score (0-5),Puntuació (0-5)
+Score Earned,Score Earned
+Score must be less than or equal to 5,Score ha de ser menor que o igual a 5
+Scrap %,Scrap%
+Seasonality for setting budgets.,Estacionalitat per fixar els pressupostos.
+Secretary,Secretari
+Secured Loans,Préstecs Garantits
+Securities & Commodity Exchanges,Securities & Commodity Exchanges
+Securities and Deposits,
+"See ""Rate Of Materials Based On"" in Costing Section",
+"Select ""Yes"" for sub - contracting items","Seleccioneu ""Sí"" per a articles subcontractables"
+"Select ""Yes"" if this item is used for some internal purpose in your company.","Seleccioneu ""Sí"" si aquest article s'utilitza per a algun propòsit intern en la seva empresa."
+"Select ""Yes"" if this item represents some work like training, designing, consulting etc.","Seleccioneu ""Sí"" si aquest article representa algun treball com formació, disseny, consultoria, etc."
+"Select ""Yes"" if you are maintaining stock of this item in your Inventory.",
+"Select ""Yes"" if you supply raw materials to your supplier to manufacture this item.","Seleccioneu ""Sí"" si subministres matèries primeres al teu proveïdor per a la fabricació d'aquest material."
+Select Budget Distribution to unevenly distribute targets across months.,Seleccioneu Pressupost distribució per distribuir de manera desigual a través d'objectius mesos.
+"Select Budget Distribution, if you want to track based on seasonality.","Seleccioneu Pressupost Distribució, si voleu fer un seguiment basat en l'estacionalitat."
+Select Company...,
+Select DocType,
+Select Fiscal Year,Seleccioneu l'any fiscal
+Select Fiscal Year...,Seleccioneu l'Any Fiscal ...
+Select Items,Seleccionar elements
+Select Sales Orders,
+Select Sales Orders from which you want to create Production Orders.,Seleccioneu ordres de venda a partir del qual vol crear ordres de producció.
+Select Time Logs and Submit to create a new Sales Invoice.,Selecciona Registres de temps i Presenta per a crear una nova factura de venda.
+Select Transaction,Seleccionar Transacció
+Select Your Language,Selecciona el teu idioma
+Select account head of the bank where cheque was deposited.,
+Select company name first.,Seleccioneu el nom de l'empresa en primer lloc.
+Select template from which you want to get the Goals,
+Select the Employee for whom you are creating the Appraisal.,Seleccioneu l'empleat per al qual està creant l'Avaluació.
+Select the period when the invoice will be generated automatically,Seleccioneu el període en què la factura es generarà de forma automàtica
+Select the relevant company name if you have multiple companies,Seleccioneu el nom de societats corresponent si disposa de diverses empreses
+Select the relevant company name if you have multiple companies.,Seleccioneu el nom de societats corresponent si disposa de diverses empreses.
+Select type of transaction,Seleccioneu el tipus de transacció
+Select who you want to send this newsletter to,
+Select your home country and check the timezone and currency.,Seleccioni el seu país d'origen i tria la zona horària i la moneda.
+"Selecting ""Yes"" will allow this item to appear in Purchase Order , Purchase Receipt.",
+"Selecting ""Yes"" will allow this item to figure in Sales Order, Delivery Note","En seleccionar ""Sí"" permetrà que aquest article estigui en ordres de venda, i notes de lliurament"
+"Selecting ""Yes"" will allow you to create Bill of Material showing raw material and operational costs incurred to manufacture this item.","En seleccionar ""Sí"" li permetrà crear la llista de materials que mostra la matèria primera i els costos operatius incorreguts en la fabricació d'aquest element."
+"Selecting ""Yes"" will allow you to make a Production Order for this item.",
+"Selecting ""Yes"" will give a unique identity to each entity of this item which can be viewed in the Serial No master.","En seleccionar ""Sí"" li donarà una identitat única a cada entitat d'aquest article que es pot veure a la taula mestre de Números de sèrie"
+Selling,De venda
+Selling Amount,
+Selling Rate,La tarifa de venda
+Selling Settings,
+"Selling must be checked, if Applicable For is selected as {0}",
+Send,
+Send Autoreply,
+Send Email,
+Send From,
+Send Notifications To,Enviar notificacions a
+Send Now,
+Send SMS,Enviar SMS
+Send To,Enviar a
+Send To Type,Enviar a Tipus
+Send automatic emails to Contacts on Submitting transactions.,Enviar correus electrònics automàtics als Contactes al Presentar les transaccions
+Send mass SMS to your contacts,
+Send regular summary reports via Email.,Enviar informes periòdics resumits per correu electrònic.
+Send to this list,Enviar a la llista
+Sender Name,
+Sent,
+Sent On,
+Separate production order will be created for each finished good item.,
+Serial #,
+Serial No,Número de sèrie
+Serial No / Batch,Número de sèrie / lot
+Serial No Details,
+Serial No Service Contract Expiry,Número de sèrie del contracte de venciment del servei
+Serial No Status,Estat del número de sèrie
+Serial No Warranty Expiry,Venciment de la garantia del número de sèrie
+Serial No is mandatory for Item {0},
+Serial No {0} created,
+Serial No {0} does not belong to Delivery Note {1},El número de sèrie {0} no pertany a la nota de lliurament {1}
+Serial No {0} does not belong to Item {1},El número de Sèrie {0} no pertany a l'article {1}
+Serial No {0} does not belong to Warehouse {1},
+Serial No {0} does not exist,El número de sèrie {0} no existeix
+Serial No {0} has already been received,
+Serial No {0} is under maintenance contract upto {1},
+Serial No {0} is under warranty upto {1},El número de sèrie {0} està en garantia fins {1}
+Serial No {0} not found,
+Serial No {0} not in stock,El número de sèrie {0} no està en estoc
+Serial No {0} quantity {1} cannot be a fraction,Número de sèrie {0} quantitat {1} no pot ser una fracció
+Serial No {0} status must be 'Available' to Deliver,
+Serial Nos Required for Serialized Item {0},Nº de Sèrie Necessari per article serialitzat {0}
+Serial Number Series,
+Serial number {0} entered more than once,
+"Serialized Item {0} cannot be updated \
+					using Stock Reconciliation",
+Series,Sèrie
+Series List for this Transaction,Llista de Sèries per a aquesta transacció
+Series Updated,
+Series Updated Successfully,
+Series is mandatory,
+Series {0} already used in {1},La sèrie {0} ja s'utilitza a {1}
+Service,Servei
+Service Address,Adreça de Servei
+Service Tax,Service Tax
+Services,Serveis
+Set,Setembre
+"Set Default Values like Company, Currency, Current Fiscal Year, etc.",
+Set Item Group-wise budgets on this Territory. You can also include seasonality by setting the Distribution.,
+Set Status as Available,Estableix l'estat com Disponible
+Set as Default,Estableix com a predeterminat
+Set as Lost,Establir com a Perdut
+Set prefix for numbering series on your transactions,Establir prefix de numeracions seriades a les transaccions
+Set targets Item Group-wise for this Sales Person.,Establir Grup d'articles per aquest venedor.
+Setting Account Type helps in selecting this Account in transactions.,Configurar el Tipus de compte ajuda en la selecció d'aquest compte en les transaccions.
+Setting this Address Template as default as there is no other default,
+Setting up...,S'està configurant ...
+Settings,Ajustos
+Settings for Accounts,Ajustaments de Comptes
+Settings for Buying Module,Ajustaments del mòdul de Compres
+Settings for HR Module,
+Settings for Selling Module,Ajustos Mòdul de vendes
+"Settings to extract Job Applicants from a mailbox e.g. ""jobs@example.com""",
+Setup,Ajustos
+Setup Already Complete!!,Configuració acabada !!
+Setup Complete,Instal·lació completa
+Setup SMS gateway settings,
+Setup Series,
+Setup Wizard,Assistent de configuració
+Setup incoming server for jobs email id. (e.g. jobs@example.com),Setup incoming server for jobs email id. (e.g. jobs@example.com)
+Setup incoming server for sales email id. (e.g. sales@example.com),
+Setup incoming server for support email id. (e.g. support@example.com),
+Share,
+Share With,Compartir amb
+Shareholders Funds,Fons dels Accionistes
+Shipments to customers.,Enviaments a clients.
+Shipping,
+Shipping Account,Compte d'Enviaments
+Shipping Address,Adreça d'nviament
+Shipping Address Name,Nom de l'Adreça d'enviament
+Shipping Amount,Total de l'enviament
+Shipping Rule,Regla d'enviament
+Shipping Rule Condition,Condicions d'enviaments
+Shipping Rule Conditions,Condicions d'enviament
+Shipping Rule Label,
+Shop,Botiga
+Shopping Cart,
+Short biography for website and other publications.,Breu biografia de la pàgina web i altres publicacions.
+Shortage Qty,Quantitat escassetat
+"Show ""In Stock"" or ""Not in Stock"" based on stock available in this warehouse.","Mostra ""En estock"" o ""No en estoc"", basat en l'estoc disponible en aquest magatzem."
+"Show / Hide features like Serial Nos, POS etc.","Mostra / Amaga característiques com Nº de Sèrie, TPV etc."
+Show In Website,Mostra en el lloc web
+Show a slideshow at the top of the page,Mostra una presentació de diapositives a la part superior de la pàgina
+Show in Website,
+Show this slideshow at the top of the page,
+Show zero values,Mostra valors zero
+Shown in Website,
+Sick Leave,
+Signature,
+Signature to be appended at the end of every email,Firma que s'afegeix al final de cada correu electrònic
+Single,Solter
+Single unit of an Item.,Unitat individual d'un article
+Sit tight while your system is being setup. This may take a few moments.,"Si us plau, espera mentre el sistema està essent configurat. Aquest procés pot trigar una estona."
+Slideshow,Slideshow
+Soap & Detergent,Sabó i Detergent
+Software,
+Software Developer,Desenvolupador de Programari
+"Sorry, Serial Nos cannot be merged","Ho sentim, els números de sèrie no es poden combinar"
+"Sorry, companies cannot be merged",
+Source,
+Source File,Arxiu d'origen
+Source Warehouse,Magatzem d'origen
+Source and target warehouse cannot be same for row {0},
+Source of Funds (Liabilities),Font dels fons (Passius)
+Source warehouse is mandatory for row {0},Magatzem d'origen obligatori per a la fila {0}
+Spartan,
+"Special Characters except ""-"" and ""/"" not allowed in naming series","Els caràcters especials excepte ""-"" i ""/"" no es permeten en el nomenament de sèries"
+Specification Details,Specification Details
+Specifications,Especificacions
+Specify Exchange Rate to convert one currency into another,
+"Specify a list of Territories, for which, this Price List is valid",Especifiqueu una llista de territoris on aquesta llista de preus és vàlida
+"Specify a list of Territories, for which, this Shipping Rule is valid",
+"Specify a list of Territories, for which, this Taxes Master is valid",Especifiqueu la llista de territoris on s'aplica aquest Patró d'Impostos
+Specify conditions to calculate shipping amount,Especifica les condicions d'enviament per calcular l'import del transport
+"Specify the operations, operating cost and give a unique Operation no to your operations.","Especifiqueu les operacions, el cost d'operació i dona una número d'operació únic a les operacions."
+Split Delivery Note into packages.,
+Sports,Esports
+Sr,
+Standard,Estàndard
+Standard Buying,Compra Standard
+Standard Reports,Informes estàndard
+Standard Selling,Standard Selling
+"Standard Terms and Conditions that can be added to Sales and Purchases.
+
+Examples:
+
+1. Validity of the offer.
+1. Payment Terms (In Advance, On Credit, part advance etc).
+1. What is extra (or payable by the Customer).
+1. Safety / usage warning.
+1. Warranty if any.
+1. Returns Policy.
+1. Terms of shipping, if applicable.
+1. Ways of addressing disputes, indemnity, liability, etc.
+1. Address and Contact of your Company.",
+Standard contract terms for Sales or Purchase.,
+"Standard tax template that can be applied to all Purchase Transactions. This template can contain list of tax heads and also other expense heads like ""Shipping"", ""Insurance"", ""Handling"" etc.
+
+#### Note
+
+The tax rate you define here will be the standard tax rate for all **Items**. If there are **Items** that have different rates, they must be added in the **Item Tax** table in the **Item** master.
+
+#### Description of Columns
+
+1. Calculation Type: 
+    - This can be on **Net Total** (that is the sum of basic amount).
+    - **On Previous Row Total / Amount** (for cumulative taxes or charges). If you select this option, the tax will be applied as a percentage of the previous row (in the tax table) amount or total.
+    - **Actual** (as mentioned).
+2. Account Head: The Account ledger under which this tax will be booked
+3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.
+4. Description: Description of the tax (that will be printed in invoices / quotes).
+5. Rate: Tax rate.
+6. Amount: Tax amount.
+7. Total: Cumulative total to this point.
+8. Enter Row: If based on ""Previous Row Total"" you can select the row number which will be taken as a base for this calculation (default is the previous row).
+9. Consider Tax or Charge for: In this section you can specify if the tax / charge is only for valuation (not a part of total) or only for total (does not add value to the item) or for both.
+10. Add or Deduct: Whether you want to add or deduct the tax.",
+"Standard tax template that can be applied to all Sales Transactions. This template can contain list of tax heads and also other expense / income heads like ""Shipping"", ""Insurance"", ""Handling"" etc.
+
+#### Note
+
+The tax rate you define here will be the standard tax rate for all **Items**. If there are **Items** that have different rates, they must be added in the **Item Tax** table in the **Item** master.
+
+#### Description of Columns
+
+1. Calculation Type: 
+    - This can be on **Net Total** (that is the sum of basic amount).
+    - **On Previous Row Total / Amount** (for cumulative taxes or charges). If you select this option, the tax will be applied as a percentage of the previous row (in the tax table) amount or total.
+    - **Actual** (as mentioned).
+2. Account Head: The Account ledger under which this tax will be booked
+3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.
+4. Description: Description of the tax (that will be printed in invoices / quotes).
+5. Rate: Tax rate.
+6. Amount: Tax amount.
+7. Total: Cumulative total to this point.
+8. Enter Row: If based on ""Previous Row Total"" you can select the row number which will be taken as a base for this calculation (default is the previous row).
+9. Is this Tax included in Basic Rate?: If you check this, it means that this tax will not be shown below the item table, but will be included in the Basic Rate in your main item table. This is useful where you want give a flat price (inclusive of all taxes) price to customers.",
+Start,Començar
+Start Date,
+Start POS,Inicia TPV
+Start date of current invoice's period,Data inicial del període de facturació actual
+Start date of current order's period,Data inicial del període de l'ordre actual
+Start date should be less than end date for Item {0},La data d'inici ha de ser anterior a la data de finalització per l'article {0}
+State,
+Statement of Account,Estat de compte
+Static Parameters,Paràmetres estàtics
+Status,
+Status must be one of {0},Estat ha de ser un {0}
+Status of {0} {1} is now {2},Situació de {0} {1} és ara {2}
+Status updated to {0},Estat actualitzat a {0}
+Statutory info and other general information about your Supplier,Informació legal i altra informació general sobre el Proveïdor
+Stay Updated,
+Stock,Estoc
+Stock Adjustment,Ajust d'estoc
+Stock Adjustment Account,Compte d'Ajust d'estocs
+Stock Ageing,
+Stock Analytics,
+Stock Assets,Actius
+Stock Balance,Saldos d'estoc
+Stock Entries already created for Production Order ,
+Stock Entry,Entrada estoc
+Stock Entry Detail,Detall de les entrades d'estoc
+Stock Expenses,Despeses d'estoc
+Stock Frozen Upto,Estoc bloquejat fins a
+Stock Item,Article d'estoc
+Stock Ledger,
+Stock Ledger Entries and GL Entries are reposted for the selected Purchase Receipts,Les entrades d'ajust d'estocs i les entrades de GL estan inserits en els rebuts de compra seleccionats
+Stock Ledger Entry,
+Stock Ledger entries balances updated,Saldos d'entrades de moviments d'estocs actualitzats
+Stock Level,Nivell d'existències
+Stock Liabilities,Stock Liabilities
+Stock Projected Qty,Quantitat d'estoc previst
+Stock Queue (FIFO),
+Stock Received But Not Billed,Estoc Rebudes però no facturats
+Stock Reconcilation Data,
+Stock Reconcilation Template,Plantilla d'ajust d'estoc
+Stock Reconciliation,Reconciliació d'Estoc
+"Stock Reconciliation can be used to update the stock on a particular date, usually as per physical inventory.",
+Stock Settings,Ajustaments d'estocs
+Stock UOM,UDM de l'estoc
+Stock UOM Replace Utility,Utilitat de susbtitució de les UDM de l'estoc
+Stock UOM updatd for Item {0},S'ha actualitzat la UDM de l'article {0}
+Stock Uom,UDM de l'Estoc
+Stock Value,
+Stock Value Difference,Diferència del valor d'estoc
+Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},
+Stock balances updated,Imatges de saldos actualitzats
+Stock cannot be updated against Delivery Note {0},L'estoc no es pot actualitzar contra la Nota de Lliurament {0}
+Stock entries exist against warehouse {0} cannot re-assign or modify 'Master Name',Stock entries exist against warehouse {0} cannot re-assign or modify 'Master Name'
+Stock transactions before {0} are frozen,
+Stock: ,
+Stop,Atura
+Stop Birthday Reminders,Aturar recordatoris d'aniversari
+Stop users from making Leave Applications on following days.,No permetis que els usuaris realitzin Aplicacions d'absències els següents dies.
+Stopped,Detingut
+Stopped order cannot be cancelled. Unstop to cancel.,
+Stores,Botigues
+Stub,
+Sub Assemblies,Sub Assemblies
+"Sub-currency. For e.g. ""Cent""","Parts de moneda. Per exemple ""Cèntims"""
+Subcontract,
+Subcontracted,Subcontractat
+Subject,
+Submit Salary Slip,Presentar nòmina
+Submit all salary slips for the above selected criteria,Presenta totes les nòmines amb els criteris anteriorment seleccionats
+Submit this Production Order for further processing.,Presentar aquesta ordre de producció per al seu posterior processament.
+Submitted,
+Subsidiary,Filial
+Successful: ,
+Successfully Reconciled,Reconciliats amb èxit
+Suggestions,Suggeriments
+Sunday,
+Supplier,
+Supplier (Payable) Account,Proveïdor (a pagar) Compte
+Supplier (vendor) name as entered in supplier master,Nom del Proveïdor (venedor) tal i com es va entrar a la configuració de proveïdors
+Supplier > Supplier Type,Proveïdor> Tipus Proveïdor
+Supplier Account,
+Supplier Account Head,
+Supplier Address,Adreça del Proveïdor
+Supplier Addresses and Contacts,Adreces i contactes dels proveïdors
+Supplier Details,
+Supplier Id,Identificador de Proveïdor
+Supplier Invoice Date,Data Factura Proveïdor
+Supplier Invoice No,Factura de Proveïdor No
+Supplier Name,Nom del proveïdor
+Supplier Naming By,NOmenament de proveïdors per
+Supplier Part Number,PartNumber del proveïdor
+Supplier Quotation,
+Supplier Quotation Item,Oferta del proveïdor d'article
+Supplier Reference,Referència Proveïdor
+Supplier Type,Tipus de Proveïdor
+Supplier Type / Supplier,
+Supplier Type master.,Taula metre de tipus de proveïdor
+Supplier Warehouse,Magatzem Proveïdor
+Supplier Warehouse mandatory for sub-contracted Purchase Receipt,
+Supplier database.,
+Supplier master.,Supplier master.
+Supplier of Goods or Services.,
+Supplier warehouse where you have issued raw materials for sub - contracting,Magatzem del proveïdor en què ha enviat les matèries primeres per a la subcontractació
+Supplier(s),Proveïdor (s)
+Supplier-Wise Sales Analytics,
+Support,Suport
+Support Analtyics,
+Support Analytics,
+Support Email,
+Support Email Settings,
+Support Manager,Gerent de Suport
+Support Password,Contrasenya de suport
+Support Team,Equip de suport
+Support Ticket,Tiquet
+Support queries from customers.,
+Symbol,
+Sync Support Mails,Sincronitzar Suport Mails
+Sync with Dropbox,Sincronització amb Dropbox
+Sync with Google Drive,Sincronitza amb Google Drive
+System,Sistema
+System Balance,Balanç de Sistema
+System Manager,Administrador del sistema
+System Settings,
+"System User (login) ID. If set, it will become default for all HR forms.","System User (login) ID. If set, it will become default for all HR forms."
+System for managing Backups,
+TDS (Advertisement),TDS (Publicitat)
+TDS (Commission),TDS (Comissió)
+TDS (Contractor),TDS (contractista)
+TDS (Interest),
+TDS (Rent),
+TDS (Salary),
+Table for Item that will be shown in Web Site,Taula d'article que es mostra en el lloc web
+Taken,
+Target,Objectiu
+Target  Amount,
+Target Detail,
+Target Details,Detalls del destí
+Target Details1,Target Details1
+Target Distribution,Target Distribution
+Target On,Target On
+Target Qty,
+Target Warehouse,Magatzem destí
+Target warehouse in row {0} must be same as Production Order,El magatzem de destinació de la fila {0} ha de ser igual que l'Ordre de Producció
+Target warehouse is mandatory for row {0},Magatzem destí obligatori per a la fila {0}
+Task,
+Task Details,Detalls de la feina
+Task Subject,
+Tasks,
+Tax,Impost
+Tax Amount After Discount Amount,Suma d'impostos Després del Descompte
+Tax Assets,
+Tax Category can not be 'Valuation' or 'Valuation and Total' as all items are non-stock items,
+Tax Rate,Tax Rate
+Tax and other salary deductions.,
+"Tax detail table fetched from item master as a string and stored in this field.
+Used for Taxes and Charges","Tax detail table fetched from item master as a string and stored in this field.
+Used for Taxes and Charges"
+Tax template for buying transactions.,Plantilla d'Impostos per a les transaccions de compres
+Tax template for selling transactions.,
+Taxes,
+Taxes and Charges,Impostos i càrrecs
+Taxes and Charges Added,Impostos i càrregues afegides
+Taxes and Charges Added (Company Currency),Impostos i Càrrecs Afegits (Divisa de la Companyia)
+Taxes and Charges Calculation,
+Taxes and Charges Deducted,Impostos i despeses deduïdes
+Taxes and Charges Deducted (Company Currency),
+Taxes and Charges Total,
+Taxes and Charges Total (Company Currency),Els impostos i càrrecs totals (Divisa de la Companyia)
+Technology,Tecnologia
+Telecommunications,Telecomunicacions
+Telephone Expenses,Despeses telefòniques
+Television,Televisió
+Template,
+Template for performance appraisals.,Plantilla per a les avaluacions d'acompliment.
+Template of terms or contract.,Plantilla de termes o contracte.
+Temporary Accounts (Assets),Comptes temporals (Actius)
+Temporary Accounts (Liabilities),
+Temporary Assets,
+Temporary Liabilities,Passius temporals
+Term Details,Detalls termini
+Terms,Condicions
+Terms and Conditions,Condicions
+Terms and Conditions Content,Contingut de Termes i Condicions
+Terms and Conditions Details,
+Terms and Conditions Template,Plantilla de Termes i Condicions
+Terms and Conditions1,Termes i Condicions 1
+Terretory,
+Territory,Territori
+Territory / Customer,
+Territory Manager,Gerent de Territory
+Territory Name,Nom del Territori
+Territory Target Variance Item Group-Wise,
+Territory Targets,
+Test,Prova
+Test Email Id,Test Email Id
+Test the Newsletter,Proveu el Newsletter
+The BOM which will be replaced,Llista de materials que serà substituïda
+The First User: You,
+"The Item that represents the Package. This Item must have ""Is Stock Item"" as ""No"" and ""Is Sales Item"" as ""Yes""",
+The Organization,L'Organització
+"The account head under Liability, in which Profit/Loss will be booked","El compte capçalera amb responsabilitat, en el que es farà l'assentament de Guany / Pèrdua"
+The date on which next invoice will be generated. It is generated on submit.,
+"The date on which next invoice will be generated. It is generated on submit.
+","La data en què es generarà la següent factura. Es genera al Presentar.
+"
+The date on which recurring invoice will be stop,La data en què s'atura la factura recurrent
+The date on which recurring order will be stop,La data en què s'aturarà la comanda recurrent
+"The day of the month on which auto invoice will be generated e.g. 05, 28 etc","El dia del mes en què es generarà factura automàtica, per exemple 05, 28, etc."
+"The day of the month on which auto invoice will be generated e.g. 05, 28 etc ",
+"The day of the month on which auto order will be generated e.g. 05, 28 etc","El dia del mes en el qual l'ordre automàtic es generarà per exemple 05, 28, etc."
+"The day of the month on which auto order will be generated e.g. 05, 28 etc ",
+The day(s) on which you are applying for leave are holiday. You need not apply for leave.,
+The first Leave Approver in the list will be set as the default Leave Approver,El primer aprovadorde d'absències de la llista s'establirà com a predeterminat
+The first user will become the System Manager (you can change that later).,El primer usuari es convertirà en l'Administrador del sistema (pot canviar això més endavant).
+The gross weight of the package. Usually net weight + packaging material weight. (for print),"El pes brut del paquet. En general, el pes net + embalatge pes del material. (Per imprimir)"
+The name of your company for which you are setting up this system.,El nom de la teva empresa per a la qual està creant aquest sistema.
+The net weight of this package. (calculated automatically as sum of net weight of items),
+The new BOM after replacement,
+The rate at which Bill Currency is converted into company's base currency,El canvi al qual la divisa de la Factura es converteix a la moneda base de la companyia
+The selected item cannot have Batch,
+The unique id for tracking all recurring invoices. It is generated on submit.,L'identificador únic per al seguiment de totes les factures recurrents. Es genera al Presentar.
+The unique id for tracking all recurring invoices. It is generated on submit.,
+"Then Pricing Rules are filtered out based on Customer, Customer Group, Territory, Supplier, Supplier Type, Campaign, Sales Partner etc.","Llavors Tarifes de Preu es filtren sobre la base de client, grup de clients, Territori, Proveïdor, Tipus Proveïdor, Campanya, soci de vendes, etc."
+There are more holidays than working days this month.,
+"There can only be one Shipping Rule Condition with 0 or blank value for ""To Value""",
+There is not enough leave balance for Leave Type {0},There is not enough leave balance for Leave Type {0}
+There is nothing to edit.,
+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.,"S'ha produït un error. Una raó probable podria ser que no ha guardat el formulari. Si us plau, poseu-vos en contacte amb support@erpnext.com si el problema persisteix."
+There were errors.,Hi han hagut errors.
+There were no updates in the items selected for this digest.,
+This Currency is disabled. Enable to use in transactions,Aquesta moneda és deshabilitada Habilitala per a utilitzar-la en les transaccions
+This Leave Application is pending approval. Only the Leave Approver can update status.,
+This Time Log Batch has been billed.,Aquest registre de temps ha estat facturat.
+This Time Log Batch has been cancelled.,Aquest registre de temps ha estat cancel·lat.
+This Time Log conflicts with {0},
+This format is used if country specific format is not found,Aquest format s'utilitza si no hi ha el format específic de cada país
+This is a root account and cannot be edited.,Es tracta d'un compte principal i no es pot editar.
+This is a root customer group and cannot be edited.,Es tracta d'un grup de clients de l'arrel i no es pot editar.
+This is a root item group and cannot be edited.,This is a root item group and cannot be edited.
+This is a root sales person and cannot be edited.,
+This is a root territory and cannot be edited.,This is a root territory and cannot be edited.
+This is an example website auto-generated from ERPNext,
+This is the number of the last created transaction with this prefix,Aquest és el nombre de l'última transacció creat amb aquest prefix
+This tool helps you to update or fix the quantity and valuation of stock in the system. It is typically used to synchronise the system values and what actually exists in your warehouses.,Aquesta eina us ajuda a actualitzar o corregir la quantitat i la valoració dels estocs en el sistema. Normalment s'utilitza per sincronitzar els valors del sistema i el que realment hi ha en els magatzems.
+This will be used for setting rule in HR module,
+Thread HTML,Thread HTML
+Thursday,Dijous
+Time Log,Hora de registre
+Time Log Batch,Registre de temps
+Time Log Batch Detail,Detall del registre de temps
+Time Log Batch Details,Detalls del registre de temps
+Time Log Batch {0} must be 'Submitted',S'ha de 'Presentar' el registre de temps {0}
+Time Log Status must be Submitted.,
+Time Log for tasks.,Registre de temps per a les tasques.
+Time Log is not billable,Registre d'hores no facturable
+Time Log {0} must be 'Submitted',
+Time Zone,Fus horari
+Time Zones,Zones horàries
+Time and Budget,Temps i Pressupost
+Time at which items were delivered from warehouse,Moment en què els articles van ser lliurats des del magatzem
+Time at which materials were received,Moment en què es van rebre els materials
+Title,Títol
+Titles for print templates e.g. Proforma Invoice.,"Títols per a plantilles d'impressió, per exemple, factura proforma."
+To,
+To Currency,
+To Date,
+To Date should be same as From Date for Half Day leave,
+To Date should be within the Fiscal Year. Assuming To Date = {0},
+To Datetime,To Datetime
+To Discuss,Per Discutir
+To Do List,
+To Package No.,Al paquet No.
+To Produce,Per a Produir
+To Time,
+To Value,
+To Warehouse,Magatzem destí
+"To add child nodes, explore tree and click on the node under which you want to add more nodes.","Per afegir nodes secundaris, explora arbre i feu clic al node en el qual voleu afegir més nodes."
+"To assign this issue, use the ""Assign"" button in the sidebar.","Per assignar aquest problema, utilitzeu el botó ""Assignar"" a la barra lateral."
+To create a Bank Account,Per crear un compte de banc
+To create a Tax Account,Per crear un compte d'impostos
+"To create an Account Head under a different company, select the company and save customer.","Per crear un Compte principal per una companyia diferent, seleccioneu l'empresa i deseu el client."
+To date cannot be before from date,Fins a la data no pot ser anterior a partir de la data
+To enable <b>Point of Sale</b> features,
+To enable <b>Point of Sale</b> view,To enable <b>Point of Sale</b> view
+To get Item Group in details table,Per obtenir Grup d'articles a la taula detalls
+"To include tax in row {0} in Item rate, taxes in rows {1} must also be included","Per incloure l'impost a la fila {0} en la tarifa d'article, els impostos a les files {1} també han de ser inclosos"
+"To merge, following properties must be same for both items",
+"To not apply Pricing Rule in a particular transaction, all applicable Pricing Rules should be disabled.",
+"To set this Fiscal Year as Default, click on 'Set as Default'","Per establir aquest any fiscal predeterminat, feu clic a ""Estableix com a predeterminat"""
+To track any installation or commissioning related work after sales,To track any installation or commissioning related work after sales
+"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",
+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.,Per realitzar el seguiment de l'article en vendes i documents de compra en base als seus números de sèrie. Aquest és també pugui utilitzat per rastrejar informació sobre la garantia del producte.
+To track items in sales and purchase documents with batch nos<br><b>Preferred Industry: Chemicals etc</b>,To track items in sales and purchase documents with batch nos<br><b>Preferred Industry: Chemicals etc</b>
+To track items using barcode. You will be able to enter items in Delivery Note and Sales Invoice by scanning barcode of item.,
+Too many columns. Export the report and print it using a spreadsheet application.,Massa columnes. Exporta l'informe i utilitza una aplicació de full de càlcul.
+Tools,
+Total,
+Total ({0}),
+Total Absent,
+Total Achieved,Total Aconseguit
+Total Actual,Actual total
+Total Advance,Avanç total
+Total Amount,Quantitat total
+Total Amount To Pay,Import total a pagar
+Total Amount in Words,Suma total en Paraules
+Total Billing This Year: ,
+Total Characters,
+Total Claimed Amount,
+Total Commission,Total Comissió
+Total Cost,Cost total
+Total Credit,Crèdit Total
+Total Debit,Dèbit total
+Total Debit must be equal to Total Credit. The difference is {0},
+Total Deduction,Deducció total
+Total Earning,Benefici total
+Total Experience,
+Total Fixed Cost,Cost Total Fix
+Total Hours,Total d'hores
+Total Hours (Expected),Total d'hores (esperat)
+Total Invoiced Amount,Suma total facturada
+Total Leave Days,Dies totals d'absències
+Total Leaves Allocated,Absències totals assignades
+Total Message(s),Total Missatge(s)
+Total Operating Cost,Cost total de funcionament
+Total Order Considered,
+Total Order Value,Valor Total de la comanda
+Total Outgoing,Sortint total
+Total Payment Amount,Suma total de Pagament
+Total Points,Punts totals
+Total Present,
+Total Qty,Quantitat total
+Total Raw Material Cost,Cost Total de Matèries Primeres
+Total Revenue,Ingressos totals
+Total Sanctioned Amount,
+Total Score (Out of 5),Puntuació total (de 5)
+Total Target,
+Total Tax (Company Currency),
+Total Taxes and Charges,Total d'impostos i càrrecs
+Total Taxes and Charges (Company Currency),Total Impostos i càrrecs (En la moneda de la Companyia)
+Total Variable Cost,
+Total Variance,
+"Total advance ({0}) against Order {1} cannot be greater \
+				than the Grand Total ({2})",
+Total allocated percentage for sales team should be 100,El Percentatge del total assignat per a l'equip de vendes ha de ser de 100
+Total amount of invoices received from suppliers during the digest period,Import total de les factures rebudes dels proveïdors durant el període
+Total amount of invoices sent to the customer during the digest period,Import total de les factures enviades al client durant el període
+Total cannot be zero,El total no pot ser zero
+Total in words,Total en paraules
+Total points for all goals should be 100. It is {0},
+Total weightage assigned should be 100%. It is {0},El pes total assignat ha de ser 100%. És {0}
+Total(Amt),
+Total(Qty),
+Totals,
+Track Leads by Industry Type.,Seguiment dels clients potencials per tipus d'indústria.
+Track separate Income and Expense for product verticals or divisions.,Seguiment d'Ingressos i Despeses per separat per a les verticals de productes o divisions.
+Track this Delivery Note against any Project,
+Track this Sales Order against any Project,Seguir aquesta Ordre Vendes cap algun projecte
+Transaction,Transacció
+Transaction Date,Data de Transacció
+Transaction not allowed against stopped Production Order {0},No es permet la transacció cap a l'ordre de producció aturada {0}
+Transfer,Transferència
+Transfer Material,Transferir material
+Transfer Raw Materials,Transferència de Matèries Primeres
+Transferred Qty,Quantitat Transferida
+Transportation,Transports
+Transporter Info,Informació del transportista
+Transporter Name,Nom Transportista
+Transporter lorry number,Número de de camió del transportista
+Travel,Viatges
+Travel Expenses,
+Tree Type,
+Tree of Item Groups.,Arbre dels grups d'articles.
+Tree of finanial Cost Centers.,
+Tree of finanial accounts.,Arbre dels comptes financers
+Trial Balance,Balanç provisional
+Tuesday,Dimarts
+Type,Tipus
+Type of document to rename.,Tipus de document per canviar el nom.
+"Type of leaves like casual, sick etc.",
+Types of Expense Claim.,
+Types of activities for Time Sheets,Tipus d'activitats per a les fitxes de Temps
+"Types of employment (permanent, contract, intern etc.).",
+UOM Conversion Detail,
+UOM Conversion Details,
+UOM Conversion Factor,
+UOM Conversion factor is required in row {0},
+UOM Name,Nom UDM
+UOM coversion factor required for UOM: {0} in Item: {1},Es necessita un factor de coversió per la UDM: {0} per l'article: {1}
+Under AMC,Sota AMC
+Under Graduate,
+Under Warranty,Sota Garantia
+Unit,Unitat
+Unit of Measure,Unitat de mesura
+Unit of Measure {0} has been entered more than once in Conversion Factor Table,La unitat de mesura {0} s'ha introduït més d'una vegada a la taula de valors de conversió
+"Unit of measurement of this item (e.g. Kg, Unit, No, Pair).","Unitat de mesura d'aquest article (per exemple kg, unitat, parell)."
+Units/Hour,
+Units/Shifts,Units/Shifts
+Unpaid,No pagat
+Unreconciled Payment Details,Detalls de Pagaments Sense conciliar
+Unscheduled,
+Unsecured Loans,
+Unstop,Desencallar
+Unstop Material Request,Desbloqueja la sol·licitud material
+Unstop Purchase Order,
+Unsubscribed,
+Upcoming Calendar Events (max 10),
+Update,
+Update Clearance Date,
+Update Cost,Actualització de Costos
+Update Finished Goods,Actualitzar Productes Acabats
+Update Series,Actualitza Sèries
+Update Series Number,
+Update Stock,
+Update additional costs to calculate landed cost of items,
+Update bank payment dates with journals.,Actualització de les dates de pagament dels bancs amb les revistes.
+Update clearance date of Journal Entries marked as 'Bank Vouchers',Update clearance date of Journal Entries marked as 'Bank Vouchers'
+Updated,
+Updated Birthday Reminders,Actualitzat recordatoris d'aniversari
+Upload Attendance,Pujar Assistència
+Upload Backups to Dropbox,Upload Backups to Dropbox
+Upload Backups to Google Drive,Upload Backups to Google Drive
+Upload HTML,
+Upload a .csv file with two columns: the old name and the new name. Max 500 rows.,
+Upload attendance from a .csv file,
+Upload stock balance via csv.,
+Upload your letter head and logo - you can edit them later.,
+Upper Income,
+Urgent,Urgent
+Use Multi-Level BOM,
+Use SSL,Utilitza SSL
+Used for Production Plan,S'utilitza per al Pla de Producció
+User,
+User ID,ID d'usuari
+User ID not set for Employee {0},ID d'usuari no entrat per l'Empleat {0}
+User Name,
+User Name or Support Password missing. Please enter and try again.,Falta el Nom d'usuari o la contrasenya. Si us plau entra-ho i torna a intentar-ho.
+User Remark,
+User Remark will be added to Auto Remark,User Remark will be added to Auto Remark
+User Specific,Específiques d'usuari
+User must always select,
+User {0} is already assigned to Employee {1},L'usuari {0} ja està assignat a l'Empleat {1}
+User {0} is disabled,
+Username,Nom d'usuari
+Users who can approve a specific employee's leave applications,Els usuaris que poden aprovar les sol·licituds de llicència d'un empleat específic
+Users with this role are allowed to create / modify accounting entry before frozen date,Els usuaris amb aquest rol poden crear/modificar assentaments comptables abans de la data de bloqueig
+Users with this role are allowed to set frozen accounts and create / modify accounting entries against frozen accounts,Els usuaris amb aquest rol poden establir comptes bloquejats i crear/modificar els assentaments comptables contra els comptes bloquejats
+Utilities,Utilitats
+Utility Expenses,
+Valid For Territories,
+Valid From,Vàlid des
+Valid Upto,Vàlid Fins
+Valid for Territories,
+Validate,Validar
+Valuation,Valoració
+Valuation Method,Mètode de Valoració
+Valuation Rate,Tarifa de Valoració
+Valuation Rate required for Item {0},Es necessita tarifa de valoració per l'article {0}
+Valuation and Total,Valoració i total
+Value,Valor
+Value or Qty,Valor o Quantitat
+Variance,Desacord
+Vehicle Dispatch Date,Vehicle Dispatch Date
+Vehicle No,
+Venture Capital,
+Verified By,Verified Per
+View Details,
+View Ledger,
+View Now,
+Visit report for maintenance call.,
+Voucher #,Comprovant #
+Voucher Detail No,Número de detall del comprovant
+Voucher Detail Number,Voucher Detail Number
+Voucher ID,Val ID
+Voucher No,Número de comprovant
+Voucher Type,
+Voucher Type and Date,Tipus d'Vals i Data
+Walk In,
+Warehouse,Magatzem
+Warehouse Contact Info,Informació del contacte del magatzem
+Warehouse Detail,Detall Magatzem
+Warehouse Name,Nom Magatzem
+Warehouse and Reference,Magatzem i Referència
+Warehouse can not be deleted as stock ledger entry exists for this warehouse.,El Magatzem no es pot eliminar perquè hi ha entrades al llibre major d'existències d'aquest magatzem.
+Warehouse can only be changed via Stock Entry / Delivery Note / Purchase Receipt,Magatzem només es pot canviar a través d'entrada d'estoc / Nota de lliurament / recepció de compra
+Warehouse cannot be changed for Serial No.,
+Warehouse is mandatory for stock Item {0} in row {1},El magatzem és obligatòria per l'article d'estoc {0} a la fila {1}
+Warehouse not found in the system,Magatzem no trobat al sistema
+Warehouse required for stock Item {0},Magatzem necessari per a l'article d'estoc {0}
+Warehouse where you are maintaining stock of rejected items,Magatzem en què es desen les existències dels articles rebutjats
+Warehouse {0} can not be deleted as quantity exists for Item {1},
+Warehouse {0} does not belong to company {1},
+Warehouse {0} does not exist,El magatzem {0} no existeix
+Warehouse {0}: Company is mandatory,Magatzem {0}: Empresa és obligatori
+Warehouse {0}: Parent account {1} does not bolong to the company {2},
+Warehouse-wise Item Reorder,Warehouse-wise Item Reorder
+Warehouses,Magatzems
+Warehouses.,Magatzems.
+Warn,Advertir
+Warning: Leave application contains following block dates,
+Warning: Material Requested Qty is less than Minimum Order Qty,Advertència: La quantitat de Material sol·licitada és inferior a la Quantitat mínima
+Warning: Sales Order {0} already exists against same Purchase Order number,Advertència: La comanda de client {0} ja existeix de la mateixa Ordre de Compra
+Warning: System will not check overbilling since amount for Item {0} in {1} is zero,Advertència: El sistema no comprovarà sobrefacturació si la quantitat de l'article {0} a {1} és zero
+Warranty / AMC Details,Detalls de la Garantia/AMC
+Warranty / AMC Status,Garantia / Estat de l'AMC
+Warranty Expiry Date,Data final de garantia
+Warranty Period (Days),Període de garantia (Dies)
+Warranty Period (in days),Període de garantia (en dies)
+We buy this Item,Comprem aquest article
+We sell this Item,Venem aquest article
+Website,Lloc web
+Website Description,Descripció del lloc web
+Website Item Group,
+Website Item Groups,Grups d'article del Web
+Website Manager,Gestor de la Pàgina web
+Website Settings,Configuració del lloc web
+Website Warehouse,Lloc Web del magatzem
+Wednesday,
+Weekly,
+Weekly Off,
+Weight UOM,UDM del pes
+"Weight is mentioned,\nPlease mention ""Weight UOM"" too","S'esmenta Pes, \n Si us plau, indica també ""UDM del pes"""
+Weightage,
+Weightage (%),Ponderació (%)
+Welcome,Benvinguda
+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!,
+Welcome to ERPNext. Please select your language to begin the Setup Wizard.,
+What does it do?,
+"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.","Quan es ""Presenta"" alguna de les operacions marcades, s'obre automàticament un correu electrònic emergent per enviar un correu electrònic al ""Contacte"" associat a aquesta transacció, amb la transacció com un arxiu adjunt. L'usuari pot decidir enviar, o no, el correu electrònic."
+"When submitted, the system creates difference entries to set the given stock and valuation on this date.","Quan es presenta, el sistema crea entrades de diferència per ajustar l'estoc i la valoració en aquesta data."
+Where items are stored.,Lloc d'emmagatzematge dels articles.
+Where manufacturing operations are carried out.,On es duen a terme les operacions de fabricació.
+Widowed,
+Will be calculated automatically when you enter the details,Es calculen automàticament quan introdueix els detalls
+Will be updated after Sales Invoice is Submitted.,
+Will be updated when batched.,Will be updated when batched.
+Will be updated when billed.,S'actualitzarà quan es facturi.
+Wire Transfer,
+With Operations,Amb Operacions
+Work Details,Detalls de treball
+Work Done,
+Work In Progress,
+Work-in-Progress Warehouse,Magatzem de treballs en procés
+Work-in-Progress Warehouse is required before Submit,Es requereix Magatzem de treballs en procés abans de Presentar
+Working,Treballant
+Working Days,
+Workstation,Lloc de treball
+Workstation Name,Nom de l'Estació de treball
+Write Off Account,
+Write Off Amount,Anota la quantitat
+Write Off Amount <=,Anota la quantitat <=
+Write Off Based On,Anotació basada en
+Write Off Cost Center,
+Write Off Outstanding Amount,Write Off Outstanding Amount
+Write Off Voucher,Anotar el comprovant
+Wrong Template: Unable to find head row.,Plantilla incorrecte: No es pot trobar la capçalera de la fila.
+Year,Any
+Year Closed,Any Tancat
+Year End Date,
+Year Name,
+Year Start Date,Any Data d'Inici
+Year of Passing,Any de defunció
+Yearly,Anual
+Yes,Sí
+You are not authorized to add or update entries before {0},
+You are not authorized to set Frozen value,No estàs autoritzat per establir el valor bloquejat
+You are the Expense Approver for this record. Please Update the 'Status' and Save,"Ets l'aprovador de despeses per a aquest registre. Actualitza l '""Estat"" i Desa"
+You are the Leave Approver for this record. Please Update the 'Status' and Save,
+You can enter any date manually,
+You can enter the minimum quantity of this item to be ordered.,Podeu introduir la quantitat mínima d'aquest article al demanar-lo.
+You can not change rate if BOM mentioned agianst any item,No es pot canviar la tarifa si el BOM va cap a un article
+You can not enter both Delivery Note No and Sales Invoice No. Please enter any one.,"No es pot deixar d'indicar el Número de nota de Lliurament Nota i Número de Factura. Si us plau, indica algun dels dos."
+You can not enter current voucher in 'Against Journal Voucher' column,No pots entrar aquest assentament a la columna 'Contra assentament de Diari'
+You can set Default Bank Account in Company master,Podeu configurar el compte bancari predeterminat a la configuració d'Empresa
+You can start by selecting backup frequency and granting access for sync,Pots començar per seleccionar la freqüència de còpia de seguretat i la concessió d'accés per a la sincronització
+You can submit this Stock Reconciliation.,Podeu presentar aquesta Reconciliació d'estoc.
+You can update either Quantity or Valuation Rate or both.,Pot actualitzar Quantitat o Tipus de valoració o ambdós.
+You cannot credit and debit same account at the same time,No es pot configurar el mateix compte com crèdit i dèbit a la vegada
+You have entered duplicate items. Please rectify and try again.,"Has introduït articles duplicats. Si us plau, rectifica-ho i torna a intentar-ho."
+You may need to update: {0},
+You must Save the form before proceeding,Has de desar el formulari abans de continuar
+Your Customer's TAX registration numbers (if applicable) or any general information,
+Your Customers,Els teus Clients
+Your Login Id,ID d'usuari
+Your Products or Services,Els Productes o Serveis de la teva companyia
+Your Suppliers,Els seus Proveïdors
+Your email address,La seva adreça de correu electrònic
+Your financial year begins on,
+Your financial year ends on,El seu exercici acaba el
+Your sales person who will contact the customer in future,La seva persona de vendes que es comunicarà amb el client en el futur
+Your sales person will get a reminder on this date to contact the customer,
+Your setup is complete. Refreshing...,La seva configuració s'ha completat. Actualitzant ...
+Your support email id - must be a valid email - this is where your emails will come!,El teu correu electrònic d'identificació - ha de ser un correu electrònic vàlid - aquí és on arribaran els teus correus electrònics!
+[Error],[Error]
+[Select],[Select]
+`Freeze Stocks Older Than` should be smaller than %d days.,`Bloqueja els estocs més antics que' ha de ser menor de %d dies.
+and,i
+are not allowed.,no estan permesos.
+assigned by,
+cannot be greater than 100,
+disabled user,
+"e.g. ""Build tools for builders""","per exemple ""Construir eines per als constructors """
+"e.g. ""MC""","per exemple ""MC """
+"e.g. ""My Company LLC""",
+e.g. 5,per exemple 5
+"e.g. Bank, Cash, Credit Card","per exemple bancària, Efectiu, Targeta de crèdit"
+"e.g. Kg, Unit, Nos, m","per exemple kg, unitat, m"
+e.g. VAT,"per exemple, l'IVA"
+eg. Cheque Number,
+example: Next Day Shipping,exemple: Enviament Dia següent
+fold,fold
+hidden,ocult
+hours,hores
+lft,
+old_parent,old_parent
+rgt,
+to,a
+website page link,website page link
+{0} '{1}' not in Fiscal Year {2},
+{0} ({1}) must have role 'Expense Approver',{0} ({1}) ha de tenir rol 'aprovador de despeses'
+{0} ({1}) must have role 'Leave Approver',
+{0} Credit limit {1} crossed,
+{0} Recipients,{0} Destinataris
+{0} Serial Numbers required for Item {0}. Only {0} provided.,{0} Números de sèrie d'articles requerits per {0}. Només {0} prevista.
+{0} Tree,{0} Arbre
+{0} against Purchase Order {1},{0} contra l'Ordre de Compra {1}
+{0} against Sales Invoice {1},
+{0} against Sales Order {1},
+{0} budget for Account {1} against Cost Center {2} will exceed by {3},
+{0} can not be negative,{0} no pot ser negatiu
+{0} created,{0} creat
+{0} days from {1},{0} dies des de {1}
+{0} does not belong to Company {1},
+{0} entered twice in Item Tax,{0} entrat dues vegades en l'Impost d'article
+"{0} is an invalid email address in 'Notification \
+					Email Address'",
+{0} is mandatory,{0} és obligatori
+{0} is mandatory for Item {1},{0} és obligatori per l'article {1}
+{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2}.,{0} és obligatori. Potser el registre de canvi de divisa no es crea per {1} a {2}.
+{0} is not a stock Item,{0} no és un article d'estoc
+{0} is not a valid Batch Number for Item {1},
+{0} is not a valid Leave Approver. Removing row #{1}.,
+{0} is not a valid email id,{0} no és un correu electrònicvàlid
+{0} is now the default Fiscal Year. Please refresh your browser for the change to take effect.,"{0} és ara l'Any Fiscal.oer defecte Si us plau, actualitzi el seu navegador perquè el canvi tingui efecte."
+{0} is required,{0} és necessari
+{0} must be a Purchased or Sub-Contracted Item in row {1},{0} ha de ser un article de compra o de subcontractació a la fila {1}
+{0} must be reduced by {1} or you should increase overflow tolerance,{0} ha de ser reduït per {1} o s'ha d'augmentar la tolerància de desbordament
+{0} valid serial nos for Item {1},
+{0} {1} against Bill {2} dated {3},{0} {1} contra la factura {2} de data {3}
+{0} {1} has already been submitted,{0} {1} ja s'ha presentat
+{0} {1} has been modified. Please refresh.,"{0} {1} ha estat modificat. Si us plau, actualitzia"
+{0} {1} is fully billed,
+{0} {1} is not submitted,
+{0} {1} is stopped,{0} {1} està aturat
+{0} {1} must be submitted,{0} {1} s'ha de Presentar
+{0} {1} not in any Fiscal Year. For more details check {2}.,"{0} {1} sense any fiscal. Per a més detalls, consulta {2}."
+{0} {1} status is 'Stopped',"{0} {1} L'Estat és ""Aturat '"
+{0} {1} status is Stopped,{0} {1} Estat Aturat
+{0} {1} status is Unstopped,{0} {1} Estat és no aturat
+{0} {1}: Cost Center is mandatory for Item {2},{0} {1}: Centre de Cost és obligatori per l'article {2}
+{0}: {1} not found in Invoice Details table,
