"""Customer Provided Item"" cannot be Purchase Item also",&quot;Kupčev predmet&quot; također ne može biti predmet kupnje,
"""Customer Provided Item"" cannot have Valuation Rate",&quot;Stavka opskrbljena kupcem&quot; ne može imati stopu vrednovanja,
"""Is Fixed Asset"" cannot be unchecked, as Asset record exists against the item","""je nepokretna imovina"" se ne može odznačiti, jer postoji zapis o imovini nad navedenom stavkom",
'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 posljednje narudžbe' mora biti veći ili jednak nuli,
'Entries' cannot be empty,'Ulazi' ne može biti prazno,
'From Date' is required,'Od datuma' je potrebno,
'From Date' must be after 'To Date','Od datuma' mora biti poslije 'Do datuma',
'Has Serial No' can not be 'Yes' for non-stock item,'Ima serijski broj' ne može biti 'Da' za neskladišne proizvode,
'Opening',&quot;Otvaranje &#39;,
'To Case No.' cannot be less than 'From Case No.','Za Predmet br' ne može biti manje od 'Od Predmeta br',
'To Date' is required,'Do datuma ' je potrebno,
'Total','Ukupno',
'Update Stock' can not be checked because items are not delivered via {0},Opcija 'Ažuriraj zalihe' nije dostupna jer stavke nisu dostavljene putem {0},
'Update Stock' cannot be checked for fixed asset sale,'Ažuriraj zalihe' ne može se provesti na prodaju osnovnog sredstva,
1 exact match.,1 točno podudaranje.,
90-Above,Iznad 90,
A Customer Group exists with same name please change the Customer name or rename the Customer Group,Postoji grupa kupaca sa istim imenom. Promijenite naziv kupca ili naziv grupe kupaca.,
A Default Service Level Agreement already exists.,Ugovor o razini usluge već postoji.,
A Lead requires either a person's name or an organization's name,Voditelj zahtijeva ili ime osobe ili ime organizacije,
A customer with the same name already exists,Kupac s istim imenom već postoji,
A question must have more than one options,Pitanje mora imati više opcija,
A qustion must have at least one correct options,Q qurance mora imati barem jednu ispravnu mogućnost,
A4,A4,
API Endpoint,API krajnja točka,
API Key,API ključ,
Abbr can not be blank or space,Abbr ne može biti prazno ili razmak,
Abbreviation already used for another company,Naziv već koristi druga tvrtka,
Abbreviation cannot have more than 5 characters,Kratica ne može imati više od 5 znakova,
Abbreviation is mandatory,Naziv je obavezan,
About the Company,O tvrtki,
About your company,O vašoj tvrtki,
Above,Iznad,
Academic Term,Akademski pojam,
Academic Term: ,Akademski naziv:,
Academic Year,Akademska godina,
Academic Year: ,Akademska godina:,
Accepted + Rejected Qty must be equal to Received quantity for Item {0},Količina prihvaćeno + odbijeno mora biti jednaka zaprimljenoj količini proizvoda {0},
Access Token,Pristupni token,
Accessable Value,Pristupačna vrijednost,
Account,Račun,
Account Number,Broj računa,
Account Number {0} already used in account {1},Broj računa {0} već se koristi u računu {1},
Account Pay Only,Račun platiti samo,
Account Type,Vrsta računa,
Account Type for {0} must be {1},Vrsta računa za {0} mora biti {1},
"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 number for account {0} is not available.<br> Please setup your Chart of Accounts correctly.,Broj računa za račun {0} nije dostupan. <br> Pravilno postavite svoj računni prikaz.,
Account with child nodes cannot be converted to ledger,Račun sa podređenim čvorom ne može se pretvoriti u glavnu knjigu,
Account with child nodes cannot be set as ledger,Račun s djetetom čvorovi se ne može postaviti kao knjiga,
Account with existing transaction can not be converted to group.,Račun s postojećom transakcijom ne može se pretvoriti u grupu.,
Account with existing transaction can not be deleted,Račun s postojećom transakcijom ne može se izbrisati,
Account with existing transaction cannot be converted to ledger,Račun s postojećom transakcijom ne može se pretvoriti u glavnu knjigu,
Account {0} does not belong to company: {1},Račun {0} ne pripada tvrtki: {1},
Account {0} does not belongs to company {1},Račun {0} ne pripada društvu {1},
Account {0} does not exist,Račun {0} ne postoji,
Account {0} does not exists,Račun {0} ne postoji,
Account {0} does not match with Company {1} in Mode of Account: {2},Račun {0} ne odgovara tvrtki {1} u načinu računa: {2},
Account {0} has been entered multiple times,Račun {0} unesen više puta,
Account {0} is added in the child company {1},Račun {0} dodaje se u podružnici tvrtke {1},
Account {0} is frozen,Račun {0} je zamrznut,
Account {0} is invalid. Account Currency must be {1},Račun {0} je nevažeći. Valuta računa mora biti {1},
Account {0}: Parent account {1} can not be a ledger,Račun {0}: nadređeni račun {1} ne može biti glavna knjiga,
Account {0}: Parent account {1} does not belong to company: {2},Račun {0}: nadređeni račun {1} ne pripada tvrtki: {2},
Account {0}: Parent account {1} does not exist,Račun {0}: nadređeni račun {1} ne postoji,
Account {0}: You can not assign itself as parent account,Račun {0}: Ne možeš ga dodijeliti kao nadređeni račun,
Account: {0} can only be updated via Stock Transactions,Račun: {0} može se ažurirati samo preko Stock promet,
Account: {0} with currency: {1} can not be selected,Račun: {0} s valutom: {1} ne može se odabrati,
Accountant,Knjigovođa,
Accounting,Knjigovodstvo,
Accounting Entry for Asset,Računovodstveni unos za imovinu,
Accounting Entry for Stock,Knjiženje na skladištu,
Accounting Entry for {0}: {1} can only be made in currency: {2},Računovodstvo Ulaz za {0}: {1} može biti samo u valuti: {2},
Accounting Ledger,Računovodstvo knjiga,
Accounting journal entries.,Knjigovodstvene temeljnice,
Accounts,Računi,
Accounts Manager,Računi Manager,
Accounts Payable,Naplativi računi,
Accounts Payable Summary,Obveze Sažetak,
Accounts Receivable,Potraživanja,
Accounts Receivable Summary,Potraživanja Sažetak,
Accounts User,Računi korisnika,
Accounts table cannot be blank.,Računi stol ne može biti prazno.,
Accumulated Depreciation,Akumulirana amortizacija,
Accumulated Depreciation Amount,Akumulirana amortizacija iznos,
Accumulated Depreciation as on,Akumulirana amortizacija na,
Accumulated Monthly,ukupna mjesečna,
Accumulated Values,Akumulirani Vrijednosti,
Accumulated Values in Group Company,Akumulirane vrijednosti u grupi tvrtke,
Achieved ({}),Postignuto ({}),
Action,Akcija,
Action Initialised,Akcija je pokrenuta,
Actions,Akcije,
Active,Aktivan,
Activity Cost exists for Employee {0} against Activity Type - {1},Aktivnost Trošak postoji zaposlenom {0} protiv tip aktivnosti - {1},
Activity Cost per Employee,Aktivnost Cijena po zaposlenom,
Activity Type,Tip aktivnosti,
Actual Cost,Stvarna cijena,
Actual Delivery Date,Stvarni datum isporuke,
Actual Qty,Stvarna kol,
Actual Qty is mandatory,Stvarni Količina je obavezno,
Actual Qty {0} / Waiting Qty {1},Stvarna kol {0} / Na čekanju kol {1},
Actual Qty: Quantity available in the warehouse.,Stvarna kol: količina dostupna na skladištu.,
Actual qty in stock,Stvarni kvota na zalihi,
Actual type tax cannot be included in Item rate in row {0},Stvarni tipa porez ne može biti uključen u stopu stavka u nizu {0},
Add,Dodaj,
Add / Edit Prices,Dodaj / uredi cijene,
Add Comment,Dodaj komentar,
Add Customers,Dodaj korisnike,
Add Employees,Dodavanje zaposlenika,
Add Item,Dodaj stavku,
Add Items,Dodaj artikle,
Add Leads,Dodaj vodi,
Add Multiple Tasks,Dodaj više zadataka,
Add Sales Partners,Dodajte partnere za prodaju,
Add Serial No,Dodaj serijski broj,
Add Students,Dodaj studente,
Add Suppliers,Dodajte dobavljače,
Add Time Slots,Dodaj vrijeme,
Add Timesheets,Dodaj timesheets,
Add Timeslots,Dodaj vremenske brojeve,
Add Users to Marketplace,Dodajte korisnike na tržište,
Add a new address,Dodaj novu adresu,
Add cards or custom sections on homepage,Dodajte kartice ili prilagođene odjeljke na početnu stranicu,
Add more items or open full form,Dodaj još stavki ili otvoriti puni oblik,
Add notes,Dodajte bilješke,
Add the rest of your organization as your users. You can also add invite Customers to your portal by adding them from Contacts,Dodajte ostatak svoje organizacije kao svoje korisnike. Također možete dodati pozvati kupce da svoj portal dodajući ih iz Kontakata,
Add/Remove Recipients,Dodaj / ukloni primatelja,
Added,Dodano,
Added {0} users,Dodano je {0} korisnika,
Additional Salary Component Exists.,Postoje dodatne komponente plaće.,
Address,Adresa,
Address Line 2,Adresa - linija 2,
Address Name,adresa Ime,
Address Title,Naziv adrese,
Address Type,Tip adrese,
Administrative Expenses,Administrativni troškovi,
Administrative Officer,Administrativni službenik,
Administrator,Upravitelj,
Admission,ulaz,
Admission and Enrollment,Upis i upis,
Admissions for {0},Upisi za {0},
Admit,Priznati,
Admitted,priznao,
Advance Amount,Iznos predujma,
Advance Payments,Avansima,
Advance account currency should be same as company currency {0},Valuta unaprijed računa mora biti jednaka valuti tvrtke {0},
Advance amount cannot be greater than {0} {1},Advance iznos ne može biti veći od {0} {1},
Advertising,Oglašavanje,
Aerospace,zračno-kosmički prostor,
Against,Protiv,
Against Account,Protiv računa,
Against Journal Entry {0} does not have any unmatched {1} entry,Protiv Temeljnica {0} nema premca {1} unos,
Against Journal Entry {0} is already adjusted against some other voucher,Protiv Temeljnica {0} već usklađuje se neki drugi bon,
Against Supplier Invoice {0} dated {1},Protiv dobavljača Račun {0} datira {1},
Against Voucher,Protiv Voucheru,
Against Voucher Type,Protiv voucher vrsti,
Age,Doba,
Age (Days),Starost (dani),
Ageing Based On,Starenje temelju On,
Ageing Range 1,Starenje Raspon 1,
Ageing Range 2,Starenje Raspon 2,
Ageing Range 3,Starenje Raspon 3,
Agriculture,Poljoprivreda,
Agriculture (beta),Poljoprivreda (beta),
Airline,aviokompanija,
All Accounts,Svi računi,
All Addresses.,Sve adrese.,
All Assessment Groups,Sve grupe za procjenu,
All BOMs,Svi Sastavnice,
All Contacts.,Svi kontakti.,
All Customer Groups,Sve grupe kupaca,
All Day,Svaki dan,
All Departments,Svi odjeli,
All Healthcare Service Units,Sve zdravstvene usluge,
All Item Groups,Sve skupine proizvoda,
All Products,Svi proizvodi,
All Products or Services.,Svi proizvodi i usluge.,
All Student Admissions,Svi Studentski Upisi,
All Supplier Groups,Sve grupe dobavljača,
All Supplier scorecards.,Sve ocjene bodova dobavljača.,
All Territories,Sve teritorije,
All Warehouses,Svi skladišta,
All communications including and above this shall be moved into the new Issue,Sve komunikacije uključujući i iznad toga bit će premještene u novi Izdanje,
All items have already been transferred for this Work Order.,Sve su stavke već prenesene za ovu radnu narudžbu.,
All other ITC,Svi ostali ITC,
All the mandatory Task for employee creation hasn't been done yet.,Sve obvezne zadaće za stvaranje zaposlenika još nisu učinjene.,
Allocate Payment Amount,Dodjela iznos otplate,
Allocated Amount,Dodijeljeni iznos,
Allocating leaves...,Dodjeljivanje lišća ...,
Already record exists for the item {0},Već postoji zapis za stavku {0},
"Already set default in pos profile {0} for user {1}, kindly disabled default","Već ste postavili zadani položaj u poziciji {0} za korisnika {1}, zadovoljavajući zadane postavke",
Alternate Item,Alternativna stavka,
Alternative item must not be same as item code,Alternativna stavka ne smije biti jednaka kodu stavke,
Amended From,Izmijenjena Od,
Amount,Iznos,
Amount After Depreciation,Iznos nakon amortizacije,
Amount of Integrated Tax,Iznos integriranog poreza,
Amount of TDS Deducted,Iznos TDS Deducted,
Amount should not be less than zero.,Iznos ne smije biti manji od nule.,
Amount to Bill,Iznositi Billa,
Amount {0} {1} against {2} {3},Iznos {0} {1} od {2} {3},
Amount {0} {1} deducted against {2},Iznos {0} {1} oduzimaju od {2},
Amount {0} {1} transferred from {2} to {3},Iznos {0} {1} prenesen iz {2} u {3},
Amount {0} {1} {2} {3},Iznos {0} {1} {2} {3},
Amt,Amt,
"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 academic term with this 'Academic Year' {0} and 'Term Name' {1} already exists. Please modify these entries and try again.,Akademska termina s ovim &#39;akademske godine&#39; {0} i &quot;Pojam Ime &#39;{1} već postoji. Molimo izmijeniti ove stavke i pokušati ponovno.,
An error occurred during the update process,Došlo je do pogreške tijekom postupka ažuriranja,
"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 Billing: {0},Godišnji naplatu: {0},
Another Budget record '{0}' already exists against {1} '{2}' and account '{3}' for fiscal year {4},Još jedan proračunski zapis &#39;{0}&#39; već postoji za {1} &#39;{2}&#39; i račun &#39;{3}&#39; za fiskalnu godinu {4},
Another Period Closing Entry {0} has been made after {1},Drugi period Zatvaranje Stupanje {0} je postignut nakon {1},
Another Sales Person {0} exists with the same Employee id,Još jedna prodaja Osoba {0} postoji s istim ID zaposlenika,
Antibiotic,Antibiotik,
Apparel & Accessories,Odjeća i modni dodaci,
Applicable For,primjenjivo za,
"Applicable if the company is SpA, SApA or SRL","Primjenjivo ako je tvrtka SpA, SApA ili SRL",
Applicable if the company is a limited liability company,Primjenjivo ako je društvo s ograničenom odgovornošću,
Applicable if the company is an Individual or a Proprietorship,Primjenjivo ako je tvrtka fizička osoba ili vlasništvo,
Application of Funds (Assets),Primjena sredstava ( aktiva ),
Applied,primijenjen,
Appointment Confirmation,Potvrda imenovanja,
Appointment Duration (mins),Trajanje sastanka (min),
Appointment Type,Vrsta imenovanja,
Appointment {0} and Sales Invoice {1} cancelled,Imenovanje {0} i prodajna faktura {1} otkazani su,
Appointments and Encounters,Imenovanja i susreti,
Appointments and Patient Encounters,Imenovanja i susreta pacijenata,
Appraisal {0} created for Employee {1} in the given date range,Procjena {0} stvorena za zaposlenika {1} u određenom razdoblju,
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 cannot be same as user the rule is Applicable To,Odobravanje korisnik ne može biti isto kao korisnikapravilo odnosi se na,
"Apps using current key won't be able to access, are you sure?","Aplikacije pomoću trenutnog ključa neće moći pristupiti, jeste li sigurni?",
Are you sure you want to cancel this appointment?,Jeste li sigurni da želite otkazati ovaj termin?,
Arrear,Zaostatak,
As Examiner,Kao ispitivač,
As On Date,Kao i na datum,
As Supervisor,Kao supervizor,
As per rules 42 & 43 of CGST Rules,Prema pravilima 42 i 43 CGST pravila,
As per section 17(5),Prema odjeljku 17 (5),
Assessment,procjena,
Assessment Criteria,Kriteriji za ocjenjivanje,
Assessment Group,Grupa procjena,
Assessment Group: ,Grupa za procjenu:,
Assessment Plan,plan Procjena,
Assessment Plan Name,Naziv plana procjene,
Assessment Report,Izvješće o procjeni,
Assessment Reports,Izvješća o procjeni,
Assessment Result,Rezultat Procjena,
Assessment Result record {0} already exists.,Zapis ocjena rezultata {0} već postoji.,
Asset,Imovina (Aktiva),
Asset Category,Kategorija imovine,
Asset Category is mandatory for Fixed Asset item,Asset Kategorija je obvezna za nepokretnu stavke imovine,
Asset Maintenance,Održavanje imovine,
Asset Movement,imovina pokret,
Asset Movement record {0} created,Unos imovine Pokret {0} stvorio,
Asset Name,Naziv imovinom,
Asset Received But Not Billed,Imovina primljena ali nije naplaćena,
Asset Value Adjustment,Podešavanje vrijednosti imovine,
"Asset cannot be cancelled, as it is already {0}","Imovina se ne može otkazati, jer je već {0}",
Asset scrapped via Journal Entry {0},Imovine otpisan putem Temeljnica {0},
"Asset {0} cannot be scrapped, as it is already {1}","Imovina {0} ne može biti otpisan, kao što je već {1}",
Asset {0} does not belong to company {1},Imovina {0} ne pripada društvu {1},
Asset {0} must be submitted,Imovina {0} mora biti predana,
Assets,Imovina,
Assign To,Dodijeliti,
Associate,pomoćnik,
At least one mode of payment is required for POS invoice.,potreban je najmanje jedan način plaćanja za POS računa.,
Atleast one item should be entered with negative quantity in return document,Atleast jedan predmet treba upisati s negativnim količinama u povratnom dokumentu,
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 Logo,Pričvrstite Logo,
Attachment,Vezanost,
Attachments,Privitci,
Attendance can not be marked for future dates,Gledatelji ne može biti označena za budući datum,
Attendance date can not be less than employee's joining date,Datum Gledatelji ne može biti manja od ulaska datuma zaposlenika,
Attendance for employee {0} is already marked,Gledatelja za zaposlenika {0} već označen,
Attendance has been marked successfully.,Sudjelovanje je uspješno označen.,
Attendance not submitted for {0} as {1} on leave.,Sudjelovanje nije poslano za {0} kao {1} na dopustu.,
Attribute table is mandatory,Osobina stol je obavezno,
Attribute {0} selected multiple times in Attributes Table,Osobina {0} izabrani više puta u Svojstva tablice,
Authorized Signatory,Ovlašteni potpisnik,
Auto Material Requests Generated,Automatski zahtjev za materijalom odobren,
Auto Repeat,Automatsko ponavljanje,
Auto repeat document updated,Ažurira se automatski ponavljanje dokumenta,
Automotive,Automobilska industrija,
Available,Dostupno,
Available Leaves,Dostupni lišće,
Available Qty,Dostupno Količina,
Available Selling,Dostupna prodaja,
Available for use date is required,Dostupan je za datum upotrebe,
Available slots,Dostupni utori,
Available {0},Dostupno {0},
Available-for-use Date should be after purchase date,Datum dostupan za upotrebu trebao bi biti nakon datuma kupnje,
Average Age,Prosječna starost,
Average Rate,Prosječna stopa,
Avg Daily Outgoing,Prosječni dnevni izlaz,
Avg. Buying Price List Rate,Prosječni. Stopa popisa cjenika,
Avg. Selling Price List Rate,Prosječni. Prodajni cjenovni popisi,
Avg. Selling Rate,Prosječna prodajna cijena,
BOM,BOM,
BOM Browser,BOM preglednik,
BOM No,BOM br.,
BOM Rate,BOM stopa,
BOM Stock Report,BOM Stock Report,
BOM and Manufacturing Quantity are required,BOM i proizvodnja Količina potrebne su,
BOM does not contain any stock item,BOM ne sadrži bilo koji zaliha stavku,
BOM {0} does not belong to Item {1},BOM {0} ne pripada Točki {1},
BOM {0} must be active,BOM {0} mora biti aktivna,
BOM {0} must be submitted,BOM {0} mora biti podnesen,
Balance,ravnoteža,
Balance (Dr - Cr),Stanje (Dr - Cr),
Balance ({0}),Stanje ({0}),
Balance Qty,Bilanca kol,
Balance Sheet,Završni račun,
Balance Value,Vrijednost bilance,
Balance for Account {0} must always be {1},Bilanca računa {0} uvijek mora biti {1},
Bank,Banka,
Bank Account,Žiro račun,
Bank Accounts,Bankovni računi,
Bank Draft,Bank Nacrt,
Bank Name,Naziv banke,
Bank Overdraft Account,Bank Prekoračenje računa,
Bank Reconciliation,Banka pomirenje,
Bank Reconciliation Statement,Izjava banka pomirenja,
Bank Statement,Izjava banke,
Bank Statement Settings,Postavke bankovnog izvoda,
Bank Statement balance as per General Ledger,Banka Izjava stanje po glavnom knjigom,
Bank account cannot be named as {0},Bankovni račun ne može biti imenovan kao {0},
Bank/Cash transactions against party or for internal transfer,Banka / Novac transakcije protiv stranke ili za internog transfera,
Banking,Bankarstvo,
Banking and Payments,Bankarstvo i plaćanje,
Barcode {0} already used in Item {1},Barkod {0} se već koristi u proizvodu {1},
Barcode {0} is not a valid {1} code,Barcode {0} nije važeći kôd {1},
Base URL,Osnovni URL,
Based On,Na temelju,
Based On Payment Terms,Na temelju uvjeta plaćanja,
Batch,serija,
Batch Entries,Ulazne serije,
Batch ID is mandatory,ID serije obvezan je,
Batch Inventory,Hrpa Inventar,
Batch Name,Batch Name,
Batch No,Broj serije,
Batch number is mandatory for Item {0},Batch broj je obvezna za točku {0},
Batch {0} of Item {1} has expired.,Hrpa {0} od {1} Stavka je istekla.,
Batch {0} of Item {1} is disabled.,Šifra {0} stavke {1} onemogućena je.,
Batch: ,serija:,
Batches,serije,
Become a Seller,Postanite prodavač,
Bill,Račun,
Bill Date,Bill Datum,
Bill No,Bill Ne,
Bill of Materials,Bill of Materials,
Bill of Materials (BOM),Sastavnice (BOM),
Billable Hours,Sati naplate,
Billed,naplaćeno,
Billed Amount,Naplaćeni iznos,
Billing Address,Adresa za naplatu,
Billing Address is same as Shipping Address,Adresa za naplatu jednaka je adresi za dostavu,
Billing Amount,Naplata Iznos,
Billing Status,Status naplate,
Billing currency must be equal to either default company's currency or party account currency,Valuta naplate mora biti jednaka valutnoj valuti ili valuti stranke računa tvrtke,
Bills raised by Suppliers.,Mjenice podigao dobavljače.,
Bills raised to Customers.,Mjenice podignuta na kupce.,
Biotechnology,Biotehnologija,
Black,Crna,
Blanket Orders from Costumers.,Deke narudžbe kupaca.,
Block Invoice,Blokirajte fakturu,
Boms,sastavnice,
Both Trial Period Start Date and Trial Period End Date must be set,Moraju biti postavljeni datum početka datuma probnog razdoblja i datum završetka probnog razdoblja,
Both Warehouse must belong to same Company,Oba skladišta moraju pripadati istoj tvrtki,
Branch,grana,
Broadcasting,radiodifuzija,
Brokerage,posredništvo,
Browse BOM,Pretraživanje BOM,
Budget Against,Proračun protiv,
Budget List,Popis proračuna,
Budget Variance Report,Proračun varijance Prijavi,
Budget cannot be assigned against Group Account {0},Proračun se ne može dodijeliti protiv grupe nalog {0},
"Budget cannot be assigned against {0}, as it's not an Income or Expense account","Proračun se ne može dodijeliti protiv {0}, kao što je nije prihod ili rashod račun",
Buildings,Građevine,
Bundle items at time of sale.,Hrpa proizvoda u vrijeme prodaje.,
Business Development Manager,Voditelj razvoja poslovanja,
Buy,Kupiti,
Buying,Nabava,
Buying Amount,Iznos kupnje,
Buying Price List,Cjenik kupnje,
Buying Rate,Stopa kupnje,
"Buying must be checked, if Applicable For is selected as {0}","Nabava mora biti provjerena, ako je primjenjivo za odabrano kao {0}",
By {0},Do {0},
Bypass credit check at Sales Order ,Zaobilaženje kreditne provjere na prodajnom nalogu,
C-Form records,C-obrazac zapisi,
C-form is not applicable for Invoice: {0},C-oblika nije primjenjiv za fakture: {0},
CEO,CEO,
CESS Amount,Iznos CESS,
CGST Amount,Iznos CGST,
CRM,CRM,
CWIP Account,CWIP račun,
Calculated Bank Statement balance,Izračunato banka Izjava stanje,
Campaign,Kampanja,
Can be approved by {0},Može biti odobren od strane {0},
"Can not filter based on Account, if grouped by Account","Ne možete filtrirati na temelju računa, ako je grupirano 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 not mark Inpatient Record Discharged, there are Unbilled Invoices {0}","Ne mogu se označiti prazni bolesnički zapis, postoje neplaćene fakture {0}",
Can only make payment against unbilled {0},Može napraviti samo plaćanje protiv Nenaplaćena {0},
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 '",
"Can't change valuation method, as there are transactions against some items which does not have it's own valuation method",Nije moguće promijeniti način vrednovanja jer postoje transakcije protiv nekih stavki koje nemaju vlastitu metodu vrednovanja,
Can't create standard criteria. Please rename the criteria,Nije moguće stvoriti standardne kriterije. Preimenujte kriterije,
Cancel,Otkaži,
Cancel Material Visit {0} before cancelling this Warranty Claim,Odustani Materijal Posjetite {0} prije otkazivanja ovog jamstva se,
Cancel Material Visits {0} before cancelling this Maintenance Visit,Odustani Posjeta materijala {0} prije otkazivanja ovog održavanja pohod,
Cancel Subscription,Odustani od pretplate,
Cancel the journal entry {0} first,Najprije poništite unos dnevnika {0},
Canceled,otkazan,
"Cannot Submit, Employees left to mark attendance","Nije moguće poslati, zaposlenici ostaju označeni za pohađanje pohađanja",
Cannot be a fixed asset item as Stock Ledger is created.,Ne može biti fiksna stavka imovine jer je Lozinka stanja stvorena.,
Cannot cancel because submitted Stock Entry {0} exists,"Ne može se otkazati, jer skladišni ulaz {0} postoji",
Cannot cancel transaction for Completed Work Order.,Nije moguće otkazati transakciju za dovršenu radnu nalog.,
Cannot cancel {0} {1} because Serial No {2} does not belong to the warehouse {3},Ne mogu otkazati {0} {1} jer serijski broj {2} ne pripada skladištu {3},
Cannot change Attributes after stock transaction. Make a new Item and transfer stock to the new Item,Nije moguće promijeniti atribute nakon transakcije zaliha. Napravite novu stavku i prenesite dionicu novoj stavci,
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 Service Stop Date for item in row {0},Nije moguće promijeniti datum zaustavljanja usluge za stavku u retku {0},
Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,Nije moguće mijenjati svojstva varijanti nakon transakcije zaliha. Morat ćete napraviti novu stavku da to učinite.,
"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 change status as student {0} is linked with student application {1},Ne može se promijeniti status studenta {0} je povezan sa studentskom primjene {1},
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 Account Type is selected.,Ne može se tajno u grupu jer je izabrana vrsta računa.,
Cannot create Retention Bonus for left Employees,Ne može se stvoriti bonus zadržavanja za lijeve zaposlenike,
Cannot create a Delivery Trip from Draft documents.,Ne mogu stvoriti putovanje dostave iz nacrta dokumenata.,
Cannot deactivate or cancel BOM as it is linked with other BOMs,Ne može deaktivirati ili otkazati BOM kao što je povezano s drugim sastavnicama,
"Cannot declare as lost, because Quotation has been made.","Ne može se proglasiti izgubljenim, jer je ponuda napravljena.",
Cannot deduct when category is for 'Valuation' or 'Valuation and Total',"Ne mogu odbiti kada kategorija je "" vrednovanje "" ili "" Vrednovanje i Total '",
Cannot deduct when category is for 'Valuation' or 'Vaulation and Total',Ne mogu odbiti kada je kategorija za &quot;vrednovanje&quot; ili &quot;Vaulation i ukupni &#39;,
"Cannot delete Serial No {0}, as it is used in stock transactions","Ne možete izbrisati Serijski broj {0}, kao što se koristi na lageru transakcija",
Cannot enroll more than {0} students for this student group.,Ne može se prijaviti više od {0} studenata za ovaj grupe studenata.,
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 promote Employee with status Left,Ne mogu promovirati zaposlenika sa statusom lijevo,
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 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 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},
Cannot set multiple Item Defaults for a company.,Nije moguće postaviti više zadanih postavki za tvrtku.,
Cannot set quantity less than delivered quantity,Ne može se postaviti količina manja od isporučene količine,
Cannot set quantity less than received quantity,Ne može se postaviti količina manja od primljene količine,
Cannot set the field <b>{0}</b> for copying in variants,Ne može se postaviti polje <b>{0}</b> za kopiranje u inačicama,
Cannot transfer Employee with status Left,Ne mogu prenijeti zaposlenika s statusom lijevo,
Cannot {0} {1} {2} without any negative outstanding invoice,Ne mogu {0} {1} {2} bez ikakvih negativnih izvanredan fakture,
Capital Equipments,Kapitalni oprema,
Capital Stock,Kapital,
Capital Work in Progress,Kapitalni radovi u tijeku,
Cart,kolica,
Cart is Empty,Košarica je prazna,
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},
Cash,Gotovina,
Cash Flow Statement,Izvještaj o novčanom tijeku,
Cash Flow from Financing,Novčani tijek iz financijskih,
Cash Flow from Investing,Novčani tijek iz investicijskih,
Cash Flow from Operations,Novčani tijek iz redovnog poslovanja,
Cash In Hand,Novac u blagajni,
Cash or Bank Account is mandatory for making payment entry,Novac ili bankovni račun je obvezna za izradu ulazak plaćanje,
Cashier Closing,Zatvaranje blagajnika,
Category,Kategorija,
Category Name,Naziv kategorije,
Caution,Oprez,
Central Tax,Središnji porez,
Certification,potvrda,
Cess,Uspjeh,
Change Amount,Promjena Iznos,
Change Item Code,Promijeni šifru stavke,
Change Release Date,Promijenite datum objavljivanja,
Change Template Code,Promijeni kôd predloška,
Changing Customer Group for the selected Customer is not allowed.,Promjena grupe kupaca za odabranog kupca nije dopuštena.,
Chapter,Poglavlje,
Chapter information.,Podaci o poglavlju.,
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,
Chargeble,Chargeble,
Charges are updated in Purchase Receipt against each item,Optužbe su ažurirani u KUPNJE protiv svake stavke,
"Charges will be distributed proportionately based on item qty or amount, as per your selection","Troškovi će se distribuirati proporcionalno na temelju točke kom ili iznos, kao i po svom izboru",
Chart of Cost Centers,Grafikon troškovnih centara,
Check all,Provjeri sve,
Checkout,Provjeri,
Chemical,kemijski,
Cheque,Ček,
Cheque/Reference No,Ček / Referentni broj,
Cheques Required,Potrebna je provjera,
Cheques and Deposits incorrectly cleared,Čekovi i depozita pogrešno izbrisani,
Child Task exists for this Task. You can not delete this Task.,Dijete Zadatak postoji za ovu Zadatak. Ne možete izbrisati ovu Zadatak.,
Child nodes can be only created under 'Group' type nodes,Dijete čvorovi mogu biti samo stvorio pod tipa čvorišta &#39;Grupa&#39;,
Child warehouse exists for this warehouse. You can not delete this warehouse.,Dijete skladište postoji za ovaj skladište. Ne možete izbrisati ovaj skladište.,
Circular Reference Error,Kružni Referentna Greška,
City,Grad,
City/Town,Grad / Mjesto,
Clay,Glina,
Clear filters,Očistite filtre,
Clear values,Jasne vrijednosti,
Clearance Date,Razmak Datum,
Clearance Date not mentioned,Razmak Datum nije spomenuo,
Clearance Date updated,Razmak Datum ažurirana,
Client,Klijent,
Client ID,ID klijenta,
Client Secret,Klijentska tajna,
Clinical Procedure,Klinički postupak,
Clinical Procedure Template,Predložak kliničkog postupka,
Close Balance Sheet and book Profit or Loss.,Zatvori bilanca i knjiga dobit ili gubitak .,
Close Loan,Zatvori zajam,
Close the POS,Zatvorite POS,
Closed,Zatvoreno,
Closed order cannot be cancelled. Unclose to cancel.,Zatvorena redoslijed ne može se otkazati. Otvarati otkazati.,
Closing (Cr),Zatvaranje (Cr),
Closing (Dr),Zatvaranje (Dr),
Closing (Opening + Total),Zatvaranje (otvaranje + ukupno),
Closing Account {0} must be of type Liability / Equity,Zatvaranje računa {0} mora biti tipa odgovornosti / Equity,
Closing Balance,Završna ravnoteža,
Code,Šifra,
Collapse All,Suzi sve,
Color,Boja,
Colour,Boja,
Combined invoice portion must equal 100%,Udio kombiniranog računa mora biti jednak 100%,
Commercial,trgovački,
Commission,provizija,
Commission Rate %,Stopa komisije%,
Commission on Sales,Komisija za prodaju,
Commission rate cannot be greater than 100,Proviziju ne može biti veća od 100,
Community Forum,Forum,
Company (not Customer or Supplier) master.,Društvo ( ne kupaca i dobavljača ) majstor .,
Company Abbreviation,Kratica Društvo,
Company Abbreviation cannot have more than 5 characters,Kratica tvrtke ne može imati više od 5 znakova,
Company Name,Ime tvrtke,
Company Name cannot be Company,Ime tvrtke ne mogu biti poduzeća,
Company currencies of both the companies should match for Inter Company Transactions.,Valute trgovačkih društava obje tvrtke trebale bi se podudarati s transakcijama tvrtke Inter.,
Company is manadatory for company account,Tvrtka je racionalna za račun tvrtke,
Company name not same,Naziv tvrtke nije isti,
Company {0} does not exist,Tvrtka {0} ne postoji,
Compensatory leave request days not in valid holidays,Doplativi dopusti za dane naplate nisu u važećem odmoru,
Complaint,prigovor,
Completion Date,Završetak Datum,
Computer,Računalo,
Condition,Stanje,
Configure,Konfigurirati,
Configure {0},Konfigurirajte {0},
Confirmed orders from Customers.,Potvrđene narudžbe kupaca.,
Connect Amazon with ERPNext,Spojite Amazon s ERPNextom,
Connect Shopify with ERPNext,Spojite Shopify s ERPNextom,
Connect to Quickbooks,Povežite se s QuickBooksom,
Connected to QuickBooks,Povezano s QuickBooksom,
Connecting to QuickBooks,Povezivanje s QuickBooksom,
Consultation,Konzultacija,
Consultations,konzultacije,
Consulting,savjetodavni,
Consumable,potrošni,
Consumed,konzumira,
Consumed Amount,Konzumira Iznos,
Consumed Qty,Potrošeno Kol,
Consumer Products,Consumer Products,
Contact,Kontakt,
Contact Us,Kontaktirajte nas,
Content,Sadržaj,
Content Masters,Sadržaji,
Content Type,Vrsta sadržaja,
Continue Configuration,Nastavite s konfiguracijom,
Contract,Ugovor,
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 Amount,Doprinos iznos,
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 to Group,Pretvori u Grupi,
Convert to Non-Group,Pretvori u ne-Group,
Cosmetics,Kozmetika,
Cost Center,Troška,
Cost Center Number,Broj mjesta troška,
Cost Center and Budgeting,Troškovno središte i proračun,
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 Centers,Troška,
Cost Updated,Trošak Ažurirano,
Cost as on,Trošak kao i na,
Cost of Delivered Items,Troškovi isporučenih stavki,
Cost of Goods Sold,Troškovi prodane robe,
Cost of Issued Items,Trošak izdanih stavki,
Cost of New Purchase,Trošak kupnje novog,
Cost of Purchased Items,Troškovi kupljene predmete,
Cost of Scrapped Asset,Troškovi otpisan imovinom,
Cost of Sold Asset,Troškovi prodane imovinom,
Cost of various activities,Troškovi raznih aktivnosti,
"Could not create Credit Note automatically, please uncheck 'Issue Credit Note' and submit again","Automatski se ne može izraditi Credit Note, poništite potvrdni okvir &#39;Issue Credit Note&#39; i ponovno pošaljite",
Could not generate Secret,Nije uspjelo generirati tajnu,
Could not retrieve information for {0}.,Nije moguće dohvatiti podatke za {0}.,
Could not solve criteria score function for {0}. Make sure the formula is valid.,Nije moguće riješiti funkciju bodova kriterija za {0}. Provjerite je li formula valjana.,
Could not solve weighted score function. Make sure the formula is valid.,Nije moguće riješiti funkciju ponderirane ocjene. Provjerite je li formula valjana.,
Could not submit some Salary Slips,Nije bilo moguće poslati nagradu za plaće,
"Could not update stock, invoice contains drop shipping item.","Ne može se ažurirati zaliha, fakture sadrži drop shipping stavke.",
Country wise default Address Templates,Država mudar zadana adresa predlošci,
Course Code: ,Šifra predmeta:,
Course Enrollment {0} does not exists,Upis na tečaj {0} ne postoji,
Course Schedule,Raspored predmeta,
Course: ,Tečaj:,
Cr,Cr,
Create,Stvoriti,
Create BOM,Stvorite BOM,
Create Delivery Trip,Kreirajte putovanje isporukom,
Create Employee,Stvorite zaposlenika,
Create Employee Records,Stvaranje zaposlenika Records,
"Create Employee records to manage leaves, expense claims and payroll","Stvaranje zaposlenika evidencije za upravljanje lišće, trošak tvrdnje i obračun plaća",
Create Fee Schedule,Kreirajte raspored naknada,
Create Fees,Napravite naknade,
Create Inter Company Journal Entry,Napravite unos časopisa Inter Company,
Create Invoice,Stvorite fakturu,
Create Invoices,Stvorite fakture,
Create Job Card,Izradite Job Card,
Create Journal Entry,Stvorite unos u časopis,
Create Lead,Stvorite olovo,
Create Leads,Stvaranje vodi,
Create Maintenance Visit,Stvorite posjetu održavanju,
Create Material Request,Izradite materijalni zahtjev,
Create Multiple,Izradi više,
Create Opening Sales and Purchase Invoices,Izradite otvaranje računa za prodaju i kupnju,
Create Payment Entries,Stvorite uplate za plaćanje,
Create Payment Entry,Izradite unos plaćanja,
Create Print Format,Stvaranje format ispisa,
Create Purchase Order,Izradi narudžbenicu,
Create Purchase Orders,Izrada narudžbenice,
Create Quotation,Napravi ponudu,
Create Sales Invoice,Stvorite račun za prodaju,
Create Sales Order,Izradi prodajni nalog,
Create Sales Orders to help you plan your work and deliver on-time,Izradite prodajne naloge za lakše planiranje posla i isporuku na vrijeme,
Create Sample Retention Stock Entry,Napravite unos zaliha uzoraka,
Create Student,Stvorite Student,
Create Student Batch,Stvorite skupinu učenika,
Create Student Groups,Stvaranje grupe učenika,
Create Supplier Quotation,Izradite ponudu ponude,
Create Tax Template,Kreirajte predložak poreza,
Create Timesheet,Napravite časopis,
Create User,Izradi korisnika,
Create Users,Stvaranje korisnika,
Create Variant,Izradi inačicu,
Create Variants,Napravite varijante,
"Create and manage daily, weekly and monthly email digests.","Stvaranje i upravljanje automatskih mailova na dnevnoj, tjednoj i mjesečnoj bazi.",
Create customer quotes,Stvaranje kupaca citati,
Create rules to restrict transactions based on values.,Napravi pravila za ograničavanje prometa na temelju vrijednosti.,
Created {0} scorecards for {1} between: ,Izrađeno {0} bodovne kartice za {1} između:,
Creating Company and Importing Chart of Accounts,Stvaranje tvrtke i uvoz računa,
Creating Fees,Stvaranje naknada,
Creating student groups,Stvaranje studentskih skupina,
Creating {0} Invoice,Izrada fakture {0},
Credit,Kredit,
Credit ({0}),Kredit ({0}),
Credit Account,Kreditni račun,
Credit Balance,Kreditna bilanca,
Credit Card,Kreditna kartica,
Credit Days cannot be a negative number,Dani kredita ne može biti negativan broj,
Credit Limit,Kreditni limit,
Credit Note,Odobrenje kupcu,
Credit Note Amount,Iznos uplate kredita,
Credit Note Issued,Odobrenje kupcu izdano,
Credit Note {0} has been created automatically,Kreditna bilješka {0} izrađena je automatski,
Credit limit has been crossed for customer {0} ({1}/{2}),Kreditna je ograničenja prekinuta za kupca {0} ({1} / {2}),
Creditors,vjerovnici,
Criteria weights must add up to 100%,Ponderi kriterija moraju se dodati do 100%,
Crop Cycle,Ciklus usjeva,
Crops & Lands,Usjevi i zemljišta,
Currency Exchange must be applicable for Buying or for Selling.,Mjenjač mora biti primjenjiv za kupnju ili prodaju.,
Currency can not be changed after making entries using some other currency,Valuta se ne može mijenjati nakon što unose pomoću neke druge valute,
Currency exchange rate master.,Majstor valute .,
Currency for {0} must be {1},Valuta za {0} mora biti {1},
Currency is required for Price List {0},Valuta je potrebna za cjenik {0},
Currency of the Closing Account must be {0},Valuta zatvaranja računa mora biti {0},
Currency of the price list {0} must be {1} or {2},Valuta cjenika {0} mora biti {1} ili {2},
Currency should be same as Price List Currency: {0},Valuta bi trebala biti ista kao i Cjenik Valuta: {0},
Current Assets,Dugotrajna imovina,
Current BOM and New BOM can not be same,Trenutni troškovnik i novi troškovnik ne mogu biti isti,
Current Liabilities,Kratkoročne obveze,
Current Qty,Trenutno Kom,
Current invoice {0} is missing,Nedostaje trenutačna faktura {0},
Custom HTML,Prilagođeni HTML,
Custom?,Prilagođeno?,
Customer,kupac,
Customer Addresses And Contacts,Kupčeve adrese i kontakti,
Customer Contact,Kupac Kontakt,
Customer Database.,Baza kupaca.,
Customer Group,Grupa kupaca,
Customer LPO,Korisnički LPO,
Customer LPO No.,Kupac LPO br.,
Customer Name,Naziv klijenta,
Customer POS Id,ID klijenta POS,
Customer Service,Služba za korisnike,
Customer and Supplier,Kupaca i dobavljača,
Customer is required,Kupac je dužan,
Customer isn't enrolled in any Loyalty Program,Kupac nije upisan u bilo koji program lojalnosti,
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} is created.,Korisnik {0} je stvoren.,
Customers in Queue,Kupci u redu,
Customize Homepage Sections,Prilagodite odjeljke početne stranice,
Customizing Forms,Prilagodba Obrasci,
Daily Project Summary for {0},Dnevni sažetak projekta za {0},
Daily Reminders,Dnevne Podsjetnici,
Data Import and Export,Uvoz i izvoz podataka,
Data Import and Settings,Uvoz podataka i postavke,
Database of potential customers.,Baza potencijalnih kupaca.,
Date Format,Oblik datuma,
Date Of Retirement must be greater than Date of Joining,Datum umirovljenja mora biti veći od datuma pristupa,
Date of Birth,Datum rođenja,
Date of Birth cannot be greater than today.,Datum rođenja ne može biti veća nego danas.,
Date of Commencement should be greater than Date of Incorporation,Datum početka mora biti veći od datuma osnivanja,
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 of Transaction,Datum transakcije,
Day,Dan,
Debit,Zaduženje,
Debit ({0}),Debit ({0}),
Debit Account,Duguje račun,
Debit Note,Rashodi - napomena,
Debit Note Amount,Debitni iznos bilješke,
Debit Note Issued,Terećenju Izdano,
Debit To is required,Zaduženja je potrebno,
Debit and Credit not equal for {0} #{1}. Difference is {2}.,Debitne i kreditne nije jednaka za {0} # {1}. Razlika je {2}.,
Debtors,dužnici,
Debtors ({0}),Dužnici ({0}),
Declare Lost,Proglasite izgubljenim,
Default Activity Cost exists for Activity Type - {0},Zadana aktivnost Troškovi postoji Vrsta djelatnosti - {0},
Default BOM ({0}) must be active for this item or its template,Zadana BOM ({0}) mora biti aktivan za tu stavku ili njegov predložak,
Default BOM for {0} not found,Zadana BOM za {0} nije pronađena,
Default BOM not found for Item {0} and Project {1},Zadani BOM nije pronađen za stavku {0} i projekt {1},
Default Letter Head,Default Pismo Head,
Default Tax Template,Zadani predložak poreza,
Default Unit of Measure for Item {0} cannot be changed directly because you have already made some transaction(s) with another UOM. You will need to create a new Item to use a different Default UOM.,"Zadana mjerna jedinica za točke {0} se ne može mijenjati izravno, jer ste već napravili neke transakcije (e) s drugim UOM. Morat ćete stvoriti novu stavku za korištenje drugačiji Default UOM.",
Default Unit of Measure for Variant '{0}' must be same as in Template '{1}',Zadana mjerna jedinica za Variant &#39;{0}&#39; mora biti isti kao u predložak &#39;{1}&#39;,
Default settings for buying transactions.,Zadane postavke za transakciju kupnje.,
Default settings for selling transactions.,Zadane postavke za prodajne transakcije.,
Default tax templates for sales and purchase are created.,Osnovni su predlošci poreza za prodaju i kupnju.,
Defaults,Zadani,
Defense,Obrana,
Define Project type.,Definiraj vrstu projekta.,
Define budget for a financial year.,Odredite proračun za financijsku godinu.,
Define various loan types,Definirati različite vrste kredita,
Del,del,
Delay in payment (Days),Kašnjenje u plaćanju (dani),
Delete all the Transactions for this Company,Izbrišite sve transakcije za ovu Društvo,
Deletion is not permitted for country {0},Brisanje nije dopušteno za zemlju {0},
Delivered,Isporučeno,
Delivered Amount,Isporučeno Iznos,
Delivered Qty,Isporučena količina,
Delivered: {0},Isporučuje se: {0},
Delivery,Isporuka,
Delivery Date,Datum isporuke,
Delivery Note,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 Notes {0} updated,Bilješke o isporuci {0} ažurirane,
Delivery Status,Status isporuke,
Delivery Trip,Putovanje isporuke,
Delivery warehouse required for stock item {0},Isporuka skladište potrebno za dionicama stavku {0},
Department,Odjel,
Department Stores,Robne kuće,
Depreciation,Amortizacija,
Depreciation Amount,Amortizacija Iznos,
Depreciation Amount during the period,Amortizacija Iznos u razdoblju,
Depreciation Date,Amortizacija Datum,
Depreciation Eliminated due to disposal of assets,Amortizacija Ispadanje zbog prodaje imovine,
Depreciation Entry,Amortizacija Ulaz,
Depreciation Method,Metoda amortizacije,
Depreciation Row {0}: Depreciation Start Date is entered as past date,Row amortizacije {0}: Datum početka amortizacije unesen je kao protekli datum,
Depreciation Row {0}: Expected value after useful life must be greater than or equal to {1},Amortizacija reda {0}: očekivana vrijednost nakon korisnog vijeka trajanja mora biti veća ili jednaka {1},
Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,Row amortizacije {0}: Sljedeći datum amortizacije ne može biti prije datuma raspoloživog korištenja,
Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,Row amortizacije {0}: Sljedeći datum amortizacije ne može biti prije datuma kupnje,
Designer,Imenovatelj,
Detailed Reason,Detaljan razlog,
Details,Detalji,
Details of Outward Supplies and inward supplies liable to reverse charge,Pojedinosti o vanjskim potrepštinama i unutarnjim zalihama koje mogu podnijeti povratno punjenje,
Details of the operations carried out.,Pojedinosti o operacijama koje se provode.,
Diagnosis,Dijagnoza,
Did not find any item called {0},Niste pronašli bilo koju stavku pod nazivom {0},
Diff Qty,Diff Qty,
Difference Account,Račun razlike,
"Difference Account must be a Asset/Liability type account, since this Stock Reconciliation is an Opening Entry","Razlika računa mora biti tipa imovine / obveza račun, jer to kataloški Pomirenje je otvaranje Stupanje",
Difference Amount,Razlika Količina,
Difference Amount must be zero,Razlika Iznos mora biti jednak nuli,
Different UOM for items will lead to incorrect (Total) Net Weight value. Make sure that Net Weight of each item is in the same UOM.,Različite mjerne jedinice proizvoda će dovesti do ukupne pogrešne neto težine. Budite sigurni da je neto težina svakog proizvoda u istoj mjernoj jedinici.,
Direct Expenses,Izravni troškovi,
Direct Income,Izravni dohodak,
Disable,Ugasiti,
Disabled template must not be default template,Onemogućeno predložak ne smije biti zadani predložak,
Disburse Loan,Isplati zajam,
Disbursed,isplaćeni,
Disc,disk,
Discharge,Pražnjenje,
Discount,Popust,
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,
Diseases & Fertilizers,Bolesti i gnojiva,
Dispatch,Otpremanje,
Dispatch Notification,Obavijest o otpremi,
Dispatch State,Država slanja,
Distance,Udaljenost,
Distribution,Distribucija,
Distributor,Distributer,
Dividends Paid,Plaćeni Dividende,
Do you really want to restore this scrapped asset?,Da li stvarno želite vratiti ovaj otpisan imovine?,
Do you really want to scrap this asset?,Da li zaista želite odbaciti ovu imovinu?,
Do you want to notify all the customers by email?,Želite li obavijestiti sve korisnike putem e-pošte?,
Doc Date,Datum dokumenta,
Doc Name,Doc ime,
Doc Type,Doc tip,
Docs Search,Pretraživanje dokumenata,
Document Name,Dokument Naziv,
Document Type,Tip dokumenta,
Domain,Domena,
Domains,Domene,
Done,Pospremljen,
Donor,donator,
Donor Type information.,Informacije o donatoru.,
Donor information.,Informacije o donatorima.,
Download JSON,Preuzmite JSON,
Draft,Nacrt,
Drop Ship,Drop Ship,
Drug,Droga,
Due / Reference Date cannot be after {0},Zbog / Referentni datum ne može biti nakon {0},
Due Date cannot be before Posting / Supplier Invoice Date,Datum roka ne može biti prije datuma knjiženja / fakture dobavljača,
Due Date is mandatory,Datum dospijeća je obavezno,
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 proizvod {0},
Duplicate customer group found in the cutomer group table,Dvostruka grupa kupaca nalaze u tablici cutomer grupe,
Duplicate entry,Dupli unos,
Duplicate item group found in the item group table,Dvostruki stavke skupina nalaze se u tablici stavke grupe,
Duplicate roll number for student {0},Duplikat broja valjaka za učenika {0},
Duplicate row {0} with same {1},Dupli red {0} sa istim {1},
Duplicate {0} found in the table,Duplikat {0} pronađen u tablici,
Duration in Days,Trajanje u danima,
Duties and Taxes,Carine i porezi,
E-Invoicing Information Missing,Informacije o e-računima nedostaju,
ERPNext Demo,ERPNext Demo,
ERPNext Settings,Postavke ERPNext,
Earliest,Najstarije,
Earnest Money,kapara,
Edit,Uredi,
Edit Publishing Details,Uredite pojedinosti o objavljivanju,
"Edit in full page for more options like assets, serial nos, batches etc.","Uređivanje u cijeloj stranici za više opcija kao što su imovina, serijski brojevi, serije itd.",
Education,Obrazovanje,
Either location or employee must be required,Moraju se tražiti lokacija ili zaposlenik,
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,
Electronic Equipments,elektroničke opreme,
Electronics,Elektronika,
Eligible ITC,Ispunjava uvjete ITC,
Email Account,E-mail računa,
Email Address,Email adresa,
"Email Address must be unique, already exists for {0}","E-mail adresa mora biti jedinstvena, već postoji za {0}",
Email Digest: ,E-pošta:,
Email Reminders will be sent to all parties with email contacts,Podsjetnici e-pošte bit će poslani svim stranama s kontaktima e-pošte,
Email Sent,E-mail poslan,
Email Template,Predložak e-pošte,
Email not found in default contact,Email nije pronađen u zadanom kontaktu,
Email sent to {0},E-mail poslan na {0},
Employee,Zaposlenik,
Employee Advances,Predujmovi zaposlenika,
Employee ID,ID zaposlenika,
Employee Lifecycle,Životni ciklus zaposlenika,
Employee Name,ime zaposlenika,
Employee Promotion cannot be submitted before Promotion Date ,Promocija zaposlenika ne može se poslati prije datuma promocije,
Employee Transfer cannot be submitted before Transfer Date ,Prijenos zaposlenika ne može se poslati prije datuma prijenosa,
Employee cannot report to himself.,Zaposlenik se ne može prijaviti na sebe.,
Employee {0} has already applied for {1} between {2} and {3} : ,Zaposlenik {0} već je podnio zahtjev za {1} između {2} i {3}:,
Employee {0} of grade {1} have no default leave policy,Zaposlenik {0} razreda {1} nema zadanu politiku odlaska,
Enable / disable currencies.,Omogućiti / onemogućiti valute .,
Enabled,Omogućeno,
"Enabling 'Use for Shopping Cart', as Shopping Cart is enabled and there should be at least one Tax Rule for Shopping Cart","Omogućavanje &#39;Koristi za košaricu&#39;, kao što Košarica je omogućena i tamo bi trebao biti barem jedan Porezna pravila za Košarica",
End Date,Datum završetka,
End Date can not be less than Start Date,Datum završetka ne može biti manji od početnog datuma,
End Date cannot be before Start Date.,Datum završetka ne može biti prije datuma početka.,
End Year,Godina završetka,
End Year cannot be before Start Year,Godina završetka ne može biti prije Početak godine,
End on,Završi,
Ends On date cannot be before Next Contact Date.,Završava Datum ne može biti prije Sljedećeg datuma kontakta.,
Energy,energija,
Engineer,Inženjer,
Enough Parts to Build,Dosta Dijelovi za izgradnju,
Enroll,Upisati,
Enrolling student,upisa studenata,
Enrolling students,Upisuje studente,
Enter depreciation details,Unesite pojedinosti amortizacije,
Enter the Bank Guarantee Number before submittting.,Unesite broj bankarske garancije prije slanja.,
Enter the name of the Beneficiary before submittting.,Unesite ime Korisnika prije slanja.,
Enter the name of the bank or lending institution before submittting.,Unesite naziv banke ili institucije posudbe prije slanja.,
Enter value betweeen {0} and {1},Unesite vrijednost betweeen {0} i {1},
Entertainment & Leisure,Zabava i slobodno vrijeme,
Entertainment Expenses,Zabava Troškovi,
Equity,pravičnost,
Error Log,Greška Prijava,
Error evaluating the criteria formula,Pogreška u procjeni formule kriterija,
Error in formula or condition: {0},Greška u formuli ili stanja: {0},
Error: Not a valid id?,Pogreška: Nije valjana id?,
Estimated Cost,Procjena cijene,
"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:",
Exchange Gain/Loss,Razmjena dobit / gubitak,
Exchange Rate Revaluation master.,Master master revalorizacije tečaja,
Exchange Rate must be same as {0} {1} ({2}),Tečaj mora biti ista kao {0} {1} ({2}),
Excise Invoice,Trošarine Račun,
Execution,Izvršenje,
Executive Search,Executive Search,
Expand All,Proširi sve,
Expected Delivery Date,Očekivani rok isporuke,
Expected Delivery Date should be after Sales Order Date,Očekivani datum isporuke trebao bi biti nakon datuma prodaje,
Expected End Date,Očekivani datum završetka,
Expected Hrs,Očekivani sati,
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 Claim,Rashodi polaganja,
Expense Claims,Rashodi Potraživanja,
Expense account is mandatory for item {0},Rashodi račun je obvezna za predmet {0},
Expenses,Troškovi,
Expenses Included In Asset Valuation,Troškovi uključeni u procjenu vrijednosti imovine,
Expenses Included In Valuation,Troškovi uključeni u vrednovanje,
Expired Batches,Istekle serije,
Expires On,istječe,
Expiring On,Istječe,
Expiry (In Days),Rok (u danima),
Explore,Istražiti,
Export E-Invoices,Izvoz E-računa,
Extra Large,Extra large,
Extra Small,Dodatni Mali,
Fail,iznevjeriti,
Failed,Neuspješno,
Failed to create website,Izrada web mjesta nije uspjela,
Failed to install presets,Instalacija preseta nije uspjela,
Failed to login,Prijava nije uspjela,
Failed to setup company,Postavljanje tvrtke nije uspjelo,
Failed to setup defaults,Nije uspjelo postavljanje zadanih postavki,
Failed to setup post company fixtures,Postavljanje post-tvrtki nije uspjelo,
Fax,Fax,
Fee,Pristojba,
Fee Created,Kreirana naknada,
Fee Creation Failed,Izrada pristojbe nije uspjela,
Fee Creation Pending,Kreiranje pristojbe na čekanju,
Fee Records Created - {0},Naknada zapisa nastalih - {0},
Feedback,Povratna veza,
Fees,naknade,
Female,Ženski,
Fetch Data,Dohvatite podatke,
Fetch Subscription Updates,Dohvati ažuriranja pretplate,
Fetch exploded BOM (including sub-assemblies),Fetch eksplodirala BOM (uključujući i podsklopova ),
Fetching records......,Dohvaćanje zapisa ......,
Field Name,Naziv polja,
Fieldname,"Podataka, Naziv Polja",
Fields,Polja,
"Filter Fields Row #{0}: Fieldname <b>{1}</b> must be of type ""Link"" or ""Table MultiSelect""",Redak polja filtra # {0}: Naziv polja <b>{1}</b> mora biti tipa &quot;Link&quot; ili &quot;Table MultiSelect&quot;,
Filter Total Zero Qty,Filtar Ukupno Zero Količina,
Finance Book,Financijska knjiga,
Financial / accounting year.,Financijska / obračunska godina.,
Financial Services,Financijske usluge,
Financial Statements,Financijska izvješća,
Financial Year,Financijska godina,
Finish,Završi,
Finished Good,Izvrsno dobro,
Finished Good Item Code,Gotov kod dobra stavka,
Finished Goods,Gotovi proizvodi,
Finished Item {0} must be entered for Manufacture type entry,Gotovi Stavka {0} mora biti upisana za tip Proizvodnja upis,
Finished product quantity <b>{0}</b> and For Quantity <b>{1}</b> cannot be different,Količina gotovog proizvoda <b>{0}</b> i za količinu <b>{1}</b> ne može se razlikovati,
First Name,Ime,
"Fiscal Regime is mandatory, kindly set the fiscal regime in the company {0}","Fiskalni režim je obvezan, ljubazno postavite fiskalni režim u poduzeću {0}",
Fiscal Year,Fiskalna godina,
Fiscal Year End Date should be one year after Fiscal Year Start Date,Datum završetka fiskalne godine trebao bi biti godinu dana nakon datuma početka fiskalne godine,
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 should be one year earlier than Fiscal Year End Date,Datum početka fiskalne godine trebao bi biti godinu dana ranije od datuma završetka fiskalne godine,
Fiscal Year {0} does not exist,Fiskalna godina {0} ne postoji,
Fiscal Year {0} is required,Fiskalna godina {0} je potrebno,
Fixed Asset,Dugotrajna imovina,
Fixed Asset Item must be a non-stock item.,Fiksni Asset Stavka mora biti ne-stock točka a.,
Fixed Assets,Dugotrajne imovine,
Following Material Requests have been raised automatically based on Item's re-order level,Sljedeći materijal Zahtjevi su automatski podigli na temelju stavke razini ponovno narudžbi,
Following accounts might be selected in GST Settings:,Sljedeći računi mogu biti odabrani u GST postavkama:,
Following course schedules were created,Izrađeni su sljedeći raspored tečajeva,
Following item {0} is not marked as {1} item. You can enable them as {1} item from its Item master,Sljedeća stavka {0} nije označena kao {1} stavka. Možete ih omogućiti kao {1} stavku iz svog master stavke,
Following items {0} are not marked as {1} item. You can enable them as {1} item from its Item master,Sljedeće stavke {0} nisu označene kao {1} stavka. Možete ih omogućiti kao {1} stavku iz svog master stavke,
"Food, Beverage & Tobacco","Hrana , piće i duhan",
For,Za,
"For 'Product Bundle' items, Warehouse, Serial No and Batch No will be considered from the 'Packing List' table. If Warehouse and Batch No are same for all packing items for any 'Product Bundle' item, those values can be entered in the main Item table, values will be copied to 'Packing List' table.","Za &#39;proizvod Bundle&#39; predmeta, skladište, rednim i hrpa Ne smatrat će se iz &quot;Popis pakiranja &#39;stol. Ako Skladište i serije ne su isti za sve pakiranje predmeta za bilo &#39;proizvod Bundle&#39; točke, te vrijednosti može se unijeti u glavnoj točki stol, vrijednosti će se kopirati u &#39;pakiranje popis&#39; stol.",
For Quantity (Manufactured Qty) is mandatory,Za Količina (Proizvedeno Kol) je obavezno,
For Supplier,za Supplier,
For Warehouse,Za galeriju,
For Warehouse is required before Submit,Jer je potrebno Warehouse prije Podnijeti,
"For an item {0}, quantity must be negative number","Za stavku {0}, količina mora biti negativni broj",
"For an item {0}, quantity must be positive number","Za stavku {0}, količina mora biti pozitivan broj",
"For job card {0}, you can only make the 'Material Transfer for Manufacture' type stock entry",Za radnu karticu {0} možete izvršiti samo unos vrste zaliha &quot;Prijenos materijala za proizvodnju&quot;,
"For row {0} in {1}. To include {2} in Item rate, rows {3} must also be included","Za red {0} {1}. Da su {2} u stopu točke, redovi {3} također moraju biti uključeni",
For row {0}: Enter Planned Qty,Za redak {0}: unesite planirani iznos,
"For {0}, only credit accounts can be linked against another debit entry","Za {0}, samo kreditne računi se mogu povezati protiv drugog ulaska debitnom",
"For {0}, only debit accounts can be linked against another credit entry","Za {0}, samo debitne računi se mogu povezati protiv druge kreditne stupanja",
Forum Activity,Aktivnost na forumu,
Free item code is not selected,Besplatni kod predmeta nije odabran,
Freight and Forwarding Charges,Teretni i Forwarding Optužbe,
Frequency,Frekvencija,
Friday,Petak,
From,Od,
From Address 1,Od adrese 1,
From Address 2,Od adrese 2,
From Currency and To Currency cannot be same,Od valute i valuta ne mogu biti isti,
From Date and To Date lie in different Fiscal Year,Datum i datum leže u različitoj fiskalnoj godini,
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 Datetime,Od datetime,
From Delivery Note,Od otpremnici,
From Fiscal Year,Od fiskalne godine,
From GSTIN,Od GSTIN-a,
From Party Name,Od imena stranke,
From Pin Code,Iz PIN koda,
From Place,Od mjesta,
From Range has to be less than To Range,Od Raspon mora biti manji od u rasponu,
From State,Iz države,
From Time,S vremena,
From Time Should Be Less Than To Time,Iz vremena treba biti manje od vremena,
From Time cannot be greater than To Time.,S vremena ne može biti veća od na vrijeme.,
"From a supplier under composition scheme, Exempt and Nil rated","Od dobavljača prema shemi sastava, Oslobođeno i Nil",
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},
From {0} | {1} {2},Od {0} | {1} {2},
Fulfillment,Ispunjenje,
Full Name,Ime i prezime,
Fully Depreciated,potpuno amortizirana,
Furnitures and Fixtures,Namještaja i rasvjete,
"Further accounts can be made under Groups, but entries can be made against non-Groups","Daljnje računi mogu biti u skupinama, ali unose se može podnijeti protiv nesrpskog Groups",
Further cost centers can be made under Groups but entries can be made against non-Groups,"Daljnje troška mogu biti u skupinama, ali unose se može podnijeti protiv nesrpskog Groups",
Further nodes can be only created under 'Group' type nodes,"Daljnje čvorovi mogu se samo stvorio pod ""Grupa"" tipa čvorova",
GSTIN,GSTIN,
GSTR3B-Form,GSTR3B-Oblik,
Gain/Loss on Asset Disposal,Dobit / gubitak od imovine Odlaganje,
Gantt Chart,Gantogram,
Gantt chart of all tasks.,Gantogram svih zadataka.,
Gender,Rod,
General,Opći,
General Ledger,Glavna knjiga,
Generate Material Requests (MRP) and Work Orders.,Generirajte materijalne zahtjeve (MRP) i radne naloge.,
Generate Secret,Generirajte tajnu,
Get Invocies,Nabavite fakture,
Get Invoices,Nabavite fakture,
Get Invoices based on Filters,Nabavite fakture na temelju Filtri,
Get Items from BOM,Kreiraj proizvode od sastavnica (BOM),
Get Items from Healthcare Services,Preuzmite stavke iz zdravstvenih usluga,
Get Items from Prescriptions,Preuzmite stavke iz recepata,
Get Items from Product Bundle,Se predmeti s Bundle proizvoda,
Get Suppliers,Nabavite dobavljače,
Get Suppliers By,Nabavite dobavljače po,
Get Updates,Nabavite ažuriranja,
Get customers from,Kupujte korisnike,
Get from Patient Encounter,Dobiti od Patient Encounter,
Getting Started,Početak rada,
GitHub Sync ID,GitHub Sync ID,
Global settings for all manufacturing processes.,Globalne postavke za sve proizvodne procese.,
Go to the Desktop and start using ERPNext,Idi na radnu površinu i početi koristiti ERPNext,
GoCardless SEPA Mandate,GoCardless SEPA mandat,
GoCardless payment gateway settings,Postavke GoCardless gateway plaćanja,
Goal and Procedure,Cilj i postupak,
Goals cannot be empty,Ciljevi ne može biti prazan,
Goods In Transit,Roba u tranzitu,
Goods Transferred,Prenesena roba,
Goods and Services Tax (GST India),Porez na robu i usluge (GST India),
Goods are already received against the outward entry {0},Roba je već primljena prema vanjskom ulazu {0},
Government,Vlada,
Grand Total,Ukupno za platiti,
Grant,Grant,
Grant Application,Grant Application,
Grant Leaves,Odustani od ostavljanja,
Grant information.,Dati informacije.,
Grocery,Trgovina prehrambenom robom,
Gross Profit,Bruto dobit,
Gross Profit %,Bruto dobit%,
Gross Profit / Loss,Bruto dobit / gubitak,
Gross Purchase Amount,Bruto Iznos narudžbe,
Gross Purchase Amount is mandatory,Bruto Iznos narudžbe je obavezno,
Group by Account,Grupa po računu,
Group by Party,Grupirajte po stranci,
Group by Voucher,Grupa po jamcu,
Group by Voucher (Consolidated),Grupiranje po vaučerima (konsolidirani),
Group node warehouse is not allowed to select for transactions,Čvor Grupa skladište ne smije odabrati za transakcije,
Group to Non-Group,Grupa ne-Group,
Group your students in batches,Grupa vaši učenici u serijama,
Groups,grupe,
Guardian1 Email ID,Guardian1 ID e-pošte,
Guardian1 Mobile No,Guardian1 Mobile Ne,
Guardian1 Name,Ime Guardian1,
Guardian2 Email ID,ID e-pošte Guardian2,
Guardian2 Mobile No,Guardian2 Mobile Ne,
Guardian2 Name,Ime Guardian2,
HR Manager,HR menadžer,
HSN,HSN,
HSN/SAC,HSN / SAC,
Half Yearly,Pola godišnji,
Half-Yearly,Polugodišnje,
Hardware,Hardver,
Head of Marketing and Sales,Voditelj marketinga i prodaje,
Health Care,Health Care,
Healthcare,Zdravstvo,
Healthcare (beta),Zdravstvo (beta),
Healthcare Practitioner,Zdravstveni praktičar,
Healthcare Practitioner not available on {0},Zdravstvena praksa nije dostupna na {0},
Healthcare Practitioner {0} not available on {1},Zdravstveni praktičar {0} nije dostupan na {1},
Healthcare Service Unit,Jedinica za zdravstvenu zaštitu,
Healthcare Service Unit Tree,Tree zdravstvene usluge,
Healthcare Service Unit Type,Vrsta jedinice za pružanje zdravstvene zaštite,
Healthcare Services,Zdravstvene usluge,
Healthcare Settings,Postavke zdravstvene zaštite,
Help Results for,Pomoć za rezultate,
High,Visok,
High Sensitivity,Visoka osjetljivost,
Hold,Zadrži,
Hold Invoice,Držite fakturu,
Holiday,Odmor,
Holiday List,Popis praznika,
Hotel Rooms of type {0} are unavailable on {1},Hotel Sobe tipa {0} nisu dostupne na {1},
Hotels,Hoteli,
Hourly,na sat,
Hours,Sati,
How Pricing Rule is applied?,Kako se primjenjuje Pravilo cijena?,
Hub Category,Kategorija hubova,
Hub Sync ID,ID sinkronizacije huba,
Human Resource,Ljudski resursi,
Human Resources,Ljudski resursi,
IFSC Code,IFSC kod,
IGST Amount,Iznos IGST,
IP Address,IP adresa,
ITC Available (whether in full op part),Dostupan ITC (bilo u cijelom op. Dijelu),
ITC Reversed,ITC preokrenut,
Identifying Decision Makers,Identificiranje donositelja odluka,
"If Auto Opt In is checked, then the customers will be automatically linked with the concerned Loyalty Program (on save)","Ako je uključeno automatsko uključivanje, klijenti će se automatski povezati s predmetnim programom lojalnosti (u pripremi)",
"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 selected Pricing Rule is made for 'Rate', it will overwrite Price List. Pricing Rule rate is the final rate, so no further discount should be applied. Hence, in transactions like Sales Order, Purchase Order etc, it will be fetched in 'Rate' field, rather than 'Price List Rate' field.","Ako je odabrano Pravilo o cijenama za &quot;Razina&quot;, ona će prebrisati Cjenik. Cijena cijene je konačna stopa, tako da nema dodatnog popusta. Dakle, u transakcijama kao što su prodajni nalog, narudžbena narudžba i sl., To će biti dohvaćeno u polju &quot;Cijena&quot;, a ne polje &quot;Cjenovna lista&quot;.",
"If two or more Pricing Rules are found based on the above conditions, Priority is applied. Priority is a number between 0 to 20 while default value is zero (blank). Higher number means it will take precedence if there are multiple Pricing Rules with same conditions.","Ako dva ili više Cijene Pravila nalaze se na temelju gore navedenih uvjeta, Prioritet se primjenjuje. Prioritet je broj između 0 do 20, a zadana vrijednost je nula (prazno). Veći broj znači da će imati prednost ako ima više Cijene pravila s istim uvjetima.",
"If unlimited expiry for the Loyalty Points, keep the Expiry Duration empty or 0.","Ako je neograničeno isteklo za Points lojalnost, zadržite trajanje isteka prazno ili 0.",
"If you have any questions, please get back to us.","Ako imate bilo kakvih pitanja, molimo vratite se u nas.",
Ignore Existing Ordered Qty,Zanemari postojeće naručene količine,
Image,Slika,
Image View,Prikaz slike,
Import Data,Uvoz podataka,
Import Day Book Data,Uvezi podatke knjige dana,
Import Log,Uvoz Prijavite,
Import Master Data,Uvoz glavnih podataka,
Import in Bulk,Uvoz u rasutom stanju,
Import of goods,Uvoz robe,
Import of services,Uvoz usluga,
Importing Items and UOMs,Uvoz predmeta i UOM-ova,
Importing Parties and Addresses,Uvoz stranaka i adresa,
In Maintenance,U održavanju,
In Production,U proizvodnji,
In Qty,U Kol,
In Stock Qty,Na skladištu Kol,
In Stock: ,Na lageru:,
In Value,u vrijednost,
"In the case of multi-tier program, Customers will be auto assigned to the concerned tier as per their spent","U slučaju višerazinskog programa, Kupci će biti automatski dodijeljeni odgovarajućem stupcu po njihovu potrošenom",
Inactive,neaktivan,
Incentives,poticaji,
Include Default Book Entries,Uključite zadane unose u knjige,
Include Exploded Items,Uključi eksplodirane predmete,
Include POS Transactions,Uključi POS transakcije,
Include UOM,Uključi UOM,
Included in Gross Profit,Uključeno u bruto dobit,
Income,prihod,
Income Account,Račun prihoda,
Income Tax,Porez na dohodak,
Incoming,dolazni,
Incoming Rate,Dolazni Stopa,
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.,
Increment cannot be 0,Prirast ne može biti 0,
Increment for Attribute {0} cannot be 0,Pomak za Osobina {0} ne može biti 0,
Indirect Expenses,Neizravni troškovi,
Indirect Income,Neizravni dohodak,
Individual,Pojedinac,
Ineligible ITC,Neprihvatljiv ITC,
Initiated,pokrenut,
Inpatient Record,Popis bolesnika,
Installation Note,Napomena instalacije,
Installation Note {0} has already been submitted,Napomena instalacije {0} je već potvrđena,
Installation date cannot be before delivery date for Item {0},Datum Instalacija ne može biti prije datuma isporuke za točke {0},
Installing presets,Instaliranje unaprijed postavljenih postavki,
Institute Abbreviation,Institut naziv,
Institute Name,Naziv Institut,
Instructor,Instruktor,
Insufficient Stock,nedovoljna Stock,
Insurance Start date should be less than Insurance End date,Osiguranje Datum početka mora biti manja od osiguranja datum završetka,
Integrated Tax,Integrirani porez,
Inter-State Supplies,Međudržavne potrepštine,
Internet Publishing,Internet izdavaštvo,
Intra-State Supplies,Unutarnje države,
Introduction,Uvod,
Invalid Attribute,Pogrešna Osobina,
Invalid Blanket Order for the selected Customer and Item,Nevažeća narudžba pokrivača za odabrane kupce i stavku,
Invalid Company for Inter Company Transaction.,Nevažeća tvrtka za transakcije između kompanija.,
Invalid GSTIN! A GSTIN must have 15 characters.,Nevažeći GSTIN! GSTIN mora imati 15 znakova.,
Invalid GSTIN! First 2 digits of GSTIN should match with State number {0}.,Nevažeći GSTIN! Prve dvije znamenke GSTIN-a trebaju se podudarati s državnim brojem {0}.,
Invalid GSTIN! The input you've entered doesn't match the format of GSTIN.,Nevažeći GSTIN! Uneseni unos ne odgovara formatu GSTIN-a.,
Invalid Posting Time,Nevažeće vrijeme knjiženja,
Invalid attribute {0} {1},Neispravan atribut {0} {1},
Invalid quantity specified for item {0}. Quantity should be greater than 0.,Navedena je pogrešna količina za proizvod {0}. Količina treba biti veći od 0.,
Invalid reference {0} {1},Pogrešna referentni {0} {1},
Invalid {0},Pogrešna {0},
Invalid {0} for Inter Company Transaction.,Nevažeći {0} za transakciju unutar tvrtke.,
Invalid {0}: {1},Pogrešna {0}: {1},
Inventory,Inventar,
Investment Banking,Investicijsko bankarstvo,
Investments,Investicije,
Invoice,Faktura,
Invoice Created,Izračun je izrađen,
Invoice Discounting,Popust na fakturama,
Invoice Patient Registration,Registracija pacijenta računa,
Invoice Posting Date,Račun knjiženja Datum,
Invoice Type,Tip fakture,
Invoice already created for all billing hours,Račun je već izrađen za sva vremena naplate,
Invoice can't be made for zero billing hour,Račun se ne može izvršiti za nulti sat naplate,
Invoice {0} no longer exists,Račun {0} više ne postoji,
Invoiced,fakturirana,
Invoiced Amount,Dostavljeni iznos,
Invoices,računi,
Invoices for Costumers.,Računi za kupce.,
Inward supplies from ISD,Unutarnje zalihe od ISD-a,
Inward supplies liable to reverse charge (other than 1 & 2 above),Unutarnje zalihe podložne povratnom naboju (osim 1 i 2 gore),
Is Active,Je aktivan,
Is Default,Je zadani,
Is Existing Asset,Je Postojeći Imovina,
Is Frozen,Je Frozen,
Is Group,Je grupe,
Issue,Izazov,
Issue Material,Materijal Izazova,
Issued,Izdano,
Issues,pitanja,
It is needed to fetch Item Details.,To je potrebno kako bi dohvatili Stavka Pojedinosti.,
Item,Proizvod,
Item 1,Stavka 1,
Item 2,Stavka 2,
Item 3,Stavka 3,
Item 4,Stavka 4,
Item 5,Stavka 5,
Item Cart,Stavka Košarica,
Item Code,Šifra proizvoda,
Item Code cannot be changed for Serial No.,Kod proizvoda ne može se mijenjati za serijski broj.,
Item Code required at Row No {0},Kod proizvoda je potreban u redu broj {0},
Item Description,Opis proizvoda,
Item Group,Grupa proizvoda,
Item Group Tree,Raspodjela grupa proizvoda,
Item Group not mentioned in item master for item {0},Stavka proizvoda se ne spominje u master artiklu za artikal {0},
Item Name,Ime proizvoda,
Item Price added for {0} in Price List {1},Cijena dodana za {0} u cjeniku {1},
"Item Price appears multiple times based on Price List, Supplier/Customer, Currency, Item, UOM, Qty and Dates.","Stavka Cijena pojavljuje se više puta na temelju Cjenika, Dobavljača / Kupca, Valute, Stavke, UOM, Qta i datuma.",
Item Price updated for {0} in Price List {1},Artikl Cijena ažuriran za {0} u Cjeniku {1},
Item Row {0}: {1} {2} does not exist in above '{1}' table,Stavka retka {0}: {1} {2} ne postoji u gornjoj tablici &quot;{1}&quot;,
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 Template,Predložak stavke,
Item Variant Settings,Postavke varijacije stavke,
Item Variant {0} already exists with same attributes,Stavka Varijanta {0} već postoji s istim atributima,
Item Variants,Stavka Varijante,
Item Variants updated,Ažurirane su varijante predmeta,
Item has variants.,Stavka ima varijante.,
Item must be added using 'Get Items from Purchase Receipts' button,Stavka mora biti dodana pomoću 'se predmeti od kupnje primitaka' gumb,
Item valuation rate is recalculated considering landed cost voucher amount,Stopa predmeta vrednovanja preračunava obzirom sletio troškova iznos vaučera,
Item variant {0} exists with same attributes,Inačica Stavka {0} postoji s istim atributima,
Item {0} does not exist,Proizvod {0} ne postoji,
Item {0} does not exist in the system or has expired,Proizvod {0} ne postoji u sustavu ili je istekao,
Item {0} has already been returned,Proizvod {0} je već vraćen,
Item {0} has been disabled,Stavka {0} je onemogućen,
Item {0} has reached its end of life on {1},Proizvod {0} je dosegao svoj rok trajanja na {1},
Item {0} ignored since it is not a stock item,Proizvod {0} se ignorira budući da nije skladišni artikal,
"Item {0} is a template, please select one of its variants","Stavka {0} je predložak, odaberite jednu od njegovih varijanti",
Item {0} is cancelled,Proizvod {0} je otkazan,
Item {0} is disabled,Stavka {0} je onemogućen,
Item {0} is not a serialized Item,Proizvod {0} nije serijalizirani proizvod,
Item {0} is not a stock Item,Proizvod {0} nije skladišni proizvod,
Item {0} is not active or end of life has been reached,Proizvod {0} nije aktivan ili nije došao do kraja roka valjanosti,
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 a Fixed Asset Item,Stavka {0} mora biti Fixed Asset predmeta,
Item {0} must be a Sub-contracted Item,Stavka {0} mora bitisklopljen ugovor artikla,
Item {0} must be a non-stock item,Stavka {0} mora biti ne-stock točka a,
Item {0} must be a stock Item,Proizvod {0} mora biti skladišni,
Item {0} not found,Stavka {0} nije pronađena,
Item {0} not found in 'Raw Materials Supplied' table in Purchase Order {1},Stavka {0} nije pronađena u &quot;sirovina nabavlja se &#39;stol narudžbenice {1},
Item {0}: Ordered qty {1} cannot be less than minimum order qty {2} (defined in Item).,Stavka {0}: Ž Količina Jedinična {1} ne može biti manja od minimalne narudžbe kom {2} (definiranom u točki).,
Item: {0} does not exist in the system,Stavka: {0} ne postoji u sustavu,
Items,Proizvodi,
Items Filter,Filtri stavki,
Items and Pricing,Stavke i cijene,
Items for Raw Material Request,Predmeti za zahtjev za sirovinom,
Job Card,Radna mjesta za posao,
Job card {0} created,Izrađena je kartica za posao {0},
Join,Pridružiti,
Journal Entries {0} are un-linked,Dnevničkih zapisa {0} su UN-povezani,
Journal Entry,Temeljnica,
Journal Entry {0} does not have account {1} or already matched against other voucher,Temeljnica {0} nema račun {1} ili već usklađeni protiv drugog bona,
Kanban Board,Kanban zajednica,
Key Reports,Ključna izvješća,
LMS Activity,LMS aktivnost,
Lab Test,Lab test,
Lab Test Report,Izvješće testiranja laboratorija,
Lab Test Sample,Uzorak laboratorija,
Lab Test Template,Predložak testa laboratorija,
Lab Test UOM,Lab test UOM,
Lab Tests and Vital Signs,Lab testovi i vitalni znakovi,
Lab result datetime cannot be before testing datetime,Datetime rezultata laboratorija ne može biti prije testiranja datetime,
Lab testing datetime cannot be before collection datetime,Datetime testiranja laboratorija ne može biti prije datetime prikupljanja,
Label,Oznaka,
Laboratory,Laboratorija,
Large,veliki,
Last Communication,Posljednja komunikacija,
Last Communication Date,Posljednji datum komunikacije,
Last Name,Prezime,
Last Order Amount,Iznos zadnje narudžbe,
Last Order Date,Zadnje narudžbe Datum,
Last Purchase Price,Zadnja kupovna cijena,
Last Purchase Rate,Zadnja kupovna cijena,
Latest,Najnovije,
Latest price updated in all BOMs,Zadnja cijena ažurirana u svim BOM-ovima,
Lead,Potencijalni kupac,
Lead Count,Olovni broj,
Lead Owner,Vlasnik potencijalnog kupca,
Lead Owner cannot be same as the Lead,Olovo Vlasnik ne može biti ista kao i olova,
Lead Time Days,Potencijalni kupac - ukupno dana,
Lead to Quotation,Dovesti do kotaciju,
"Leads help you get business, add all your contacts and more as your leads","Potencijalni kupci će vam pomoći u posao, dodati sve svoje kontakte, a više kao svoje potencijalne klijente",
Learn,Naučiti,
Leave Management,Ostavite upravljanje,
Leave and Attendance,Ostavi i posjećenost,
Leave application {0} already exists against the student {1},Napusti program {0} već postoji protiv učenika {1},
Leaves has been granted sucessfully,Lišće je dobilo uspješno,
Leaves must be allocated in multiples of 0.5,"Odsustva moraju biti dodijeljena kao višekratnici od 0,5",
Ledger,glavna knjiga,
Legal,pravni,
Legal Expenses,Pravni troškovi,
Letter Head,Zaglavlje,
Letter Heads for print templates.,Zaglavlja za ispis predložaka.,
Level,Razina,
Liability,Odgovornost,
Limit Crossed,Ograničenje Crossed,
Link to Material Request,Veza na Zahtjev materijala,
List of all share transactions,Popis svih transakcija dionica,
List of available Shareholders with folio numbers,Popis dostupnih dioničara s folijskim brojevima,
Loading Payment System,Učitavanje sustava plaćanja,
Loan,Zajam,
Loan Start Date and Loan Period are mandatory to save the Invoice Discounting,Datum početka i razdoblje zajma obvezni su za spremanje popusta na fakture,
Loans (Liabilities),Zajmovi (pasiva),
Loans and Advances (Assets),Zajmovi i predujmovi (aktiva),
Local,Lokalno,
Logs for maintaining sms delivery status,Trupci za održavanje statusa isporuke sms,
Lost,izgubljen,
Lost Reasons,Izgubljeni razlozi,
Low,Nisko,
Low Sensitivity,Niska osjetljivost,
Lower Income,Niža primanja,
Loyalty Amount,Iznos odanosti,
Loyalty Point Entry,Ulaznica za lojalnost,
Loyalty Points,Bodovi lojalnosti,
"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.","Bodovne bodove izračunat će se iz potrošnje (putem Prodajnog računa), na temelju faktora prikupljanja.",
Loyalty Points: {0},Bodovi vjernosti: {0},
Loyalty Program,Program odanosti,
Main,Glavni,
Maintenance,Održavanje,
Maintenance Log,Zapisnik održavanja,
Maintenance Manager,Upravitelj održavanja,
Maintenance Schedule,Raspored održavanja,
Maintenance Schedule is not generated for all the items. Please click on 'Generate Schedule',Raspored održavanja nije generiran za sve proizvode. Molimo kliknite na 'Generiraj raspored',
Maintenance Schedule {0} exists against {1},Raspored održavanja {0} postoji protiv {1},
Maintenance Schedule {0} must be cancelled before cancelling this Sales Order,Stavka održavanja {0} mora biti otkazana prije poništenja ove narudžbe kupca,
Maintenance Status has to be Cancelled or Completed to Submit,Status održavanja mora biti poništen ili dovršen za slanje,
Maintenance User,Korisnik održavanja,
Maintenance Visit,Održavanje Posjetite,
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},Početni datum održavanja ne može biti stariji od datuma isporuke s rednim brojem {0},
Make,Napravi,
Make Payment,Izvršiti plaćanje,
Make project from a template.,Napravite projekt iz predloška.,
Making Stock Entries,Izrada Stock unose,
Male,Mužijak,
Manage Customer Group Tree.,Uredi hijerarhiju grupe kupaca.,
Manage Sales Partners.,Uredi prodajne partnere.,
Manage Sales Person Tree.,Uredi raspodjelu prodavača.,
Manage Territory Tree.,Uredi teritorijalnu raspodjelu.,
Manage your orders,Upravljanje narudžbe,
Management,Uprava,
Manager,Upravitelj,
Managing Projects,Upravljanje projektima,
Managing Subcontracting,Upravljanje podugovaranje,
Mandatory,Obavezno,
Mandatory field - Academic Year,Obavezno polje - akademska godina,
Mandatory field - Get Students From,Obavezno polje - Get Students From,
Mandatory field - Program,Obvezno polje - Program,
Manufacture,Proizvodnja,
Manufacturer,Proizvođač,
Manufacturer Part Number,Proizvođačev broj dijela,
Manufacturing,Proizvodnja,
Manufacturing Quantity is mandatory,Proizvedena količina je obvezna,
Mapping,Kartografija,
Mapping Type,Vrsta kartiranja,
Mark Absent,Mark Odsutni,
Mark Half Day,Mark Poludnevni,
Mark Present,Mark Sadašnje,
Marketing,Marketing,
Marketing Expenses,Troškovi marketinga,
Marketplace,tržište,
Marketplace Error,Pogreška na tržištu,
Masters,Masteri,
Match Payments with Invoices,Match Plaćanja s faktura,
Match non-linked Invoices and Payments.,Klađenje na ne-povezane faktura i plaćanja.,
Material,Materijal,
Material Consumption,Potrošnja materijala,
Material Consumption is not set in Manufacturing Settings.,Potrošnja materijala nije postavljena u Postavkama za proizvodnju.,
Material Receipt,Potvrda primitka robe,
Material Request,Zahtjev za robom,
Material Request Date,Materijal Zahtjev Datum,
Material Request No,Zahtjev za robom br.,
"Material Request not created, as quantity for Raw Materials already available.","Zahtjev za materijal nije kreiran, jer je količina za sirovine već dostupna.",
Material Request of maximum {0} can be made for Item {1} against Sales Order {2},Zahtjev za robom od maksimalnih {0} može biti napravljen za proizvod {1} od narudžbe kupca {2},
Material Request to Purchase Order,Materijal Zahtjev za Narudžbenica,
Material Request {0} is cancelled or stopped,Zahtjev za robom {0} je otkazan ili zaustavljen,
Material Request {0} submitted.,Poslan je materijalni zahtjev {0}.,
Material Transfer,Transfer robe,
Material Transferred,Prijenos materijala,
Material to Supplier,Materijal za dobavljača,
Max discount allowed for item: {0} is {1}%,Maksimalni dopušteni popust za proizvod: {0} je {1}%,
Max: {0},Maksimalno: {0},
Maximum Samples - {0} can be retained for Batch {1} and Item {2}.,Maksimalni uzorci - {0} mogu se zadržati za šaržu {1} i stavku {2}.,
Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,Maksimalni uzorci - {0} već su zadržani za šaržu {1} i stavku {2} u seriji {3}.,
Maximum discount for Item {0} is {1}%,Maksimalni popust za stavku {0} je {1}%,
Medical Code,Medicinski kodeks,
Medical Code Standard,Standard medicinskog koda,
Medical Department,Medicinski odjel,
Medical Record,Medicinski zapis,
Medium,Srednji,
Member Activity,Aktivnost članova,
Member ID,članska iskaznica,
Member Name,Ime člana,
Member information.,Informacije članova.,
Membership,Članstvo,
Membership Details,Pojedinosti o članstvu,
Membership ID,ID čl,
Membership Type,Vrsta članstva,
Memebership Details,Pojedinosti o članstvu,
Memebership Type Details,Pojedinosti o vrstama kontakata,
Merge,Sjediniti,
Merge Account,Spoji račun,
Merge with Existing Account,Spajanje s postojećim računom,
"Merging is only possible if following properties are same in both records. Is Group, Root Type, Company","Spajanje je moguće samo ako sljedeća svojstva su isti u obje evidencije. Je Grupa, korijen Vrsta, Društvo",
Message Examples,Primjeri poruka,
Message Sent,Poslana poruka,
Method,Metoda,
Middle Income,Srednji Prihodi,
Middle Name,Srednje ime,
Middle Name (Optional),Krsno ime (opcionalno),
Min Amt can not be greater than Max Amt,Min Amt ne može biti veći od Max Amt,
Min Qty can not be greater than Max Qty,Minimalna količina ne može biti veća od maksimalne količine,
Minimum Lead Age (Days),Minimalna dob (olovo),
Miscellaneous Expenses,Razni troškovi,
Missing Currency Exchange Rates for {0},Nedostaje Valuta za {0},
Missing email template for dispatch. Please set one in Delivery Settings.,Nedostaje predložak e-pošte za slanje. Postavite jedan u Postavke isporuke.,
"Missing value for Password, API Key or Shopify URL","Nedostaje vrijednost za zaporku, API ključ ili Shopify URL",
Mode of Payment,Nacin placanja,
Mode of Payments,Način plaćanja,
Mode of Transport,Način prijevoza,
Mode of Transportation,Način prijevoza,
Model,Model,
Moderate Sensitivity,Umjerena osjetljivost,
Monday,Ponedjeljak,
Monthly,Mjesečno,
Monthly Distribution,Mjesečna distribucija,
More,Više,
More Information,Više informacija,
More...,Više...,
Motion Picture & Video,Pokretna slika & video,
Move,Potez,
Move Item,Premještanje stavke,
Multi Currency,Više valuta,
Multiple Item prices.,Višestruke cijene proizvoda.,
Multiple Loyalty Program found for the Customer. Please select manually.,Korisnik je pronašao više programa lojalnosti. Odaberite ručno.,
"Multiple Price Rules exists with same criteria, please resolve conflict by assigning priority. Price Rules: {0}","Više Pravila Cijena postoji sa istim kriterijima, molimo rješavanje sukoba dodjeljivanjem prioriteta. Pravila Cijena: {0}",
Multiple Variants,Višestruke inačice,
Multiple fiscal years exist for the date {0}. Please set company in Fiscal Year,Više fiskalne godine postoji za sada {0}. Molimo postavite tvrtka u fiskalnoj godini,
Music,glazba,
Name error: {0},greška Ime: {0},
Name of new Account. Note: Please don't create accounts for Customers and Suppliers,Naziv novog računa. Napomena: Molimo vas da ne stvaraju račune za kupce i dobavljače,
Name or Email is mandatory,Ime ili e-mail je obavezno,
Nature Of Supplies,Priroda potrošnog materijala,
Navigating,Kretanje,
Needs Analysis,Analiza potreba,
Negative Quantity is not allowed,Negativna količina nije dopuštena,
Negative Valuation Rate is not allowed,Negativna stopa vrijednovanja nije dopuštena,
Negotiation/Review,Pregovaranje / pregled,
Net Asset value as on,Neto imovina kao i na,
Net Cash from Financing,Neto novčani tijek iz financijskih,
Net Cash from Investing,Neto novac od investicijskih,
Net Cash from Operations,Neto novčani tijek iz operacije,
Net Change in Accounts Payable,Neto promjena u obveze prema dobavljačima,
Net Change in Accounts Receivable,Neto promjena u potraživanja,
Net Change in Cash,Neto promjena u gotovini,
Net Change in Equity,Neto promjena u kapitalu,
Net Change in Fixed Asset,Neto promjena u dugotrajne imovine,
Net Change in Inventory,Neto promjena u inventar,
Net ITC Available(A) - (B),Neto dostupan ITC (A) - (B),
Net Profit,Neto dobit,
Net Total,Osnovica,
New Account Name,Naziv novog računa,
New Address,Nova adresa,
New BOM,Novi BOM,
New Batch ID (Optional),Novo ID serije (izborno),
New Batch Qty,Nova količina serije,
New Company,Nova tvrtka,
New Cost Center Name,Novi naziv troškovnog centra,
New Customer Revenue,Novi prihod kupca,
New Customers,Novi kupci,
New Department,Novi odjel,
New Employee,Novi zaposlenik,
New Location,Nova lokacija,
New Quality Procedure,Novi postupak kvalitete,
New Sales Invoice,Novi prodajni Račun,
New Sales Person Name,Novo ime prodajnog agenta,
New Serial No cannot have Warehouse. Warehouse must be set by Stock Entry or Purchase Receipt,Novi serijski broj ne može biti na skladištu. Skladište mora biti postavljen od strane međuskladišnice ili primke,
New Warehouse Name,Novo ime skladišta,
New credit limit is less than current outstanding amount for the customer. Credit limit has to be atleast {0},Novi kreditni limit je manja od trenutne preostali iznos za kupca. Kreditni limit mora biti atleast {0},
New task,Novi zadatak,
New {0} pricing rules are created,Stvorena su nova {0} pravila o cijenama,
Newspaper Publishers,Novinski izdavači,
Next,Sljedeći,
Next Contact By cannot be same as the Lead Email Address,Sljedeća Kontakt Po ne može biti ista kao što je vodeći e-mail adresa,
Next Contact Date cannot be in the past,Sljedeća Kontakt Datum ne može biti u prošlosti,
Next Steps,Sljedeći koraci,
No Action,Nema akcije,
No Customers yet!,Još nema kupaca!,
No Data,Nema podataka,
No Delivery Note selected for Customer {},Nijedna isporuka nije odabrana za kupca {},
No Item with Barcode {0},Nema proizvoda sa barkodom {0},
No Item with Serial No {0},Nema proizvoda sa serijskim brojem {0},
No Items available for transfer,Nema dostupnih stavki za prijenos,
No Items selected for transfer,Nema odabranih stavki za prijenos,
No Items to pack,Nema proizvoda za pakiranje,
No Items with Bill of Materials to Manufacture,Nema Stavke sa Bill materijala za proizvodnju,
No Items with Bill of Materials.,Nema predmeta s računom materijala.,
No Permission,Nemate dopuštenje,
No Remarks,Nema primjedbi,
No Result to submit,Nema rezultata za slanje,
No Student Groups created.,Nema studentskih grupa stvorena.,
No Students in,Nema studenata u Zagrebu,
No Tax Withholding data found for the current Fiscal Year.,Nema podataka o zadržavanju poreza za aktualnu fiskalnu godinu.,
No Work Orders created,Nema stvorenih radnih naloga,
No accounting entries for the following warehouses,Nema računovodstvenih unosa za ova skladišta,
No contacts with email IDs found.,Nije pronađen nijedan kontakt s ID-ovima e-pošte.,
No data for this period,Nema podataka za ovo razdoblje,
No description given,Nema opisa,
No employees for the mentioned criteria,Nema zaposlenika za navedene kriterije,
No gain or loss in the exchange rate,Nema dobitka ili gubitka tečaja,
No items listed,Nema navedenih stavki,
No items to be received are overdue,Nijedna stavka koju treba primiti nije kasna,
No material request created,Nije stvoren materijalni zahtjev,
No of Interactions,Broj interakcija,
No of Shares,Broj dionica,
No pending Material Requests found to link for the given items.,Nisu pronađeni materijalni zahtjevi na čekanju za povezivanje za određene stavke.,
No products found,Nije pronađen nijedan proizvod,
No products found.,Nisu pronađeni proizvodi.,
No record found,Nije pronađen zapis,
No records found in the Invoice table,Nisu pronađeni zapisi u tablici računa,
No records found in the Payment table,Nisu pronađeni zapisi u tablici plaćanja,
No tasks,Nema zadataka,
No time sheets,Nema vremenske tablice,
No values,Nema vrijednosti,
No {0} found for Inter Company Transactions.,Ne postoji {0} pronađen za transakcije tvrtke Inter.,
Non GST Inward Supplies,Non GST ulazne potrepštine,
Non Profit,Neprofitno,
Non Profit (beta),Neprofitna (beta),
Non-GST outward supplies,Vanjske zalihe bez GST-a,
Non-Group to Group,Non-skupine do skupine,
None,nijedan,
None of the items have any change in quantity or value.,Nitko od stavki ima bilo kakve promjene u količini ili vrijednosti.,
Nos,kom,
Not Available,Nije dostupno,
Not Marked,neobilježen,
Not Paid and Not Delivered,Ne plaća i ne Isporučeno,
Not Permitted,Nije dopuštena,
Not Started,Ne pokrenuto,
Not active,Nije aktivan,
Not allow to set alternative item for the item {0},Ne dopusti postavljanje alternativne stavke za stavku {0},
Not allowed to update stock transactions older than {0},Nije dopušteno ažuriranje skladišnih transakcija starijih od {0},
Not authorized to edit frozen Account {0},Niste ovlašteni za uređivanje zamrznutog računa {0},
Not authroized since {0} exceeds limits,Niste ovlašteni od {0} prijeđenog limita,
Not permitted for {0},Nije dopušteno {0},
"Not permitted, configure Lab Test Template as required","Nije dopušteno, konfigurirajte predložak laboratorija za testiranje prema potrebi",
Not permitted. Please disable the Service Unit Type,Nije dopušteno. Onemogućite vrstu usluge,
Note: Due / Reference Date exceeds allowed customer credit days by {0} day(s),Napomena: S obzirom / Referentni datum prelazi dopuštene kupca kreditne dana od {0} dana (s),
Note: Item {0} entered multiple times,Napomena : Proizvod {0} je upisan 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škovni centar je grupa. Nije moguće napraviti računovodstvene unose od grupe.,
Note: {0},Napomena: {0},
Notes,Zabilješke,
Nothing is included in gross,Ništa nije uključeno u bruto,
Nothing more to show.,Ništa više za pokazati.,
Notify Customers via Email,Obavijesti korisnike putem e-pošte,
Number,Broj,
Number of Depreciations Booked cannot be greater than Total Number of Depreciations,Broj deprecijaciju rezervirano ne može biti veća od Ukupan broj deprecijaciju,
Number of Interaction,Broj interakcija,
Number of Order,Broj narudžbe,
"Number of new Account, it will be included in the account name as a prefix","Broj novog računa, bit će uključen u naziv računa kao prefiks",
"Number of new Cost Center, it will be included in the cost center name as a prefix","Broj novog mjesta troška, bit će uključen u naziv mjesta troška kao prefiks",
Number of root accounts cannot be less than 4,Broj korijenskih računa ne može biti manji od 4,
Odometer,mjerač za pređeni put,
Office Equipments,Uredska oprema,
Office Maintenance Expenses,Troškovi održavanja ureda,
Office Rent,Najam ureda,
On Hold,Na čekanju,
On Net Total,VPC,
One customer can be part of only single Loyalty Program.,Jedan klijent može biti dio samo jednog programa lojalnosti.,
Online Auctions,Online aukcije,
"Only the Student Applicant with the status ""Approved"" will be selected in the table below.",U sljedećoj tablici odabrat će se samo kandidatkinja za studente s statusom &quot;Odobreno&quot;.,
Only users with {0} role can register on Marketplace,Samo korisnici s ulogom {0} mogu se registrirati na Marketplace,
Open BOM {0},Otvoreno BOM {0},
Open Item {0},Otvoreno Stavka {0},
Open Notifications,Otvoreno Obavijesti,
Open Orders,Otvori narudžbe,
Open a new ticket,Otvorite novu kartu,
Opening,Otvaranje,
Opening (Cr),Otvaranje ( Cr ),
Opening (Dr),Otvaranje (Dr),
Opening Accounting Balance,Otvori računovodstveno stanje,
Opening Accumulated Depreciation,Otvaranje Akumulirana amortizacija,
Opening Accumulated Depreciation must be less than equal to {0},Otvaranje za akumuliranu amortizaciju mora biti manja od jednaka {0},
Opening Balance,Početno stanje,
Opening Balance Equity,Početno stanje kapital,
Opening Date and Closing Date should be within same Fiscal Year,Otvaranje i zatvaranje Datum datum mora biti unutar iste fiskalne godine,
Opening Date should be before Closing Date,Otvaranje Datum bi trebao biti prije datuma zatvaranja,
Opening Entry Journal,Časopis za otvaranje,
Opening Invoice Creation Tool,Otvaranje alata za izradu računa,
Opening Invoice Item,Stavka fakture otvaranja fakture,
Opening Invoices,Otvori računa,
Opening Invoices Summary,Sažetak otvaranja faktura,
Opening Qty,Otvaranje Kol,
Opening Stock,Otvaranje Stock,
Opening Stock Balance,Otvaranje kataloški bilanca,
Opening Value,Otvaranje vrijednost,
Opening {0} Invoice created,Otvaranje {0} fakture je izrađeno,
Operation,Operacija,
Operation Time must be greater than 0 for Operation {0},Operacija vrijeme mora biti veći od 0 za rad {0},
"Operation {0} longer than any available working hours in workstation {1}, break down the operation into multiple operations","Operacija {0} više nego bilo raspoloživih radnih sati u radnom {1}, razbiti rad u više operacija",
Operations,operacije,
Operations cannot be left blank,Rad se ne može ostati prazno,
Opp Count,Count Count,
Opp/Lead %,Opp / Lead%,
Opportunities,Mogućnosti,
Opportunities by lead source,Mogućnosti izvora olova,
Opportunity,Prilika,
Opportunity Amount,Iznos prilika,
"Optional. Sets company's default currency, if not specified.","Izborni. Postavlja tvrtke zadanu valutu, ako nije navedeno.",
Optional. This setting will be used to filter in various transactions.,Izborni . Ova postavka će se koristiti za filtriranje u raznim transakcijama .,
Options,Opcije,
Order Count,Broj naloga,
Order Entry,Unos narudžbe,
Order Value,Vrijednost narudžbe,
Order rescheduled for sync,Redoslijed je preusmjeren za sinkronizaciju,
Order/Quot %,Redoslijed / kvota%,
Ordered,Naručeno,
Ordered Qty,Naručena kol,
"Ordered Qty: Quantity ordered for purchase, but not received.","Naručena količina: količina naručena za kupnju, ali nije došla .",
Orders,Narudžbe,
Orders released for production.,Narudžbe objavljen za proizvodnju.,
Organization,Organizacija,
Organization Name,Naziv organizacije,
Other,Drugi,
Other Reports,Ostala izvješća,
"Other outward supplies(Nil rated,Exempted)","Ostale vanjske zalihe (ocjenjivano bez vrijednosti, izuzeće)",
Others,Ostali,
Out Qty,Od kol,
Out Value,Iz vrijednost,
Out of Order,Izvanredno,
Outgoing,Odlazni,
Outstanding,izvanredan,
Outstanding Amount,Izvanredna Iznos,
Outstanding Amt,Izvanredna amt,
Outstanding Cheques and Deposits to clear,Izvanredna Čekovi i depoziti za brisanje,
Outstanding for {0} cannot be less than zero ({1}),Izvanredna za {0} ne može biti manji od nule ( {1} ),
Outward taxable supplies(zero rated),Porezni porezi (nulta ocjena),
Overdue,prezadužen,
Overlap in scoring between {0} and {1},Preklapanje u bodovanju između {0} i {1},
Overlapping conditions found between:,Preklapanje uvjeti nalaze između :,
Owner,vlasnik,
PAN,PAN,
POS,POS,
POS Profile,POS profil,
POS Profile is required to use Point-of-Sale,POS Profil je potreban za korištenje Point-of-Sale,
POS Profile required to make POS Entry,POS Profil potrebna da bi POS unos,
POS Settings,POS postavke,
Packed quantity must equal quantity for Item {0} in row {1},Pakirana količina mora biti jednaka količini za proizvod {0} u redku {1},
Packing Slip,Odreskom,
Packing Slip(s) cancelled,Pakiranje proklizavanja ( s) otkazan,
Paid,plaćen,
Paid Amount,Plaćeni iznos,
Paid Amount cannot be greater than total negative outstanding amount {0},Uplaćeni iznos ne može biti veći od ukupnog negativnog preostali iznos {0},
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,
Paid and Not Delivered,Plaćeni i nije isporučena,
Parameter,Parametar,
Parent Item {0} must not be a Stock Item,Roditelj Stavka {0} ne smije biti kataloški predmeta,
Parents Teacher Meeting Attendance,Sastanak sudionika učitelja roditelja,
Partially Depreciated,djelomično amortiziraju,
Partially Received,Djelomično primljeno,
Party,Stranka,
Party Name,Naziv stranke,
Party Type,Tip stranke,
Party Type and Party is mandatory for {0} account,Vrsta stranke i stranka obvezni su za {0} račun,
Party Type is mandatory,Tip stranka je obvezna,
Party is mandatory,Stranka je obvezna,
Past Due Date,Prošli rok dospijeća,
Patient,Pacijent,
Patient Appointment,Imenovanje pacijenata,
Patient Encounter,Pacijentni susret,
Patient not found,Pacijent nije pronađen,
Pay Remaining,Plaćanje preostalo,
Pay {0} {1},Plaćajte {0} {1},
Payable,plativ,
Payable Account,Obveze prema dobavljačima,
Payment,Uplata,
Payment Cancelled. Please check your GoCardless Account for more details,Plaćanje je otkazano. Više pojedinosti potražite u svojem računu za GoCardless,
Payment Confirmation,Potvrda uplate,
Payment Document,Dokument plaćanja,
Payment Due Date,Plaćanje Due Date,
Payment Entries {0} are un-linked,Prijave plaćanja {0} su UN-linked,
Payment Entry,Ulaz za plaćanje,
Payment Entry already exists,Ulaz za plaćanje već postoji,
Payment Entry has been modified after you pulled it. Please pull it again.,Ulazak Plaćanje je izmijenjen nakon što ga je izvukao. Ponovno izvucite ga.,
Payment Entry is already created,Ulazak Plaćanje je već stvorio,
Payment Failed. Please check your GoCardless Account for more details,Plaćanje neuspjelo. Više pojedinosti potražite u svojem računu za GoCardless,
Payment Gateway,Payment Gateway,
"Payment Gateway Account not created, please create one manually.","Payment Gateway računa nije stvorio, ručno stvoriti jedan.",
Payment Gateway Name,Ime platnog prolaza,
Payment Mode,Način plaćanja,
Payment Receipt Note,Plaćanje Potvrda Napomena,
Payment Request,Zahtjev za plaćanje,
Payment Request for {0},Zahtjev za plaćanje {0},
Payment Tems,Teme plaćanja,
Payment Term,Rok plaćanja,
Payment Terms,Uvjeti plaćanja,
Payment Terms Template,Predložak o plaćanju,
Payment Terms based on conditions,Uvjeti plaćanja na temelju uvjeta,
Payment Type,Vrsta plaćanja,
"Payment Type must be one of Receive, Pay and Internal Transfer","Vrsta plaćanja mora biti jedan od primati, platiti i unutarnje prijenos",
Payment against {0} {1} cannot be greater than Outstanding Amount {2},Plaćanje protiv {0} {1} ne može biti veća od preostali iznos {2},
Payment request {0} created,Izrađen je zahtjev za plaćanje {0},
Payments,Plaćanja,
Payroll Payable,Plaće Plaća,
Payslip,Payslip,
Pending Activities,Aktivnosti na čekanju,
Pending Amount,Iznos na čekanju,
Pending Leaves,Na čekanju ostavlja,
Pending Qty,U tijeku Kom,
Pending Quantity,Količina na čekanju,
Pending Review,U tijeku pregled,
Pending activities for today,Čekanju aktivnosti za danas,
Pension Funds,Mirovinski fondovi,
Percentage Allocation should be equal to 100%,Postotak izdvajanja mora biti 100 %,
Perception Analysis,Analiza percepcije,
Period,Razdoblje,
Period Closing Entry,Zatvaranje razdoblja Stupanje,
Period Closing Voucher,Razdoblje Zatvaranje bon,
Periodicity,Periodičnost,
Personal Details,Osobni podaci,
Pharmaceutical,Farmaceutski,
Pharmaceuticals,Farmaceutske,
Physician,Liječnik,
Place Of Supply (State/UT),Mjesto opskrbe (država / UT),
Place Order,Naručiti,
Plan Name,Naziv plana,
Plan for maintenance visits.,Plan održavanja posjeta.,
Planned Qty,Planirani Kol,
"Planned Qty: Quantity, for which, Work Order has been raised, but is pending to be manufactured.","Količina planiranih količina: Količina za koju je radni nalog podizan, ali čeka se izrada.",
Planning,Planiranje,
Plants and Machineries,Biljke i strojevi,
Please Set Supplier Group in Buying Settings.,Postavite grupu dobavljača u Postavke kupnje.,
Please add a Temporary Opening account in Chart of Accounts,Dodajte Privremeni račun otvaranja u računskom planu,
Please add the account to root level Company - ,Dodajte račun u korijensku razinu Tvrtka -,
Please check Multi Currency option to allow accounts with other currency,Molimo provjerite više valuta mogućnost dopustiti račune s druge valute,
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 purchase receipt or purchase invoice for the item {0},Izradite račun za kupnju ili fakturu za kupnju stavke {0},
Please define grade for Threshold 0%,Definirajte ocjenu za Prag 0%,
Please enable Applicable on Booking Actual Expenses,Omogući primjenjivo na aktualne troškove rezervacije,
Please enable Applicable on Purchase Order and Applicable on Booking Actual Expenses,Omogući primjenjivo na narudžbenicu i odnosi se na aktualne troškove rezervacije,
Please enable pop-ups,Molimo omogućite pop-up prozora,
Please enter 'Is Subcontracted' as Yes or No,Unesite ' Je podugovoren ' kao da ili ne,
Please enter API Consumer Key,Unesite API ključ korisnika,
Please enter API Consumer Secret,Unesite API Consumer Secret,
Please enter Account for Change Amount,Unesite račun za promjene visine,
Please enter Approving Role or Approving User,Unesite Odobravanje ulogu ili Odobravanje korisnike,
Please enter Cost Center,Unesite troška,
Please enter Delivery Date,Unesite datum isporuke,
Please enter Employee Id of this sales person,Unesite ID zaposlenika ove prodaje osobi,
Please enter Expense Account,Unesite trošak računa,
Please enter Item Code to get Batch Number,Unesite Šifra dobiti broj serije,
Please enter Item Code to get batch no,Unesite kod Predmeta da se hrpa nema,
Please enter Item first,Unesite predmeta prvi,
Please enter Maintaince Details first,Unesite prva Maintaince Detalji,
Please enter Planned Qty for Item {0} at row {1},Unesite Planirano Qty za točku {0} na redu {1},
Please enter Preferred Contact Email,Unesite igraca Kontakt email,
Please enter Production Item first,Unesite Proizvodnja predmeta prvi,
Please enter Purchase Receipt first,Unesite prvo primku,
Please enter Receipt Document,Unesite primitka dokumenta,
Please enter Reference date,Unesite referentni datum,
Please enter Reqd by Date,Unesite Reqd po datumu,
Please enter Woocommerce Server URL,Unesite Woocommerce URL poslužitelja,
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 currency in Company Master,Unesite zadanu valutu u tvrtki Master,
Please enter message before sending,Unesite poruku prije slanja,
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 valid Financial Year Start and End Dates,Unesite valjani financijske godine datum početka i kraja,
Please enter valid email address,Unesite valjanu e-adresu,
Please enter {0} first,Unesite {0} prvi,
Please fill in all the details to generate Assessment Result.,Molimo vas da popunite sve pojedinosti da biste stvorili rezultat procjene.,
Please identify/create Account (Group) for type - {0},Identificirajte / kreirajte račun (grupu) za vrstu - {0},
Please identify/create Account (Ledger) for type - {0},Identificirajte / kreirajte račun (knjigu) za vrstu - {0},
Please login as another user to register on Marketplace,Prijavite se kao drugi korisnik da biste se registrirali na tržištu,
Please make sure you really want to delete all the transactions for this company. Your master data will remain as it is. This action cannot be undone.,Molimo provjerite da li stvarno želite izbrisati sve transakcije za ovu tvrtku. Vaši matični podaci će ostati kao što je to. Ova radnja se ne može poništiti.,
Please mention Basic and HRA component in Company,Molimo navedite komponentu Basic i HRA u tvrtki,
Please mention Round Off Account in Company,Molimo spomenuti zaokružiti račun u Društvu,
Please mention Round Off Cost Center in Company,Molimo spomenuti zaokružiti troška u Društvu,
Please mention no of visits required,Molimo spomenuti nema posjeta potrebnih,
Please mention the Lead Name in Lead {0},Navedite Lead Name u Lead {0},
Please pull items from Delivery Note,Molimo povucite stavke iz Dostavnica,
Please register the SIREN number in the company information file,Molimo registrirajte SIREN broj u informativnu datoteku tvrtke,
Please remove this Invoice {0} from C-Form {1},Molimo uklonite ovu fakturu {0} od C-obrasca {1},
Please save the patient first,Prvo spasi pacijenta,
Please save the report again to rebuild or update,Spremite izvješće ponovo da biste ga ponovo izgradili ili ažurirali,
"Please select Allocated Amount, Invoice Type and Invoice Number in atleast one row","Odaberite Dodijeljeni iznos, Vrsta računa i broj računa u atleast jednom redu",
Please select Apply Discount On,Odaberite Primijeni popusta na,
Please select BOM against item {0},Odaberite BOM prema stavci {0},
Please select BOM for Item in Row {0},Odaberite BOM za točku u nizu {0},
Please select BOM in BOM field for Item {0},Odaberite BOM u BOM polje za točku {0},
Please select Category first,Molimo odaberite kategoriju prvi,
Please select Charge Type first,Odaberite Naknada za prvi,
Please select Company,Odaberite tvrtke,
Please select Company and Posting Date to getting entries,Odaberite unos za tvrtku i datum knjiženja,
Please select Company first,Odaberite tvrtka prvi,
Please select Completion Date for Completed Asset Maintenance Log,Molimo odaberite Datum završetka za Dovršeni dnevnik održavanja imovine,
Please select Completion Date for Completed Repair,Odaberite Datum dovršetka za dovršen popravak,
Please select Course,Odaberite Tečaj,
Please select Drug,Odaberite Lijek,
Please select Existing Company for creating Chart of Accounts,Odaberite postojeće tvrtke za izradu grafikona o računima,
Please select Healthcare Service,Odaberite Zdravstvenu službu,
"Please select Item where ""Is Stock Item"" is ""No"" and ""Is Sales Item"" is ""Yes"" and there is no other Product Bundle","Molimo odaberite stavku u kojoj &quot;Je kataloški Stavka&quot; je &quot;Ne&quot; i &quot;Je Prodaja Stavka&quot; &quot;Da&quot;, a ne postoji drugi bala proizvoda",
Please select Maintenance Status as Completed or remove Completion Date,Odaberite Status održavanja kao dovršen ili uklonite datum dovršetka,
Please select Party Type first,Odaberite Party Tip prvi,
Please select Patient,Odaberite Pacijent,
Please select Patient to get Lab Tests,Odaberite Pacijent da biste dobili laboratorijske testove,
Please select Posting Date before selecting Party,Odaberite datum knjiženja prije odabira stranku,
Please select Posting Date first,Molimo odaberite datum knjiženja prvo,
Please select Price List,Molim odaberite cjenik,
Please select Program,Odaberite Program,
Please select Qty against item {0},Odaberite Qty od stavke {0},
Please select Sample Retention Warehouse in Stock Settings first,Najprije odaberite Pohrana skladišta za uzorke u zalihama,
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 Student Admission which is mandatory for the paid student applicant,Molimo odaberite Studentski ulaz koji je obvezan za plaćenog studenta,
Please select a BOM,Odaberite BOM,
Please select a Batch for Item {0}. Unable to find a single batch that fulfills this requirement,Odaberite Batch for Item {0}. Nije moguće pronaći jednu seriju koja ispunjava taj uvjet,
Please select a Company,Odaberite tvrtku,
Please select a batch,Odaberite grupu,
Please select a field to edit from numpad,Odaberite polje za uređivanje iz numpad,
Please select a table,Odaberite tablicu,
Please select a valid Date,Odaberite valjani datum,
Please select a value for {0} quotation_to {1},Molimo odabir vrijednosti za {0} quotation_to {1},
Please select a warehouse,Odaberite skladište,
Please select at least one domain.,Odaberite barem jednu domenu.,
Please select correct account,Molimo odaberite ispravnu račun,
Please select date,Odaberite datum,
Please select item code,Odaberite Šifra,
Please select month and year,Molimo odaberite mjesec i godinu,
Please select the Company,Odaberite tvrtku,
Please select the Multiple Tier Program type for more than one collection rules.,Odaberite višestruki tip programa za više pravila za naplatu.,
Please select the assessment group other than 'All Assessment Groups',Odaberite grupu za procjenu osim &quot;Sve grupe za procjenu&quot;,
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 set 'Apply Additional Discount On',Molimo postavite &quot;Primijeni dodatni popust na &#39;,
Please set 'Asset Depreciation Cost Center' in Company {0},Molimo postavite &quot;imovinom Centar Amortizacija troškova &#39;u Društvu {0},
Please set 'Gain/Loss Account on Asset Disposal' in Company {0},Molimo postavite &quot;dobici / gubici računa na sredstva Odlaganje &#39;u Društvu {0},
Please set Account in Warehouse {0} or Default Inventory Account in Company {1},Postavite račun u skladištu {0} ili zadani račun oglasnog prostora u tvrtki {1},
Please set B2C Limit in GST Settings.,Postavite ograničenje B2C u GST postavkama.,
Please set Company,Postavite tvrtku,
Please set Company filter blank if Group By is 'Company',Postavite prazan filtar Tvrtke ako je Skupna pošta &quot;Tvrtka&quot;,
Please set Default Payroll Payable Account in Company {0},Molimo postavite zadanog Platne naplativo račun u Društvu {0},
Please set Depreciation related Accounts in Asset Category {0} or Company {1},Molimo postavite Amortizacija se odnose računi u imovini Kategorija {0} ili Društvo {1},
Please set GST Accounts in GST Settings,Postavite GST račune u GST postavkama,
Please set Hotel Room Rate on {},Molimo postavite Hotel Room Rate na {},
Please set Number of Depreciations Booked,Molimo postavite Broj deprecijaciju Rezervirano,
Please set Unrealized Exchange Gain/Loss Account in Company {0},Unesite neispunjeni račun dobiti i gubitka u tvrtki {0},
Please set User ID field in an Employee record to set Employee Role,Molimo postavite korisnički ID polje u zapisu zaposlenika za postavljanje uloga zaposlenika,
Please set a default Holiday List for Employee {0} or Company {1},Postavite zadani popis za odmor za zaposlenika {0} ili poduzeću {1},
Please set account in Warehouse {0},Postavite račun u skladištu {0},
Please set an active menu for Restaurant {0},Postavite aktivni izbornik za restoran {0},
Please set associated account in Tax Withholding Category {0} against Company {1},Postavite pridruženi račun u kategoriju zadržavanja poreza {0} tvrtke {1},
Please set at least one row in the Taxes and Charges Table,Molimo postavite najmanje jedan redak u tablici poreza i nameta,
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 account in Salary Component {0},Molimo postavite zadani račun plaće komponente {0},
Please set default customer in Restaurant Settings,Postavite zadani klijent u Postavkama restorana,
Please set default {0} in Company {1},Molimo postavite zadani {0} u Društvu {1},
Please set filter based on Item or Warehouse,Molimo postavite filter na temelju stavka ili skladište,
Please set leave policy for employee {0} in Employee / Grade record,Postavite pravila o dopustu za zaposlenika {0} u zapisniku zaposlenika / razreda,
Please set recurring after saving,Molimo postavite ponavljajući nakon spremanja,
Please set the Customer Address,Molimo postavite korisničku adresu,
Please set the Default Cost Center in {0} company.,Postavite Zadani centar troškova u tvrtki {0}.,
Please set the Email ID for the Student to send the Payment Request,Postavite ID e-pošte za učenika da pošalje zahtjev za plaćanjem,
Please set the Item Code first,Najprije postavite šifru stavke,
Please set the Payment Schedule,Molimo postavite Raspored plaćanja,
Please set {0} for address {1},Postavite {0} za adresu {1},
Please setup Students under Student Groups,Postavite učenike u studentske grupe,
Please specify Company,Navedite tvrtke,
Please specify Company to proceed,Navedite Tvrtka postupiti,
Please specify a valid 'From Case No.',Navedite važeću &#39;iz Predmet br&#39;,
Please specify a valid Row ID for row {0} in table {1},Navedite valjanu Row ID za redom {0} u tablici {1},
Please specify at least one attribute in the Attributes table,Navedite barem jedan atribut u tablici Svojstva,
Please specify currency in Company,Navedite valutu u Društvu,
Please specify either Quantity or Valuation Rate or both,Navedite ili količini ili vrednovanja Ocijenite ili oboje,
Please specify from/to range,Navedite od / do rasponu,
Please supply the specified items at the best possible rates,Molimo dostaviti navedene stavke po najboljim mogućim cijenama,
Please wait 3 days before resending the reminder.,Pričekajte 3 dana prije ponovnog slanja podsjetnika.,
Point of Sale,Point of Sale,
Point-of-Sale,Prodajno mjesto,
Point-of-Sale Profile,Point-of-prodaju Profil,
Portal,Portal,
Possible Supplier,Mogući dobavljač,
Postal Expenses,Poštanski troškovi,
Posting Date,Datum objave,
Posting Date cannot be future date,Knjiženja Datum ne može biti datum u budućnosti,
Posting Time,Vrijeme knjiženja,
Posting date and posting time is mandatory,Datum knjiženja i knjiženje vrijeme je obvezna,
Posting timestamp must be after {0},Vremenska oznaka knjiženja mora biti nakon {0},
Potential opportunities for selling.,Potencijalne prilike za prodaju.,
Practitioner Schedule,Raspored praktičara,
Pre Sales,Pretprodaja,
Preference,Prednost,
Prescribed Procedures,Propisani postupci,
Prescription,Recept,
Prescription Dosage,Doziranje na recept,
Prescription Duration,Trajanje liječenja,
Prescriptions,propisi,
Prev,Prethodna,
Preview,pregled,
Previous Financial Year is not closed,Prethodne financijske godine nije zatvoren,
Price,Cijena,
Price List,Cjenik,
Price List Currency not selected,Valuta cjenika nije odabrana,
Price List Rate,Stopa cjenika,
Price List master.,Glavni cjenik.,
Price List must be applicable for Buying or Selling,Cjenik mora biti primjenjiv za kupnju ili prodaju,
Price List {0} is disabled or does not exist,Cjenik {0} je onemogućen ili ne postoji,
Price or product discount slabs are required,Obavezne su ploče sa cijenama ili popustima na proizvode,
Pricing,cijena,
Pricing Rule,Pravila cijena,
"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 Rule {0} is updated,Pravilo cijene {0} se ažurira,
Pricing Rules are further filtered based on quantity.,Pravilnik o određivanju cijena dodatno se filtrira na temelju količine.,
Primary Address Details,Primarni podaci o adresi,
Primary Contact Details,Primarni podaci za kontakt,
Print Format,Format ispisa,
Print IRS 1099 Forms,Ispiši obrasce IRS 1099,
Print Report Card,Ispis izvješća,
Print Settings,Postavke ispisa,
Print and Stationery,Ispis i konfekcija,
Print settings updated in respective print format,Postavke ispisa ažurirana u odgovarajućem formatu za ispis,
Print taxes with zero amount,Ispis poreza s nula iznosa,
Printing and Branding,Tiskanje i brendiranje,
Private Equity,Private Equity,
Procedure,Postupak,
Process Day Book Data,Obradi podatke o dnevnim knjigama,
Process Master Data,Obradi matične podatke,
Processing Chart of Accounts and Parties,Obrada kontnog plana i stranaka,
Processing Items and UOMs,Obrada predmeta i UOM-ova,
Processing Party Addresses,Obrada stranačkih adresa,
Processing Vouchers,Obrada bonova,
Procurement,nabavka,
Produced Qty,Proizvedena količina,
Product,Proizvod,
Product Bundle,Snop proizvoda,
Product Search,Pretraga proizvoda,
Production,Proizvodnja,
Production Item,Proizvodni proizvod,
Products,proizvodi,
Profit and Loss,Račun dobiti i gubitka,
Profit for the year,Dobit za godinu,
Program,Program,
Program in the Fee Structure and Student Group {0} are different.,Program u strukturi naknada i studentskoj grupi {0} razlikuju se.,
Program {0} does not exist.,Program {0} ne postoji.,
Program: ,Program:,
Progress % for a task cannot be more than 100.,Napredak% za zadatak ne može biti više od 100.,
Project Collaboration Invitation,Projekt Suradnja Poziv,
Project Id,Id projekta,
Project Manager,Voditelj projekta,
Project Name,naziv projekta,
Project Start Date,Datum početka projekta,
Project Status,Status projekta,
Project Summary for {0},Sažetak projekta za {0},
Project Update.,Ažuriranje projekta.,
Project Value,Vrijednost projekta,
Project activity / task.,Projekt aktivnost / zadatak.,
Project master.,Projekt majstor.,
Project-wise data is not available for Quotation,Projekt - mudar podaci nisu dostupni za ponudu,
Projected,Predviđeno,
Projected Qty,Predviđena količina,
Projected Quantity Formula,Projektirana količina količine,
Projects,Projekti,
Proposal Writing,Pisanje prijedlog,
Proposal/Price Quote,Prijedlog / Citat,
Prospecting,Ležišta,
Provisional Profit / Loss (Credit),Privremeni dobit / gubitak (Credit),
Publications,publikacije,
Publish Items on Website,Objavi stavke na web stranici,
Published,Objavljen,
Publishing,Objavljivanje,
Purchase,Nabava,
Purchase Amount,Iznos narudžbe,
Purchase Date,Datum kupnje,
Purchase Invoice,Ulazni račun,
Purchase Invoice {0} is already submitted,Nabavni račun {0} je već podnesen,
Purchase Manager,Upravitelj nabave,
Purchase Master Manager,Upravitelj predloška nabave,
Purchase Order,Narudžbenica,
Purchase Order Amount,Iznos narudžbe,
Purchase Order Amount(Company Currency),Iznos narudžbe (valuta tvrtke),
Purchase Order Date,Datum narudžbe,
Purchase Order Items not received on time,Stavke za kupnju nisu dobivene na vrijeme,
Purchase Order number required for Item {0},Broj narudžbenice kupnje je potreban za artikal {0},
Purchase Order to Payment,Narudžbenice za plaćanje,
Purchase Order {0} is not submitted,Narudžbenicu {0} nije podnesen,
Purchase Orders are not allowed for {0} due to a scorecard standing of {1}.,Narudžbenice za zabavu nisu dozvoljene za {0} zbog položaja ocjene bodova {1}.,
Purchase Orders given to Suppliers.,Narudžbenice poslane dobavljačima,
Purchase Price List,Kupovni cjenik,
Purchase Receipt,Primka,
Purchase Receipt {0} is not submitted,Primka {0} nije potvrđena,
Purchase Tax Template,Predložak poreza pri nabavi,
Purchase User,Korisnik nabave,
Purchase orders help you plan and follow up on your purchases,Narudžbenice vam pomoći planirati i pratiti na Vašoj kupnji,
Purchasing,Nabava,
Purpose must be one of {0},Svrha mora biti jedna od {0},
Qty,Kol,
Qty To Manufacture,Količina za proizvodnju,
Qty Total,Ukupni broj,
Qty for {0},Količina za {0},
Qualification,Kvalifikacija,
Quality,kvaliteta,
Quality Action,Kvalitetna akcija,
Quality Goal.,Cilj kvalitete.,
Quality Inspection,Provjera kvalitete,
Quality Inspection: {0} is not submitted for the item: {1} in row {2},Provjera kvalitete: {0} ne podnosi se za stavku: {1} u retku {2},
Quality Management,Upravljanje kvalitetom,
Quality Meeting,Sastanak kvalitete,
Quality Procedure,Postupak kvalitete,
Quality Procedure.,Postupak kvalitete.,
Quality Review,Pregled kvalitete,
Quantity,Količina,
Quantity for Item {0} must be less than {1},Količina za proizvod {0} mora biti manja od {1},
Quantity in row {0} ({1}) must be same as manufactured quantity {2},Količina u redku {0} ({1}) mora biti ista kao proizvedena količina {2},
Quantity must be less than or equal to {0},Količina mora biti manji ili jednak {0},
Quantity must not be more than {0},Količina ne smije biti veća od {0},
Quantity required for Item {0} in row {1},Količina potrebna za proizvod {0} u redku {1},
Quantity should be greater than 0,Količina bi trebala biti veća od 0,
Quantity to Make,Količina za izradu,
Quantity to Manufacture must be greater than 0.,Količina za proizvodnju mora biti veći od 0.,
Quantity to Produce,Količina za proizvodnju,
Quantity to Produce can not be less than Zero,Količina za proizvodnju ne može biti manja od Nula,
Query Options,Opcije upita,
Queued for replacing the BOM. It may take a few minutes.,U redu čekanja za zamjenu BOM-a. Može potrajati nekoliko minuta.,
Queued for updating latest price in all Bill of Materials. It may take a few minutes.,U redu čekanja za ažuriranje najnovije cijene u svim Bill of Materials. Može potrajati nekoliko minuta.,
Quick Journal Entry,Brzo Temeljnica,
Quot Count,Broj kvote,
Quot/Lead %,Kvota / olovo%,
Quotation,Ponuda,
Quotation {0} is cancelled,Ponuda {0} je otkazana,
Quotation {0} not of type {1},Ponuda {0} nije tip {1},
Quotations,citati,
"Quotations are proposals, bids you have sent to your customers","Citati su prijedlozi, ponude koje ste poslali na svoje klijente",
Quotations received from Suppliers.,Ponude dobivene od dobavljača.,
Quotations: ,citati:,
Quotes to Leads or Customers.,Ponude za kupce ili potencijalne kupce.,
RFQs are not allowed for {0} due to a scorecard standing of {1},Zahtjevi za odobrenje nisu dopušteni za {0} zbog položaja {1},
Range,Domet,
Rate,VPC,
Rate:,Stopa:,
Rating,Ocjena,
Raw Material,sirovine,
Raw Materials,Sirovine,
Raw Materials cannot be blank.,Sirovine ne može biti prazno.,
Re-open,Ponovno otvorena,
Read blog,Pročitajte blog,
Read the ERPNext Manual,Pročitajte ERPNext priručnik,
Reading Uploaded File,Čitanje prenesene datoteke,
Real Estate,Nekretnine,
Reason For Putting On Hold,Razlog za stavljanje na čekanje,
Reason for Hold,Razlog zadržavanja,
Reason for hold: ,Razlog zadržavanja:,
Receipt,Priznanica,
Receipt document must be submitted,Prijem dokumenata moraju biti dostavljeni,
Receivable,potraživanja,
Receivable Account,Potraživanja račun,
Received,primljen,
Received On,Primila je u,
Received Quantity,Primljena količina,
Received Stock Entries,Primljene prijave na dionice,
Receiver List is empty. Please create Receiver List,Receiver Lista je prazna . Molimo stvoriti Receiver Popis,
Recipients,Primatelji,
Reconcile,Pomiriti,
"Record of all communications of type email, phone, chat, visit, etc.","Snimanje svih komunikacija tipa e-mail, telefon, chat, posjete, itd",
Records,ploče,
Redirect URL,URL za preusmjeravanje,
Ref,Ref.,
Ref Date,Ref Datum,
Reference,Upućivanje,
Reference #{0} dated {1},Reference # {0} od {1},
Reference Date,Referentni datum,
Reference Doctype must be one of {0},Referentni DOCTYPE mora biti jedan od {0},
Reference Document,Referentni dokument,
Reference Document Type,Referentna Tip dokumenta,
Reference No & Reference Date is required for {0},Reference Nema & Reference Datum je potrebno za {0},
Reference No and Reference Date is mandatory for Bank transaction,Referentni broj i reference Datum obvezna je za banke transakcije,
Reference No is mandatory if you entered Reference Date,Reference Ne obvezno ako ušao referentnog datuma,
Reference No.,Referentni broj,
Reference Number,Referentni broj,
Reference Type,Referentna Tip,
"Reference: {0}, Item Code: {1} and Customer: {2}","Referenca: {0}, šifra stavke: {1} i klijent: {2}",
References,Reference,
Refresh Token,Osvježi token,
Register,Registrirajte se,
Rejected,Odbijen,
Related,povezan,
Relation with Guardian1,Odnos s Guardian1,
Relation with Guardian2,Odnos s Guardian2,
Release Date,Datum izlaska,
Reload Linked Analysis,Ponovno učitaj povezanu analizu,
Remaining,ostali,
Remaining Balance,Preostali saldo,
Remarks,Primjedbe,
Reminder to update GSTIN Sent,Podsjetnik za ažuriranje GSTIN posla,
Remove item if charges is not applicable to that item,Uklanjanje stavke ako troškovi se ne odnosi na tu stavku,
Removed items with no change in quantity or value.,Uklonjene stvari bez promjena u količini ili vrijednosti.,
Reopen,Ponovno otvori,
Reorder Level,Poredaj Razina,
Reorder Qty,Poredaj Kom,
Repeat Customer Revenue,Ponovite kupaca prihoda,
Repeat Customers,Ponoviti kupaca,
Replace BOM and update latest price in all BOMs,Zamijenite BOM i ažurirajte najnoviju cijenu u svim BOM-ovima,
Replied,Odgovoreno,
Report,Prijavi,
Report Type,Prijavi Vid,
Report Type is mandatory,Vrsta izvješća je obvezno,
Reports,Izvješća,
Reqd By Date,Reqd Po datumu,
Reqd Qty,Reqd Qty,
Request for Quotation,Zahtjev za ponudu,
Request for Quotations,Zahtjev za dostavljanje ponuda,
Request for Raw Materials,Zahtjev za sirovine,
Request for purchase.,Zahtjev za kupnju.,
Request for quotation.,Zahtjev za ponudu.,
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 .",
Requesting Site,Podnositelj zahtjeva,
Requesting payment against {0} {1} for amount {2},Zahtjev za isplatu od {0} {1} za iznos {2},
Requestor,Podnositelj zahtjeva,
Required On,Potrebna On,
Required Qty,Potrebna Kol,
Required Quantity,Potrebna količina,
Reschedule,napraviti nov raspored,
Research,Istraživanje,
Research & Development,Istraživanje i razvoj,
Researcher,Istraživač,
Resend Payment Email,Ponovno slanje plaćanja Email,
Reserve Warehouse,Rezervni skladište,
Reserved Qty,Rezervirano Kol,
Reserved Qty for Production,Rezervirano Kol za proizvodnju,
Reserved Qty for Production: Raw materials quantity to make manufacturing items.,Količina rezervirane za proizvodnju: Količina sirovina za izradu proizvodnih predmeta.,
"Reserved Qty: Quantity ordered for sale, but not delivered.","Rezervirano Količina : Količina naručiti za prodaju , ali nije dostavljena .",
Reserved Warehouse is mandatory for Item {0} in Raw Materials supplied,Rezervirano skladište obvezno je za stavku {0} u sirovinama koje ste dobili,
Reserved for manufacturing,Rezervirano za proizvodnju,
Reserved for sale,Rezervirano za prodaju,
Reserved for sub contracting,Rezervirano za podugovaranje,
Resistant,otporan,
Resolve error and upload again.,Riješite pogrešku i prenesite ponovo.,
Rest Of The World,Ostatak svijeta,
Restart Subscription,Ponovo pokreni pretplatu,
Restaurant,Restoran,
Result Date,Rezultat datuma,
Result already Submitted,Rezultat je već poslan,
Resume,Rezime,
Retail,Maloprodaja,
Retail & Wholesale,Trgovina na veliko i,
Retail Operations,Trgovina na malo,
Retained Earnings,Zadržana dobit,
Retention Stock Entry,Zadržavanje dionice,
Retention Stock Entry already created or Sample Quantity not provided,Dionice za zadržavanje koji su već stvoreni ili Uzorak Količina nije predviđen,
Return,Povratak,
Return / Credit Note,Povrat / odobrenje kupcu,
Return / Debit Note,Povratak / debitna Napomena,
Returns,vraća,
Reverse Journal Entry,Obrnuti unos dnevnika,
Review Invitation Sent,Pregledajte pozivnicu poslanu,
Review and Action,Pregled i radnja,
Rooms Booked,Sobe rezervirane,
Root Company,Root Company,
Root Type,korijen Tip,
Root Type is mandatory,Korijen Tip je obvezno,
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,
Round Off,Zaokružiti,
Rounded Total,Zaokruženi iznos,
Route,put,
Row # {0}: ,Red # {0}:,
Row # {0}: Batch No must be same as {1} {2},Red # {0}: Batch Ne mora biti ista kao {1} {2},
Row # {0}: Cannot return more than {1} for Item {2},Red # {0}: Ne može se vratiti više od {1} za točku {2},
Row # {0}: Rate cannot be greater than the rate used in {1} {2},Red # {0}: Stopa ne može biti veća od stope korištene u {1} {2},
Row # {0}: Serial No is mandatory,Red # {0}: Serijski br obvezno,
Row # {0}: Serial No {1} does not match with {2} {3},Red # {0}: Serijski br {1} ne odgovara {2} {3},
Row #{0} (Payment Table): Amount must be negative,Redak # {0} (Tablica plaćanja): iznos mora biti negativan,
Row #{0} (Payment Table): Amount must be positive,Red # {0} (Tablica plaćanja): iznos mora biti pozitivan,
Row #{0}: Account {1} does not belong to company {2},Red # {0}: Račun {1} ne pripada tvrtki {2},
Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Red # {0}: dodijeljeni iznos ne može biti veći od nepodmirenog iznosa.,
"Row #{0}: Asset {1} cannot be submitted, it is already {2}","Red # {0}: Imovina {1} ne može se podnijeti, to je već {2}",
Row #{0}: Cannot set Rate if amount is greater than billed amount for Item {1}.,Redak # {0}: Nije moguće postaviti stopu ako je iznos veći od naplaćenog iznosa za stavku {1}.,
Row #{0}: Clearance date {1} cannot be before Cheque Date {2},Red # {0}: Datum Razmak {1} ne može biti prije Ček Datum {2},
Row #{0}: Duplicate entry in References {1} {2},Red # {0}: ponovljeni unos u referencama {1} {2},
Row #{0}: Expected Delivery Date cannot be before Purchase Order Date,Red # {0}: očekivani datum isporuke ne može biti prije datuma narudžbe,
Row #{0}: Item added,Redak # {0}: stavka je dodana,
Row #{0}: Journal Entry {1} does not have account {2} or already matched against another voucher,Red # {0}: časopis za ulazak {1} nema računa {2} ili već usklađeni protiv drugog bona,
Row #{0}: Not allowed to change Supplier as Purchase Order already exists,Red # {0}: Nije dopušteno mijenjati dobavljača kao narudžbenice već postoji,
Row #{0}: Please set reorder quantity,Red # {0}: Molimo postavite naručivanja količinu,
Row #{0}: Please specify Serial No for Item {1},Row # {0}: Navedite rednim brojem predmeta za {1},
Row #{0}: Qty increased by 1,Red # {0}: Količina povećana za 1,
Row #{0}: Rate must be same as {1}: {2} ({3} / {4}) ,Red # {0}: Ocijenite mora biti ista kao {1}: {2} ({3} / {4}),
Row #{0}: Reference Document Type must be one of Expense Claim or Journal Entry,Redak # {0}: Referentni tip dokumenta mora biti jedan od zahtjeva za trošak ili unos dnevnika,
"Row #{0}: Reference Document Type must be one of Purchase Order, Purchase Invoice or Journal Entry","Red # {0}: Referenca Tip dokumenta mora biti jedan od narudžbenice, fakture kupovine ili Journal Entry",
Row #{0}: Rejected Qty can not be entered in Purchase Return,Red # {0}: Odbijen Kom se ne može upisati u kupnju povratak,
Row #{0}: Rejected Warehouse is mandatory against rejected Item {1},Red # {0}: Odbijen Skladište je obvezna protiv odbijena točka {1},
Row #{0}: Reqd by Date cannot be before Transaction Date,Redak # {0}: Reqd by Date ne može biti prije datuma transakcije,
Row #{0}: Set Supplier for item {1},Red # {0}: Postavite dobavljač za stavke {1},
Row #{0}: Status must be {1} for Invoice Discounting {2},Redak # {0}: Status mora biti {1} za popust fakture {2},
"Row #{0}: The batch {1} has only {2} qty. Please select another batch which has {3} qty available or split the row into multiple rows, to deliver/issue from multiple batches","Red # {0}: Šarža {1} ima samo {2} qty. Odaberite drugu seriju koja ima {3} količinu dostupnu ili razdijelite red u više redaka, kako biste ih isporučili / izdali iz više šarži",
Row #{0}: Timings conflicts with row {1},Red # {0}: vremenu sukobi s redom {1},
Row #{0}: {1} can not be negative for item {2},Red # {0}: {1} ne može biti negativna za predmet {2},
Row No {0}: Amount cannot be greater than Pending Amount against Expense Claim {1}. Pending Amount is {2},Redak Ne {0}: Iznos ne može biti veća od visine u tijeku protiv Rashodi Zahtjeva {1}. U tijeku Iznos je {2},
Row {0} : Operation is required against the raw material item {1},Redak {0}: Potrebna je operacija prema stavci sirovine {1},
Row {0}# Item {1} cannot be transferred more than {2} against Purchase Order {3},Red {0} # Stavka {1} ne može se prenijeti više od {2} od narudžbenice {3},
Row {0}: Activity Type is mandatory.,Red {0}: Tip aktivnost je obavezna.,
Row {0}: Advance against Customer must be credit,Red {0}: Advance protiv Kupac mora biti kreditna,
Row {0}: Advance against Supplier must be debit,Red {0}: Advance protiv Dobavljač mora teretiti,
Row {0}: Allocated amount {1} must be less than or equals to Payment Entry amount {2},Red {0}: Dodijeljeni iznos {1} mora biti manja ili jednaka količini unosa Plaćanje {2},
Row {0}: Allocated amount {1} must be less than or equals to invoice outstanding amount {2},Red {0}: Dodijeljeni iznos {1} mora biti manji od ili jednak fakturirati preostali iznos {2},
Row {0}: An Reorder entry already exists for this warehouse {1},Red {0}: Ulazak redoslijeda već postoji za to skladište {1},
Row {0}: Bill of Materials not found for the Item {1},Redak {0}: broj materijala koji nije pronađen za stavku {1},
Row {0}: Conversion Factor is mandatory,Red {0}: pretvorbe Factor je obvezno,
Row {0}: Cost center is required for an item {1},Redak {0}: centar za trošak je potreban za stavku {1},
Row {0}: Credit entry can not be linked with a {1},Red {0}: Kredit unos ne može biti povezan s {1},
Row {0}: Currency of the BOM #{1} should be equal to the selected currency {2},Red {0}: Valuta sastavnice # {1} bi trebao biti jednak odabranoj valuti {2},
Row {0}: Debit entry can not be linked with a {1},Red {0}: debitne unos ne može biti povezan s {1},
Row {0}: Depreciation Start Date is required,Redak {0}: potreban je početni datum amortizacije,
Row {0}: Enter location for the asset item {1},Redak {0}: unesite mjesto stavke stavke {1},
Row {0}: Exchange Rate is mandatory,Red {0}: tečaj je obavezno,
Row {0}: Expected Value After Useful Life must be less than Gross Purchase Amount,Redak {0}: očekivana vrijednost nakon korisnog životnog vijeka mora biti manja od bruto narudžbenice,
Row {0}: From Time and To Time is mandatory.,Red {0}: Od vremena i vremena je obavezno.,
Row {0}: From Time and To Time of {1} is overlapping with {2},Red {0}: S vremena i na vrijeme od {1} je preklapanje s {2},
Row {0}: From time must be less than to time,Red {0}: S vremena na vrijeme mora biti manje,
Row {0}: Hours value must be greater than zero.,Red {0}: Sati vrijednost mora biti veća od nule.,
Row {0}: Invalid reference {1},Red {0}: Pogrešna referentni {1},
Row {0}: Party / Account does not match with {1} / {2} in {3} {4},Red {0}: stranka / računa ne odgovara {1} / {2} u {3} {4},
Row {0}: Party Type and Party is required for Receivable / Payable account {1},Red {0}: Stranka Tip i stranka je potrebno za potraživanja / obveze prema dobavljačima račun {1},
Row {0}: Payment against Sales/Purchase Order should always be marked as advance,Red {0}: Plaćanje protiv prodaje / narudžbenice treba uvijek biti označena kao unaprijed,
Row {0}: Please check 'Is Advance' against Account {1} if this is an advance entry.,"Red {0}: Provjerite 'Je li Advance ""protiv nalog {1} Ako je to unaprijed ulaz.",
Row {0}: Please set at Tax Exemption Reason in Sales Taxes and Charges,Redak {0}: Postavite razlog oslobađanja od poreza u porezima i naknadama na promet,
Row {0}: Please set the Mode of Payment in Payment Schedule,Redak {0}: Postavite Način plaćanja u Raspored plaćanja,
Row {0}: Please set the correct code on Mode of Payment {1},Redak {0}: postavite ispravan kôd na način plaćanja {1},
Row {0}: Qty is mandatory,Red {0}: Količina je obvezno,
Row {0}: Quality Inspection rejected for item {1},Redak {0}: Odbačena inspekcija kvalitete za stavku {1},
Row {0}: UOM Conversion Factor is mandatory,Red {0}: UOM pretvorbe faktor je obavezno,
Row {0}: select the workstation against the operation {1},Red {0}: odaberite radnu stanicu protiv operacije {1},
Row {0}: {1} Serial numbers required for Item {2}. You have provided {3}.,Redak {0}: {1} Serijski brojevi potrebni za stavku {2}. Naveli ste {3}.,
Row {0}: {1} must be greater than 0,Redak {0}: {1} mora biti veći od 0,
Row {0}: {1} {2} does not match with {3},Red {0}: {1} {2} ne odgovara {3},
Row {0}:Start Date must be before End Date,Red {0} : Datum početka mora biti prije datuma završetka,
Rows with duplicate due dates in other rows were found: {0},Nađeno je redaka s datumima duplikata u drugim redcima: {0},
Rules for adding shipping costs.,Pravila za dodavanje troškova prijevoza.,
Rules for applying pricing and discount.,Pravila za primjenu cijena i popusta.,
S.O. No.,N.K.br.,
SGST Amount,Iznos SGST,
SO Qty,SO Kol,
Safety Stock,Sigurnost Stock,
Salary,Plaća,
Salary Slip submitted for period from {0} to {1},Plaća poslana za razdoblje od {0} do {1},
Salary Structure must be submitted before submission of Tax Ememption Declaration,Struktura plaće mora se podnijeti prije podnošenja Izjave o porezu,
Sales,Prodaja,
Sales Account,Račun prodaje,
Sales Expenses,Prodajni troškovi,
Sales Funnel,prodaja dimnjak,
Sales Invoice,Prodajni račun,
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 Manager,Sales Manager,
Sales Master Manager,Prodaja Master Manager,
Sales Order,Narudžba kupca,
Sales Order Item,Naručeni proizvod - prodaja,
Sales Order required for Item {0},Prodajnog naloga potrebna za točke {0},
Sales Order to Payment,Prodajnog naloga za plaćanje,
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 {1},Prodaja Naručite {0} {1},
Sales Orders,Narudžbe kupca,
Sales Partner,Prodajni partner,
Sales Pipeline,Prodaja cjevovoda,
Sales Price List,Prodajni cjenik,
Sales Return,Povrat robe,
Sales Summary,Sažetak prodaje,
Sales Tax Template,Porez Predložak,
Sales Team,Prodajni tim,
Sales User,Prodaja Korisnik,
Sales and Returns,Prodaja i povrat,
Sales campaigns.,Prodajne kampanje.,
Sales orders are not available for production,Narudžbe za prodaju nisu dostupne za proizvodnju,
Salutation,Pozdrav,
Same Company is entered more than once,Ista tvrtka je ušao više od jednom,
Same item cannot be entered multiple times.,Isti predmet ne može se upisati više puta.,
Same supplier has been entered multiple times,Isti dobavljač je unesen više puta,
Sample Collection,Prikupljanje uzoraka,
Sample quantity {0} cannot be more than received quantity {1},Uzorak {0} ne može biti veći od primljene količine {1},
Sanctioned,kažnjeni,
Sand,Pijesak,
Saturday,Subota,
Saving {0},Spremanje {0},
Scan Barcode,Skenirajte crtični kod,
Schedule,Raspored,
Schedule Admission,Raspored prijama,
Schedule Course,Raspored nastave,
Schedule Date,Raspored Datum,
Schedule Discharge,Raspored otpuštanja,
Scheduled,Planiran,
Scheduled Upto,Planirano upto,
"Schedules for {0} overlaps, do you want to proceed after skiping overlaped slots ?","Rasporedi za {0} preklapanja, želite li nastaviti nakon preskakanja preklapanih utora?",
Score cannot be greater than Maximum Score,Rezultat ne može biti veća od najvišu ocjenu,
Scorecards,bodovima,
Scrapped,otpisan,
Search,Traži,
Search Results,Rezultati pretraživanja,
Search Sub Assemblies,Traži Sub skupštine,
"Search by item code, serial number, batch no or barcode","Pretraživanje po kodu stavke, serijskog broja, šarže ili crtičnog koda",
"Seasonality for setting budgets, targets etc.","Sezonska za postavljanje proračuna, ciljevi itd",
Secret Key,Tajni ključ,
Secretary,Tajnica,
Section Code,Kod sekcije,
Secured Loans,osigurani krediti,
Securities & Commodity Exchanges,Vrijednosni papiri i robne razmjene,
Securities and Deposits,Vrijednosni papiri i depoziti,
See All Articles,Pogledajte sve članke,
See all open tickets,Pogledajte sve otvorene ulaznice,
See past orders,Pogledajte prošle narudžbe,
See past quotations,Pogledajte dosadašnje citate,
Select,Odabrati,
Select Alternate Item,Odaberite alternativnu stavku,
Select Attribute Values,Odaberite Vrijednosti atributa,
Select BOM,Odaberi BOM,
Select BOM and Qty for Production,Odaberite BOM i Kol za proizvodnju,
"Select BOM, Qty and For Warehouse","Odaberite BOM, Qty i za skladište",
Select Batch,Odaberite Batch,
Select Batch Numbers,Odaberite Batch Numbers,
Select Brand...,Odaberite brand ...,
Select Company,Odaberite tvrtku,
Select Company...,Odaberite tvrtku ...,
Select Customer,Odaberite klijenta,
Select Days,Odaberite Dani,
Select Default Supplier,Odabir Primarna Dobavljač,
Select DocType,Odaberite DOCTYPE,
Select Fiscal Year...,Odaberite fiskalnu godinu ...,
Select Item (optional),Odaberite stavku (nije obavezno),
Select Items based on Delivery Date,Odaberite stavke na temelju datuma isporuke,
Select Items to Manufacture,Odaberite stavke za proizvodnju,
Select Loyalty Program,Odaberite Program lojalnosti,
Select Patient,Odaberite Pacijent,
Select Possible Supplier,Odaberite Mogući dobavljač,
Select Quantity,Odaberite Količina,
Select Serial Numbers,Odaberite serijske brojeve,
Select Target Warehouse,Odaberite Target Warehouse,
Select Warehouse...,Odaberite Warehouse ...,
Select an account to print in account currency,Odaberite račun za ispis u valuti računa,
Select at least one value from each of the attributes.,Odaberite barem jednu vrijednost iz svakog od atributa.,
Select change amount account,Iznos računa Odaberi promjene,
Select company first,Najprije odaberite tvrtku,
Select students manually for the Activity based Group,Ručno odaberite studente za Grupu temeljenu na aktivnostima,
Select the customer or supplier.,Odaberite kupca ili dobavljača.,
Select the nature of your business.,Odaberite prirodu Vašeg poslovanja.,
Select the program first,Najprije odaberite program,
Select to add Serial Number.,Odaberite za dodavanje serijskog broja.,
Select your Domains,Odaberite svoje domene,
Selected Price List should have buying and selling fields checked.,Odabrani cjenik trebao bi biti provjeren na poljima kupnje i prodaje.,
Sell,Prodavati,
Selling,Prodaja,
Selling Amount,Prodaja Iznos,
Selling Price List,Cjenik prodaje,
Selling Rate,Stopa prodaje,
"Selling must be checked, if Applicable For is selected as {0}","Prodaje se mora provjeriti, ako je primjenjivo za odabrano kao {0}",
Send Grant Review Email,Slanje e-pošte za evaluaciju potpore,
Send Now,Pošalji odmah,
Send SMS,Pošalji SMS,
Send mass SMS to your contacts,Pošalji grupne SMS poruke svojim kontaktima,
Sensitivity,Osjetljivost,
Sent,Poslano,
Serial No and Batch,Serijski broj i serije,
Serial No is mandatory for Item {0},Serijski Nema je obvezna za točke {0},
Serial No {0} does not belong to Batch {1},Serijski broj {0} ne pripada skupini {1},
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 belong to any Warehouse,Serijski broj {0} ne pripada bilo Skladište,
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 found,Serijski broj {0} nije pronađen,
Serial No {0} not in stock,Serijski broj {0} nije na skladištu,
Serial No {0} quantity {1} cannot be a fraction,Serijski Ne {0} {1} količina ne može bitidio,
Serial Nos Required for Serialized Item {0},Serijski Nos potrebna za serijaliziranom točke {0},
Serial Number: {0} is already referenced in Sales Invoice: {1},Serijski broj: {0} već se odnosi na prodajnu fakturu: {1},
Serial Numbers,Serijski brojevi,
Serial Numbers in row {0} does not match with Delivery Note,Serijski brojevi u retku {0} ne podudaraju se s dostavom,
Serial no {0} has been already returned,Serijski broj {0} već je vraćen,
Serial number {0} entered more than once,Serijski broj {0} ušao više puta,
Serialized Inventory,Serijaliziranom Inventar,
Series Updated,Serija ažurirana,
Series Updated Successfully,Serija je uspješno ažurirana,
Series is mandatory,Serija je obvezno,
Service,usluga,
Service Level Agreement,Ugovor o razini usluge,
Service Level Agreement.,Ugovor o razini usluge.,
Service Level.,Razina usluge.,
Service Stop Date cannot be after Service End Date,Zaustavni datum usluge ne može biti nakon datuma završetka usluge,
Service Stop Date cannot be before Service Start Date,Servisni datum zaustavljanja ne može biti prije datuma početka usluge,
Services,usluge,
"Set Default Values like Company, Currency, Current Fiscal Year, etc.","Postavi zadane vrijednosti kao što su tvrtka, valuta, tekuća fiskalna godina, itd.",
Set Details,Postavite pojedinosti,
Set New Release Date,Postavite novi datum izdavanja,
Set Project and all Tasks to status {0}?,Postaviti Projekt i sve zadatke na status {0}?,
Set Status,Postavite status,
Set Tax Rule for shopping cart,Postavite Porezni Pravilo za košaricu,
Set as Closed,Postavi kao zatvoreno,
Set as Completed,Postavite kao dovršeno,
Set as Lost,Postavi kao Lost,
Set as Open,Postavi kao Opena,
Set default inventory account for perpetual inventory,Postavite zadani oglasni prostor za trajni oglasni prostor,
Set this if the customer is a Public Administration company.,To postavite ako je kupac tvrtka za javnu upravu.,
Set {0} in asset category {1} or company {2},Postavite {0} u kategoriji imovine {1} ili tvrtku {2},
"Setting Events to {0}, since the Employee attached to the below Sales Persons does not have a User ID{1}","Postavljanje Događaji na {0}, budući da je zaposlenik u prilogu niže prodaje osoba nema ID korisnika {1}",
Setting defaults,Postavljanje zadanih postavki,
Setting up Email,Postavljanje e-poštu,
Setting up Email Account,Postavljanje račun e-pošte,
Setting up Employees,Postavljanje zaposlenika,
Setting up Taxes,Postavljanje Porezi,
Setting up company,Osnivanje tvrtke,
Settings,postavke,
"Settings for online shopping cart such as shipping rules, price list etc.","Postavke za online košarici, kao što su utovar pravila, cjenika i sl",
Settings for website homepage,Postavke za web stranice početnu stranicu,
Settings for website product listing,Postavke za popis proizvoda na web mjestu,
Settled,Obavljene,
Setup Gateway accounts.,Postava Gateway račune.,
Setup SMS gateway settings,Postavke SMS pristupnika,
Setup cheque dimensions for printing,Provjera postavljanje dimenzije za ispis,
Setup default values for POS Invoices,Postavljanje zadanih vrijednosti za POS fakture,
Setup mode of POS (Online / Offline),Način postavljanja POS (Online / Offline),
Setup your Institute in ERPNext,Postavite svoj Institut u ERPNext,
Share Balance,Dionički saldo,
Share Ledger,Dijelite knjigu,
Share Management,Upravljanje dijeljenjem,
Share Transfer,Dijeljenje prijenosa,
Share Type,Vrsta dijeljenja,
Shareholder,dioničar,
Ship To State,Brod u državu,
Shipments,pošiljke,
Shipping Address,Dostava Adresa,
"Shipping Address does not have country, which is required for this Shipping Rule",Adresa za isporuku nema državu koja je potrebna za ovaj Pravilnik za isporuku,
Shipping rule only applicable for Buying,Pravilo isporuke primjenjivo je samo za kupnju,
Shipping rule only applicable for Selling,Pravilo o isporuci primjenjuje se samo za prodaju,
Shopify Supplier,Dobavljač trgovine,
Shopping Cart,Košarica,
Shopping Cart Settings,Košarica Postavke,
Short Name,Kratko Ime,
Shortage Qty,Nedostatak Kom,
Show Completed,Prikaži dovršeno,
Show Cumulative Amount,Prikaži kumulativni iznos,
Show Open,Prikaži otvorena,
Show Opening Entries,Prikaži unose otvaranja,
Show Payment Details,Prikaži pojedinosti o plaćanju,
Show Return Entries,Prikaži povratne unose,
Show Variant Attributes,Prikaži svojstva varijacije,
Show Variants,Pokaži varijante,
Show closed,Prikaži zatvorene,
Show exploded view,Prikaži eksplodirao pogled,
Show only POS,Prikaži samo POS,
Show unclosed fiscal year's P&L balances,Prikaži nezatvorena fiskalne godine u P &amp; L stanja,
Show zero values,Pokaži nulte vrijednosti,
Silt,Mulj,
Single Variant,Jedna varijanta,
Single unit of an Item.,Jedna jedinica stavku.,
"Skipping Leave Allocation for the following employees, as Leave Allocation records already exists against them. {0}","Preskakanje dodjele odmora za sljedeće zaposlenike, kao što Dokumenti raspodjele odmora već postoje protiv njih. {0}",
Slideshow,Slideshow,
Slots for {0} are not added to the schedule,Mjesta za {0} ne dodaju se u raspored,
Small,Mali,
Soap & Detergent,Sapun i deterdžent,
Software,Softver,
Software Developer,Software Developer,
Softwares,Software,
Soil compositions do not add up to 100,Sastavi tla ne dodaju do 100,
Sold,prodan,
Some emails are invalid,Neke e-poruke nisu važeće,
Some information is missing,Neki podaci nedostaju,
Something went wrong!,Nešto je pošlo po krivu!,
"Sorry, Serial Nos cannot be merged","Žao nam je , Serial Nos ne mogu spojiti",
Source,Izvor,
Source Name,source Name,
Source Warehouse,Izvor galerija,
Source and Target Location cannot be same,Izvor i ciljna lokacija ne mogu biti isti,
Source and target warehouse cannot be same for row {0},Izvor i ciljna skladište ne može biti isti za redom {0},
Source and target warehouse must be different,Izvorna i odredišna skladište mora biti drugačiji,
Source of Funds (Liabilities),Izvor sredstava ( pasiva),
Source warehouse is mandatory for row {0},Izvor skladište je obvezno za redom {0},
Specified BOM {0} does not exist for Item {1},Određena BOM {0} ne postoji za točku {1},
Split,Split,
Split Batch,Split Batch,
Split Issue,Split Issue,
Sports,sportovi,
Standard Buying,Standardna kupnju,
Standard Selling,Standardna prodaja,
Standard contract terms for Sales or Purchase.,Standardni uvjeti ugovora za prodaju ili kupnju.,
Start Date,Datum početka,
Start Date of Agreement can't be greater than or equal to End Date.,Datum početka ugovora ne može biti veći ili jednak Krajnjem datumu.,
Start Year,Početak godine,
Start date should be less than end date for Item {0},Početak bi trebao biti manji od krajnjeg datuma za točke {0},
Start date should be less than end date for task {0},Datum početka trebao bi biti manji od datuma završetka zadatka {0},
Start day is greater than end day in task '{0}',Dan početka je veći od završnog dana u zadatku &#39;{0}&#39;,
Start on,Započnite,
State,država,
State/UT Tax,Porez na države / UT,
Statement of Account,Izjava o računu,
Status must be one of {0},Status mora biti jedan od {0},
Stock,Lager,
Stock Adjustment,Stock Podešavanje,
Stock Analytics,Analitika skladišta,
Stock Assets,dionicama u vrijednosti,
Stock Available,Dostupno,
Stock Balance,Skladišna bilanca,
Stock Entries already created for Work Order ,Dionice već stvorene za radni nalog,
Stock Entry,Međuskladišnica,
Stock Entry {0} created,Stock Ulazak {0} stvorio,
Stock Entry {0} is not submitted,Međuskladišnica {0} nije potvrđena,
Stock Expenses,Stock Troškovi,
Stock In Hand,Stock u ruci,
Stock Items,zalihi,
Stock Ledger,Glavna knjiga,
Stock Ledger Entries and GL Entries are reposted for the selected Purchase Receipts,Upisi u glavnu knjigu i GL upisi su ponovno postavljeni za odabrane primke.,
Stock Levels,Stock Razine,
Stock Liabilities,Stock Obveze,
Stock Qty,Kataloški broj,
Stock Received But Not Billed,Stock primljeni Ali ne Naplaćeno,
Stock Reports,dionica izvješća,
Stock Summary,Stock Sažetak,
Stock Transactions,Stock transakcije,
Stock UOM,Kataloški UOM,
Stock Value,Stock vrijednost,
Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},Stock ravnoteža u batch {0} postat negativna {1} za točku {2} na skladištu {3},
Stock cannot be updated against Delivery Note {0},Dionica ne može biti obnovljeno protiv isporuke Napomena {0},
Stock cannot be updated against Purchase Receipt {0},Stock ne može se ažurirati na potvrdi o kupnji {0},
Stock cannot exist for Item {0} since has variants,Stock ne može postojati točkom {0} jer ima varijante,
Stock transactions before {0} are frozen,Stock transakcije prije {0} se zamrznut,
Stop,zaustaviti,
Stopped,Zaustavljen,
"Stopped Work Order cannot be cancelled, Unstop it first to cancel","Zaustavljen radni nalog ne može se otkazati, prvo ga otkazati",
Stores,prodavaonice,
Student,Student,
Student Activity,Aktivnost studenata,
Student Address,Studentska adresa,
Student Admissions,Studentski Upisi,
Student Attendance,Studentski Gledatelja,
"Student Batches help you track attendance, assessments and fees for students","Studentski Serije vam pomoći pratiti posjećenost, procjene i naknade za učenike",
Student Email Address,Studentski e-mail adresa,
Student Email ID,Student ID e-pošte,
Student Group,Studentski Grupa,
Student Group Strength,Snaga grupe učenika,
Student Group is already updated.,Studentska grupa je već ažurirana.,
Student Group: ,Skupina studenata:,
Student ID,studentska iskaznica,
Student ID: ,Studentska iskaznica:,
Student LMS Activity,LMS aktivnost učenika,
Student Mobile No.,Studentski Mobile Ne,
Student Name,Ime studenta,
Student Name: ,Ime studenta:,
Student Report Card,Kartica studentskog izvješća,
Student is already enrolled.,Student je već upisan.,
Student {0} - {1} appears Multiple times in row {2} & {3},Student {0} - {1} pojavljuje više puta u nizu {2} {3},
Student {0} does not belong to group {1},Student {0} ne pripada skupini {1},
Student {0} exist against student applicant {1},Student {0} postoje protiv studenta podnositelja prijave {1},
"Students are at the heart of the system, add all your students","Studenti se u središtu sustava, dodati sve svoje studente",
Sub Assemblies,pod skupštine,
Sub Type,Sub Type,
Sub-contracting,Podugovaranje,
Subcontract,Podugovor,
Subject,Predmet,
Submit,Potvrdi,
Submit this Work Order for further processing.,Pošaljite ovaj radni nalog za daljnju obradu.,
Subscription,Pretplata,
Subscription Management,Upravljanje pretplatama,
Subscriptions,Pretplate,
Subtotal,suma stavke,
Successful,uspješan,
Successfully Reconciled,Uspješno Pomirio,
Successfully Set Supplier,Uspješno postavite dobavljača,
Successfully created payment entries,Uspješno stvorene stavke plaćanja,
Successfully deleted all transactions related to this company!,Uspješno izbrisati sve transakcije vezane uz ovu tvrtku!,
Sum of Scores of Assessment Criteria needs to be {0}.,Zbroj ocjene kriterija za ocjenjivanje treba biti {0}.,
Sum of points for all goals should be 100. It is {0},Zbroj bodova svih ciljeva trebao biti 100. To je {0},
Summary,Sažetak,
Summary for this month and pending activities,Sažetak za ovaj mjesec i tijeku aktivnosti,
Summary for this week and pending activities,Sažetak za ovaj tjedan i tijeku aktivnosti,
Sunday,Nedjelja,
Suplier,suplier,
Supplier,Dobavljač,
Supplier Group,Grupa dobavljača,
Supplier Group master.,Majstor grupa dobavljača.,
Supplier Id,Id Dobavljač,
Supplier Invoice Date cannot be greater than Posting Date,Datum Dobavljač Račun ne može biti veća od datum knjiženja,
Supplier Invoice No,Dobavljač Račun br,
Supplier Invoice No exists in Purchase Invoice {0},Dobavljač Račun br postoji u fakturi {0},
Supplier Name,Dobavljač Ime,
Supplier Part No,Dobavljač Dio Ne,
Supplier Quotation,Dobavljač Ponuda,
Supplier Scorecard,Dobavljač ocjena,
Supplier Warehouse mandatory for sub-contracted Purchase Receipt,Dobavljač skladišta obvezan je za sub - ugovoreni kupiti primitka,
Supplier database.,Dobavljač baza podataka.,
Supplier {0} not found in {1},Dobavljač {0} nije pronađen {1},
Supplier(s),Dobavljač (s),
Supplies made to UIN holders,Nabave za držače UIN-a,
Supplies made to Unregistered Persons,Isporuka za neregistrirane osobe,
Suppliies made to Composition Taxable Persons,Isporuke za porezne obveznike na sastav,
Supply Type,Vrsta napajanja,
Support,podrška,
Support Analytics,Analitike podrške,
Support Settings,Postavke za podršku,
Support Tickets,Podržite ulaznice,
Support queries from customers.,Upiti podršci.,
Susceptible,Osjetljiv,
Sync has been temporarily disabled because maximum retries have been exceeded,Sinkronizacija je privremeno onemogućena zbog prekoračenja maksimalnih pokušaja,
Syntax error in condition: {0},Pogreška sintakse u stanju: {0},
Syntax error in formula or condition: {0},sintaktička pogreška u formuli ili stanja: {0},
System Manager,Sustav Manager,
TDS Rate %,TDS stopa%,
Tap items to add them here,Dodirnite stavke da biste ih dodali ovdje,
Target,Meta,
Target ({}),Cilj ({}),
Target On,Target Na,
Target Warehouse,Ciljana galerija,
Target warehouse is mandatory for row {0},Target skladište je obvezno za redom {0},
Task,Zadatak,
Tasks,poslovi,
Tasks have been created for managing the {0} disease (on row {1}),Zadaci su stvoreni za upravljanje {0} bolestom (u retku {1}),
Tax,Porez,
Tax Assets,Porezna imovina,
Tax Category,Porezna kategorija,
Tax Category for overriding tax rates.,Porezna kategorija za previsoke porezne stope.,
"Tax Category has been changed to ""Total"" because all the Items are non-stock items",Kategorija poreza promijenjena je u &quot;Ukupno&quot; jer su sve stavke nedopuštene stavke,
Tax ID,OIB,
Tax Id: ,ID poreza:,
Tax Rate,Porezna stopa,
Tax Rule Conflicts with {0},Porezni Pravilo Sukobi s {0},
Tax Rule for transactions.,Porezni Pravilo za transakcije.,
Tax Template is mandatory.,Porez Predložak je obavezno.,
Tax Withholding rates to be applied on transactions.,Stope zadržavanja poreza koje će se primjenjivati na transakcije.,
Tax template for buying transactions.,Porezna Predložak za kupnju transakcije .,
Tax template for item tax rates.,Obrazac poreza za porezne stope na stavke.,
Tax template for selling transactions.,Porezni predložak za prodajne transakcije.,
Taxable Amount,Iznos oporezivanja,
Taxes,Porezi,
Technology,Tehnologija,
Telecommunications,Telekomunikacije,
Telephone Expenses,Telefonski troškovi,
Television,Televizija,
Template Name,Naziv predloška,
Template of terms or contract.,Predložak izraza ili ugovora.,
Templates of supplier scorecard criteria.,Predlošci kriterija dobavljača bodova.,
Templates of supplier scorecard variables.,Predlošci varijabli s rezultatima dobavljača.,
Templates of supplier standings.,Predlošci stanja dobavljača.,
Temporarily on Hold,Privremeno na čekanju,
Temporary,privremen,
Temporary Accounts,Privremeni računi,
Temporary Opening,Privremeni Otvaranje,
Terms and Conditions,Odredbe i uvjeti,
Terms and Conditions Template,Uvjeti i odredbe - šprance,
Territory,Teritorij,
Thank you for your business!,Hvala vam na poslovanju!,
The 'From Package No.' field must neither be empty nor it's value less than 1.,&#39;Iz paketa br.&#39; polje ne smije biti prazno niti vrijednost manja od 1.,
The Brand,Brand,
The Item {0} cannot have Batch,Stavka {0} ne može imati Hrpa,
The Loyalty Program isn't valid for the selected company,Program lojalnosti ne vrijedi za odabranu tvrtku,
The Payment Term at row {0} is possibly a duplicate.,Plaćanje u redu {0} vjerojatno je duplikat.,
The Term End Date cannot be earlier than the Term Start Date. Please correct the dates and try again.,Datum Pojam završetka ne može biti ranije od datuma Pojam Start. Ispravite datume i pokušajte ponovno.,
The Term End Date cannot be later than the Year End Date of the Academic Year to which the term is linked (Academic Year {}). Please correct the dates and try again.,Datum Pojam završetka ne može biti kasnije od godine datum završetka školske godine u kojoj je pojam vezan (Akademska godina {}). Ispravite datume i pokušajte ponovno.,
The Term Start Date cannot be earlier than the Year Start Date of the Academic Year to which the term is linked (Academic Year {}). Please correct the dates and try again.,Datum Pojam početka ne može biti ranije od godine Datum početka akademske godine u kojoj je pojam vezan (Akademska godina {}). Ispravite datume i pokušajte ponovno.,
The Year End Date cannot be earlier than the Year Start Date. Please correct the dates and try again.,Godina Datum završetka ne može biti ranije od datuma Godina Start. Ispravite datume i pokušajte ponovno.,
The amount of {0} set in this payment request is different from the calculated amount of all payment plans: {1}. Make sure this is correct before submitting the document.,Iznos {0} postavljen u ovom zahtjevu za plaćanje razlikuje se od izračunatog iznosa svih planova plaćanja: {1}. Provjerite je li to ispravno prije slanja dokumenta.,
The field From Shareholder cannot be blank,Polje Od dioničara ne može biti prazno,
The field To Shareholder cannot be blank,Polje Dioničar ne može biti prazno,
The fields From Shareholder and To Shareholder cannot be blank,Polja Od dioničara i dioničara ne mogu biti prazna,
The folio numbers are not matching,Folio brojevi se ne podudaraju,
The holiday on {0} is not between From Date and To Date,Odmor na {0} nije između Od Datum i do sada,
The name of the institute for which you are setting up this system.,Ime instituta za koju postavljate ovaj sustav.,
The name of your company for which you are setting up this system.,Ime vaše tvrtke za koje ste postavljanje ovog sustava .,
The number of shares and the share numbers are inconsistent,Broj dionica i brojeva udjela nedosljedni su,
The payment gateway account in plan {0} is different from the payment gateway account in this payment request,Račun za gateway plaćanja u planu {0} se razlikuje od računa za pristupnik plaćanja u ovom zahtjevu za plaćanje,
The selected BOMs are not for the same item,Odabrane sastavnice nisu za istu stavku,
The selected item cannot have Batch,Izabrani predmet ne može imati Hrpa,
The seller and the buyer cannot be the same,Prodavatelj i kupac ne mogu biti isti,
The shareholder does not belong to this company,Dioničar ne pripada ovoj tvrtki,
The shares already exist,Dionice već postoje,
The shares don't exist with the {0},Dionice ne postoje kod {0},
"The task has been enqueued as a background job. In case there is any issue on processing in background, the system will add a comment about the error on this Stock Reconciliation and revert to the Draft stage","Zadatak je zamišljen kao pozadinski posao. U slučaju da dođe do problema s obradom u pozadini, sustav će dodati komentar o pogrešci ovog usklađivanja zaliha i vratit će se u fazu skice.",
"Then Pricing Rules are filtered out based on Customer, Customer Group, Territory, Supplier, Supplier Type, Campaign, Sales Partner etc.","Cjenovna pravila filtriraju se na temelju kupca, grupe kupaca, regije, dobavljača, proizvođača, kampanje, prodajnog partnera i sl.",
"There are inconsistencies between the rate, no of shares and the amount calculated","Postoje nedosljednosti između stope, broja dionica i izračunate iznosa",
There can be multiple tiered collection factor based on the total spent. But the conversion factor for redemption will always be same for all the tier.,Može postojati višestruki skupni faktor zbirke na temelju ukupnog utrošenog. Ali pretvorbeni faktor za iskupljenje uvijek će biti isti za cijelu razinu.,
There can only be 1 Account per Company in {0} {1},Tu može biti samo 1 račun po društvo u {0} {1},
"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 isn't any item variant for the selected item,Nema odabrane stavke za odabranu stavku,
"There seems to be an issue with the server's GoCardless configuration. Don't worry, in case of failure, the amount will get refunded to your account.","Čini se da postoji problem s konfiguracijom GoCardless poslužitelja. Ne brinite, u slučaju neuspjeha, iznos će biti vraćen na vaš račun.",
There were errors creating Course Schedule,Došlo je do pogrešaka prilikom izrade tečaja Raspored,
There were errors.,Bilo je grešaka .,
This Item is a Template and cannot be used in transactions. Item attributes will be copied over into the variants unless 'No Copy' is set,"Ova točka je predložak i ne može se koristiti u prometu. Atributi artikl će biti kopirana u varijanti osim 'Ne Copy ""je postavljena",
This Item is a Variant of {0} (Template).,Ova stavka je varijanta od {0} (Predložak).,
This Month's Summary,Ovomjesečnom Sažetak,
This Week's Summary,Ovaj tjedan Sažetak,
This action will stop future billing. Are you sure you want to cancel this subscription?,Ta će radnja zaustaviti buduće naplate. Jeste li sigurni da želite otkazati ovu pretplatu?,
This covers all scorecards tied to this Setup,To obuhvaća sve bodove vezane uz ovu postavku,
This document is over limit by {0} {1} for item {4}. Are you making another {3} against the same {2}?,Ovaj dokument je preko granice po {0} {1} za stavku {4}. Jeste li što drugo {3} protiv iste {2}?,
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.,Ovo je glavna grupa kupaca i ne može se mijenjati.,
This is a root department and cannot be edited.,Ovo je korijenski odjel i ne može se uređivati.,
This is a root healthcare service unit and cannot be edited.,Ovo je jedinica za zdravstvenu zaštitu root i ne može se uređivati.,
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 supplier group and cannot be edited.,Ovo je grupa dobavljača i ne može se uređivati.,
This is a root territory and cannot be edited.,Ovo je glavni 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 based on logs against this Vehicle. See timeline below for details,To se temelji na zapisima protiv tog vozila. Pogledajte vremensku crtu ispod za detalje,
This is based on stock movement. See {0} for details,To se temelji na dionicama kretanja. Vidi {0} za detalje,
This is based on the Time Sheets created against this project,To se temelji na vremenske tablice stvorene na ovom projektu,
This is based on the attendance of this Student,To se temelji na prisustvo ovog Student,
This is based on transactions against this Customer. See timeline below for details,To se temelji na transakcijama protiv tog kupca. Pogledajte vremensku crtu ispod za detalje,
This is based on transactions against this Healthcare Practitioner.,To se temelji na transakcijama protiv ove zdravstvene prakse.,
This is based on transactions against this Patient. See timeline below for details,To se temelji na transakcijama protiv ovog pacijenta. Pojedinosti potražite u nastavku,
This is based on transactions against this Sales Person. See timeline below for details,To se temelji na transakcijama protiv ove prodajne osobe. Pojedinosti potražite u nastavku,
This is based on transactions against this Supplier. See timeline below for details,To se temelji na transakcijama protiv tog dobavljača. Pogledajte vremensku crtu ispod za detalje,
This {0} conflicts with {1} for {2} {3},To {0} sukobi s {1} od {2} {3},
Time Sheet for manufacturing.,Vrijeme list za proizvodnju.,
Time Tracking,Praćenje vremena,
"Time slot skiped, the slot {0} to {1} overlap exisiting slot {2} to {3}","Vremenski utor je preskočen, utor {0} do {1} preklapa vanjski otvor {2} na {3}",
Time slots added,Dodano je vrijeme,
Time(in mins),Vrijeme (u minutama),
Timer,Odbrojavanje,
Timer exceeded the given hours.,Timer je premašio zadani broj sati.,
Timesheet,kontrolna kartica,
Timesheet for tasks.,Timesheet za zadatke.,
Timesheet {0} is already completed or cancelled,Timesheet {0} već je završen ili otkazan,
Timesheets,timesheets,
"Timesheets help keep track of time, cost and billing for activites done by your team","Timesheets pomoći pratiti vrijeme, troškove i naplatu za aktivnostima obavljaju unutar vašeg tima",
Titles for print templates e.g. Proforma Invoice.,"Naslovi za ispis predložaka, na primjer predračuna.",
To,Do,
To Address 1,Adresa 1,
To Address 2,Adresa 2,
To Bill,Za Billa,
To Date,Za datum,
To Date cannot be before From Date,Do danas ne može biti prije od datuma,
To Date cannot be less than From Date,Do datuma ne može biti manji od datuma,
To Date must be greater than From Date,Do datuma mora biti veći od Od datuma,
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 Datetime,Za Datetime,
To Deliver,Za isporuku,
To Deliver and Bill,Za isporuku i Bill,
To Fiscal Year,Fiskalnoj godini,
To GSTIN,Za GSTIN,
To Party Name,Za ime partije,
To Pin Code,Za kodiranje koda,
To Place,Mjesto,
To Receive,Primiti,
To Receive and Bill,Za primanje i Bill,
To State,Izjaviti,
To Warehouse,Za skladište,
To create a Payment Request reference document is required,Za izradu referentnog dokumenta zahtjeva za plaćanje potrebno je,
"To filter based on Party, select Party Type first","Za filtriranje se temelji na stranke, odaberite stranka Upišite prvi",
"To get the best out of ERPNext, we recommend that you take some time and watch these help videos.","Da biste dobili najbolje iz ERPNext, preporučamo da odvojite malo vremena i gledati te pomoći videa.",
"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 make Customer based incentive schemes.,Da biste napravili poticajne sheme temeljene na kupcu.,
"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 view logs of Loyalty Points assigned to a Customer.,Za pregled zapisnika lojalnih bodova dodijeljenih kupcu.,
To {0},Za {0},
To {0} | {1} {2},Za {0} | {1} {2},
Toggle Filters,Uključi filtre,
Too many columns. Export the report and print it using a spreadsheet application.,Previše stupovi. Izvesti izvješće i ispisati pomoću aplikacije za proračunske tablice.,
Tools,Alati,
Total (Credit),Ukupno (Credit),
Total (Without Tax),Ukupno (bez poreza),
Total Achieved,Ukupno Ostvareno,
Total Actual,Ukupno Stvarni,
Total Allocated Leaves,Ukupno dopuštena lišća,
Total Amount,Ukupan iznos,
Total Amount Credited,Ukupan iznos je odobren,
Total Applicable Charges in Purchase Receipt Items table must be same as Total Taxes and Charges,Ukupno odgovarajuće naknade u potvrdi o kupnji stavke stolu mora biti ista kao i Total poreza i naknada,
Total Budget,Ukupni proračun,
Total Collected: {0},Ukupno prikupljeno: {0},
Total Commission,Ukupno komisija,
Total Contribution Amount: {0},Iznos ukupnog iznosa doprinosa: {0},
Total Credit/ Debit Amount should be same as linked Journal Entry,Ukupni iznos kredita / debitnog iznosa mora biti isti kao i povezani unos dnevnika,
Total Debit must be equal to Total Credit. The difference is {0},Ukupno zaduženje mora biti jednak ukupnom kreditnom .,
Total Invoiced Amount,Ukupno Iznos dostavnice,
Total Order Considered,Ukupno Naručite Smatra,
Total Order Value,Ukupna vrijednost narudžbe,
Total Outgoing,Ukupno odlazni,
Total Outstanding,Ukupno izvanredno,
Total Outstanding Amount,Ukupni iznos,
Total Outstanding: {0},Ukupno izvrsno: {0},
Total Paid Amount,Ukupno uplaćeni iznos,
Total Payment Amount in Payment Schedule must be equal to Grand / Rounded Total,Ukupni iznos plaćanja u rasporedu plaćanja mora biti jednak Grand / Rounded Total,
Total Payments,Ukupna plaćanja,
Total Qty,Ukupna količina,
Total Quantity,Ukupna količina,
Total Revenue,Ukupni prihodi,
Total Student,Ukupno učenika,
Total Target,Ukupno Target,
Total Tax,Ukupno porez,
Total Taxable Amount,Ukupni iznos oporezive,
Total Taxable Value,Ukupna oporeziva vrijednost,
Total Unpaid: {0},Ukupno Neplaćeni: {0},
Total Variance,Ukupne varijance,
Total Weightage of all Assessment Criteria must be 100%,Ukupno weightage svih kriterija za ocjenjivanje mora biti 100%,
Total advance ({0}) against Order {1} cannot be greater than the Grand Total ({2}),Ukupno unaprijed ({0}) protiv Red {1} ne može biti veći od sveukupnog ({2}),
Total advance amount cannot be greater than total claimed amount,Ukupni iznos predujma ne može biti veći od ukupnog iznosa potraživanja,
Total allocated leaves are more days than maximum allocation of {0} leave type for employee {1} in the period,Ukupni dodijeljeni listovi su više dana od maksimalne raspodjele {0} vrste dopusta za zaposlenika {1} u razdoblju,
Total allocated leaves are more than days in the period,Ukupno dodijeljeni Listovi su više od dana u razdoblju,
Total allocated percentage for sales team should be 100,Ukupno dodijeljeno postotak za prodajni tim bi trebao biti 100,
Total cannot be zero,Ukupna ne može biti nula,
Total contribution percentage should be equal to 100,Ukupni postotak doprinosa trebao bi biti jednak 100,
Total hours: {0},Ukupno vrijeme: {0},
Total {0} ({1}),Ukupno {0} ({1}),
"Total {0} for all items is zero, may be you should change 'Distribute Charges Based On'","Ukupno {0} za sve stavke nula, možda biste trebali promijeniti &#39;Podijeliti optužbi na temelju&#39;",
Total(Amt),Ukupno (AMT),
Total(Qty),Ukupno (Kol),
Traceability,sljedivost,
Track Leads by Lead Source.,Prati vodio izvorom olova.,
Transaction,Transakcija,
Transaction Date,Transakcija Datum,
Transaction Type,vrsta transakcije,
Transaction currency must be same as Payment Gateway currency,Transakcija valute mora biti isti kao i Payment Gateway valute,
Transaction not allowed against stopped Work Order {0},Transakcija nije dopuštena protiv zaustavljene radne narudžbe {0},
Transaction reference no {0} dated {1},Transakcija referenca ne {0} datumom {1},
Transactions,Transakcije,
Transactions can only be deleted by the creator of the Company,Transakcije se mogu samo izbrisana od tvorca Društva,
Transfer,Prijenos,
Transfer Material,Prijenos materijala,
Transfer Type,Vrsta prijenosa,
Transfer an asset from one warehouse to another,Prijenos imovine s jednog skladišta na drugo,
Transfered,prenose,
Transferred Quantity,Prenesena količina,
Transport Receipt Date,Datum prijema prijevoza,
Transport Receipt No,Prijevoz br,
Transportation,promet,
Transporter ID,ID transportera,
Transporter Name,Transporter Ime,
Travel Expenses,Putni troškovi,
Tree Type,Tree Type,
Tree of Bill of Materials,Drvo Bill materijala,
Tree of Item Groups.,Stablo grupe proizvoda.,
Tree of Procedures,Stablo postupaka,
Tree of Quality Procedures.,Stablo postupaka kvalitete.,
Tree of financial Cost Centers.,Drvo centara financijski trošak.,
Tree of financial accounts.,Drvo financijske račune.,
Treshold {0}% appears more than once,Prag {0}% se pojavljuje više od jednom,
Trial Period End Date Cannot be before Trial Period Start Date,Datum završetka probnog razdoblja Ne može biti prije datuma početka probnog razdoblja,
Trialling,trialling,
Type of Business,Vrsta poslovanja,
Types of activities for Time Logs,Vrste aktivnosti za vrijeme Evidencije,
UOM,UOM,
UOM Conversion factor is required in row {0},Faktor UOM pretvorbe je potrebno u redu {0},
UOM coversion factor required for UOM: {0} in Item: {1},UOM faktor coversion potrebna za UOM: {0} u točki: {1},
URL,URL,
Unable to find exchange rate for {0} to {1} for key date {2}. Please create a Currency Exchange record manually,Nije moguće pronaći kurs za {0} do {1} za ključni datum {2}. Ručno stvorite zapis za mjenjačnicu,
Unable to find score starting at {0}. You need to have standing scores covering 0 to 100,Nije moguće pronaći rezultat koji započinje na {0}. Morate imati postignute rezultate koji pokrivaju 0 do 100,
Unable to find variable: ,Nije moguće pronaći varijablu:,
Unblock Invoice,Deblokiraj fakturu,
Uncheck all,Poništite sve,
Unclosed Fiscal Years Profit / Loss (Credit),Nezatvorena Fiskalna godina Dobit / gubitak (Credit),
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,
Unknown,nepoznat,
Unpaid,neplaćen,
Unsecured Loans,unsecured krediti,
Unsubscribe from this Email Digest,Odjaviti s ovog Pošalji Digest,
Unsubscribed,Pretplatu,
Until,Do,
Unverified Webhook Data,Neprovjereni podaci webhook podataka,
Update Account Name / Number,Ažuriranje naziva / broja računa,
Update Account Number / Name,Ažuriranje broja i naziva računa,
Update Cost,Update cost,
Update Items,Ažuriraj stavke,
Update Print Format,Ažuriranje Format ispisa,
Update bank payment dates with journals.,Update banka datum plaćanja s časopisima.,
Update in progress. It might take a while.,Ažuriranje je u tijeku. Može potrajati neko vrijeme.,
Update rate as per last purchase,Stopa ažuriranja po zadnjoj kupnji,
Update stock must be enable for the purchase invoice {0},Ažuriranje zaliha mora biti omogućeno za fakturu kupnje {0},
Updating Variants...,Ažuriranje varijanti ...,
Upload your letter head and logo. (you can edit them later).,Upload Vaše pismo glavu i logotip. (Možete ih uređivati kasnije).,
Upper Income,Gornja Prihodi,
Use Sandbox,Sandbox,
Used Leaves,Koristi lišće,
User,Korisnik,
User ID,Korisnički ID,
User ID not set for Employee {0},Korisnik ID nije postavljen za zaposlenika {0},
User Remark,Upute Zabilješka,
User has not applied rule on the invoice {0},Korisnik nije primijenio pravilo na računu {0},
User {0} already exists,Korisnik {0} već postoji,
User {0} created,Korisnik {0} je stvoren,
User {0} does not exist,Korisnik {0} ne postoji,
User {0} doesn't have any default POS Profile. Check Default at Row {1} for this User.,Korisnik {0} nema zadani POS profil. Provjerite zadani redak {1} za ovog korisnika.,
User {0} is already assigned to Employee {1},Korisnik {0} već dodijeljena zaposlenika {1},
User {0} is already assigned to Healthcare Practitioner {1},Korisnik {0} već je dodijeljen zdravstvenoj praksi {1},
Users,Korisnici,
Utility Expenses,komunalna Troškovi,
Valid From Date must be lesser than Valid Upto Date.,Vrijedi od datuma mora biti manji od Valid Upto Date.,
Valid Till,Vrijedi do,
Valid from and valid upto fields are mandatory for the cumulative,Vrijedna od i valjana upto polja obavezna su za kumulativ,
Valid from date must be less than valid upto date,Vrijedi od datuma mora biti manje od važećeg do datuma,
Valid till date cannot be before transaction date,Vrijednost do datuma ne može biti prije datuma transakcije,
Validity,Valjanost,
Validity period of this quotation has ended.,Rok valjanosti ove ponude je završen.,
Valuation Rate,Stopa vrednovanja,
Valuation Rate is mandatory if Opening Stock entered,Vrednovanje stopa je obavezno ako Otvaranje Stock ušao,
Valuation type charges can not marked as Inclusive,Troškovi tipa Vrednovanje se ne može označiti kao Inclusive,
Value Or Qty,"Vrijednost, ili Kol",
Value Proposition,Vrijednost propozicija,
Value for Attribute {0} must be within the range of {1} to {2} in the increments of {3} for Item {4},Vrijednost za atribut {0} mora biti unutar raspona od {1} {2} u koracima od {3} za točku {4},
Value must be between {0} and {1},Vrijednost mora biti između {0} i {1},
"Values of exempt, nil rated and non-GST inward supplies","Vrijednosti izuzetih, nultih bodova i unutarnjih isporuka bez GST-a",
Variance,varijacija,
Variance ({}),Varijanca ({}),
Variant,Varijanta,
Variant Attributes,Varijante Značajke,
Variant Based On cannot be changed,Varijanta na temelju temelji se ne može promijeniti,
Variant Details Report,Izvješće o pojedinostima o varijacijama,
Variant creation has been queued.,Izrada inačice je u redu čekanja.,
Vehicle Expenses,Troškovi vozila,
Vehicle No,Ne vozila,
Vehicle Type,tip vozila,
Vehicle/Bus Number,Broj vozila / autobusa,
Venture Capital,Venture Capital,
View Chart of Accounts,Prikaz sheme računa,
View Fees Records,Prikaz zapisa o naknadama,
View Form,Pogledajte obrazac,
View Lab Tests,Pogledajte laboratorijske testove,
View Leads,Pogledaj vodi,
View Ledger,Pogledaj Ledger,
View Now,Pogledaj sada,
View a list of all the help videos,Pregled popisa svih pomoć videa,
View in Cart,Pogledaj u košaricu,
Visit report for maintenance call.,Pogledajte izvješće razgovora vezanih uz održavanje.,
Visit the forums,Posjetite forume,
Vital Signs,Vitalni znakovi,
Volunteer,dobrovoljac,
Volunteer Type information.,Informacije o volonteru.,
Volunteer information.,Dobrovoljne informacije.,
Voucher #,bon #,
Voucher No,Bon Ne,
Voucher Type,Bon Tip,
WIP Warehouse,WIP skladište,
Warehouse can not be deleted as stock ledger entry exists for this warehouse.,Skladište se ne može izbrisati dok postoje upisi u glavnu knjigu za ovo skladište.,
Warehouse cannot be changed for Serial No.,Skladište se ne može promijeniti za serijskog broja,
Warehouse is mandatory,Skladište je obavezno,
Warehouse is mandatory for stock Item {0} in row {1},Skladište je obvezno za skladišne proizvode {0} u redu {1},
Warehouse not found in the system,Skladište nije pronađeno u sustavu,
"Warehouse required at Row No {0}, please set default warehouse for the item {1} for the company {2}","Skladište je potrebno za redak br. {0}, postavite zadano skladište za stavku {1} za tvrtku {2}",
Warehouse required for stock Item {0},Skladište je potrebno za skladišne proizvode {0},
Warehouse {0} can not be deleted as quantity exists for Item {1},Skladište {0} ne može biti izbrisano ako na njemu ima proizvod {1},
Warehouse {0} does not belong to company {1},Skladište {0} ne pripada tvrtki {1},
Warehouse {0} does not exist,Skladište {0} ne postoji,
"Warehouse {0} is not linked to any account, please mention the account in  the warehouse record or set default inventory account in company {1}.","Skladište {0} nije povezano s bilo kojim računom, navedite račun u skladištu ili postavite zadani račun zaliha u tvrtki {1}.",
Warehouses with child nodes cannot be converted to ledger,Skladišta s djetetom čvorovi se ne može pretvoriti u glavnoj knjizi,
Warehouses with existing transaction can not be converted to group.,Skladišta s postojećim transakcije se ne može pretvoriti u skupinu.,
Warehouses with existing transaction can not be converted to ledger.,Skladišta s postojećim transakcije ne može pretvoriti u knjigu.,
Warning,Upozorenje,
Warning: Another {0} # {1} exists against stock entry {2},Upozorenje: Još {0} # {1} postoji protiv ulaska dionicama {2},
Warning: Invalid SSL certificate on attachment {0},Upozorenje: Invalid SSL potvrda o vezanosti {0},
Warning: Invalid attachment {0},Upozorenje: Invalid Prilog {0},
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 Customer's Purchase Order {1},Upozorenje: Prodaja Naručite {0} već postoji protiv Kupca narudžbenice {1},
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,garancija,
Warranty Claim,Jamstvo Zatraži,
Warranty Claim against Serial No.,Jamstvo tužbu protiv Serial No.,
Website,Web stranica,
Website Image should be a public file or website URL,Web slika bi trebala biti javna datoteke ili URL web stranice,
Website Image {0} attached to Item {1} cannot be found,Web stranica slike {0} prilogu točki {1} Ne mogu naći,
Website Manager,Web Manager,
Website Settings,Postavke web stranice,
Wednesday,Srijeda,
Week,Tjedan,
Weekly,Tjedni,
"Weight is mentioned,\nPlease mention ""Weight UOM"" too","Težina se spomenuto, \n Molimo spomenuti ""težinu UOM"" previše",
Welcome email sent,Poslao Dobrodošli e-mail,
Welcome to ERPNext,Dobrodošli u ERPNext,
What do you need help with?,Što vam je potrebna pomoć?,
What does it do?,Što učiniti ?,
Where manufacturing operations are carried.,Gdje se odvija proizvodni postupci.,
White,bijela,
Wire Transfer,Wire Transfer,
WooCommerce Products,WooCommerce proizvodi,
Work In Progress,Radovi u tijeku,
Work Order,Radni nalog,
Work Order already created for all items with BOM,Radni nalog već stvoren za sve stavke s BOM-om,
Work Order cannot be raised against a Item Template,Radni nalog ne može se podići na predložak stavke,
Work Order has been {0},Radni nalog je bio {0},
Work Order not created,Radni nalog nije izrađen,
Work Order {0} must be cancelled before cancelling this Sales Order,Radni nalog {0} mora biti otkazan prije otkazivanja ovog prodajnog naloga,
Work Order {0} must be submitted,Mora se poslati radni nalog {0},
Work Orders Created: {0},Kreirani radni nalozi: {0},
Work-in-Progress Warehouse is required before Submit,Rad u tijeku Warehouse je potrebno prije Podnijeti,
Working,Radni,
Working Hours,Radnih sati,
Workstation,Radna stanica,
Workstation is closed on the following dates as per Holiday List: {0},Radna stanica je zatvorena na sljedeće datume po Holiday Popis: {0},
Wrapping up,Završavati,
Wrong Password,Pogrešna lozinka,
Year start date or end date is overlapping with {0}. To avoid please set company,Godina datum početka ili završetka je preklapanje s {0}. Da bi se izbjegla postavite tvrtku,
You are not authorized to add or update entries before {0},Niste ovlašteni dodavati ili ažurirati unose prije {0},
You are not authorized to set Frozen value,Niste ovlašteni za postavljanje zamrznute vrijednosti,
You can not change rate if BOM mentioned agianst any item,Ne možete promijeniti cijenu ako je sastavnica spomenuta u bilo kojem proizvodu,
You can not enter current voucher in 'Against Journal Entry' column,Ne možete unijeti trenutni nalog u stupac 'u odnosu na temeljnicu',
You can only have Plans with the same billing cycle in a Subscription,U Pretplati možete imati samo planove s istim ciklusom naplate,
You can only redeem max {0} points in this order.,U tom redoslijedu možete iskoristiti najviše {0} bodova.,
You can only renew if your membership expires within 30 days,Možete obnoviti pretplatu samo ako vaše članstvo istekne u roku od 30 dana,
You can only select a maximum of one option from the list of check boxes.,Na popisu potvrdnih okvira možete odabrati najviše jednu opciju.,
You can't redeem Loyalty Points having more value than the Grand Total.,Ne možete iskoristiti bodove lojalnosti koji imaju više vrijednosti od ukupnog iznosa.,
You cannot credit and debit same account at the same time,Ne možete istovremeno kreditirati i debitirati isti račun,
You cannot delete Fiscal Year {0}. Fiscal Year {0} is set as default in Global Settings,Ne možete izbrisati Fiskalnu godinu {0}. Fiskalna godina {0} je postavljena kao zadana u Globalnim postavkama,
You cannot delete Project Type 'External',Ne možete izbrisati vrstu projekta &#39;Vanjski&#39;,
You cannot edit root node.,Ne možete uređivati root čvor.,
You cannot restart a Subscription that is not cancelled.,Ne možete ponovo pokrenuti pretplatu koja nije otkazana.,
You don't have enough Loyalty Points to redeem,Nemate dovoljno bodova lojalnosti za otkup,
You have already assessed for the assessment criteria {}.,Već ste ocijenili kriterije procjene {}.,
You have already selected items from {0} {1},Već ste odabrali stavke iz {0} {1},
You have been invited to collaborate on the project: {0},Pozvani ste za suradnju na projektu: {0},
You have entered duplicate items. Please rectify and try again.,Unijeli ste dupli proizvod. Ispravite i pokušajte ponovno.,
You need to be a user other than Administrator with System Manager and Item Manager roles to register on Marketplace.,Morate biti korisnik koji nije administrator s ulogama upravitelja sustava i upravitelja stavki da biste se registrirali na tržištu.,
You need to be a user with System Manager and Item Manager roles to add users to Marketplace.,Morate biti korisnik s ulogama upravitelja sustava i upravitelja stavki kako biste korisnike dodali na tržište.,
You need to be a user with System Manager and Item Manager roles to register on Marketplace.,Morate biti korisnik s ulogama upravitelja sustava i upravitelja stavki da biste se registrirali na tržištu.,
You need to enable Shopping Cart,Morate omogućiti košaricu,
You will lose records of previously generated invoices. Are you sure you want to restart this subscription?,Izgubit ćete evidenciju prethodno generiranih faktura. Jeste li sigurni da želite ponovno pokrenuti ovu pretplatu?,
Your Organization,Vaša organizacija,
Your cart is Empty,Vaša je košarica prazna,
Your email address...,Vaša email adresa...,
Your order is out for delivery!,Vaša je narudžba izvan isporuke!,
Your tickets,Vaše ulaznice,
ZIP Code,Poštanski broj,
[Error],[Greška],
[{0}](#Form/Item/{0}) is out of stock,[{0}] (# Obrazac / Artikl / {0}) nema na skladištu,
`Freeze Stocks Older Than` should be smaller than %d days.,` Zamrzni Zalihe starije od ` bi trebao biti manji od % d dana .,
based_on,based_on,
cannot be greater than 100,ne može biti veće od 100,
disabled user,onemogućen korisnika,
"e.g. ""Build tools for builders""","na primjer ""Alati za graditelje""",
"e.g. ""Primary School"" or ""University""",npr &quot;Osnovna škola&quot; ili &quot;Sveučilište&quot;,
"e.g. Bank, Cash, Credit Card","npr. banka, gotovina, kreditne kartice",
hidden,skriven,
modified,promijenjen,
old_parent,old_parent,
on,na,
{0} '{1}' is disabled,{0} '{1}' je onemogućen,
{0} '{1}' not in Fiscal Year {2},{0} '{1}' nije u fiskalnoj godini {2},
{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0} ({1}) ne može biti veći od planirane količine ({2}) u Radnoj nalogu {3},
{0} - {1} is inactive student,{0} - {1} je neaktivan učenik,
{0} - {1} is not enrolled in the Batch {2},{0} - {1} nije upisana u skupinu {2},
{0} - {1} is not enrolled in the Course {2},{0} - {1} nije upisana u tečaj {2},
{0} Budget for Account {1} against {2} {3} is {4}. It will exceed by {5},{0} Proračun za račun {1} od {2} {3} je {4}. To će biti veći od {5},
{0} Digest,{0} Digest,
{0} Request for {1},{0} Zahtjev za {1},
{0} Result submittted,{0} Rezultat poslan,
{0} Serial Numbers required for Item {1}. You have provided {2}.,{0} serijski brojevi potrebni za Artikl {1}. Ti su dali {2}.,
{0} Student Groups created.,Stvorena je {0} studentska grupa.,
{0} Students have been enrolled,{0} Učenici su upisani,
{0} against Bill {1} dated {2},{0} u odnosu na račun {1} s datumom {2},
{0} against Purchase Order {1},{0} u odnosu na narudžbu {1},
{0} against Sales Invoice {1},{0} u odnosu na prodajnom računu {1},
{0} against Sales Order {1},{0} u odnosu na prodajni nalog {1},
{0} asset cannot be transferred,{0} imovina se ne može se prenijeti,
{0} can not be negative,{0} ne može biti negativna,
{0} created,{0} stvorio,
"{0} currently has a {1} Supplier Scorecard standing, and Purchase Orders to this supplier should be issued with caution.","{0} trenutačno ima status dobavljača {1}, a narudžbenice za ovog dobavljača trebaju biti izdane s oprezom.",
"{0} currently has a {1} Supplier Scorecard standing, and RFQs to this supplier should be issued with caution.","{0} trenutačno ima stajalište dobavljača rezultata {1}, a zahtjevi za odobrenje dobavljaču trebaju biti izdani s oprezom.",
{0} does not belong to Company {1},{0} ne pripada Društvu {1},
{0} does not have a Healthcare Practitioner Schedule. Add it in Healthcare Practitioner master,{0} nema raspored zdravstvenih radnika. Dodajte ga u majstor zdravstvene prakse,
{0} entered twice in Item Tax,{0} dva puta ušao u točki poreza,
{0} for {1},{0} od {1},
{0} has been submitted successfully,{0} uspješno je poslan,
{0} has fee validity till {1},{0} ima valjanost do {1},
{0} hours,{0} sata,
{0} in row {1},{0} u retku {1},
{0} is blocked so this transaction cannot proceed,{0} blokiran je tako da se ova transakcija ne može nastaviti,
{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} nije skladišni proizvod,
{0} is not a valid Batch Number for Item {1},{0} nije ispravan broj serije za točku {1},
{0} is not added in the table,{0} nije dodan u tablici,
{0} is now the default Fiscal Year. Please refresh your browser for the change to take effect.,{0} je sada zadana fiskalna godina. Osvježi preglednik kako bi se promjene aktualizirale.,
{0} is on hold till {1},{0} je na čekanju do {1},
{0} item found.,{0} predmet je pronađen.,
{0} items found.,{0} pronađenih predmeta.,
{0} items in progress,{0} stavke u tijeku,
{0} items produced,{0} predmeti koji,
{0} must appear only once,{0} mora pojaviti samo jednom,
{0} must be negative in return document,{0} mora biti negativan u povratnom dokumentu,
{0} not allowed to transact with {1}. Please change the Company.,{0} nije dopušteno izvršiti transakciju s {1}. Promijenite tvrtku.,
{0} not found for item {1},{0} nije pronađen za stavku {1},
{0} parameter is invalid,Parametar {0} nije važeći,
{0} payment entries can not be filtered by {1},{0} unosa plaćanja ne može se filtrirati po {1},
{0} should be a value between 0 and 100,{0} mora biti vrijednost između 0 i 100,
{0} units of [{1}](#Form/Item/{1}) found in [{2}](#Form/Warehouse/{2}),{0} jedinica [{1}] (# Form / Artikl / {1}) naći u [{2}] (# Form / Skladište / {2}),
{0} units of {1} needed in {2} on {3} {4} for {5} to complete this transaction.,{0} jedinica {1} potrebna u {2} na {3} {4} od {5} za dovršetak ovu transakciju.,
{0} units of {1} needed in {2} to complete this transaction.,{0} jedinica {1} potrebna u {2} za dovršetak ovu transakciju.,
{0} valid serial nos for Item {1},{0} valjani serijski nos za Stavka {1},
{0} variants created.,Stvorene su varijante {0}.,
{0} {1} created,{0} {1} stvorio,
{0} {1} does not exist,{0} {1} ne postoji,
{0} {1} has been modified. Please refresh.,{0} {1} je izmijenjen. Osvježi stranicu.,
{0} {1} has not been submitted so the action cannot be completed,{0} {1} nije poslano tako da se radnja ne može dovršiti,
"{0} {1} is associated with {2}, but Party Account is {3}","{0} {1} povezan je s {2}, ali račun stranke je {3}",
{0} {1} is cancelled or closed,{0} {1} je otkazan ili zatvoren,
{0} {1} is cancelled or stopped,{0} {1} otkazan ili zaustavljen,
{0} {1} is cancelled so the action cannot be completed,{0} {1} je otkazana pa se radnja ne može dovršiti,
{0} {1} is closed,{0} {1} je zatvorena,
{0} {1} is disabled,{0} {1} je onemogućen,
{0} {1} is frozen,{0} {1} je zamrznuta,
{0} {1} is fully billed,{0} {1} je naplaćen u cijelosti,
{0} {1} is not active,{0} {1} nije aktivan,
{0} {1} is not associated with {2} {3},{0} {1} nije povezan s {2} {3},
{0} {1} is not present in the parent company,{0} {1} nije prisutno u matičnoj tvrtki,
{0} {1} is not submitted,{0} {1} nije podnesen,
{0} {1} is {2},{0} {1} je {2},
{0} {1} must be submitted,{0} {1} mora biti podnesen,
{0} {1} not in any active Fiscal Year.,{0} {1} nije u nijednoj fiskalnoj godini.,
{0} {1} status is {2},{0} {1} status je {2},
{0} {1}: 'Profit and Loss' type account {2} not allowed in Opening Entry,{0} {1}: Tip računa 'Dobit i gubitak'  {2} nije dopušten u Početnom Unosu,
{0} {1}: Account {2} does not belong to Company {3},{0} {1}: Račun {2} ne pripada Društvu {3},
{0} {1}: Account {2} is inactive,{0} {1}: Račun {2} nije aktivan,
{0} {1}: Accounting Entry for {2} can only be made in currency: {3},{0} {1}: knjiženje za {2} je moguće izvesti samo u valuti: {3},
{0} {1}: Cost Center is mandatory for Item {2},{0} {1}: Mjesto troška je ovezno za stavku {2},
{0} {1}: Cost Center is required for 'Profit and Loss' account {2}. Please set up a default Cost Center for the Company.,{0} {1}: Troškovno mjesto potrebno je za račun dobiti i gubitka {2}. Molimo postaviti zadano mjesto troška.,
{0} {1}: Cost Center {2} does not belong to Company {3},{0} {1}: Troškovno mjesto {2} ne pripada Društvu {3},
{0} {1}: Customer is required against Receivable account {2},{0} {1}: potrebna je Kupac protiv Potraživanja računa {2},
{0} {1}: Either debit or credit amount is required for {2},{0} {1}: Iznos potraživanja ili dugovanja potreban za {2},
{0} {1}: Supplier is required against Payable account {2},{0} {1}: potreban Dobavljač u odnosu na plativi račun{2},
{0}% Billed,{0}% Naplaćeno,
{0}% Delivered,{0}% Isporučeno,
{0}: From {1},{0}: od {1},
{0}: {1} does not exists,{0}: {1} Ne radi postoji,
{0}: {1} not found in Invoice Details table,{0}: {1} nije pronađen u Pojedinosti dostavnice stolu,
{} of {},{} od {},
Assigned To,Dodijeljeno,
Chat,Razgovor,
Completed By,Završio,
Day of Week,Dan u tjednu,
"Dear System Manager,","Dragi System Manager,",
Default Value,Zadana vrijednost,
Email Group,E-mail Group,
Email Settings,Postavke e-pošte,
Email not sent to {0} (unsubscribed / disabled),E-mail nije poslan {0} (neprijavljen ili ugašen račun),
Error Message,Poruka o pogrešci,
Fieldtype,Fieldtype,
Help Articles,Članci pomoći,
ID,ID,
Import,Uvoz,
Language,Jezik,
Likes,Voli,
Merge with existing,Spoji sa postojećim,
Orientation,Orijentacija,
Parent,Nadređen,
Payment Failed,Plaćanje nije uspjelo,
Personal,Osobno,
Post,poslije,
Postal Code,poštanski broj,
Provider,davatelj,
Read Only,Read Only,
Recipient,Primalac,
Reviews,Recenzije,
Sender,Pošiljalac,
There were errors while sending email. Please try again.,Bilo je grešaka tijekom slanja e-pošte. Molimo pokušajte ponovno .,
Values Changed,Vrijednosti promjene,
or,ili,
Ageing Range 4,Raspon starenja 4,
Allocated amount cannot be greater than unadjusted amount,Dodijeljeni iznos ne može biti veći od neprilagođenog iznosa,
Allocated amount cannot be negative,Dodijeljeni iznos ne može biti negativan,
"Difference Account must be a Asset/Liability type account, since this Stock Entry is an Opening Entry","Račun razlike mora biti račun vrste imovine / odgovornosti, jer je ovaj unos dionica uvodni unos",
Import Successful,Uvoz je uspješan,
Please save first,Prvo spremite,
Price not found for item {0} in price list {1},Cijena nije pronađena za artikl {0} u cjeniku {1},
Warehouse Type,Vrsta skladišta,
'Date' is required,Obavezan je datum,
Budgets,proračuni,
Bundle Qty,Količina paketa,
Company GSTIN,Tvrtka GSTIN,
Company field is required,Polje tvrtke je obavezno,
Creating Dimensions...,Izrada dimenzija ...,
Duplicate entry against the item code {0} and manufacturer {1},Duplikat unosa sa šifrom artikla {0} i proizvođačem {1},
Invalid GSTIN! The input you've entered doesn't match the GSTIN format for UIN Holders or Non-Resident OIDAR Service Providers,Nevažeći GSTIN! Uneseni unos ne odgovara formatu GSTIN za vlasnike UIN-a ili nerezidentne davatelje usluga OIDAR-a,
Invoice Grand Total,Faktura ukupno,
Last carbon check date cannot be a future date,Posljednji datum provjere ugljika ne može biti budući datum,
Make Stock Entry,Unesite zalihe,
Quality Feedback,Povratne informacije o kvaliteti,
Quality Feedback Template,Predložak povratne informacije o kvaliteti,
Rules for applying different promotional schemes.,Pravila za primjenu različitih promotivnih shema.,
Show {0},Prikaži {0},
Target Details,Pojedinosti cilja,
{0} already has a Parent Procedure {1}.,{0} već ima roditeljski postupak {1}.,
API,API,
Annual,godišnji,
Change,Promjena,
Contact Email,Kontakt email,
From Date,Od datuma,
Group By,Grupiranje prema,
Invalid URL,Neispravan URL,
Landscape,pejzaž,
Naming Series,Imenovanje serije,
No data to export,Nema podataka za izvoz,
Portrait,Portret,
Print Heading,Ispis naslova,
Scheduler Inactive,Planer neaktivan,
Scheduler is inactive. Cannot import data.,Planer je neaktivan. Nije moguće uvesti podatke.,
Show Document,Prikaži dokument,
Show Traceback,Prikaži Traceback,
Video,Video,
% Of Grand Total,% Od ukupnog broja,
<b>Company</b> is a mandatory filter.,<b>Tvrtka</b> je obvezan filtar.,
<b>From Date</b> is a mandatory filter.,<b>From Date</b> je obavezan filtar.,
<b>From Time</b> cannot be later than <b>To Time</b> for {0},<b>{Time} od vremena</b> ne može biti kasnije od <b>To ~ a</b> {0},
<b>To Date</b> is a mandatory filter.,<b>Do danas</b> je obvezan filtar.,
A new appointment has been created for you with {0},Za vas je stvoren novi sastanak s uslugom {0},
Account Value,Vrijednost računa,
Account is mandatory to get payment entries,Račun je obvezan za unos plaćanja,
Account is not set for the dashboard chart {0},Račun nije postavljen za grafikon na nadzornoj ploči {0},
Account {0} does not exists in the dashboard chart {1},Račun {0} ne postoji na grafikonu nadzorne ploče {1},
Account: <b>{0}</b> is capital Work in progress and can not be updated by Journal Entry,Račun: <b>{0}</b> je kapital U tijeku je rad i ne može ga ažurirati Entry Journal,
Account: {0} is not permitted under Payment Entry,Račun: {0} nije dopušten unosom plaćanja,
Accounting Dimension <b>{0}</b> is required for 'Balance Sheet' account {1}.,Za račun &quot;Bilans stanja&quot; {1} potrebna je knjigovodstvena dimenzija <b>{0</b> }.,
Accounting Dimension <b>{0}</b> is required for 'Profit and Loss' account {1}.,Za račun &quot;Dobit i gubitak&quot; {1} potrebna je knjigovodstvena dimenzija <b>{0</b> }.,
Accounting Masters,Majstori računovodstva,
Accounting Period overlaps with {0},Računovodstveno razdoblje se preklapa s {0},
Activity,Aktivnost,
Add / Manage Email Accounts.,Dodaj / uredi email račun.,
Add Child,Dodaj dijete,
Add Multiple,Dodaj više stavki,
Add Participants,Dodaj sudionike,
Add to Featured Item,Dodajte u istaknuti predmet,
Add your review,Dodajte svoju recenziju,
Add/Edit Coupon Conditions,Dodavanje / uređivanje uvjeta kupona,
Added to Featured Items,Dodano u istaknute stavke,
Added {0} ({1}),Dodano {0} ({1}),
Address Line 1,Adresa - linija 1,
Addresses,Adrese,
Admission End Date should be greater than Admission Start Date.,Datum završetka prijema trebao bi biti veći od datuma početka upisa.,
All,svi,
All bank transactions have been created,Sve su bankovne transakcije stvorene,
All the depreciations has been booked,Sve su amortizacije knjižene,
Allow Resetting Service Level Agreement from Support Settings.,Dopusti resetiranje sporazuma o razini usluge iz postavki podrške.,
Amount of {0} is required for Loan closure,Za zatvaranje zajma potreban je iznos {0},
Applied Coupon Code,Primijenjeni kod kupona,
Apply Coupon Code,Primijenite kod kupona,
Appointment Booking,Rezervacija termina,
"As there are existing transactions against item {0}, you can not change the value of {1}","Kao što postoje neki poslovi protiv točki {0}, ne možete promijeniti vrijednost {1}",
Asset Id,Id sredstva,
Asset Value,Vrijednost imovine,
Asset Value Adjustment cannot be posted before Asset's purchase date <b>{0}</b>.,Podešavanje vrijednosti imovine ne može se objaviti prije datuma kupnje imovine <b>{0}</b> .,
Asset {0} does not belongs to the custodian {1},Imovina {0} ne pripada staratelju {1},
Asset {0} does not belongs to the location {1},Imovina {0} ne pripada lokaciji {1},
At least one of the Applicable Modules should be selected,Treba odabrati barem jedan od primjenjivih modula,
Atleast one asset has to be selected.,Treba odabrati najmanje jedan iznos.,
Authentication Failed,Provjera autentičnosti nije uspjela,
Automatic Reconciliation,Automatsko pomirenje,
Available For Use Date,Datum upotrebe,
Available Stock,Dostupne zalihe,
"Available quantity is {0}, you need {1}","Dostupna količina je {0}, treba vam {1}",
BOM 1,BOM 1,
BOM 2,BOM 2,
BOM Comparison Tool,Alat za usporedbu BOM-a,
BOM recursion: {0} cannot be child of {1},BOM rekurzija: {0} ne može biti dijete od {1},
BOM recursion: {0} cannot be parent or child of {1},BOM rekurzija: {0} ne može biti roditelj ili dijete od {1},
Back to Messages,Natrag na poruke,
Bank Data mapper doesn't exist,Karti za bankovne podatke ne postoje,
Bank Details,Bankovni detalji,
Bank account '{0}' has been synchronized,Bankovni račun &quot;{0}&quot; sinkroniziran je,
Bank account {0} already exists and could not be created again,Bankovni račun {0} već postoji i ne može ga se ponovo stvoriti,
Bank accounts added,Dodani su bankovni računi,
Batch no is required for batched item {0},Za serijsku stavku nije potreban broj serije {0},
Billing Date,Datum naplate,
Billing Interval Count cannot be less than 1,Interval naplate ne može biti manji od 1,
Blue,Plava,
Book,Knjiga,
Book Appointment,Sređivanje knjige,
Brand,Brend,
Browse,Pretraži,
Call Connected,Poziv je povezan,
Call Disconnected,Poziv prekinuti,
Call Missed,Poziv propušten,
Call Summary,Sažetak poziva,
Call Summary Saved,Sažetak poziva je spremljen,
Cancelled,OTKAZANO,
Cannot Calculate Arrival Time as Driver Address is Missing.,Ne mogu izračunati vrijeme dolaska jer nedostaje adresa vozača.,
Cannot Optimize Route as Driver Address is Missing.,Ruta se ne može optimizirati jer nedostaje adresa vozača.,
Cannot complete task {0} as its dependant task {1} are not ccompleted / cancelled.,Ne mogu dovršiti zadatak {0} jer njegov ovisni zadatak {1} nije dovršen / otkazan.,
Cannot find a matching Item. Please select some other value for {0}.,Ne možete pronaći odgovarajući stavku. Odaberite neku drugu vrijednost za {0}.,
"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set allowance in Accounts Settings","Nije moguće preplatiti za stavku {0} u retku {1} više od {2}. Da biste omogućili prekomjerno naplaćivanje, molimo postavite dodatak u Postavkama računa",
"Capacity Planning Error, planned start time can not be same as end time","Pogreška planiranja kapaciteta, planirano vrijeme početka ne može biti isto vrijeme završetka",
Categories,Kategorije,
Changes in {0},Promjene u {0},
Chart,Grafikon,
Choose a corresponding payment,Odaberite odgovarajuće plaćanje,
Click on the link below to verify your email and confirm the appointment,Kliknite donju vezu kako biste potvrdili svoju e-poštu i potvrdili sastanak,
Close,Zatvoriti,
Communication,Mail,
Compact Item Print,Kompaktni Stavka Print,
Company,Društvo,
Company of asset {0} and purchase document {1} doesn't matches.,Tvrtka imovine {0} i dokument o kupnji {1} ne odgovaraju.,
Compare BOMs for changes in Raw Materials and Operations,Usporedite BOM za promjene u sirovinama i načinu rada,
Compare List function takes on list arguments,Funkcija Usporedi popis preuzima argumente liste,
Complete,Kompletna,
Completed,Dovršen,
Completed Quantity,Popunjena količina,
Connect your Exotel Account to ERPNext and track call logs,Povežite svoj Exotel račun na ERPNext i pratite zapise poziva,
Connect your bank accounts to ERPNext,Povežite svoje bankovne račune s ERPNext-om,
Contact Seller,Kontaktirajte prodavača,
Continue,Nastaviti,
Cost Center: {0} does not exist,Centar troškova: {0} ne postoji,
Couldn't Set Service Level Agreement {0}.,Nije moguće postaviti ugovor o razini usluge {0}.,
Country,Zemlja,
Country Code in File does not match with country code set up in the system,Kôd države u datoteci ne podudara se s kodom države postavljenim u sustavu,
Create New Contact,Stvorite novi kontakt,
Create New Lead,Stvorite novi potencijal,
Create Pick List,Stvorite popis za odabir,
Create Quality Inspection for Item {0},Napravite inspekciju kvalitete za predmet {0},
Creating Accounts...,Stvaranje računa ...,
Creating bank entries...,Izrada bankovnih unosa ...,
Credit limit is already defined for the Company {0},Kreditni limit je već definiran za Društvo {0},
Ctrl + Enter to submit,Ctrl + Enter za slanje,
Ctrl+Enter to submit,Ctrl + Enter za slanje,
Currency,Valuta,
Current Status,Trenutni status,
Customer PO,Kupci PO,
Daily,Svakodnevno,
Date,Datum,
Date of Birth cannot be greater than Joining Date.,Datum rođenja ne može biti veći od datuma pridruživanja.,
Dear,Poštovani,
Default,Zadano,
Define coupon codes.,Definirajte kodove kupona.,
Delayed Days,Odloženi dani,
Delete,Izbrisati,
Delivered Quantity,Količina isporučena,
Delivery Notes,Obavijesti o isporuci,
Depreciated Amount,Amortizirani iznos,
Description,Opis,
Designation,Oznaka,
Difference Value,Vrijednost razlike,
Dimension Filter,Dimenzijski filter,
Disabled,Ugašeno,
Disbursement and Repayment,Isplata i otplata,
Distance cannot be greater than 4000 kms,Udaljenost ne može biti veća od 4000 km,
Do you want to submit the material request,Želite li poslati materijalni zahtjev,
Doctype,DOCTYPE,
Document {0} successfully uncleared,Dokument {0} uspješno izbrisan,
Download Template,Preuzmite predložak,
Dr,Doktor,
Due Date,Datum dospijeća,
Duplicate,Duplikat,
Duplicate Project with Tasks,Umnožavanje projekta sa zadacima,
Duplicate project has been created,Izrađen je duplikat projekta,
E-Way Bill JSON can only be generated from a submitted document,e-Way Bill JSON može se generirati samo iz poslanog dokumenta,
E-Way Bill JSON can only be generated from submitted document,e-Way Bill JSON može se generirati samo iz poslanog dokumenta,
E-Way Bill JSON cannot be generated for Sales Return as of now,e-Way Bill JSON od sada se ne može generirati za povrat prodaje,
ERPNext could not find any matching payment entry,ERPNext nije mogao pronaći nijedan odgovarajući unos za plaćanje,
Earliest Age,Najranije doba,
Edit Details,Uredi pojedinosti,
Either GST Transporter ID or Vehicle No is required if Mode of Transport is Road,"Ako je način prijevoza cestovni, nije potreban ili GST Transporter ID ili vozilo",
Email,E-mail,
Email Campaigns,Kampanje e-pošte,
Employee ID is linked with another instructor,ID zaposlenika povezan je s drugim instruktorom,
Employee Tax and Benefits,Porez na zaposlenike i beneficije,
Employee is required while issuing Asset {0},Zaposlenik je dužan prilikom izdavanja imovine {0},
Employee {0} does not belongs to the company {1},Zaposlenik {0} ne pripada tvrtki {1},
Enable Auto Re-Order,Omogući automatsku ponovnu narudžbu,
End Date of Agreement can't be less than today.,Datum završetka ugovora ne može biti manji od današnjeg.,
End Time,Kraj vremena,
Energy Point Leaderboard,Energy Point Leaderboard,
Enter API key in Google Settings.,Unesite ključ API-a u Google postavke.,
Enter Supplier,Unesite dobavljača,
Enter Value,Unesite vrijednost,
Entity Type,Vrsta entiteta,
Error,Pogreška,
Error in Exotel incoming call,Pogreška u dolaznom pozivu Exotela,
Error: {0} is mandatory field,Pogreška: {0} je obavezno polje,
Exception occurred while reconciling {0},Izuzeće je došlo tijekom usklađivanja {0},
Expected and Discharge dates cannot be less than Admission Schedule date,Očekivani i iskrcajni datumi ne mogu biti manji od datuma Plana prijema,
Expired,Istekla,
Export,Izvoz,
Export not allowed. You need {0} role to export.,Izvoz nisu dopušteni . Trebate {0} ulogu za izvoz .,
Failed to add Domain,Dodavanje Domene nije uspjelo,
Fetch Items from Warehouse,Dohvaćanje predmeta iz skladišta,
Fetching...,Preuzimanje u tijeku ...,
Field,Polje,
Filters,Filteri,
Finding linked payments,Pronalaženje povezanih plaćanja,
Fleet Management,Mornarički menađer,
Following fields are mandatory to create address:,Sljedeća polja su obavezna za stvaranje adrese:,
For Month,Mjesec dana,
"For item {0} at row {1}, count of serial numbers does not match with the picked quantity","Za stavku {0} u retku {1}, broj serijskih brojeva ne odgovara odabranoj količini",
For operation {0}: Quantity ({1}) can not be greter than pending quantity({2}),Za rad {0}: Količina ({1}) ne može biti veća od količine na čekanju ({2}),
For quantity {0} should not be greater than work order quantity {1},Za količinu {0} ne smije biti veća od količine radnog naloga {1},
Free item not set in the pricing rule {0},Besplatna stavka nije postavljena u pravilu o cijenama {0},
From Date and To Date are Mandatory,Od datuma i do dana obvezni su,
From employee is required while receiving Asset {0} to a target location,Od zaposlenika je potrebno za vrijeme prijema imovine {0} do ciljanog mjesta,
Future Payment Amount,Budući iznos plaćanja,
Future Payment Ref,Buduće plaćanje Ref,
Future Payments,Buduće isplate,
GST HSN Code does not exist for one or more items,GST HSN kod ne postoji za jednu ili više stavki,
Generate E-Way Bill JSON,Stvorite e-Way Bill JSON,
Get Items,Kreiraj proizvode,
Get Outstanding Documents,Nabavite izvanredne dokumente,
Goal,Cilj,
Greater Than Amount,Veća od iznosa,
Green,Zelena,
Group,Grupa,
Group By Customer,Grupiranje prema kupcu,
Group By Supplier,Grupiranje po dobavljaču,
Group Node,Group Node,
Group Warehouses cannot be used in transactions. Please change the value of {0},Grupne skladišta ne mogu se koristiti u transakcijama. Promijenite vrijednost {0},
Help,Pomoć,
Help Article,Pomoć članak,
"Helps you keep tracks of Contracts based on Supplier, Customer and Employee","Pomaže vam pratiti ugovore na temelju dobavljača, kupca i zaposlenika",
Helps you manage appointments with your leads,Pomaže vam u upravljanju sastancima s potencijalnim klijentima,
Home,dom,
IBAN is not valid,IBAN nije valjan,
Import Data from CSV / Excel files.,Uvoz podataka iz CSV / Excel datoteka.,
In Progress,U nastajanju,
Incoming call from {0},Dolazni poziv od {0},
Incorrect Warehouse,Pogrešno skladište,
Invalid Barcode. There is no Item attached to this barcode.,Nevažeći barkod. Nijedna stavka nije priložena ovom barkodu.,
Invalid credentials,Nevažeće vjerodajnice,
Issue Priority.,Prioritet pitanja.,
Issue Type.,Vrsta izdanja,
"It seems that there is an issue with the server's stripe configuration. In case of failure, the amount will get refunded to your account.","Čini se da postoji problem s konfiguracijom trake poslužitelja. U slučaju neuspjeha, iznos će biti vraćen na vaš račun.",
Item Reported,Stavka prijavljena,
Item listing removed,Popis predmeta uklonjen je,
Item quantity can not be zero,Količina predmeta ne može biti jednaka nuli,
Item taxes updated,Ažurirani su porezi na stavke,
Item {0}: {1} qty produced. ,Stavka {0}: {1} Količina proizvedena.,
Joining Date can not be greater than Leaving Date,Datum pridruživanja ne može biti veći od Datum napuštanja,
Lab Test Item {0} already exist,Predmet laboratorijskog testa {0} već postoji,
Last Issue,Zadnje izdanje,
Latest Age,Najnovije doba,
Leaves Taken,Lišće uzeto,
Less Than Amount,Manje od iznosa,
Liabilities,pasiva,
Loading...,Učitavanje ...,
Loan Applications from customers and employees.,Prijave za zajmove od kupaca i zaposlenika.,
Loan Processes,Procesi zajma,
Loan Type for interest and penalty rates,Vrsta zajma za kamate i zatezne stope,
Loans,krediti,
Loans provided to customers and employees.,Krediti kupcima i zaposlenicima.,
Location,Lokacija,
Looks like someone sent you to an incomplete URL. Please ask them to look into it.,Izgleda da ti je netko poslao nepotpune URL. Zamolite ih gledati u nju.,
Make Journal Entry,Provjerite Temeljnica,
Make Purchase Invoice,Napravi račun kupnje,
Manufactured,Proizveden,
Mark Work From Home,Označi rad od kuće,
Master,Master,
Max strength cannot be less than zero.,Maksimalna čvrstoća ne može biti manja od nule.,
Maximum attempts for this quiz reached!,Došli su maksimalni pokušaji ovog kviza!,
Message,Poruka,
Missing Values Required,Nedostaje vrijednosti potrebne,
Mobile No,Mobitel br,
Mobile Number,Broj mobitela,
Month,Mjesec,
Name,Ime,
Near you,Blizu tebe,
Net Profit/Loss,Neto dobit / gubitak,
New Expense,Novi trošak,
New Invoice,Nova faktura,
New Payment,Novo plaćanje,
New release date should be in the future,Novi datum izlaska trebao bi biti u budućnosti,
No Account matched these filters: {},Nijedan račun ne odgovara tim filterima: {},
No communication found.,Nije pronađena komunikacija.,
No correct answer is set for {0},Nije postavljen ispravan odgovor za {0},
No description,bez opisa,
No issue has been raised by the caller.,Nazivatelj nije pokrenuo nijedan problem.,
No items to publish,Nema stavki za objavljivanje,
No outstanding invoices found,Nisu pronađene nepodmirene fakture,
No outstanding invoices found for the {0} {1} which qualify the filters you have specified.,Nisu pronađene nepodmirene fakture za {0} {1} koji ispunjavaju filtre koje ste naveli.,
No outstanding invoices require exchange rate revaluation,Nijedna nepodmirena faktura ne zahtijeva revalorizaciju tečaja,
No reviews yet,Još nema recenzija,
No views yet,Još nema prikaza,
Non stock items,Nedostaju artikli,
Not Allowed,Nije dopušteno,
Not allowed to create accounting dimension for {0},Nije dopušteno stvaranje računovodstvenih dimenzija za {0},
Not permitted. Please disable the Lab Test Template,Nije dopušteno. Onemogućite predložak laboratorijskog testa,
Note,Zabilješka,
Notes: ,Zabilješke:,
On Converting Opportunity,O mogućnosti pretvorbe,
On Purchase Order Submission,Nakon predaje narudžbe,
On Sales Order Submission,Na predaju prodajnih naloga,
On Task Completion,Po završetku zadatka,
On {0} Creation,Na {0} Stvaranje,
Only .csv and .xlsx files are supported currently,Trenutno su podržane samo .csv i .xlsx datoteke,
Open,Otvoreno,
Open Contact,Otvori kontakt,
Open Lead,Otvoreno olovo,
Opening and Closing,Otvaranje i zatvaranje,
Operating Cost as per Work Order / BOM,Operativni trošak po radnom nalogu / BOM,
Order Amount,Iznos narudžbe,
Page {0} of {1},Stranica {0} od {1},
Paid amount cannot be less than {0},Plaćeni iznos ne može biti manji od {0},
Parent Company must be a group company,Matično društvo mora biti tvrtka u grupi,
Passing Score value should be between 0 and 100,Vrijednost prolaska rezultata trebala bi biti između 0 i 100,
Patient History,Povijest bolesnika,
Pause,Pauza,
Pay,Platiti,
Payment Document Type,Vrsta dokumenta plaćanja,
Payment Name,Naziv plaćanja,
Pending,Na čekanju,
Performance,Izvođenje,
Period based On,Razdoblje na temelju,
Perpetual inventory required for the company {0} to view this report.,Trajni inventar potreban je kompaniji {0} za pregled ovog izvještaja.,
Phone,Telefon,
Pick List,Popis popisa,
Plaid authentication error,Greška provjere autentičnosti,
Plaid public token error,Pogreška javnog tokena u obliku video zapisa,
Plaid transactions sync error,Pogreška sinkronizacije plaidnih transakcija,
Please check the error log for details about the import errors,Provjerite dnevnik pogrešaka za detalje o uvoznim pogreškama,
Please create <b>DATEV Settings</b> for Company <b>{}</b>.,Izradite <b>DATEV postavke</b> za tvrtku <b>{}</b> .,
Please create adjustment Journal Entry for amount {0} ,Napravite unos prilagodbe u časopisu za iznos {0},
Please do not create more than 500 items at a time,Ne stvarajte više od 500 predmeta odjednom,
Please enter <b>Difference Account</b> or set default <b>Stock Adjustment Account</b> for company {0},Unesite <b>račun razlike</b> ili postavite zadani <b>račun</b> za <b>prilagodbu dionica</b> za tvrtku {0},
Please enter GSTIN and state for the Company Address {0},Unesite GSTIN i upišite adresu tvrtke {0},
Please enter Item Code to get item taxes,Unesite šifru predmeta da biste dobili porez na artikl,
Please enter Warehouse and Date,Unesite datum skladišta i datum,
Please login as a Marketplace User to edit this item.,Prijavite se kao Korisnik Marketplacea da biste uredili ovu stavku.,
Please login as a Marketplace User to report this item.,Prijavite se kao korisnik Marketplacea kako biste prijavili ovu stavku.,
Please select <b>Template Type</b> to download template,Odaberite <b>vrstu predloška</b> za preuzimanje predloška,
Please select Customer first,Prvo odaberite kupca,
Please select Item Code first,Prvo odaberite šifru predmeta,
Please select a Delivery Note,Odaberite bilješku o isporuci,
Please select a Sales Person for item: {0},Odaberite prodajnu osobu za stavku: {0},
Please select another payment method. Stripe does not support transactions in currency '{0}',Odaberite drugi način plaćanja. Traka ne podržava transakcije u valuti &quot;{0}&quot;,
Please select the customer.,Odaberite kupca.,
Please set a Supplier against the Items to be considered in the Purchase Order.,Molimo postavite dobavljača protiv proizvoda koji će se smatrati narudžbenicom.,
Please set account heads in GST Settings for Compnay {0},Postavite glave računa u GST Postavke za tvrtku {0},
Please set an email id for the Lead {0},Molimo vas da odredite ID e-pošte za Lead {0},
Please set default UOM in Stock Settings,Postavite zadani UOM u postavkama zaliha,
Please set filter based on Item or Warehouse due to a large amount of entries.,Molimo postavite filtar na temelju predmeta ili skladišta zbog velike količine unosa.,
Please set up the Campaign Schedule in the Campaign {0},Postavite Raspored kampanje u kampanji {0},
Please set valid GSTIN No. in Company Address for company {0},Molimo postavite važeći GSTIN broj na adresi tvrtke za tvrtku {0},
Please set {0},Postavite {0},customer
Please setup a default bank account for company {0},Postavite zadani bankovni račun za tvrtku {0},
Please specify,Navedite,
Please specify a {0},Navedite {0},lead
Priority,Prioritet,
Priority has been changed to {0}.,Prioritet je promijenjen u {0}.,
Priority {0} has been repeated.,Prioritet {0} je ponovljen.,
Processing XML Files,Obrada XML datoteka,
Profitability,rentabilnost,
Project,Projekt,
Provide the academic year and set the starting and ending date.,Navedite akademsku godinu i postavite datum početka i završetka.,
Public token is missing for this bank,Javni token nedostaje za ovu banku,
Publish 1 Item,Objavite 1 predmet,
Publish Items,Objavite stavke,
Publish More Items,Objavite još predmeta,
Publish Your First Items,Objavite svoje prve stavke,
Publish {0} Items,Objavite {0} stavke,
Published Items,Objavljeni predmeti,
Purchase Invoice cannot be made against an existing asset {0},Račun za kupnju ne može se izvršiti protiv postojećeg sredstva {0},
Purchase Invoices,Kupnja fakture,
Purchase Orders,Narudžbenice,
Purchase Receipt doesn't have any Item for which Retain Sample is enabled.,Kupnja potvrde nema stavku za koju je omogućen zadržati uzorak.,
Purchase Return,Kupnja Povratak,
Qty of Finished Goods Item,Količina proizvoda gotove robe,
Quality Inspection required for Item {0} to submit,Inspekcija kvalitete potrebna je za predavanje predmeta {0},
Quantity to Manufacture,Količina za proizvodnju,
Quantity to Manufacture can not be zero for the operation {0},Količina za proizvodnju ne može biti nula za operaciju {0},
Quarterly,Tromjesečni,
Queued,Čekanju,
Quick Entry,Brzi Ulaz,
Quiz {0} does not exist,Kviz {0} ne postoji,
Quotation Amount,Iznos kotacije,
Rate or Discount is required for the price discount.,Za popust na cijenu potreban je popust ili popust.,
Reason,Razlog,
Reconcile Entries,Usklađivanje unosa,
Reconcile this account,Uskladi ovaj račun,
Reconciled,pomiren,
Recruitment,regrutacija,
Red,Crvena,
Release date must be in the future,Datum izlaska mora biti u budućnosti,
Relieving Date must be greater than or equal to Date of Joining,Datum oslobađanja mora biti veći ili jednak datumu pridruživanja,
Rename,Preimenuj,
Rename Not Allowed,Preimenovanje nije dopušteno,
Report Item,Stavka izvješća,
Report this Item,Prijavite ovu stavku,
Reserved Qty for Subcontract: Raw materials quantity to make subcontracted items.,Količina rezerviranog za podugovor: Količina sirovina za izradu predmeta koji su predmet podugovora.,
Reset,Reset,
Reset Service Level Agreement,Poništite ugovor o razini usluge,
Resetting Service Level Agreement.,Ponovno postavljanje ugovora o razini usluge.,
Return amount cannot be greater unclaimed amount,Iznos povrata ne može biti veći nenaplaćeni iznos,
Review,Pregled,
Room,Soba,
Room Type,Vrsta sobe,
Row # ,Red #,
Row #{0}: Accepted Warehouse and Supplier Warehouse cannot be same,Redak # {0}: Prihvaćena skladišta i skladišta dobavljača ne mogu biti isti,
Row #{0}: Cannot delete item {1} which has already been billed.,Redak # {0}: Nije moguće izbrisati stavku {1} koja je već naplaćena.,
Row #{0}: Cannot delete item {1} which has already been delivered,Redak # {0}: Ne može se izbrisati stavka {1} koja je već isporučena,
Row #{0}: Cannot delete item {1} which has already been received,Redak # {0}: Ne može se izbrisati stavka {1} koja je već primljena,
Row #{0}: Cannot delete item {1} which has work order assigned to it.,Redak broj {0}: Ne može se izbrisati stavka {1} kojoj je dodijeljen radni nalog.,
Row #{0}: Cannot delete item {1} which is assigned to customer's purchase order.,Redak broj {0}: Ne može se izbrisati stavka {1} koja je dodijeljena kupčevoj narudžbi za kupnju.,
Row #{0}: Cannot select Supplier Warehouse while suppling raw materials to subcontractor,Redak broj {0}: Nije moguće odabrati skladište dobavljača dok dobavlja sirovine podizvođaču,
Row #{0}: Cost Center {1} does not belong to company {2},Redak # {0}: Troškovno mjesto {1} ne pripada tvrtki {2},
Row #{0}: Operation {1} is not completed for {2} qty of finished goods in Work Order {3}. Please update operation status via Job Card {4}.,Redak # {0}: Operacija {1} nije dovršena za {2} količinu gotovih proizvoda u radnom nalogu {3}. Ažurirajte status rada putem Job Card {4}.,
Row #{0}: Payment document is required to complete the transaction,Redak # {0}: Dokument za plaćanje potreban je za dovršavanje transakcije,
Row #{0}: Serial No {1} does not belong to Batch {2},Redak br. {0}: Serijski br. {1} ne pripada grupi {2},
Row #{0}: Service End Date cannot be before Invoice Posting Date,Redak broj {0}: datum završetka usluge ne može biti prije datuma knjiženja fakture,
Row #{0}: Service Start Date cannot be greater than Service End Date,Redak broj {0}: Datum početka usluge ne može biti veći od datuma završetka usluge,
Row #{0}: Service Start and End Date is required for deferred accounting,Redak broj {0}: Datum početka i završetka usluge potreban je za odgođeno računovodstvo,
Row {0}: Invalid Item Tax Template for item {1},Redak {0}: nevažeći predložak poreza na stavku za stavku {1},
Row {0}: Quantity not available for {4} in warehouse {1} at posting time of the entry ({2} {3}),Redak {0}: Količina nije dostupna za {4} u skladištu {1} u vrijeme knjiženja unosa ({2} {3}),
Row {0}: user has not applied the rule {1} on the item {2},Redak {0}: korisnik nije primijenio pravilo {1} na stavku {2},
Row {0}:Sibling Date of Birth cannot be greater than today.,Redak {0}: datum rođenja braće ne može biti veći od današnjeg.,
Row({0}): {1} is already discounted in {2},Red ({0}): {1} već je snižen u {2},
Rows Added in {0},Redovi dodano u {0},
Rows Removed in {0},Redovi su uklonjeni za {0},
Save,Spremi,
Save Item,Spremi stavku,
Saved Items,Spremljene stavke,
Search Items ...,Stavke za pretraživanje ...,
Search for a payment,Traži plaćanje,
Search for anything ...,Traži bilo što ...,
Search results for,Rezultati pretrage za,
Select Difference Account,Odaberite račun razlike,
Select a Default Priority.,Odaberite zadani prioritet.,
Select a company,Odaberite tvrtku,
Select finance book for the item {0} at row {1},Odaberite knjigu financija za stavku {0} u retku {1},
Select only one Priority as Default.,Odaberite samo jedan prioritet kao zadani.,
Seller Information,Podaci o prodavaču,
Send,Poslati,
Send a message,Pošalji poruku,
Sending,slanje,
Sends Mails to lead or contact based on a Campaign schedule,Šalje poruke e-pošte koja vodi ili kontaktira na temelju rasporeda kampanje,
Serial Number Created,Izrađen serijski broj,
Serial Numbers Created,Napravljeni su serijski brojevi,
Serial no(s) required for serialized item {0},Serijski brojevi potrebni za serijsku stavku {0},
Series,Serija,
Server Error,pogreška servera,
Service Level Agreement has been changed to {0}.,Ugovor o razini usluge promijenjen je u {0}.,
Service Level Agreement was reset.,Ugovor o razini usluge vraćen je na zadano.,
Service Level Agreement with Entity Type {0} and Entity {1} already exists.,Ugovor o razini usluge s tipom entiteta {0} i entitetom {1} već postoji.,
Set Meta Tags,Postavljanje metaoznaka,
Set {0} in company {1},Postavite {0} u tvrtki {1},
Setup,Postavke,
Shift Management,Upravljanje pomakom,
Show Future Payments,Prikaži buduće isplate,
Show Linked Delivery Notes,Prikaži povezane bilješke o isporuci,
Show Sales Person,Pokaži prodajnu osobu,
Show Stock Ageing Data,Pokaži podatke o starenju zaliha,
Show Warehouse-wise Stock,Pokažite zalihe pametne,
Size,Veličina,
Something went wrong while evaluating the quiz.,Nešto je pošlo po zlu tijekom vrednovanja kviza.,
Sr,sr,
Start,početak,
Start Date cannot be before the current date,Datum početka ne može biti prije trenutnog datuma,
Start Time,Vrijeme početka,
Status,Status,
Status must be Cancelled or Completed,Status mora biti otkazan ili dovršen,
Stock Balance Report,Izvještaj o stanju dionica,
Stock Entry has been already created against this Pick List,Unos dionica već je stvoren protiv ove liste odabira,
Stock Ledger ID,ID knjige dionice,
Stock Value ({0}) and Account Balance ({1}) are out of sync for account {2} and it's linked warehouses.,Vrijednost dionica ({0}) i saldo računa ({1}) nisu sinkronizirani za račun {2} i povezani su skladišta.,
Stores - {0},Trgovine - {0},
Student with email {0} does not exist,Student s adresom e-pošte {0} ne postoji,
Submit Review,Pošaljite pregled,
Submitted,Potvrđeno,
Supplier Addresses And Contacts,Supplier Adrese i kontakti,
Synchronize this account,Sinkronizirajte ovaj račun,
Tag,Označiti,
Target Location is required while receiving Asset {0} from an employee,Ciljana lokacija potrebna je dok primate imovinu {0} od zaposlenika,
Target Location is required while transferring Asset {0},Ciljana lokacija potrebna je tijekom prijenosa imovine {0},
Target Location or To Employee is required while receiving Asset {0},Ciljana lokacija ili zaposlenik su potrebni za vrijeme prijema imovine {0},
Task's {0} End Date cannot be after Project's End Date.,{0} Krajnji datum zadatka ne može biti nakon završetka datuma projekta.,
Task's {0} Start Date cannot be after Project's End Date.,Zadatak {0} Datum početka ne može biti nakon završetka datuma projekta.,
Tax Account not specified for Shopify Tax {0},Porezni račun nije naveden za Shopify Tax {0},
Tax Total,Porez ukupno,
Template,Predložak,
The Campaign '{0}' already exists for the {1} '{2}',Kampanja &quot;{0}&quot; već postoji za {1} &quot;{2}&quot;,
The difference between from time and To Time must be a multiple of Appointment,Razlika između vremena i vremena mora biti višestruka,
The field Asset Account cannot be blank,Polje Račun imovine ne može biti prazno,
The field Equity/Liability Account cannot be blank,Polje na računu glavnice / odgovornosti ne može biti prazno,
The following serial numbers were created: <br><br> {0},Napravljeni su sljedeći serijski brojevi: <br><br> {0},
The parent account {0} does not exists in the uploaded template,Nadređeni račun {0} ne postoji u prenesenom predlošku,
The question cannot be duplicate,Pitanje ne može biti duplicirano,
The selected payment entry should be linked with a creditor bank transaction,Odabrani unos za plaćanje trebao bi biti povezan s bankovnom transakcijom vjerovnika,
The selected payment entry should be linked with a debtor bank transaction,Odabrani unos za plaćanje trebao bi biti povezan s bankovnom transakcijom dužnika,
The total allocated amount ({0}) is greated than the paid amount ({1}).,Ukupni dodijeljeni iznos ({0}) namazan je od uplaćenog iznosa ({1}).,
This Service Level Agreement is specific to Customer {0},Ovaj Ugovor o razini usluge specifičan je za kupca {0},
This action will unlink this account from any external service integrating ERPNext with your bank accounts. It cannot be undone. Are you certain ?,Ova akcija će prekinuti vezu ovog računa s bilo kojom vanjskom uslugom koja integrira ERPNext s vašim bankovnim računima. To se ne može poništiti. Jesi li siguran ?,
This bank account is already synchronized,Taj je bankovni račun već sinkroniziran,
This bank transaction is already fully reconciled,Ova je bankovna transakcija već u potpunosti usklađena,
This page keeps track of items you want to buy from sellers.,Ova stranica prati stvari koje želite kupiti od prodavača.,
This page keeps track of your items in which buyers have showed some interest.,Ova stranica prati vaše predmete za koje su kupci pokazali neki interes.,
Thursday,Četvrtak,
Title,Naslov,
"To allow over billing, update ""Over Billing Allowance"" in Accounts Settings or the Item.","Da biste omogućili prekomerno naplaćivanje, ažurirajte &quot;Nadoplata za naplatu&quot; u Postavkama računa ili Stavka.",
"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.","Da biste omogućili primanje / isporuku, ažurirajte &quot;Preplata primanja / Dostava&quot; u Postavkama zaliha ili Stavka.",
Total,ukupno,
Total Payment Request amount cannot be greater than {0} amount,Ukupni iznos zahtjeva za plaćanje ne može biti veći od {0},
Total payments amount can't be greater than {},Ukupni iznos plaćanja ne može biti veći od {},
Totals,Ukupan rezultat,
Transactions already retreived from the statement,Transakcije su već povučene iz izjave,
Transfer Material to Supplier,Prebaci Materijal Dobavljaču,
Transport Receipt No and Date are mandatory for your chosen Mode of Transport,Broj potvrde prijevoza i datum obvezni su za odabrani način prijevoza,
Tuesday,Utorak,
Type,Vrsta,
Unable to find the time slot in the next {0} days for the operation {1}.,Nije moguće pronaći vremensko mjesto u sljedećih {0} dana za operaciju {1}.,
Unable to update remote activity,Nije moguće ažurirati daljinsku aktivnost,
Unknown Caller,Nepoznati pozivatelj,
Unlink external integrations,Prekini vezu s vanjskim integracijama,
Unpublish Item,Ponipublishtavanje stavke,
Unreconciled,nesaglašen,
Unsupported GST Category for E-Way Bill JSON generation,Nepodržana GST kategorija za e-Way Bill JSON generacije,
Update,Ažuriraj,
Update Taxes for Items,Ažurirajte poreze na stavke,
"Upload a bank statement, link or reconcile a bank account","Prenesite bankovni izvod, povežite ili usklađujete bankovni račun",
Upload a statement,Prenesite izjavu,
Use a name that is different from previous project name,Koristite ime koje se razlikuje od prethodnog naziva projekta,
User {0} is disabled,Korisnik {0} je onemogućen,
Users and Permissions,Korisnici i dozvole,
Valuation Rate required for Item {0} at row {1},Stopa vrednovanja potrebna za stavku {0} u retku {1},
Values Out Of Sync,Vrijednosti nisu sinkronizirane,
Vehicle Type is required if Mode of Transport is Road,Vrsta vozila potrebna je ako je način prijevoza cestovni,
Vendor Name,Naziv dobavljača,
Verify Email,Potvrditi email,
View,Pogled,
View all issues from {0},Pregled svih izdanja od {0},
View call log,Pogledajte dnevnik poziva,
Warehouse,Skladište,
Warehouse not found against the account {0},Skladište nije pronađeno na računu {0},
Welcome to {0},Slobodno {0},
Why do think this Item should be removed?,Zašto mislite da bi ovaj predmet trebao biti uklonjen?,
Work Order {0}: Job Card not found for the operation {1},Radni nalog {0}: kartica posla nije pronađena za operaciju {1},
Workday {0} has been repeated.,Radni dan {0} je ponovljen.,
XML Files Processed,Obrađene su XML datoteke,
Year,Godina,
Yearly,Godišnji,
You are not allowed to enroll for this course,Nije vam dopušteno upisati se na ovaj tečaj,
You are not enrolled in program {0},Niste upisani u program {0},
You can Feature upto 8 items.,Možete predstaviti do 8 predmeta.,
You can also copy-paste this link in your browser,Također možete kopirati ovaj link u Vaš preglednik,
You can publish upto 200 items.,Možete objaviti do 200 predmeta.,
You have to enable auto re-order in Stock Settings to maintain re-order levels.,"Da biste održali razinu ponovne narudžbe, morate omogućiti automatsku ponovnu narudžbu u Postavkama dionica.",
You must be a registered supplier to generate e-Way Bill,Za generiranje računa za e-put morate biti registrirani dobavljač,
You need to login as a Marketplace User before you can add any reviews.,"Prije nego što dodate bilo koju recenziju, morate se prijaviti kao korisnik Marketplacea.",
Your Featured Items,Istaknuti predmeti,
Your Items,Vaše stavke,
Your Profile,Tvoj profil,
Your rating:,Vaša ocjena:,
and,i,
e-Way Bill already exists for this document,Za ovaj dokument već postoji e-Way Bill,
woocommerce - {0},woocommerce - {0},
{0} Coupon used are {1}. Allowed quantity is exhausted,{0} Kuponi se koriste {1}. Dozvoljena količina se iscrpljuje,
{0} Operations: {1},{0} Operacije: {1},
{0} bank transaction(s) created,{0} stvorene bankovne transakcije,
{0} bank transaction(s) created and {1} errors,{0} stvorene bankovne transakcije i {1} pogreške,
{0} can not be greater than {1},{0} ne može biti veći od {1},
{0} conversations,{0} razgovora,
{0} is not a company bank account,{0} nije bankovni račun tvrtke,
{0} is not a group node. Please select a group node as parent cost center,{0} nije grupni čvor. Odaberite čvor grupe kao nadređeno mjesto troškova,
{0} is not the default supplier for any items.,{0} nije zadani dobavljač za bilo koju robu.,
{0} is required,{0} je potrebno,
{0}: {1} must be less than {2},{0}: {1} mora biti manji od {2},
{} is required to generate E-Way Bill JSON,{} je potreban za generiranje e-Way Bill JSON,
"Invalid lost reason {0}, please create a new lost reason","Nevažeći izgubljeni razlog {0}, izradite novi izgubljeni razlog",
Profit This Year,Dobit ove godine,
Total Expense,Ukupni rashodi,
Total Expense This Year,Ukupni troškovi ove godine,
Total Income,Ukupni prihod,
Total Income This Year,Ukupni prihod u ovoj godini,
Barcode,Barkod,
Clear,Čisto,
Comments,Komentari,
DocType,DOCTYPE,
Download,preuzimanje datoteka,
Left,Lijevo,
Link,Veza,
New,Novi,
Print,otisak,
Reference Name,Naziv poveznice,
Refresh,Osvježi stranicu,
Success,Uspjeh,
Time,Vrijeme,
Value,Vrijednost,
Actual,stvaran,
Add to Cart,Dodaj u košaricu,
Days Since Last Order,Dana od zadnje narudžbe,
In Stock,Na zalihi,
Mode Of Payment,Nacin placanja,
No students Found,Studenti nisu pronađeni,
Not in Stock,Ne u skladištu,
Please select a Customer,Odaberite klijenta,
Received From,Primljeno od,
Sales Person,Prodajna osoba,
To date cannot be before From date,Do danas ne može biti prije Od datuma,
Write Off,Otpisati,
{0} Created,{0} stvorio,
Email Id,E-mail ID,
No,Br,
Reference Doctype,Referentna DOCTYPEhtml,
Yes,Da,
Actual ,stvaran,
Add to cart,Dodaj u košaricu,
Budget,budžet,
Chart of Accounts,Kontni plan,
Customer database.,Baza podataka korisnika.,
Days Since Last order,Dana od posljednje narudžbe,
Download as JSON,Preuzmi kao Json,
End date can not be less than start date,Datum završetka ne može biti manja od početnog datuma,
For Default Supplier (Optional),Za dobavljača zadano (neobavezno),
From date cannot be greater than To date,Datum ne može biti veći od datuma,
Group by,Grupiranje prema,
In stock,Na lageru,
Item name,Naziv proizvoda,
Minimum Qty,Minimalni broj,
More details,Više pojedinosti,
Nature of Supplies,Priroda potrošnog materijala,
No Items found.,Nema pronađenih stavki.,
No students found,Nema učenika Pronađeno,
Not in stock,Nije na zalihama,
Not permitted,Nije dopušteno,
Open Issues ,Otvorena pitanja,
Open Projects ,Otvoreno Projekti,
Open To Do ,Otvoreni učiniti,
Operation Id,Operacija ID,
Partially ordered,djelomično Ž,
Please select company first,Najprije odaberite tvrtku,
Please select patient,Odaberite Pacijent,
Printed On ,Tiskano na,
Projected qty,Predviđena količina,
Sales person,Prodajna osoba,
Serial No {0} Created,Serijski Ne {0} stvorio,
Source Location is required for the Asset {0},Izvor Lokacija je potrebna za imovinu {0},
Tax Id,Porezni broj,
To Time,Za vrijeme,
To date cannot be before from date,Datum ne može biti prije datuma,
Total Taxable value,Ukupna porezna vrijednost,
Upcoming Calendar Events ,Nadolazeći Kalendar događanja,
Value or Qty,Vrijednost ili broj,
Variance ,varijacija,
Variant of,Varijanta,
Write off,Otpisati,
hours,sati,
received from,primljeno od,
to,za,
Cards,Kartice,
Percentage,Postotak,
Failed to setup defaults for country {0}. Please contact support@erpnext.com,Nije uspjelo postavljanje zadanih postavki za zemlju {0}. Molimo kontaktirajte support@erpnext.com,
Row #{0}: Item {1} is not a Serialized/Batched Item. It cannot have a Serial No/Batch No against it.,Redak # {0}: Stavka {1} nije serijski / skupa stavka. Protiv njega ne može imati serijski broj / br.,
Please set {0},Molimo postavite {0},
Please set {0},Postavite {0},supplier
Draft,Nacrt,"docstatus,=,0"
Cancelled,otkazan,"docstatus,=,2"
Please setup Instructor Naming System in Education > Education Settings,Postavite sustav imenovanja instruktora u Obrazovanje&gt; Postavke obrazovanja,
Please set Naming Series for {0} via Setup > Settings > Naming Series,Postavite Nameing Series za {0} putem Podešavanje&gt; Postavke&gt; Imenovanje serija,
UOM Conversion factor ({0} -> {1}) not found for item: {2},Faktor konverzije UOM ({0} -&gt; {1}) nije pronađen za stavku: {2},
Item Code > Item Group > Brand,Kod artikla&gt; Grupa artikala&gt; Marka,
Customer > Customer Group > Territory,Kupac&gt; Grupa kupaca&gt; Teritorij,
Supplier > Supplier Type,Dobavljač&gt; vrsta dobavljača,
The value of {0} differs between Items {1} and {2},Vrijednost {0} razlikuje se između stavki {1} i {2},
Auto Fetch,Automatsko dohvaćanje,
Fetch Serial Numbers based on FIFO,Dohvati serijske brojeve na temelju FIFO-a,
"Outward taxable supplies(other than zero rated, nil rated and exempted)","Vanjsko oporezive isporuke (osim nula, nula i izuzete)",
"To allow different rates, disable the {0} checkbox in {1}.","Da biste omogućili različite cijene, onemogućite {0} potvrdni okvir u {1}.",
Asset{} {assets_link} created for {},Sredstvo {} {assets_link} stvoreno za {},
Row {}: Asset Naming Series is mandatory for the auto creation for item {},Red {}: Serija imenovanja sredstava obavezna je za automatsko stvaranje stavke {},
Assets not created for {0}. You will have to create asset manually.,Elementi nisu izrađeni za {0}. Morat ćete stvoriti materijal ručno.,
{0} {1} has accounting entries in currency {2} for company {3}. Please select a receivable or payable account with currency {2}.,{0} {1} ima knjigovodstvene stavke u valuti {2} za tvrtku {3}. Odaberite račun potraživanja ili plaćanja u valuti {2}.,
Invalid Account,Nevažeći račun,
Purchase Order Required,Narudžbenica kupnje je obavezna,
Purchase Receipt Required,Primka je obvezna,
Account Missing,Račun nedostaje,
Requested,Tražena,
Partially Paid,Djelomično plaćeno,
Invalid Account Currency,Nevažeća valuta računa,
"Row {0}: The item {1}, quantity must be positive number","Redak {0}: Stavka {1}, količina mora biti pozitivan broj",
"Please set {0} for Batched Item {1}, which is used to set {2} on Submit.","Postavite {0} za skupnu stavku {1}, koja se koristi za postavljanje {2} na Submit.",
Expiry Date Mandatory,Datum isteka Obvezno,
Variant Item,Varijanta,
BOM 1 {0} and BOM 2 {1} should not be same,BOM 1 {0} i BOM 2 {1} ne bi trebali biti isti,
Note: Item {0} added multiple times,Napomena: Stavka {0} dodana je više puta,
YouTube,YouTube,
Vimeo,Vimeo,
Publish Date,Datum objave,
Duration,Trajanje,
Advanced Settings,Napredne postavke,
Path,Staza,
Components,Komponente,
Verified By,Ovjeren od strane,
Invalid naming series (. missing) for {0},Nevažeća serija imenovanja (. Nedostaje) za {0},
Filter Based On,Filtar zasnovan na,
Reqd by date,Zahtjev po datumu,
Manufacturer Part Number <b>{0}</b> is invalid,Broj dijela proizvođača <b>{0}</b> nije važeći,
Invalid Part Number,Nevažeći broj dijela,
Select atleast one Social Media from Share on.,Odaberite barem jedan društveni medij iz Share on.,
Invalid Scheduled Time,Nevažeće zakazano vrijeme,
Length Must be less than 280.,Dužina Mora biti manja od 280.,
Error while POSTING {0},Pogreška prilikom POSTAVLJANJA {0},
"Session not valid, Do you want to login?","Sesija nije važeća, želite li se prijaviti?",
Session Active,Sjednica aktivna,
Session Not Active. Save doc to login.,Sesija nije aktivna. Spremite dokument za prijavu.,
Error! Failed to get request token.,Pogreška! Dohvaćanje tokena zahtjeva nije uspjelo.,
Invalid {0} or {1},Nevažeće {0} ili {1},
Error! Failed to get access token.,Pogreška! Dohvaćanje tokena za pristup nije uspjelo.,
Invalid Consumer Key or Consumer Secret Key,Nevažeći potrošački ključ ili tajni ključ potrošača,
Your Session will be expire in ,Vaša sesija istječe za,
 days.,dana.,
Session is expired. Save doc to login.,Sjednica je istekla. Spremite dokument za prijavu.,
Error While Uploading Image,Pogreška prilikom prijenosa slike,
You Didn't have permission to access this API,Niste imali dozvolu za pristup ovom API-ju,
Valid Upto date cannot be before Valid From date,Valjano do datuma ne može biti prije Važi od datuma,
Valid From date not in Fiscal Year {0},Vrijedi od datuma koji nije u fiskalnoj godini {0},
Valid Upto date not in Fiscal Year {0},Vrijedi do datuma koji nije u fiskalnoj godini {0},
Group Roll No,Grupna rola br,
Maintain Same Rate Throughout Sales Cycle,Održavaj istu stopu tijekom cijelog prodajnog ciklusa,
"Row {1}: Quantity ({0}) cannot be a fraction. To allow this, disable '{2}' in UOM {3}.","Redak {1}: Količina ({0}) ne može biti razlomak. Da biste to omogućili, onemogućite &quot;{2}&quot; u UOM-u {3}.",
Must be Whole Number,Mora biti cijeli broj,
Please setup Razorpay Plan ID,Molimo postavite Razorpay ID plana,
Contact Creation Failed,Stvaranje kontakta nije uspjelo,
Leaves Expired,Lišće je isteklo,
Row #{}: {} of {} should be {}. Please modify the account or select a different account.,Red # {}: {} od {} trebao bi biti {}. Izmijenite račun ili odaberite drugi račun.,
Row #{}: Please asign task to a member.,Redak {{}: Molimo dodijelite zadatak članu.,
Process Failed,Proces nije uspio,
Tally Migration Error,Pogreška migracije Tally-a,
Please set Warehouse in Woocommerce Settings,Molimo postavite Warehouse u postavkama Woocommercea,
Row {0}: Delivery Warehouse ({1}) and Customer Warehouse ({2}) can not be same,Redak {0}: Skladište za dostavu ({1}) i Skladište za kupce ({2}) ne mogu biti isto,
Row {0}: Due Date in the Payment Terms table cannot be before Posting Date,Redak {0}: Datum dospijeća u tablici Uvjeti plaćanja ne može biti prije datuma knjiženja,
Cannot find {} for item {}. Please set the same in Item Master or Stock Settings.,Nije moguće pronaći {} za stavku {}. Postavite isto u stavci Master Master ili Stock Settings.,
Row #{0}: The batch {1} has already expired.,Redak {0}: serija {1} je već istekla.,
Start Year and End Year are mandatory,Početna i završna godina su obvezne,
GL Entry,GL ulaz,
Cannot allocate more than {0} against payment term {1},Ne možete dodijeliti više od {0} prema roku plaćanja {1},
The root account {0} must be a group,Korijenski račun {0} mora biti grupa,
Shipping rule not applicable for country {0} in Shipping Address,Pravilo dostave nije primjenjivo za zemlju {0} u adresi za dostavu,
Get Payments from,Primajte uplate od,
Set Shipping Address or Billing Address,Postavite adresu za dostavu ili adresu za naplatu,
Consultation Setup,Postavljanje konzultacija,
Fee Validity,Valjanost naknade,
Laboratory Setup,Postavljanje laboratorija,
Dosage Form,Oblik doziranja,
Records and History,Zapisi i povijest,
Patient Medical Record,Patient Medical Record,
Rehabilitation,Rehabilitacija,
Exercise Type,Vrsta vježbe,
Exercise Difficulty Level,Razina težine vježbanja,
Therapy Type,Vrsta terapije,
Therapy Plan,Plan terapije,
Therapy Session,Sjednica terapije,
Motor Assessment Scale,Skala za procjenu motora,
[Important] [ERPNext] Auto Reorder Errors,[Važno] [ERPNext] Pogreške automatskog preuređivanja,
"Regards,","Pozdrav,",
The following {0} were created: {1},Stvoreni su sljedeći {0}: {1},
Work Orders,Nalozi za rad,
The {0} {1} created sucessfully,{0} {1} je uspješno stvoren,
Work Order cannot be created for following reason: <br> {0},Radni nalog nije moguće stvoriti iz sljedećeg razloga:<br> {0},
Add items in the Item Locations table,Dodajte stavke u tablicu Lokacije predmeta,
Update Current Stock,Ažurirajte trenutnu zalihu,
"{0} Retain Sample is based on batch, please check Has Batch No to retain sample of item","{0} Zadrži uzorak temelji se na seriji, označite Ima seriju ne da biste zadržali uzorak predmeta",
Empty,Prazan,
Currently no stock available in any warehouse,Trenutno nema zaliha na skladištu,
BOM Qty,BOM Količina,
Time logs are required for {0} {1},Za {0} {1} potrebni su vremenski dnevnici,
Total Completed Qty,Ukupno završeno Količina,
Qty to Manufacture,Količina za proizvodnju,
Social Media Campaigns,Kampanje na društvenim mrežama,
From Date can not be greater than To Date,Od datuma ne može biti veći od datuma,
Please set a Customer linked to the Patient,Molimo postavite kupca povezanog s pacijentom,
Customer Not Found,Kupac nije pronađen,
Please Configure Clinical Procedure Consumable Item in ,Molimo konfigurirajte potrošni predmet za klinički postupak u sustavu Windows,
Missing Configuration,Nedostaje konfiguracija,
Out Patient Consulting Charge Item,Naplaćuje se naknada za savjetovanje o pacijentu,
Inpatient Visit Charge Item,Naknada za naplatu bolničkog posjeta,
OP Consulting Charge,OP Savjetodavna naknada,
Inpatient Visit Charge,Naknada za bolničko posjećivanje,
Appointment Status,Status imenovanja,
Test: ,Test:,
Collection Details: ,Pojedinosti o kolekciji:,
{0} out of {1},{0} od {1},
Select Therapy Type,Odaberite vrstu terapije,
{0} sessions completed,Završeno je {0} sesija,
{0} session completed,Završena je {0} sesija,
 out of {0},od {0},
Therapy Sessions,Sjednice terapije,
Add Exercise Step,Dodajte korak vježbe,
Edit Exercise Step,Uredi korak vježbanja,
Patient Appointments,Imenovanja pacijenta,
Item with Item Code {0} already exists,Stavka s kodom artikla {0} već postoji,
Registration Fee cannot be negative or zero,Naknada za registraciju ne može biti negativna ili nula,
Configure a service Item for {0},Konfigurirajte stavku usluge za {0},
Temperature: ,Temperatura:,
Pulse: ,Puls:,
Respiratory Rate: ,Stopa disanja:,
BP: ,BP:,
BMI: ,BMI:,
Note: ,Bilješka:,
Check Availability,Provjera dostupnosti,
Please select Patient first,Prvo odaberite Pacijent,
Please select a Mode of Payment first,Prvo odaberite način plaćanja,
Please set the Paid Amount first,Prvo postavite plaćeni iznos,
Not Therapies Prescribed,Nisu propisane terapije,
There are no Therapies prescribed for Patient {0},Nisu propisane terapije za pacijenta {0},
Appointment date and Healthcare Practitioner are Mandatory,Datum imenovanja i liječnik su obavezni,
No Prescribed Procedures found for the selected Patient,Nisu pronađeni propisani postupci za odabranog pacijenta,
Please select a Patient first,Prvo odaberite pacijenta,
There are no procedure prescribed for ,Ne postoji postupak propisan za,
Prescribed Therapies,Propisane terapije,
Appointment overlaps with ,Imenovanje se preklapa sa,
{0} has appointment scheduled with {1} at {2} having {3} minute(s) duration.,{0} ima zakazan sastanak s {1} u {2} u trajanju od {3} minuta.,
Appointments Overlapping,Preklapanje termina,
Consulting Charges: {0},Naknade za savjetovanje: {0},
Appointment Cancelled. Please review and cancel the invoice {0},Imenovanje otkazano. Pregledajte i otkažite fakturu {0},
Appointment Cancelled.,Imenovanje otkazano.,
Fee Validity {0} updated.,Valjanost naknade {0} ažurirana.,
Practitioner Schedule Not Found,Raspored praktičara nije pronađen,
{0} is on a Half day Leave on {1},{0} je na poludnevnom odsustvu {1},
{0} is on Leave on {1},{0} je na dopustu {1},
{0} does not have a Healthcare Practitioner Schedule. Add it in Healthcare Practitioner,{0} nema raspored zdravstvenih radnika. Dodajte ga u Healthcare Practitioner,
Healthcare Service Units,Jedinice zdravstvene zaštite,
Complete and Consume,Dovršite i potrošite,
Complete {0} and Consume Stock?,Ispuniti {0} i potrošiti zalihe?,
Complete {0}?,Dovršiti {0}?,
Stock quantity to start the Procedure is not available in the Warehouse {0}. Do you want to record a Stock Entry?,Količina zaliha za pokretanje postupka nije dostupna u Skladištu {0}. Želite li snimiti unos dionica?,
{0} as on {1},{0} kao i {1},
Clinical Procedure ({0}):,Klinički postupak ({0}):,
Please set Customer in Patient {0},Postavite kupca za pacijenta {0},
Item {0} is not active,Stavka {0} nije aktivna,
Therapy Plan {0} created successfully.,Plan terapije {0} uspješno je stvoren.,
Symptoms: ,Simptomi:,
No Symptoms,Nema simptoma,
Diagnosis: ,Dijagnoza:,
No Diagnosis,Nema dijagnoze,
Drug(s) Prescribed.,Lijek (i) propisani.,
Test(s) Prescribed.,Test (i) propisani.,
Procedure(s) Prescribed.,Propisani postupak (i).,
Counts Completed: {0},Brojanja završena: {0},
Patient Assessment,Procjena pacijenta,
Assessments,Procjene,
Heads (or groups) against which Accounting Entries are made and balances are maintained.,Šefovi (ili skupine) od kojih računovodstvenih unosa su i sredstva su održavani.,
Account Name,Naziv računa,
Inter Company Account,Inter račun tvrtke,
Parent Account,Nadređeni račun,
Setting Account Type helps in selecting this Account in transactions.,Postavljanje Vrsta računa pomaže u odabiru ovaj račun u prometu.,
Chargeable,Naplativ,
Rate at which this tax is applied,Stopa po kojoj je taj porez se primjenjuje,
Frozen,Zaleđeni,
"If the account is frozen, entries are allowed to restricted users.","Ako je račun zamrznut , unosi dopušteno ograničene korisnike .",
Balance must be,Bilanca mora biti,
Lft,Lft,
Rgt,Rgt,
Old Parent,Stari Roditelj,
Include in gross,Uključite u bruto,
Auditor,Revizor,
Accounting Dimension,Računovodstvena dimenzija,
Dimension Name,Naziv dimenzije,
Dimension Defaults,Zadane dimenzije,
Accounting Dimension Detail,Detalji dimenzije računovodstva,
Default Dimension,Zadana dimenzija,
Mandatory For Balance Sheet,Obavezno za bilancu,
Mandatory For Profit and Loss Account,Obvezno za račun dobiti i gubitka,
Accounting Period,Obračunsko razdoblje,
Period Name,Naziv razdoblja,
Closed Documents,Zatvoreni dokumenti,
Accounts Settings,Postavke računa,
Settings for Accounts,Postavke za račune,
Make Accounting Entry For Every Stock Movement,Provjerite knjiženje za svaki burzi pokreta,
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,
Determine Address Tax Category From,Odredite kategoriju adrese poreza od,
Over Billing Allowance (%),Preko dopunske naplate (%),
Credit Controller,Kreditne kontroler,
Check Supplier Invoice Number Uniqueness,Provjerite Dobavljač Račun broj Jedinstvenost,
Make Payment via Journal Entry,Plaćanje putem Temeljnica,
Unlink Payment on Cancellation of Invoice,Prekini vezu Plaćanje o otkazu fakture,
Book Asset Depreciation Entry Automatically,Automatski ulazi u amortizaciju imovine u knjizi,
Automatically Add Taxes and Charges from Item Tax Template,Automatski dodajte poreze i pristojbe sa predloška poreza na stavke,
Automatically Fetch Payment Terms,Automatski preuzmi Uvjete plaćanja,
Show Payment Schedule in Print,Prikaži raspored plaćanja u ispisu,
Currency Exchange Settings,Postavke mjenjačke valute,
Allow Stale Exchange Rates,Dopusti stale tečaj,
Stale Days,Dani tišine,
Report Settings,Postavke izvješća,
Use Custom Cash Flow Format,Koristite prilagođeni format novčanog toka,
Allowed To Transact With,Dopušteno za transakciju s,
SWIFT number,SWIFT broj,
Branch Code,Kod podružnice,
Address and Contact,Kontakt,
Address HTML,Adressa u HTML-u,
Contact HTML,Kontakt HTML,
Data Import Configuration,Konfiguracija uvoza podataka,
Bank Transaction Mapping,Kartiranje bankovnih transakcija,
Plaid Access Token,Plaid Access Token,
Company Account,Račun tvrtke,
Account Subtype,Podvrsta računa,
Is Default Account,Je zadani račun,
Is Company Account,Je li račun tvrtke,
Party Details,Detalji stranke,
Account Details,Detalji računa,
IBAN,IBAN,
Bank Account No,Bankovni račun br,
Integration Details,Detalji integracije,
Integration ID,Integracijski ID,
Last Integration Date,Zadnji datum integracije,
Change this date manually to setup the next synchronization start date,Ručno promijenite ovaj datum da biste postavili sljedeći datum početka sinkronizacije,
Mask,Maska,
Bank Account Subtype,Podvrsta bankovnog računa,
Bank Account Type,Vrsta bankovnog računa,
Bank Guarantee,Jamstvo banke,
Bank Guarantee Type,Vrsta bankarskog jamstva,
Receiving,Primanje,
Providing,pružanje,
Reference Document Name,Referentni naziv dokumenta,
Validity in Days,Valjanost u danima,
Bank Account Info,Podaci o bankovnom računu,
Clauses and Conditions,Klauzule i uvjeti,
Other Details,Ostali detalji,
Bank Guarantee Number,Broj bankarske garancije,
Name of Beneficiary,Naziv Korisnika,
Margin Money,Margin Money,
Charges Incurred,Naplaćeni troškovi,
Fixed Deposit Number,Fiksni broj pologa,
Account Currency,Valuta računa,
Select the Bank Account to reconcile.,Odaberite bankovni račun da biste ga uskladili.,
Include Reconciled Entries,Uključi pomirio objave,
Get Payment Entries,Dobiti Ulaz plaćanja,
Payment Entries,Prijave plaćanja,
Update Clearance Date,Ažurirajte provjeri datum,
Bank Reconciliation Detail,Banka Pomirenje Detalj,
Cheque Number,Ček Broj,
Cheque Date,Ček Datum,
Statement Header Mapping,Mapping Header Izjave,
Statement Headers,Izrazi Headers,
Transaction Data Mapping,Mapping podataka transakcija,
Mapped Items,Mapped Items,
Bank Statement Settings Item,Postavka bankovne izjave,
Mapped Header,Mapped Header,
Bank Header,Bank Header,
Bank Statement Transaction Entry,Unos transakcije bankovnih transakcija,
Bank Transaction Entries,Unosi bankovnih transakcija,
New Transactions,Nove transakcije,
Match Transaction to Invoices,Podudaranje transakcije s fakturama,
Create New Payment/Journal Entry,Izradi novu uplatu / unos dnevnika,
Submit/Reconcile Payments,Pošaljite / Uskladite plaćanja,
Matching Invoices,Usklađivanje faktura,
Payment Invoice Items,Stavke fakture za plaćanje,
Reconciled Transactions,Usklađene transakcije,
Bank Statement Transaction Invoice Item,Stavka transakcijske fakture bankovne izjave,
Payment Description,Opis plaćanja,
Invoice Date,Datum računa,
invoice,dostavnica,
Bank Statement Transaction Payment Item,Stavka plaćanja transakcije bankovne izjave,
outstanding_amount,preostali iznos,
Payment Reference,Uputstvo za plaćanje,
Bank Statement Transaction Settings Item,Stavka o postavkama transakcije bankovne izjave,
Bank Data,Podaci o bankama,
Mapped Data Type,Vrsta kartiranog podataka,
Mapped Data,Prijenos podataka,
Bank Transaction,Bankovna transakcija,
ACC-BTN-.YYYY.-,ACC-BTN-.YYYY.-,
Transaction ID,ID transakcije,
Unallocated Amount,Nealocirano Količina,
Field in Bank Transaction,Polje u bankovnoj transakciji,
Column in Bank File,Stupac u datoteci banke,
Bank Transaction Payments,Plaćanja putem bankovnih transakcija,
Control Action,Kontrolna radnja,
Applicable on Material Request,Primjenjivo na zahtjev za materijal,
Action if Annual Budget Exceeded on MR,Postupak ako je godišnji proračun prekoračen na MR,
Warn,Upozoriti,
Ignore,Ignorirati,
Action if Accumulated Monthly Budget Exceeded on MR,Akcija ako je gomilanje mjesečnog proračuna premašeno na MR,
Applicable on Purchase Order,Primjenjivo na narudžbenicu,
Action if Annual Budget Exceeded on PO,Postupak ako je godišnji proračun prekoračen na PO,
Action if Accumulated Monthly Budget Exceeded on PO,Ako je akumulirani mjesečni proračun premašen na PO,
Applicable on booking actual expenses,Primjenjivo pri rezerviranju stvarnih troškova,
Action if Annual Budget Exceeded on Actual,Postupak ako je godišnji proračun prekoračen na stvarnom,
Action if Accumulated Monthly Budget Exceeded on Actual,Akcija ako je akumulirani mjesečni proračun premašen na stvarnu,
Budget Accounts,Proračun računa,
Budget Account,proračun računa,
Budget Amount,Iznos proračuna,
C-Form,C-obrazac,
ACC-CF-.YYYY.-,ACC-CF-.YYYY.-,
C-Form No,C-obrazac br,
Received Date,Datum pozicija,
Quarter,Četvrtina,
I,ja,
II,II,
III,III,
IV,IV,
C-Form Invoice Detail,C-obrazac detalj računa,
Invoice No,Račun br,
Cash Flow Mapper,Mapper novčanog toka,
Section Name,Naziv odjeljka,
Section Header,Header odjeljka,
Section Leader,Voditelj odsjeka,
e.g Adjustments for:,npr. prilagodbe za:,
Section Subtotal,Podskupina odjeljka,
Section Footer,Podnožje podatka,
Cash Flow Mapping,Mapiranje novčanog toka,
Select Maximum Of 1,Odaberite Maksimalno od 1,
Is Finance Cost,Je li trošak financiranja,
Is Working Capital,Radni kapital,
Is Finance Cost Adjustment,Je li prilagodba troškova financija,
Is Income Tax Liability,Je li obveza poreza na dobit,
Is Income Tax Expense,Je li trošak poreza na dohodak,
Cash Flow Mapping Accounts,Računi za mapiranje novčanog toka,
account,Račun,
Cash Flow Mapping Template,Predložak za mapiranje novčanog toka,
Cash Flow Mapping Template Details,Pojedinosti o predlošku mapiranja novčanog toka,
POS-CLO-,POS-CLO-,
Custody,starateljstvo,
Net Amount,Neto Iznos,
Cashier Closing Payments,Blagajna isplata blagajnika,
Chart of Accounts Importer,Kontni plan Uvoznik,
Import Chart of Accounts from a csv file,Uvezi račun s CSV datoteke,
Attach custom Chart of Accounts file,Priložite datoteku prilagođenog računa računa,
Chart Preview,Pregled grafikona,
Chart Tree,Stablo grafikona,
Cheque Print Template,Ček Predložak Ispis,
Has Print Format,Ima format ispisa,
Primary Settings,Primarne postavke,
Cheque Size,Ček Veličina,
Regular,redovan,
Starting position from top edge,Početni položaj od gornjeg ruba,
Cheque Width,Ček Širina,
Cheque Height,Ček Visina,
Scanned Cheque,Scanned Ček,
Is Account Payable,Je li račun naplativo,
Distance from top edge,Udaljenost od gornjeg ruba,
Distance from left edge,Udaljenost od lijevog ruba,
Message to show,Poruka za prikaz,
Date Settings,Datum Postavke,
Starting location from left edge,Počevši lokaciju od lijevog ruba,
Payer Settings,Postavke Payer,
Width of amount in word,Širina iznosa u riječi,
Line spacing for amount in words,Prored za iznos u riječima,
Amount In Figure,Iznos u slici,
Signatory Position,potpisnik pozicija,
Closed Document,Zatvoreni dokument,
Track separate Income and Expense for product verticals or divisions.,Pratite poseban prihodi i rashodi za vertikala proizvoda ili podjele.,
Cost Center Name,Troška Name,
Parent Cost Center,Nadređeni troškovni centar,
lft,LFT,
rgt,RGT,
Coupon Code,Kupon kod,
Coupon Name,Naziv kupona,
"e.g. ""Summer Holiday 2019 Offer 20""",npr. &quot;Ljetni odmor 201 ponuda 20&quot;,
Coupon Type,Vrsta kupona,
Promotional,reklamni,
Gift Card,Poklon kartica,
unique e.g. SAVE20  To be used to get discount,jedinstven npr. SAVE20 Da biste koristili popust,
Validity and Usage,Valjanost i upotreba,
Valid From,Vrijedi od,
Valid Upto,Vrijedi do,
Maximum Use,Maksimalna upotreba,
Used,koristi,
Coupon Description,Opis kupona,
Discounted Invoice,Račun s popustom,
Debit to,Zadužiti za,
Exchange Rate Revaluation,Revalorizacija tečaja,
Get Entries,Dobijte unose,
Exchange Rate Revaluation Account,Račun revalorizacije tečaja,
Total Gain/Loss,Ukupni dobitak / gubitak,
Balance In Account Currency,Saldo u valuti računa,
Current Exchange Rate,Trenutačna tečajna lista,
Balance In Base Currency,Stanje u valuti baze,
New Exchange Rate,Novi tečaj,
New Balance In Base Currency,Novi saldo u osnovnoj valuti,
Gain/Loss,Dobit / Gubitak,
**Fiscal Year** represents a Financial Year. All accounting entries and other major transactions are tracked against **Fiscal Year**.,**Fiskalna godina** predstavlja poslovnu godinu. Svi računovodstvene stavke i druge glavne transakcije su praćene od **Fiskalne godine**.,
Year Name,Naziv godine,
"For e.g. 2012, 2012-13","Za npr. 2012, 2012-13",
Year Start Date,Početni datum u godini,
Year End Date,Završni datum godine,
Companies,Tvrtke,
Auto Created,Auto Created,
Stock User,Stock Korisnik,
Fiscal Year Company,Fiskalna godina - tvrtka,
Debit Amount,Duguje iznos,
Credit Amount,Kreditni iznos,
Debit Amount in Account Currency,Debitna Iznos u valuti računa,
Credit Amount in Account Currency,Kreditna Iznos u valuti računa,
Voucher Detail No,Bon Detalj Ne,
Is Opening,Je Otvaranje,
Is Advance,Je Predujam,
To Rename,Za preimenovanje,
GST Account,GST račun,
CGST Account,CGST račun,
SGST Account,SGST račun,
IGST Account,IGST račun,
CESS Account,CESS račun,
Loan Start Date,Datum početka zajma,
Loan Period (Days),Razdoblje zajma (dani),
Loan End Date,Datum završetka zajma,
Bank Charges,Bankovne naknade,
Short Term Loan Account,Kratkoročni račun zajma,
Bank Charges Account,Račun bankovnih naknada,
Accounts Receivable Credit Account,Račun za naplatu potraživanja,
Accounts Receivable Discounted Account,Račun s diskontiranim potraživanjima,
Accounts Receivable Unpaid Account,Neplaćeni račun za potraživanja,
Item Tax Template,Predložak poreza na stavku,
Tax Rates,Porezne stope,
Item Tax Template Detail,Detalj predloška predloška poreza,
Entry Type,Ulaz Tip,
Inter Company Journal Entry,Unos dnevnika Inter tvrtke,
Bank Entry,Bank Stupanje,
Cash Entry,Novac Stupanje,
Credit Card Entry,Credit Card Stupanje,
Contra Entry,Contra Stupanje,
Excise Entry,Trošarine Stupanje,
Write Off Entry,Otpis unos,
Opening Entry,Otvaranje - ulaz,
ACC-JV-.YYYY.-,ACC-JV-.YYYY.-,
Accounting Entries,Računovodstvenih unosa,
Total Debit,Ukupno zaduženje,
Total Credit,Ukupna kreditna,
Difference (Dr - Cr),Razlika ( dr. - Cr ),
Make Difference Entry,Čine razliku Entry,
Total Amount Currency,Ukupno Valuta Iznos,
Total Amount in Words,Ukupan iznos riječima,
Remark,Primjedba,
Paid Loan,Plaćeni zajam,
Inter Company Journal Entry Reference,Referentni referentni časopis za tvrtke,
Write Off Based On,Otpis na temelju,
Get Outstanding Invoices,Kreiraj neplaćene račune,
Write Off Amount,Otpis iznosa,
Printing Settings,Ispis Postavke,
Pay To / Recd From,Platiti do / primiti od,
Payment Order,Nalog za plaćanje,
Subscription Section,Odjeljak za pretplatu,
Journal Entry Account,Temeljnica račun,
Account Balance,Bilanca računa,
Party Balance,Bilanca stranke,
Accounting Dimensions,Računovodstvene dimenzije,
If Income or Expense,Ako prihoda i rashoda,
Exchange Rate,Tečaj,
Debit in Company Currency,Zaduženja tvrtke valuti,
Credit in Company Currency,Kredit u trgovačkim društvima valuti,
Payroll Entry,Ulazak plaće,
Employee Advance,Predujam zaposlenika,
Reference Due Date,Referentni datum dospijeća,
Loyalty Program Tier,Razina lojalnosti,
Redeem Against,Otkupiti protiv,
Expiry Date,Datum isteka,
Loyalty Point Entry Redemption,Otkup ulaska u Loyalty Point,
Redemption Date,Datum otkupa,
Redeemed Points,Otkupljene točke,
Loyalty Program Name,Ime programa za lojalnost,
Loyalty Program Type,Vrsta programa vjernosti,
Single Tier Program,Program jednog stupnja,
Multiple Tier Program,Multiple Tier program,
Customer Territory,Teritorij korisnika,
Auto Opt In (For all customers),Automatsko uključivanje (za sve korisnike),
Collection Tier,Zbirka Tier,
Collection Rules,Pravila za prikupljanje,
Redemption,otkup,
Conversion Factor,Konverzijski faktor,
1 Loyalty Points = How much base currency?,1 lojalnost bodova = kolika bazna valuta?,
Expiry Duration (in days),Trajanje isteka (u danima),
Help Section,Odjeljak za pomoć,
Loyalty Program Help,Pomoć za program vjernosti,
Loyalty Program Collection,Zbirka programa lojalnosti,
Tier Name,Tier Name,
Minimum Total Spent,Minimalno ukupno potrošeno,
Collection Factor (=1 LP),Faktor zbirke (= 1 LP),
For how much spent = 1 Loyalty Point,Koliko potrošeno = 1 Loyalty Point,
Mode of Payment Account,Način plaćanja računa,
Default Account,Zadani račun,
Default account will be automatically updated in POS Invoice when this mode is selected.,Zadani račun automatski će se ažurirati u POS fakturu kada je ovaj način odabran.,
**Monthly Distribution** helps you distribute the Budget/Target across months if you have seasonality in your business.,"** Mjesečna distribucija ** pomaže vam rasporediti proračun / Target preko mjeseca, ako imate sezonalnost u Vašem poslovanju.",
Distribution Name,Naziv distribucije,
Name of the Monthly Distribution,Naziv mjesečne distribucije,
Monthly Distribution Percentages,Mjesečni postotci distribucije,
Monthly Distribution Percentage,Mjesečni postotak distribucije,
Percentage Allocation,Postotak raspodjele,
Create Missing Party,Stvorite stranu koja nedostaje,
Create missing customer or supplier.,Stvorite nedostaje kupca ili dobavljača.,
Opening Invoice Creation Tool Item,Stavka Alata za stvaranje fakture otvaranja,
Temporary Opening Account,Privremeni račun otvaranja,
Party Account,Račun stranke,
Type of Payment,Vrsta plaćanja,
ACC-PAY-.YYYY.-,ACC-PAY-.YYYY.-,
Receive,Primite,
Internal Transfer,Interni premještaj,
Payment Order Status,Status naloga za plaćanje,
Payment Ordered,Plaćanje je naručeno,
Payment From / To,Plaćanje Od / Do,
Company Bank Account,Bankovni račun tvrtke,
Party Bank Account,Račun stranke,
Account Paid From,Račun se plaća iz,
Account Paid To,Račun plaćeni za,
Paid Amount (Company Currency),Plaćeni iznos (Društvo valuta),
Received Amount,primljeni iznos,
Received Amount (Company Currency),Primljeni Iznos (Društvo valuta),
Get Outstanding Invoice,Nabavite izvanredni račun,
Payment References,Reference plaćanja,
Writeoff,Otpisati,
Total Allocated Amount,Ukupni raspoređeni iznos,
Total Allocated Amount (Company Currency),Ukupno Dodijeljeni iznos (Društvo valuta),
Set Exchange Gain / Loss,Postavite Exchange dobici / gubici,
Difference Amount (Company Currency),Razlika Iznos (Društvo valuta),
Write Off Difference Amount,Otpis razlika visine,
Deductions or Loss,Odbitaka ili gubitak,
Payment Deductions or Loss,Odbici plaćanja ili gubitak,
Cheque/Reference Date,Ček / Referentni datum,
Payment Entry Deduction,Plaćanje Ulaz Odbitak,
Payment Entry Reference,Plaćanje Ulaz Referenca,
Allocated,Dodijeljeni,
Payment Gateway Account,Payment Gateway račun,
Payment Account,Račun za plaćanje,
Default Payment Request Message,Zadana Zahtjev Plaćanje poruku,
PMO-,PMO-,
Payment Order Type,Vrsta naloga za plaćanje,
Payment Order Reference,Referentni nalog za plaćanje,
Bank Account Details,Detalji bankovnog računa,
Payment Reconciliation,Pomirenje plaćanja,
Receivable / Payable Account,Potraživanja / Plaća račun,
Bank / Cash Account,Banka / Cash račun,
From Invoice Date,Iz dostavnice Datum,
To Invoice Date,Za Račun Datum,
Minimum Invoice Amount,Minimalni iznos fakture,
Maximum Invoice Amount,Maksimalna Iznos dostavnice,
System will fetch all the entries if limit value is zero.,Sustav će preuzeti sve unose ako je granična vrijednost jednaka nuli.,
Get Unreconciled Entries,Kreiraj neusklađene ulaze,
Unreconciled Payment Details,Nesaglašen Detalji plaćanja,
Invoice/Journal Entry Details,Račun / Temeljnica Detalji,
Payment Reconciliation Invoice,Pomirenje Plaćanje fakture,
Invoice Number,Račun broj,
Payment Reconciliation Payment,Pomirenje Plaćanje Plaćanje,
Reference Row,Referentni Row,
Allocated amount,Dodijeljeni iznos,
Payment Request Type,Vrsta zahtjeva za plaćanje,
Outward,van,
Inward,Unutra,
ACC-PRQ-.YYYY.-,ACC-PRQ-.YYYY.-,
Transaction Details,detalji transakcije,
Amount in customer's currency,Iznos u valuti kupca,
Is a Subscription,Je li pretplata,
Transaction Currency,transakcija valuta,
Subscription Plans,Planovi pretplate,
SWIFT Number,SWIFT broj,
Recipient Message And Payment Details,Primatelj poruke i podatke o plaćanju,
Make Sales Invoice,Napravi prodajni račun,
Mute Email,Mute e,
payment_url,payment_url,
Payment Gateway Details,Payment Gateway Detalji,
Payment Schedule,Raspored plaćanja,
Invoice Portion,Dio dostavnice,
Payment Amount,Iznos za plaćanje,
Payment Term Name,Naziv plaćanja,
Due Date Based On,Datum dospijeća na temelju,
Day(s) after invoice date,Dan (a) nakon datuma fakture,
Day(s) after the end of the invoice month,Dan (i) nakon završetka mjeseca fakture,
Month(s) after the end of the invoice month,Mjesec (i) nakon završetka mjeseca fakture,
Credit Days,Kreditne Dani,
Credit Months,Mjeseci kredita,
Allocate Payment Based On Payment Terms,Dodijelite plaćanje na temelju uvjeta plaćanja,
"If this checkbox is checked, paid amount will be splitted and allocated as per the amounts in payment schedule against each payment term","Ako je ovaj potvrdni okvir označen, uplaćeni iznos podijelit će se i rasporediti prema iznosima u rasporedu plaćanja prema svakom roku plaćanja",
Payment Terms Template Detail,Detalji o predlošku uvjeta plaćanja,
Closing Fiscal Year,Zatvaranje Fiskalna godina,
Closing Account Head,Zatvaranje računa šefa,
"The account head under Liability or Equity, in which Profit/Loss will be booked","Glava račun pod odgovornosti ili glavnice, u kojem Dobit / gubitak će biti rezervirano",
POS Customer Group,POS Korisnička Grupa,
POS Field,POS polje,
POS Item Group,POS Točka Grupa,
Company Address,adresa tvrtke,
Update Stock,Ažuriraj zalihe,
Ignore Pricing Rule,Ignorirajte Cijene pravilo,
Applicable for Users,Primjenjivo za korisnike,
Sales Invoice Payment,Prodaja fakture za plaćanje,
Item Groups,stavka Grupe,
Only show Items from these Item Groups,Prikažite samo stavke iz ovih grupa predmeta,
Customer Groups,kupaca Grupe,
Only show Customer of these Customer Groups,Pokaži samo kupca ovih korisničkih grupa,
Write Off Account,Napišite Off račun,
Write Off Cost Center,Otpis troška,
Account for Change Amount,Račun za promjene visine,
Taxes and Charges,Porezi i naknade,
Apply Discount On,Nanesite popusta na,
POS Profile User,Korisnik POS profila,
Apply On,Nanesite na,
Price or Product Discount,Popust na cijenu ili proizvod,
Apply Rule On Item Code,Primijenite pravilo na kod predmeta,
Apply Rule On Item Group,Primijeni pravilo na grupu predmeta,
Apply Rule On Brand,Primijeni pravilo na marku,
Mixed Conditions,Mješoviti uvjeti,
Conditions will be applied on all the selected items combined. ,Uvjeti će se primjenjivati na sve odabrane stavke zajedno.,
Is Cumulative,Je kumulativno,
Coupon Code Based,Na temelju koda kupona,
Discount on Other Item,Popust na drugi artikl,
Apply Rule On Other,Primijenite Pravilo na ostalo,
Party Information,Informacije o zabavi,
Quantity and Amount,Količina i količina,
Min Qty,Min kol,
Max Qty,Maksimalna količina,
Min Amt,Min Amt,
Max Amt,Max Amt,
Period Settings,Postavke razdoblja,
Margin,Marža,
Margin Type,Margina Vrsta,
Margin Rate or Amount,Margina brzine ili količine,
Price Discount Scheme,Shema popusta na cijene,
Rate or Discount,Stopa ili Popust,
Discount Percentage,Postotak popusta,
Discount Amount,Iznos popusta,
For Price List,Za cjenik,
Product Discount Scheme,Shema popusta na proizvode,
Same Item,Ista stavka,
Free Item,Besplatna stavka,
Threshold for Suggestion,Prag za prijedlog,
System will notify to increase or decrease quantity or amount ,Sustav će obavijestiti da poveća ili smanji količinu ili količinu,
"Higher the number, higher the priority","Veći broj, veći prioritet",
Apply Multiple Pricing Rules,Primijenite više pravila o cijenama,
Apply Discount on Rate,Primijenite popust na rate,
Validate Applied Rule,Potvrdite primijenjeno pravilo,
Rule Description,Opis pravila,
Pricing Rule Help,Pravila cijena - pomoć,
Promotional Scheme Id,ID promotivne sheme,
Promotional Scheme,Promotivna shema,
Pricing Rule Brand,Marka pravila o cijenama,
Pricing Rule Detail,Detalj pravila o cijenama,
Child Docname,Ime djeteta,
Rule Applied,Pravilo se primjenjuje,
Pricing Rule Item Code,Pravilo cijene Kôd predmeta,
Pricing Rule Item Group,Skupina stavki pravila o cijenama,
Price Discount Slabs,Ploče s popustom na cijene,
Promotional Scheme Price Discount,Popust na cijene promotivne sheme,
Product Discount Slabs,Ploče s popustom na proizvode,
Promotional Scheme Product Discount,Popust na promotivne sheme,
Min Amount,Min. Iznos,
Max Amount,Maksimalni iznos,
Discount Type,Vrsta popusta,
ACC-PINV-.YYYY.-,ACC-PINV-.YYYY.-,
Tax Withholding Category,Kategorija zadržavanja poreza,
Edit Posting Date and Time,Uredi datum knjiženja i vrijeme,
Is Paid,je plaćen,
Is Return (Debit Note),Je li povrat (debitna bilješka),
Apply Tax Withholding Amount,Primijenite iznos zadržavanja poreza,
Accounting Dimensions ,Računovodstvene dimenzije,
Supplier Invoice Details,Dobavljač Detalji Račun,
Supplier Invoice Date,Dobavljač Datum fakture,
Return Against Purchase Invoice,Povratak protiv fakturi,
Select Supplier Address,Odaberite Dobavljač adresa,
Contact Person,Kontakt osoba,
Select Shipping Address,Odaberite Adresa za dostavu,
Currency and Price List,Valuta i cjenik,
Price List Currency,Valuta cjenika,
Price List Exchange Rate,Tečaj cjenika,
Set Accepted Warehouse,Postavite Prihvaćeno skladište,
Rejected Warehouse,Odbijen galerija,
Warehouse where you are maintaining stock of rejected items,Skladište na kojem držite zalihe odbijenih proizvoda,
Raw Materials Supplied,Sirovine nabavlja,
Supplier Warehouse,Dobavljač galerija,
Pricing Rules,Pravila cijena,
Supplied Items,Isporučeni pribor,
Total (Company Currency),Ukupno (Društvo valuta),
Net Total (Company Currency),Ukupno neto (valuta tvrtke),
Total Net Weight,Ukupna neto težina,
Shipping Rule,Dostava Pravilo,
Purchase Taxes and Charges Template,Predložak nabavnih poreza i terećenja,
Purchase Taxes and Charges,Nabavni porezi i terećenja,
Tax Breakup,Porezna prekid,
Taxes and Charges Calculation,Porezi i naknade Proračun,
Taxes and Charges Added (Company Currency),Porezi i naknade uvrštenja (Društvo valuta),
Taxes and Charges Deducted (Company Currency),Porezi i naknade Umanjenja (Društvo valuta),
Total Taxes and Charges (Company Currency),Ukupno Porezi i naknade (Društvo valuta),
Taxes and Charges Added,Porezi i naknade Dodano,
Taxes and Charges Deducted,Porezi i naknade oduzeti,
Total Taxes and Charges,Ukupno Porezi i naknade,
Additional Discount,Dodatni popust,
Apply Additional Discount On,Nanesite dodatni popust na,
Additional Discount Amount (Company Currency),Dodatni popust Iznos (valuta Društvo),
Additional Discount Percentage,Dodatni postotak popusta,
Additional Discount Amount,Dodatni iznos popusta,
Grand Total (Company Currency),Sveukupno (valuta tvrtke),
Rounding Adjustment (Company Currency),Prilagođavanje zaokruživanja (valuta tvrtke),
Rounded Total (Company Currency),Zaobljeni Ukupno (Društvo valuta),
In Words (Company Currency),Riječima (valuta tvrtke),
Rounding Adjustment,Podešavanje zaokruživanja,
In Words,Riječima,
Total Advance,Ukupno predujma,
Disable Rounded Total,Ugasiti zaokruženi iznos,
Cash/Bank Account,Novac / bankovni račun,
Write Off Amount (Company Currency),Otpis iznos (Društvo valuta),
Set Advances and Allocate (FIFO),Postavi unaprijed i dodijeliti (FIFO),
Get Advances Paid,Kreiraj avansno plaćanje,
Advances,Predujmovi,
Terms,Uvjeti,
Terms and Conditions1,Odredbe i Conditions1,
Group same items,Isti predmeti grupe,
Print Language,Ispis Language,
"Once set, this invoice will be on hold till the set date","Nakon postavljanja, ova će faktura biti na čekanju do zadanog datuma",
Credit To,Kreditne Da,
Party Account Currency,Strana valuta računa,
Against Expense Account,Protiv Rashodi račun,
Inter Company Invoice Reference,Referentna faktura tvrtke Inter Company,
Is Internal Supplier,Je li unutarnji dobavljač,
Start date of current invoice's period,Početak datum tekućeg razdoblja dostavnice,
End date of current invoice's period,Kraj datum tekućeg razdoblja dostavnice,
Update Auto Repeat Reference,Ažuriraj referencu za automatsko ponavljanje,
Purchase Invoice Advance,Ulazni račun - predujam,
Purchase Invoice Item,Proizvod ulaznog računa,
Quantity and Rate,Količina i stopa,
Received Qty,Pozicija Kol,
Accepted Qty,Prihvaćeno Količina,
Rejected Qty,Odbijen Kol,
UOM Conversion Factor,UOM konverzijski faktor,
Discount on Price List Rate (%),Popust na cjenik (%),
Price List Rate (Company Currency),Stopa cjenika (valuta tvrtke),
Rate ,VPC,
Rate (Company Currency),Ocijeni (Društvo valuta),
Amount (Company Currency),Iznos (valuta tvrtke),
Is Free Item,Je besplatna stavka,
Net Rate,Neto stopa,
Net Rate (Company Currency),Neto stopa (Društvo valuta),
Net Amount (Company Currency),Neto iznos (Društvo valuta),
Item Tax Amount Included in Value,Iznos poreza na stavku uključen u vrijednost,
Landed Cost Voucher Amount,Iznos naloga zavisnog troška,
Raw Materials Supplied Cost,Sirovine Isporuka Troškovi,
Accepted Warehouse,Prihvaćeno skladište,
Serial No,Serijski br,
Rejected Serial No,Odbijen Serijski br,
Expense Head,Rashodi voditelj,
Is Fixed Asset,Je nepokretne imovine,
Asset Location,Lokacija imovine,
Deferred Expense,Odgođeni trošak,
Deferred Expense Account,Odgođeni raćun rashoda,
Service Stop Date,Datum zaustavljanja usluge,
Enable Deferred Expense,Omogući odgođeno plaćanje,
Service Start Date,Datum početka usluge,
Service End Date,Datum završetka usluge,
Allow Zero Valuation Rate,Dopusti stopu nulte procjene,
Item Tax Rate,Porezna stopa proizvoda,
Tax detail table fetched from item master as a string and stored in this field.\nUsed for Taxes and Charges,Porezna detalj Tablica preuzeta iz točke majstora kao string i pohranjeni u tom području.\n Koristi se za poreze i troškove,
Purchase Order Item,Stavka narudžbenice,
Purchase Receipt Detail,Detalji potvrde o kupnji,
Item Weight Details,Detalji o težini stavke,
Weight Per Unit,Težina po jedinici,
Total Weight,Totalna tezina,
Weight UOM,Težina UOM,
Page Break,Prijelom stranice,
Consider Tax or Charge for,Razmislite poreza ili pristojbi za,
Valuation and Total,Vrednovanje i Total,
Valuation,Procjena,
Add or Deduct,Zbrajanje ili oduzimanje,
Deduct,Odbiti,
On Previous Row Amount,Na prethodnu Row visini,
On Previous Row Total,Na prethodni redak Ukupno,
On Item Quantity,Na Količina predmeta,
Reference Row #,Reference Row #,
Is this Tax included in Basic Rate?,Je li ovo pristojba uključena u osnovne stope?,
"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",
Account Head,Zaglavlje računa,
Tax Amount After Discount Amount,Iznos poreza Nakon iznosa popusta,
Item Wise Tax Detail ,Pojedinosti o porezu na mudre stavke,
"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.\n\n#### Note\n\nThe 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.\n\n#### Description of Columns\n\n1. Calculation Type: \n    - This can be on **Net Total** (that is the sum of basic amount).\n    - **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.\n    - **Actual** (as mentioned).\n2. Account Head: The Account ledger under which this tax will be booked\n3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.\n4. Description: Description of the tax (that will be printed in invoices / quotes).\n5. Rate: Tax rate.\n6. Amount: Tax amount.\n7. Total: Cumulative total to this point.\n8. 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).\n9. 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.\n10. Add or Deduct: Whether you want to add or deduct the tax.","Standardni porez predložak koji se može primijeniti na sve kupovnih transakcija. Ovaj predložak može sadržavati popis poreznih glava, a također ostalih rashoda glave poput ""brodova"", ""osiguranje"", ""Rukovanje"" itd \n\n #### Napomena \n\n porezna stopa ste odredili ovdje će biti standardna stopa poreza za sve ** Opcije **. Ako postoje ** Predmeti ** koji imaju različite cijene, one moraju biti dodan u ** točke poreza ** stol u ** točke ** majstora.\n\n #### Opis Kolumne \n\n 1. Vrsta Proračun: \n - To može biti na ** Neto Ukupno ** (to je zbroj osnovnog iznosa).\n - ** U odnosu na prethodnu Row ukupno / Iznos ** (za kumulativne poreza ili troškova). Ako odaberete ovu opciju, porez će se primjenjivati postotak prethodnog reda (u poreznom sustavu) iznos ili ukupno.\n - ** Stvarni ** (kao što je navedeno).\n 2. Voditelj račun: knjiga računa pod kojima se ovaj porez će biti rezervirano \n 3. Trošak Centar: Ako porezni / naboj je prihod (kao što su utovar) i rashoda treba biti rezervirano protiv troška.\n 4. Opis: Opis poreza (koji će se tiskati u račune / citati).\n 5. Rate: Porezna stopa.\n 6. Iznos: Iznos poreza.\n 7. Ukupno: Kumulativna ukupno do ove točke.\n 8. Unesite Row: Ako na temelju ""prethodnog retka Ukupno"" možete odabrati broj retka koji će se uzeti kao osnova za ovaj izračun (zadana je prethodni redak).\n 9. Razmislite poreza ili naplatiti za: U ovom dijelu možete odrediti ako porezni / zadužen samo za vrednovanje (nije dio ukupno), ili samo za ukupno (ne dodaju vrijednost predmeta), ili za oboje.\n 10. Dodavanje ili oduzimamo: Bilo da želite dodati ili oduzeti porez.",
ACC-SINV-.YYYY.-,ACC-SINV-.YYYY.-,
Include Payment (POS),Uključi plaćanje (POS),
Offline POS Name,Offline POS Ime,
Is Return (Credit Note),Je li povrat (kreditna bilješka),
Return Against Sales Invoice,Povratak protiv prodaje fakturu,
Update Billed Amount in Sales Order,Ažurirajte količinu naplaćenu u prodajnom nalogu,
Customer PO Details,Detalji o kupcima,
Customer's Purchase Order,Kupca narudžbenice,
Customer's Purchase Order Date,Kupca narudžbenice Datum,
Customer Address,Kupac Adresa,
Shipping Address Name,Dostava Adresa Ime,
Company Address Name,Naziv tvrtke,
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 customer's base currency,Stopa po kojoj Cjenik valute se pretvaraju u kupca osnovne valute,
Set Source Warehouse,Postavi Izvor skladišta,
Packing List,Popis pakiranja,
Packed Items,Pakirani proizvodi,
Product Bundle Help,Proizvod bala Pomoć,
Time Sheet List,Vrijeme Lista list,
Time Sheets,vremenske tablice,
Total Billing Amount,Ukupno naplate Iznos,
Sales Taxes and Charges Template,Prodaja Porezi i pristojbe Predložak,
Sales Taxes and Charges,Prodaja Porezi i naknade,
Loyalty Points Redemption,Otkup lojalnih bodova,
Redeem Loyalty Points,Iskoristite bodove lojalnosti,
Redemption Account,Otkupni račun,
Redemption Cost Center,Otvoreni troškovni centar,
In Words will be visible once you save the Sales Invoice.,U riječi će biti vidljiv nakon što spremite prodaje fakture.,
Allocate Advances Automatically (FIFO),Automatsko dodjeljivanje prednosti (FIFO),
Get Advances Received,Kreiraj avansno primanje,
Base Change Amount (Company Currency),Baza Promjena Iznos (Društvo valuta),
Write Off Outstanding Amount,Otpisati preostali iznos,
Terms and Conditions Details,Uvjeti Detalji,
Is Internal Customer,Interni je kupac,
Is Discounted,Se snižava,
Unpaid and Discounted,Neplaćeno i sniženo,
Overdue and Discounted,Prepušteni i popusti,
Accounting Details,Računovodstvo Detalji,
Debit To,Rashodi za,
Is Opening Entry,je početni unos,
C-Form Applicable,Primjenjivi C-obrazac,
Commission Rate (%),Komisija stopa (%),
Sales Team1,Prodaja Team1,
Against Income Account,Protiv računu dohotka,
Sales Invoice Advance,Predujam prodajnog računa,
Advance amount,Iznos predujma,
Sales Invoice Item,Prodajni proizvodi,
Customer's Item Code,Kupca Stavka Šifra,
Brand Name,Naziv brenda,
Qty as per Stock UOM,Količina po skladišnom UOM-u,
Discount and Margin,Popusti i margina,
Rate With Margin,Ocijenite s marginom,
Discount (%) on Price List Rate with Margin,Popust (%) na Cjeniku s marginom,
Rate With Margin (Company Currency),Ocijenite s marginom (valuta tvrtke),
Delivered By Supplier,Isporučio dobavljač,
Deferred Revenue,Odgođeni prihod,
Deferred Revenue Account,Odgođeni račun prihoda,
Enable Deferred Revenue,Omogućivanje odgođenog prihoda,
Stock Details,Stock Detalji,
Customer Warehouse (Optional),Kupac skladišta (po izboru),
Available Batch Qty at Warehouse,Dostupno Batch Količina na skladištu,
Available Qty at Warehouse,Dostupna količina na skladištu,
Delivery Note Item,Otpremnica proizvoda,
Base Amount (Company Currency),Baza Iznos (Društvo valuta),
Sales Invoice Timesheet,Prodaja Račun timesheet,
Time Sheet,Vrijeme list,
Billing Hours,Radno vrijeme naplate,
Timesheet Detail,timesheet Detalj,
Tax Amount After Discount Amount (Company Currency),Porezna Iznos Nakon Popust Iznos (Društvo valuta),
Item Wise Tax Detail,Stavka Wise Porezna Detalj,
Parenttype,Nadređeni tip,
"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.\n\n#### Note\n\nThe 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.\n\n#### Description of Columns\n\n1. Calculation Type: \n    - This can be on **Net Total** (that is the sum of basic amount).\n    - **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.\n    - **Actual** (as mentioned).\n2. Account Head: The Account ledger under which this tax will be booked\n3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.\n4. Description: Description of the tax (that will be printed in invoices / quotes).\n5. Rate: Tax rate.\n6. Amount: Tax amount.\n7. Total: Cumulative total to this point.\n8. 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).\n9. Is this Tax included in Basic Rate?: If you check this, it means that this tax will not be shown below the item table, but will be included in the Basic Rate in your main item table. This is useful where you want give a flat price (inclusive of all taxes) price to customers.","Standardni porez predložak koji se može primijeniti na sve prodajnih transakcija. Ovaj predložak može sadržavati popis poreznih glava, a također ostali rashodi / dohotka glave poput ""brodova"", ""osiguranje"", ""Rukovanje"" itd \n\n #### Napomena \n\n stopa poreza na vas definirati ovdje će biti standardna stopa poreza za sve ** Opcije **. Ako postoje ** Predmeti ** koji imaju različite cijene, one moraju biti dodan u ** točke poreza ** stol u ** točke ** majstora.\n\n #### Opis Kolumne \n\n 1. Vrsta Proračun: \n - To može biti na ** Neto Ukupno ** (to je zbroj osnovnog iznosa).\n - ** U odnosu na prethodnu Row ukupno / Iznos ** (za kumulativne poreza ili troškova). Ako odaberete ovu opciju, porez će se primjenjivati postotak prethodnog reda (u poreznom sustavu) iznos ili ukupno.\n - ** Stvarni ** (kao što je navedeno).\n 2. Voditelj račun: knjiga računa pod kojima se ovaj porez će biti rezervirano \n 3. Trošak Centar: Ako porezni / naboj je prihod (kao što su utovar) i rashoda treba biti rezervirano protiv troška.\n 4. Opis: Opis poreza (koji će se tiskati u račune / citati).\n 5. Rate: Porezna stopa.\n 6. Iznos: Iznos poreza.\n 7. Ukupno: Kumulativna ukupno do ove točke.\n 8. Unesite Row: Ako na temelju ""prethodnog retka Ukupno"" možete odabrati broj retka koji će se uzeti kao osnova za ovaj izračun (zadana je prethodni redak).\n 9. Je li taj porez uključen u osnovna stopa ?: Ako ste to provjerili, to znači da je taj porez neće biti prikazani ispod točke stola, nego će biti uključeni u osnovne stope u glavnom točkom stolu. To je korisno kada želite dati stan cijenu (uključujući sve poreze) cijene za kupce.",
* Will be calculated in the transaction.,* Bit će izračunata u transakciji.,
From No,Od br,
To No,Za br,
Is Company,Tvrtka,
Current State,Trenutna država,
Purchased,kupljen,
From Shareholder,Od dioničara,
From Folio No,Iz folije br,
To Shareholder,Dioničarima,
To Folio No,Folio br,
Equity/Liability Account,Račun vlasničke i odgovornosti,
Asset Account,Asset Account,
(including),(uključujući),
ACC-SH-.YYYY.-,ACC-SH-.YYYY.-,
Folio no.,Folio br.,
Address and Contacts,Adresa i kontakti,
Contact List,Popis kontakata,
Hidden list maintaining the list of contacts linked to Shareholder,Skriveni popis koji vodi popis kontakata povezanih s Dioničarom,
Specify conditions to calculate shipping amount,Navedite uvjete za izračunavanje iznosa dostave,
Shipping Rule Label,Dostava Pravilo Label,
example: Next Day Shipping,Primjer: Sljedeći dan Dostava,
Shipping Rule Type,Pravilo vrste isporuke,
Shipping Account,Dostava račun,
Calculate Based On,Izračun temeljen na,
Fixed,fiksni,
Net Weight,Neto težina,
Shipping Amount,Dostava Iznos,
Shipping Rule Conditions,Dostava Koje uvjete,
Restrict to Countries,Ograničite na zemlje,
Valid for Countries,Vrijedi za zemlje,
Shipping Rule Condition,Dostava Pravilo Stanje,
A condition for a Shipping Rule,Uvjet za Pravilo isporuke,
From Value,Od Vrijednost,
To Value,Za vrijednost,
Shipping Rule Country,Pravilo dostava Država,
Subscription Period,Razdoblje pretplate,
Subscription Start Date,Datum početka pretplate,
Cancelation Date,Datum otkazivanja,
Trial Period Start Date,Datum početka probnog razdoblja,
Trial Period End Date,Datum završetka probnog razdoblja,
Current Invoice Start Date,Datum početka tekuće fakture,
Current Invoice End Date,Datum završetka tekuće fakture,
Days Until Due,Dani do dospijeća,
Number of days that the subscriber has to pay invoices generated by this subscription,Broj dana za koje pretplatnik mora platiti račune koje je generirala ova pretplata,
Cancel At End Of Period,Odustani na kraju razdoblja,
Generate Invoice At Beginning Of Period,Generiranje fakture na početku razdoblja,
Plans,Planovi,
Discounts,Popusti,
Additional DIscount Percentage,Dodatni Postotak Popust,
Additional DIscount Amount,Dodatni popust Iznos,
Subscription Invoice,Pretplatnička faktura,
Subscription Plan,Plan pretplate,
Cost,cijena,
Billing Interval,Interval naplate,
Billing Interval Count,Brojač intervala naplate,
"Number of intervals for the interval field e.g if Interval is 'Days' and Billing Interval Count is 3, invoices will be generated every 3 days","Broj intervala za polje intervala, npr. Ako Interval je &quot;Dani&quot; i broj intervala naplate je 3, fakture će se generirati svaka 3 dana",
Payment Plan,Plan plaćanja,
Subscription Plan Detail,Detalji o planu pretplate,
Plan,Plan,
Subscription Settings,Postavke pretplate,
Grace Period,Razdoblje milosti,
Number of days after invoice date has elapsed before canceling subscription or marking subscription as unpaid,Broj dana nakon datuma fakture protekao je prije otkazivanja pretplate ili označavanja pretplate kao neplaćen,
Prorate,Proporcionalno podijeliti,
Tax Rule,Porezni Pravilo,
Tax Type,Porezna Tip,
Use for Shopping Cart,Koristite za Košarica,
Billing City,Naplata Grad,
Billing County,županija naplate,
Billing State,Državna naplate,
Billing Zipcode,Poštanski broj za slanje računa,
Billing Country,Naplata Država,
Shipping City,Dostava Grad,
Shipping County,dostava županija,
Shipping State,Državna dostava,
Shipping Zipcode,Dostava poštanski broj,
Shipping Country,Dostava Država,
Tax Withholding Account,Račun za zadržavanje poreza,
Tax Withholding Rates,Stope zadržavanja poreza,
Rates,Cijene,
Tax Withholding Rate,Stopa zadržavanja poreza,
Single Transaction Threshold,Prag pojedinačne transakcije,
Cumulative Transaction Threshold,Kumulativni Prag transakcije,
Agriculture Analysis Criteria,Kriteriji analize poljoprivrede,
Linked Doctype,Povezani Doctype,
Water Analysis,Analiza vode,
Soil Analysis,Analiza tla,
Plant Analysis,Analiza biljaka,
Fertilizer,gnojivo,
Soil Texture,Tekstura tla,
Weather,Vrijeme,
Agriculture Manager,Voditelj poljoprivrede,
Agriculture User,Korisnik poljoprivrede,
Agriculture Task,Zadatak poljoprivrede,
Task Name,Zadatak Naziv,
Start Day,Dan početka,
End Day,Dan završetka,
Holiday Management,Upravljanje odmorom,
Ignore holidays,Zanemari blagdane,
Previous Business Day,Prethodni radni dan,
Next Business Day,Sljedeći radni dan,
Urgent,Hitan,
Crop Name,Naziv usjeva,
Scientific Name,Znanstveno ime,
"You can define all the tasks which need to carried out for this crop here. The day field is used to mention the day on which the task needs to be carried out, 1 being the 1st day, etc.. ","Ovdje možete definirati sve zadatke koji su potrebni za ovaj usjev. Dnevno polje se koristi za spominjanje dana kada se zadatak treba obaviti, 1 je 1. dan itd.",
Crop Spacing,Razmak bjelančevina,
Crop Spacing UOM,Obrezivanje razmaka UOM,
Row Spacing,Spremanje redaka,
Row Spacing UOM,Raspored razmaka UOM,
Perennial,višegodišnji,
Biennial,dvogodišnjica,
Planting UOM,Sadnja UOM-a,
Planting Area,Područje sadnje,
Yield UOM,Prinos UOM,
Materials Required,Potrebni materijali,
Produced Items,Proizvedene stavke,
Produce,proizvoditi,
Byproducts,nusproizvodi,
Linked Location,Povezana lokacija,
A link to all the Locations in which the Crop is growing,Veza na sve lokacije u kojima raste usjeva,
This will be day 1 of the crop cycle,Ovo će biti prvi dan ciklusa usjeva,
ISO 8601 standard,ISO 8601 standard,
Cycle Type,Vrsta ciklusa,
Less than a year,Manje od godinu dana,
The minimum length between each plant in the field for optimum growth,Minimalna duljina između svake biljke u polju za optimalni rast,
The minimum distance between rows of plants for optimum growth,Najmanja udaljenost između redova biljaka za optimalni rast,
Detected Diseases,Otkrivene bolesti,
List of diseases detected on the field. When selected it'll automatically add a list of tasks to deal with the disease ,Popis bolesti otkrivenih na terenu. Kada je odabrana automatski će dodati popis zadataka za rješavanje ove bolesti,
Detected Disease,Otkrivena bolest,
LInked Analysis,LInked analiza,
Disease,Bolest,
Tasks Created,Created Tasks,
Common Name,Uobičajeno ime,
Treatment Task,Zadatak liječenja,
Treatment Period,Razdoblje liječenja,
Fertilizer Name,Ime gnojiva,
Density (if liquid),Gustoća (ako je tekućina),
Fertilizer Contents,Sadržaj gnojiva,
Fertilizer Content,Sadržaj gnojiva,
Linked Plant Analysis,Povezana analiza biljaka,
Linked Soil Analysis,Povezana analiza tla,
Linked Soil Texture,Povezana tekstura tla,
Collection Datetime,Datum datuma prikupljanja,
Laboratory Testing Datetime,Laboratorijsko ispitivanje Datetime,
Result Datetime,Rezultat Datetime,
Plant Analysis Criterias,Criterija analize bilja,
Plant Analysis Criteria,Kriteriji analize biljaka,
Minimum Permissible Value,Minimalna dopuštena vrijednost,
Maximum Permissible Value,Najveća dopuštena vrijednost,
Ca/K,Ca / K,
Ca/Mg,Ca / Mg,
Mg/K,Mg / K,
(Ca+Mg)/K,(+ Ca Mg) / K,
Ca/(K+Ca+Mg),Ca / (K + Ca + Mg),
Soil Analysis Criterias,Kriteriji analize tla,
Soil Analysis Criteria,Kriteriji analize tla,
Soil Type,Vrsta tla,
Loamy Sand,Loamy Sand,
Sandy Loam,Sandy Loam,
Loam,Ilovača,
Silt Loam,Silt Loam,
Sandy Clay Loam,Pješčana Clay Loam,
Clay Loam,Clay Loam,
Silty Clay Loam,Silty Clay Loam,
Sandy Clay,Sandy Clay,
Silty Clay,Silty Clay,
Clay Composition (%),Sastava glina (%),
Sand Composition (%),Sastav pijeska (%),
Silt Composition (%),Sastav kompilacije (%),
Ternary Plot,Ternarna ploča,
Soil Texture Criteria,Kriteriji teksture tla,
Type of Sample,Vrsta uzorka,
Container,kontejner,
Origin,Podrijetlo,
Collection Temperature ,Temperatura zbirke,
Storage Temperature,Temperatura skladištenja,
Appearance,Izgled,
Person Responsible,Osoba odgovorna,
Water Analysis Criteria,Kriteriji analize vode,
Weather Parameter,Parametar vremena,
ACC-ASS-.YYYY.-,ACC-ASS-.YYYY.-,
Asset Owner,Vlasnik imovine,
Asset Owner Company,Tvrtka vlasnika imovine,
Custodian,staratelj,
Disposal Date,Datum Odlaganje,
Journal Entry for Scrap,Temeljnica za otpad,
Available-for-use Date,Datum dostupan za upotrebu,
Calculate Depreciation,Izračunajte amortizaciju,
Allow Monthly Depreciation,Dopustite mjesečnu amortizaciju,
Number of Depreciations Booked,Broj deprecijaciju Rezervirano,
Finance Books,Financijske knjige,
Straight Line,Ravna crta,
Double Declining Balance,Dvaput padu Stanje,
Manual,Priručnik,
Value After Depreciation,Vrijednost Nakon Amortizacija,
Total Number of Depreciations,Ukupan broj deprecijaciju,
Frequency of Depreciation (Months),Učestalost Amortizacija (mjeseci),
Next Depreciation Date,Sljedeći datum Amortizacija,
Depreciation Schedule,Amortizacija Raspored,
Depreciation Schedules,amortizacija Raspored,
Insurance details,Podaci o osiguranju,
Policy number,Broj osiguranja,
Insurer,osiguravač,
Insured value,Osigurana vrijednost,
Insurance Start Date,Datum početka osiguranja,
Insurance End Date,Završni datum osiguranja,
Comprehensive Insurance,Sveobuhvatno osiguranje,
Maintenance Required,Potrebno je održavanje,
Check if Asset requires Preventive Maintenance or Calibration,Provjerite zahtijeva li Asset preventivno održavanje ili umjeravanje,
Booked Fixed Asset,Rezervirano fiksno sredstvo,
Purchase Receipt Amount,Iznos priznavanja kupnje,
Default Finance Book,Zadana knjiga o financiranju,
Quality Manager,Upravitelj kvalitete,
Asset Category Name,Imovina Kategorija Naziv,
Depreciation Options,Opcije amortizacije,
Enable Capital Work in Progress Accounting,Omogući kapitalni rad u računovodstvu u toku,
Finance Book Detail,Financijska knjiga pojedinosti,
Asset Category Account,Imovina Kategorija račun,
Fixed Asset Account,Fiksni račun imovinom,
Accumulated Depreciation Account,Akumulirana amortizacija računa,
Depreciation Expense Account,Amortizacija reprezentaciju,
Capital Work In Progress Account,Račun za kapitalni rad u tijeku,
Asset Finance Book,Financijska knjiga o imovini,
Written Down Value,Pisana vrijednost,
Expected Value After Useful Life,Očekivana vrijednost nakon korisnog vijeka trajanja,
Rate of Depreciation,Stopa amortizacije,
In Percentage,U postocima,
Maintenance Team,Tim za održavanje,
Maintenance Manager Name,Ime upravitelja održavanja,
Maintenance Tasks,Zadatci održavanja,
Manufacturing User,Proizvodni korisnik,
Asset Maintenance Log,Zapisnik o održavanju imovine,
ACC-AML-.YYYY.-,ACC-AML-.YYYY.-,
Maintenance Type,Tip održavanja,
Maintenance Status,Status održavanja,
Planned,Planirani,
Has Certificate ,Ima certifikat,
Certificate,Potvrda,
Actions performed,Radnje izvršene,
Asset Maintenance Task,Zadatak održavanja imovine,
Maintenance Task,Zadatak održavanja,
Preventive Maintenance,Preventivni remont,
Calibration,Kalibriranje,
2 Yearly,2 Godišnje,
Certificate Required,Potvrda je potrebna,
Assign to Name,Dodijeli imenu,
Next Due Date,Sljedeći datum dospijeća,
Last Completion Date,Datum posljednjeg dovršetka,
Asset Maintenance Team,Tim za održavanje imovine,
Maintenance Team Name,Ime tima za održavanje,
Maintenance Team Members,Održavanje članova tima,
Purpose,Svrha,
Stock Manager,Stock Manager,
Asset Movement Item,Stavka kretanja imovine,
Source Location,Izvor lokacije,
From Employee,Od zaposlenika,
Target Location,Ciljana lokacija,
To Employee,Za zaposlenika,
Asset Repair,Popravak imovine,
ACC-ASR-.YYYY.-,ACC-ASR-.YYYY.-,
Failure Date,Datum neuspjeha,
Assign To Name,Dodijeli ime,
Repair Status,Status popravka,
Error Description,Opis pogreške,
Downtime,Prekid rada,
Repair Cost,Popravak troškova,
Manufacturing Manager,Upravitelj proizvodnje,
Current Asset Value,Trenutna vrijednost aktive,
New Asset Value,Nova vrijednost imovine,
Make Depreciation Entry,Provjerite Amortizacija unos,
Finance Book Id,ID knjige financiranja,
Location Name,Naziv lokacije,
Parent Location,Mjesto roditelja,
Is Container,Je li kontejner,
Check if it is a hydroponic unit,Provjerite je li to hidroponična jedinica,
Location Details,Detalji o lokaciji,
Latitude,širina,
Longitude,dužina,
Area,područje,
Area UOM,Područje UOM,
Tree Details,stablo Detalji,
Maintenance Team Member,Odjel za tim za održavanje,
Team Member,Član tima,
Maintenance Role,Uloga za održavanje,
Buying Settings,Ppostavke nabave,
Settings for Buying Module,Postavke za kupnju modula,
Supplier Naming By,Dobavljač nazivanje,
Default Supplier Group,Zadana skupina dobavljača,
Default Buying Price List,Zadani kupovni cjenik,
Backflush Raw Materials of Subcontract Based On,Na temelju sirovina povratne fluktuacije podugovaranja,
Material Transferred for Subcontract,Prijenos materijala za podugovaranje,
Over Transfer Allowance (%),Naknada za prebacivanje prijenosa (%),
Percentage you are allowed to transfer more against the quantity ordered. For example: If you have ordered 100 units. and your Allowance is 10% then you are allowed to transfer 110 units.,"Postotak koji vam dopušta prijenos više u odnosu na naručenu količinu. Na primjer: Ako ste naručili 100 jedinica. a vaš dodatak iznosi 10%, tada vam je omogućen prijenos 110 jedinica.",
PUR-ORD-.YYYY.-,PUR-ORD-.YYYY.-,
Get Items from Open Material Requests,Se predmeti s Otvori Materijal zahtjeva,
Fetch items based on Default Supplier.,Dohvaćajte stavke na temelju zadanog dobavljača.,
Required By,Potrebna Do,
Order Confirmation No,Potvrda narudžbe br,
Order Confirmation Date,Datum potvrde narudžbe,
Customer Mobile No,Kupac mobilne Ne,
Customer Contact Email,Kupac Kontakt e,
Set Target Warehouse,Postavite Ciljni skladište,
Sets 'Warehouse' in each row of the Items table.,Postavlja &#39;Skladište&#39; u svaki redak tablice Predmeti.,
Supply Raw Materials,Supply sirovine,
Purchase Order Pricing Rule,Pravilo cijene narudžbe,
Set Reserve Warehouse,Postavite pričuvnu skladište,
In Words will be visible once you save the Purchase Order.,U riječi će biti vidljiv nakon što spremite narudžbenice.,
Advance Paid,Unaprijed plaćeni,
Tracking,Praćenje,
% Billed,% Naplaćeno,
% Received,% Zaprimljeno,
Ref SQ,Ref. SQ,
Inter Company Order Reference,Inter Company Referenca naloga,
Supplier Part Number,Dobavljač Broj dijela,
Billed Amt,Naplaćeno Amt,
Warehouse and Reference,Skladište i reference,
To be delivered to customer,Da biste se dostaviti kupcu,
Material Request Item,Zahtjev za robom - proizvod,
Supplier Quotation Item,Dobavljač ponudu artikla,
Against Blanket Order,Protiv blanketnog reda,
Blanket Order,Narudžba pokrivača,
Blanket Order Rate,Brzina narudžbe,
Returned Qty,Vraćeno Kom,
Purchase Order Item Supplied,Stavka narudžbenice broj,
BOM Detail No,BOM detalji - broj,
Stock Uom,Kataloški UOM,
Raw Material Item Code,Sirovine Stavka Šifra,
Supplied Qty,Isporučena količina,
Purchase Receipt Item Supplied,Zaprimljena stavka iz primke,
Current Stock,Trenutačno stanje skladišta,
PUR-RFQ-.YYYY.-,PUR-RFQ-.YYYY.-,
For individual supplier,Za pojedinog opskrbljivača,
Link to Material Requests,Link do zahtjeva za materijalom,
Message for Supplier,Poruka za dobavljača,
Request for Quotation Item,Zahtjev za ponudu točke,
Required Date,Potrebna Datum,
Request for Quotation Supplier,Zahtjev za ponudu dobavljača,
Send Email,Pošaljite e-poštu,
Quote Status,Status citata,
Download PDF,Preuzmite PDF,
Supplier of Goods or Services.,Dobavljač dobara ili usluga.,
Name and Type,Naziv i tip,
SUP-.YYYY.-,SUP-.YYYY.-,
Default Bank Account,Zadani bankovni račun,
Is Transporter,Je transporter,
Represents Company,Predstavlja tvrtku,
Supplier Type,Dobavljač Tip,
Allow Purchase Invoice Creation Without Purchase Order,Dopusti stvaranje računa za kupnju bez narudžbenice,
Allow Purchase Invoice Creation Without Purchase Receipt,Dopusti stvaranje računa za kupnju bez potvrde o kupnji,
Warn RFQs,Upozorite RFQ-ove,
Warn POs,Upozorite PO-ove,
Prevent RFQs,Spriječiti rasprave,
Prevent POs,Spriječite PO-ove,
Billing Currency,Naplata valuta,
Default Payment Terms Template,Predložak predloženih uvjeta plaćanja,
Block Supplier,Blokirajte dobavljača,
Hold Type,Držite tip,
Leave blank if the Supplier is blocked indefinitely,Ostavite prazno ako je dobavljač blokiran na neodređeno vrijeme,
Default Payable Accounts,Zadane naplativo račune,
Mention if non-standard payable account,Navedite ako je nestandardni račun koji se plaća,
Default Tax Withholding Config,Zadana potvrda zadržavanja poreza,
Supplier Details,Dobavljač Detalji,
Statutory info and other general information about your Supplier,Zakonska info i druge opće informacije o vašem Dobavljaču,
PUR-SQTN-.YYYY.-,PUR-SQTN-.YYYY.-,
Supplier Address,Dobavljač Adresa,
Link to material requests,Link na materijalnim zahtjevima,
Rounding Adjustment (Company Currency,Podešavanje zaokruživanja (valuta tvrtke,
Auto Repeat Section,Auto Repeat Section,
Is Subcontracted,Je podugovarati,
Lead Time in days,Olovo Vrijeme u danima,
Supplier Score,Ocjena dobavljača,
Indicator Color,Boja indikatora,
Evaluation Period,Razdoblje procjene,
Per Week,Tjedno,
Per Month,Na mjesec,
Per Year,Godišnje,
Scoring Setup,Bodovanje postavki,
Weighting Function,Funkcija vaganja,
"Scorecard variables can be used, as well as:\n{total_score} (the total score from that period),\n{period_number} (the number of periods to present day)\n","Mogu se koristiti varijable tablice s rezultatima, kao i: {total_score} (ukupni rezultat iz tog razdoblja), {period_number} (broj razdoblja do današnjeg dana)",
Scoring Standings,Ocjenjivanje poretka,
Criteria Setup,Postavljanje kriterija,
Load All Criteria,Učitaj sve kriterije,
Scoring Criteria,Kriteriji za bodovanje,
Scorecard Actions,Akcije tablice rezultata,
Warn for new Request for Quotations,Upozorenje za novi zahtjev za ponudu,
Warn for new Purchase Orders,Upozorenje za nove narudžbenice,
Notify Supplier,Obavijesti dobavljača,
Notify Employee,Obavijesti zaposlenika,
Supplier Scorecard Criteria,Kriteriji ocjenjivanja dobavljača,
Criteria Name,Naziv kriterija,
Max Score,Maksimalni rezultat,
Criteria Formula,Formula kriterija,
Criteria Weight,Težina kriterija,
Supplier Scorecard Period,Razdoblje ocjena dobavljača,
PU-SSP-.YYYY.-,PU SSP-.YYYY.-,
Period Score,Ocjena razdoblja,
Calculations,izračuni,
Criteria,kriteriji,
Variables,Varijable,
Supplier Scorecard Setup,Postavljanje tablice dobavljača,
Supplier Scorecard Scoring Criteria,Kriterij bodovanja ocjenjivača dobavljača,
Score,Postići,
Supplier Scorecard Scoring Standing,Ocjena ocjenitelja dobiva bodovanje,
Standing Name,Stalni naziv,
Purple,Ljubičasta,
Yellow,Žuta boja,
Orange,naranča,
Min Grade,Min Grade,
Max Grade,Max Grade,
Warn Purchase Orders,Upozorite narudžbenice,
Prevent Purchase Orders,Spriječiti narudžbenice,
Employee ,Zaposlenik,
Supplier Scorecard Scoring Variable,Dobavljačka tabela ocjena varijable,
Variable Name,Variable Name,
Parameter Name,Naziv parametra,
Supplier Scorecard Standing,Stalna ocjena dobavljača,
Notify Other,Obavijesti ostalo,
Supplier Scorecard Variable,Variable Scorecard dobavljača,
Call Log,Popis poziva,
Received By,Primljeno od,
Caller Information,Informacije o pozivaocu,
Contact Name,Kontakt ime,
Lead ,voditi,
Lead Name,Ime potencijalnog kupca,
Ringing,zvonjava,
Missed,Propušteni,
Call Duration in seconds,Trajanje poziva u sekundi,
Recording URL,URL za snimanje,
Communication Medium,Komunikacijski medij,
Communication Medium Type,Komunikacijski medij,
Voice,Glas,
Catch All,Uhvatiti sve,
"If there is no assigned timeslot, then communication will be handled by this group","Ako nema dodijeljenog vremenskog intervala, komunikacija će upravljati ovom skupinom",
Timeslots,vremenskih isječaka,
Communication Medium Timeslot,Srednja komunikacija vremena,
Employee Group,Grupa zaposlenika,
Appointment,Imenovanje,
Scheduled Time,Zakazano vrijeme,
Unverified,Neprovjereno,
Customer Details,Korisnički podaci,
Phone Number,Broj telefona,
Skype ID,Skype ID,
Linked Documents,Povezani dokumenti,
Appointment With,Sastanak s,
Calendar Event,Kalendarski događaj,
Appointment Booking Settings,Postavke rezervacije termina,
Enable Appointment Scheduling,Omogući zakazivanje termina,
Agent Details,Pojedinosti o agentu,
Availability Of Slots,Dostupnost mjesta,
Number of Concurrent Appointments,Broj istodobnih imenovanja,
Agents,agenti,
Appointment Details,Pojedinosti o imenovanju,
Appointment Duration (In Minutes),Trajanje sastanka (u nekoliko minuta),
Notify Via Email,Obavijesti putem e-pošte,
Notify customer and agent via email on the day of the appointment.,Obavijestite kupca i agenta putem e-pošte na dan sastanka.,
Number of days appointments can be booked in advance,Broj dana termina može se unaprijed rezervirati,
Success Settings,Postavke uspjeha,
Success Redirect URL,URL uspjeha za preusmjeravanje,
"Leave blank for home.\nThis is relative to site URL, for example ""about"" will redirect to ""https://yoursitename.com/about""","Ostavite prazno kod kuće. To se odnosi na URL web mjesta, na primjer, &quot;about&quot; će preusmjeriti na &quot;https://yoursitename.com/about&quot;",
Appointment Booking Slots,Slotovi za rezervaciju termina,
Day Of Week,Dan u tjednu,
From Time ,S vremena,
Campaign Email Schedule,Raspored e-pošte kampanje,
Send After (days),Pošaljite nakon (dana),
Signed,potpisan,
Party User,Korisnik stranke,
Unsigned,Nepotpisan,
Fulfilment Status,Status ispunjenja,
N/A,N / A,
Unfulfilled,neispunjen,
Partially Fulfilled,Djelomično ispunjeno,
Fulfilled,ispunjena,
Lapsed,posrnuo,
Contract Period,Trajanje ugovora,
Signee Details,Signee Detalji,
Signee,Signee,
Signed On,Potpisan,
Contract Details,Pojedinosti ugovora,
Contract Template,Predložak ugovora,
Contract Terms,Uvjeti ugovora,
Fulfilment Details,Pojedinosti ispunjenja,
Requires Fulfilment,Zahtijeva ispunjenje,
Fulfilment Deadline,Rok provedbe,
Fulfilment Terms,Uvjeti ispunjenja,
Contract Fulfilment Checklist,Kontrolni popis ispunjavanja ugovora,
Requirement,Zahtjev,
Contract Terms and Conditions,Uvjeti i odredbe ugovora,
Fulfilment Terms and Conditions,Uvjeti ispunjavanja uvjeta,
Contract Template Fulfilment Terms,Uvjeti ispunjenja predloška ugovora,
Email Campaign,Kampanja e-pošte,
Email Campaign For ,Kampanja e-pošte za,
Lead is an Organization,Olovo je organizacija,
CRM-LEAD-.YYYY.-,CRM-OLOVO-.YYYY.-,
Person Name,Osoba ime,
Lost Quotation,Izgubljena Ponuda,
Interested,Zainteresiran,
Converted,Pretvoreno,
Do Not Contact,Ne kontaktirati,
From Customer,Od kupca,
Campaign Name,Naziv kampanje,
Follow Up,Pratiti,
Next Contact By,Sljedeći kontakt od,
Next Contact Date,Sljedeći datum kontakta,
Ends On,Završava,
Address & Contact,Adresa i kontakt,
Mobile No.,Mobitel br.,
Lead Type,Tip potencijalnog kupca,
Channel Partner,Channel Partner,
Consultant,Konzultant,
Market Segment,Tržišni segment,
Industry,Industrija,
Request Type,Zahtjev Tip,
Product Enquiry,Upit,
Request for Information,Zahtjev za informacije,
Suggestions,Prijedlozi,
Blog Subscriber,Blog pretplatnik,
LinkedIn Settings,Postavke LinkedIn-a,
Company ID,ID tvrtke,
OAuth Credentials,Vjerodajnice OAuth,
Consumer Key,Potrošački ključ,
Consumer Secret,Potrošačka tajna,
User Details,Podaci o korisniku,
Person URN,Osoba URN,
Session Status,Status sjednice,
Lost Reason Detail,Detalj o izgubljenom razlogu,
Opportunity Lost Reason,Prilika izgubljen razlog,
Potential Sales Deal,Potencijalni Prodaja Deal,
CRM-OPP-.YYYY.-,CRM-OPP-.YYYY.-,
Opportunity From,Prilika od,
Customer / Lead Name,Kupac / Potencijalni kupac,
Opportunity Type,Tip prilike,
Converted By,Pretvorio,
Sales Stage,Prodajna pozornica,
Lost Reason,Razlog gubitka,
Expected Closing Date,Očekivani datum zatvaranja,
To Discuss,Za Raspravljajte,
With Items,S Stavke,
Probability (%),Vjerojatnost (%),
Contact Info,Kontakt Informacije,
Customer / Lead Address,Kupac / Olovo Adresa,
Contact Mobile No,Kontak GSM,
Enter name of campaign if source of enquiry is campaign,"Unesite naziv kampanje, ako je izvor upit je kampanja",
Opportunity Date,Datum prilike,
Opportunity Item,Prilika proizvoda,
Basic Rate,Osnovna stopa,
Stage Name,Naziv stadija,
Social Media Post,Post na društvenim mrežama,
Post Status,Status objave,
Posted,Objavljeno,
Share On,Dijeli,
Twitter,Cvrkut,
LinkedIn,LinkedIn,
Twitter Post Id,Twitter post Id,
LinkedIn Post Id,LinkedIn Post Id,
Tweet,Cvrkut,
Twitter Settings,Twitter postavke,
API Secret Key,Tajni ključ API-ja,
Term Name,pojam ime,
Term Start Date,Pojam Datum početka,
Term End Date,Pojam Datum završetka,
Academics User,Akademski korisnik,
Academic Year Name,Naziv akademske godine,
Article,Članak,
LMS User,Korisnik LMS-a,
Assessment Criteria Group,Kriteriji za ocjenu Grupa,
Assessment Group Name,Naziv grupe procjena,
Parent Assessment Group,Roditelj Grupa procjena,
Assessment Name,Naziv Procjena,
Grading Scale,ljestvici,
Examiner,Ispitivač,
Examiner Name,Naziv ispitivač,
Supervisor,Nadzornik,
Supervisor Name,Naziv Supervisor,
Evaluate,procijeniti,
Maximum Assessment Score,Maksimalni broj bodova Procjena,
Assessment Plan Criteria,Plan Procjena Kriteriji,
Maximum Score,Maksimalni broj bodova,
Grade,Razred,
Assessment Result Detail,Procjena Detalj Rezultat,
Assessment Result Tool,Procjena Alat Rezultat,
Result HTML,rezultat HTML,
Content Activity,Sadržajna aktivnost,
Last Activity ,Zadnja aktivnost,
Content Question,Sadržajno pitanje,
Question Link,Link pitanja,
Course Name,Naziv predmeta,
Topics,Teme,
Hero Image,Slika heroja,
Default Grading Scale,Zadana ljestvici,
Education Manager,Voditelj obrazovanja,
Course Activity,Aktivnost tečaja,
Course Enrollment,Upis na tečaj,
Activity Date,Datum aktivnosti,
Course Assessment Criteria,Kriteriji za procjenu predmeta,
Weightage,Weightage,
Course Content,Sadržaj predmeta,
Quiz,Kviz,
Program Enrollment,Program za upis,
Enrollment Date,Datum registracije,
Instructor Name,Instruktor Ime,
EDU-CSH-.YYYY.-,EDU-CSH-.YYYY.-,
Course Scheduling Tool,Naravno alat za raspoređivanje,
Course Start Date,Naravno Datum početka,
To TIme,Za vrijeme,
Course End Date,Naravno Datum završetka,
Course Topic,Tema predmeta,
Topic Name,tema Naziv,
Education Settings,Postavke za obrazovanje,
Current Academic Year,Tekuća akademska godina,
Current Academic Term,Trenutni akademski naziv,
Attendance Freeze Date,Datum zamrzavanja pohađanja,
Validate Batch for Students in Student Group,Validirati seriju za studente u grupi studenata,
"For Batch based Student Group, the Student Batch will be validated for every Student from the Program Enrollment.","Za grupu studenata temeljenih na bazi, studentska će se serijska cjelina validirati za svakog studenta iz prijave za program.",
Validate Enrolled Course for Students in Student Group,Validirati upisani tečaj za studente u studentskoj grupi,
"For Course based Student Group, the Course will be validated for every Student from the enrolled Courses in Program Enrollment.","Za Studentsku grupu na tečaju, tečaj će biti validiran za svakog studenta iz upisanih kolegija u upisu na program.",
Make Academic Term Mandatory,Učini akademski pojam obvezan,
"If enabled, field Academic Term will be Mandatory in Program Enrollment Tool.","Ako je omogućeno, polje Akademsko razdoblje bit će obvezno u Alatu za upis na program.",
Skip User creation for new Student,Preskoči stvaranje korisnika za novog učenika,
"By default, a new User is created for every new Student. If enabled, no new User will be created when a new Student is created.","Prema zadanim postavkama za svakog novog učenika stvara se novi korisnik. Ako je omogućeno, novi korisnik neće biti stvoren kada se stvori novi student.",
Instructor Records to be created by,Instruktorski zapisi moraju biti izrađeni od strane,
Employee Number,Broj zaposlenika,
Fee Category,Naknada Kategorija,
Fee Component,Naknada Komponenta,
Fees Category,naknade Kategorija,
Fee Schedule,Naknada Raspored,
Fee Structure,Struktura naknade,
EDU-FSH-.YYYY.-,EDU-FSH-.YYYY.-,
Fee Creation Status,Status kreiranja naknade,
In Process,U procesu,
Send Payment Request Email,Pošaljite e-poštu za zahtjev za plaćanjem,
Student Category,Studentski Kategorija,
Fee Breakup for each student,Otkazivanje naknade za svakog studenta,
Total Amount per Student,Ukupni iznos po studentu,
Institution,Institucija,
Fee Schedule Program,Program rasporeda naknada,
Student Batch,Student serije,
Total Students,Ukupno studenata,
Fee Schedule Student Group,Fee raspored skupinu studenata,
EDU-FST-.YYYY.-,EDU-FST-.YYYY.-,
EDU-FEE-.YYYY.-,EDU-FEE-.YYYY.-,
Include Payment,Uključi plaćanje,
Send Payment Request,Pošalji zahtjev za plaćanje,
Student Details,Pojedinosti studenata,
Student Email,Studentska e-pošta,
Grading Scale Name,Ljestvici Ime,
Grading Scale Intervals,Ljestvici Intervali,
Intervals,intervali,
Grading Scale Interval,Ocjenjivanje ljestvice,
Grade Code,Grade Šifra,
Threshold,Prag,
Grade Description,Razred Opis,
Guardian,Čuvar,
Guardian Name,Naziv Guardian,
Alternate Number,Alternativni broj,
Occupation,Okupacija,
Work Address,Adresa na poslu,
Guardian Of ,staratelj,
Students,Studenti,
Guardian Interests,Guardian Interesi,
Guardian Interest,Guardian kamata,
Interest,Interes,
Guardian Student,Guardian Student,
EDU-INS-.YYYY.-,EDU-INS-.YYYY.-,
Instructor Log,Zapisnik instruktora,
Other details,Ostali detalji,
Option,Opcija,
Is Correct,Je točno,
Program Name,Naziv programa,
Program Abbreviation,naziv programa,
Courses,Tečajevi,
Is Published,Objavljeno je,
Allow Self Enroll,Dopusti samoprijavljivanje,
Is Featured,Je istaknuto,
Intro Video,Intro video,
Program Course,Program predmeta,
School House,Škola Kuća,
Boarding Student,Učenica za ukrcaj,
Check this if the Student is residing at the Institute's Hostel.,Provjerite je li student boravio u Hostelu Instituta.,
Walking,Hodanje,
Institute's Bus,Autobus instituta,
Self-Driving Vehicle,Vozila samostojećih,
Pick/Drop by Guardian,Pick / Drop od strane Guardian,
Enrolled courses,Upisani tečajevi,
Program Enrollment Course,Tečaj za upis na program,
Program Enrollment Fee,Program za upis naknada,
Program Enrollment Tool,Program za upis alat,
Get Students From,Dobiti studenti iz,
Student Applicant,Studentski Podnositelj zahtjeva,
Get Students,dobiti studente,
Enrollment Details,Pojedinosti o upisu,
New Program,Novi program,
New Student Batch,Nova studentska serija,
Enroll Students,upisati studenti,
New Academic Year,Nova akademska godina,
New Academic Term,Novi akademski naziv,
Program Enrollment Tool Student,Program za alat Upis studenata,
Student Batch Name,Studentski Batch Name,
Program Fee,Naknada program,
Question,Pitanje,
Single Correct Answer,Jedan točan odgovor,
Multiple Correct Answer,Više točnih odgovora,
Quiz Configuration,Konfiguracija kviza,
Passing Score,Prolazni rezultat,
Score out of 100,Rezultat od 100,
Max Attempts,Maks pokušaji,
Enter 0 to waive limit,Unesite 0 za odricanje od ograničenja,
Grading Basis,Osnove ocjenjivanja,
Latest Highest Score,Najnoviji najviši rezultat,
Latest Attempt,Najnoviji pokušaj,
Quiz Activity,Aktivnost kviza,
Enrollment,Upis,
Pass,Proći,
Quiz Question,Pitanje za kviz,
Quiz Result,Rezultat kviza,
Selected Option,Odabrana opcija,
Correct,ispravan,
Wrong,pogrešno,
Room Name,Soba Naziv,
Room Number,Broj sobe,
Seating Capacity,Sjedenje Kapacitet,
House Name,Ime kuća,
EDU-STU-.YYYY.-,EDU-STU-.YYYY.-,
Student Mobile Number,Studentski broj mobitela,
Blood Group,Krvna grupa,
A+,A +,
A-,A-,
B+,B +,
B-,B-,
O+,O +,
O-,O-,
AB+,AB +,
AB-,AB,
Nationality,Nacionalnost,
Home Address,Kućna adresa,
Guardian Details,Guardian Detalji,
Guardians,čuvari,
Sibling Details,polubrat Detalji,
Siblings,Braća i sestre,
Exit,Izlaz,
Date of Leaving,Datum Napuštanje,
Leaving Certificate Number,Ostavljajući broj certifikata,
Reason For Leaving,Razlog za odlazak,
Student Admission,Studentski Ulaz,
Admission Start Date,Prijem Datum početka,
Admission End Date,Prijem Datum završetka,
Eligibility and Details,Podobnost i pojedinosti,
Student Admission Program,Program upisa studenata,
Minimum Age,Minimalna dob,
Maximum Age,Maksimalna dob,
Application Fee,Naknada Primjena,
Naming Series (for Student Applicant),Imenovanje serije (za studentske zahtjeva),
LMS Only,Samo LMS,
EDU-APP-.YYYY.-,EDU-APP-.YYYY.-,
Application Date,Datum Primjena,
Student Attendance Tool,Studentski Gledatelja alat,
Group Based On,Grupirano na temelju,
Students HTML,Studenti HTML,
Group Based on,Skupina temeljena na,
Student Group Name,Naziv grupe studenata,
Max Strength,Max snaga,
Set 0 for no limit,Postavite 0 bez granica,
Instructors,Instruktori,
Student Group Creation Tool,Studentski alat za izradu Grupa,
Leave blank if you make students groups per year,Ostavite prazno ako grupe studenata godišnje unesete,
Get Courses,dobiti Tečajevi,
Separate course based Group for every Batch,Odvojena grupa za tečajeve za svaku seriju,
Leave unchecked if you don't want to consider batch while making course based groups. ,Ostavite neoznačeno ako ne želite razmotriti grupu dok stvarate grupe temeljene na tečajima.,
Student Group Creation Tool Course,Tečaj Student Grupa alat za izradu,
Course Code,kod predmeta,
Student Group Instructor,Instruktor grupe studenata,
Student Group Student,Studentski Group Studentski,
Group Roll Number,Broj grupe grupa,
Student Guardian,Studentski Guardian,
Relation,Odnos,
Mother,Majka,
Father,Otac,
Student Language,Student jezika,
Student Leave Application,Studentski Ostavite aplikacija,
Mark as Present,Označi kao sadašnja,
Student Log,Studentski Prijava,
Academic,Akademski,
Achievement,dostignuće,
Student Report Generation Tool,Alat za generiranje izvještaja studenata,
Include All Assessment Group,Uključi sve grupe za procjenu,
Show Marks,Prikaži oznake,
Add letterhead,Dodaj pismo zaglavlja,
Print Section,Ispiši odjeljak,
Total Parents Teacher Meeting,Sastanak učitelja svih roditelja,
Attended by Parents,Prisustvovali su roditelji,
Assessment Terms,Uvjeti procjene,
Student Sibling,Studentski iste razine,
Studying in Same Institute,Studiranje u istom institutu,
NO,NE,
YES,DA,
Student Siblings,Studentski Braća i sestre,
Topic Content,Sadržaj teme,
Amazon MWS Settings,Amazon MWS postavke,
ERPNext Integrations,ERPNext integracije,
Enable Amazon,Omogućite Amazon,
MWS Credentials,MWS vjerodajnice,
Seller ID,ID prodavatelja,
AWS Access Key ID,ID ključa za pristup AWS-u,
MWS Auth Token,MWS autentni token,
Market Place ID,ID mjesta tržišta,
AE,AE,
AU,AU,
BR,BR,
CA,CA,
CN,CN,
DE,DE,
ES,ES,
FR,FR,
JP,JP,
IT,TO,
MX,MX,
UK,Velika Britanija,
US,NAS,
Customer Type,Vrsta kupca,
Market Place Account Group,Grupa računa robne kuće,
After Date,Nakon datuma,
Amazon will synch data updated after this date,Amazon će sinkronizirati podatke ažurirane nakon tog datuma,
Sync Taxes and Charges,Sinkronizirajte poreze i naknade,
Get financial breakup of Taxes and charges data by Amazon ,Preuzmite financijsku raspad poreznih i administrativnih podataka Amazon,
Sync Products,Proizvodi za sinkronizaciju,
Always sync your products from Amazon MWS before synching the Orders details,Uvijek sinkronizirajte svoje proizvode s Amazona MWS prije sinkronizacije detalja narudžbi,
Sync Orders,Sinkroniziraj narudžbe,
Click this button to pull your Sales Order data from Amazon MWS.,Kliknite ovaj gumb da biste povukli podatke o prodajnom nalogu tvrtke Amazon MWS.,
Enable Scheduled Sync,Omogućite planiranu sinkronizaciju,
Check this to enable a scheduled Daily synchronization routine via scheduler,Označite ovu opciju kako biste omogućili planiranu rutinu Dnevne sinkronizacije putem rasporeda,
Max Retry Limit,Maksimalni pokušaj ponovnog pokušaja,
Exotel Settings,Postavke egzotela,
Account SID,SID računa,
API Token,API token,
GoCardless Mandate,Mandat za GoCardless,
Mandate,Mandat,
GoCardless Customer,GoCardless Customer,
GoCardless Settings,Postavke GoCardless,
Webhooks Secret,Webhooks Secret,
Plaid Settings,Postavke pleta,
Synchronize all accounts every hour,Sinkronizirajte sve račune na svakih sat vremena,
Plaid Client ID,Plaid ID klijenta,
Plaid Secret,Plaid Secret,
Plaid Environment,Plaid okoliš,
sandbox,kutija s pijeskom,
development,razvoj,
production,proizvodnja,
QuickBooks Migrator,Migrator za QuickBooks,
Application Settings,Postavke aplikacije,
Token Endpoint,Endpoint Tokena,
Scope,djelokrug,
Authorization Settings,Postavke autorizacije,
Authorization Endpoint,Endpoint autorizacije,
Authorization URL,URL za autorizaciju,
Quickbooks Company ID,ID tvrtke QuickBooks,
Company Settings,Tvrtka Postavke,
Default Shipping Account,Zadani račun za otpreme,
Default Warehouse,Glavno skladište,
Default Cost Center,Zadana troškovnih centara,
Undeposited Funds Account,Neraspoređeni račun sredstava,
Shopify Log,Zapisnik trgovine,
Shopify Settings,Postavke trgovine,
status html,status html,
Enable Shopify,Omogući Shopify,
App Type,Vrsta aplikacije,
Last Sync Datetime,Zadnji datum sinkronizacije,
Shop URL,URL trgovine,
eg: frappe.myshopify.com,npr. frappe.myshopify.com,
Shared secret,Zajednička tajna,
Webhooks Details,Webhooks Detalji,
Webhooks,Webhooks,
Customer Settings,Postavke korisnika,
Default Customer,Zadani kupac,
Customer Group will set to selected group while syncing customers from Shopify,Skupina kupaca postavit će se na odabranu skupinu prilikom sinkronizacije kupaca s Shopify,
For Company,Za tvrtke,
Cash Account will used for Sales Invoice creation,Račun novca upotrebljavat će se za izradu fakture prodaje,
Update Price from Shopify To ERPNext Price List,Ažurirajte cijenu od Shopify do ERPNext Cjenik,
Default Warehouse to to create Sales Order and Delivery Note,Zadana skladišta za izradu narudžbe o prodaji i dostavi,
Sales Order Series,Serija prodajnih naloga,
Import Delivery Notes from Shopify on Shipment,Uvoz isporuke o isporuci iz trgovine na pošiljci,
Delivery Note Series,Serija s isporukom,
Import Sales Invoice from Shopify if Payment is marked,Uvozite prodajnu fakturu od tvrtke Shopify ako je Plaćanje označeno,
Sales Invoice Series,Serija prodajnih faktura,
Shopify Tax Account,Kupnja poreznog računa,
Shopify Tax/Shipping Title,Zapišite porez / dostavu,
ERPNext Account,ERPNext račun,
Shopify Webhook Detail,Detalj Shopify Webhook,
Webhook ID,Webhook ID,
Tally Migration,Tally Migration,
Master Data,Glavni podaci,
"Data exported from Tally that consists of the Chart of Accounts, Customers, Suppliers, Addresses, Items and UOMs","Podaci izvezeni iz Tally-a koji se sastoje od kontnog plana, kupaca, dobavljača, adresa, predmeta i UOM-ova",
Is Master Data Processed,Obrađuju li se glavni podaci,
Is Master Data Imported,Uvezu se glavni podaci,
Tally Creditors Account,Račun vjerovnika Tally-a,
Creditors Account set in Tally,Račun vjerovnika postavljen u Tally,
Tally Debtors Account,Račun dužnika,
Debtors Account set in Tally,Račun dužnika postavljen u Tally,
Tally Company,Tally Company,
Company Name as per Imported Tally Data,Naziv tvrtke prema uvoznim Tally podacima,
Default UOM,Zadani UOM,
UOM in case unspecified in imported data,UOM u slučaju da nije naveden u uvezenim podacima,
ERPNext Company,Tvrtka ERPNext,
Your Company set in ERPNext,Vaša je tvrtka postavljena u ERPNext,
Processed Files,Obrađene datoteke,
Parties,Strane,
UOMs,J. MJ.,
Vouchers,bonovi,
Round Off Account,Zaokružiti račun,
Day Book Data,Podaci o dnevnoj knjizi,
Day Book Data exported from Tally that consists of all historic transactions,Podaci iz dnevne knjige izvezeni iz Tally-a koji se sastoje od svih povijesnih transakcija,
Is Day Book Data Processed,Obrađuju li se podaci dnevnih knjiga,
Is Day Book Data Imported,Uvoze li se podaci dnevnih knjiga,
Woocommerce Settings,Postavke Woocommerce,
Enable Sync,Omogući sinkronizaciju,
Woocommerce Server URL,URL poslužitelja Woocommerce,
Secret,Tajna,
API consumer key,API ključ potrošača,
API consumer secret,API tajna potrošača,
Tax Account,Porezni račun,
Freight and Forwarding Account,Račun za otpremu i prosljeđivanje,
Creation User,Stvaranje korisnika,
"The user that will be used to create Customers, Items and Sales Orders. This user should have the relevant permissions.","Korisnik koji će se koristiti za kreiranje kupaca, predmeta i naloga za prodaju. Taj bi korisnik trebao imati relevantna dopuštenja.",
"This warehouse will be used to create Sales Orders. The fallback warehouse is ""Stores"".",Ovo će se skladište koristiti za izradu prodajnih naloga. Rezervno skladište su &quot;Trgovine&quot;.,
"The fallback series is ""SO-WOO-"".",Povratna serija je &quot;SO-WOO-&quot;.,
This company will be used to create Sales Orders.,Ova će se tvrtka koristiti za izradu prodajnih naloga.,
Delivery After (Days),Dostava nakon (dana),
This is the default offset (days) for the Delivery Date in Sales Orders. The fallback offset is 7 days from the order placement date.,Ovo je zadani offset (dani) za datum isporuke u prodajnim narudžbama. Ponovno nadoknađivanje iznosi 7 dana od datuma slanja narudžbe.,
"This is the default UOM used for items and Sales orders. The fallback UOM is ""Nos"".",Ovo je zadani UOM koji se koristi za artikle i prodajne naloge. Povratni UOM je &quot;Nos&quot;.,
Endpoints,Krajnje točke,
Endpoint,Endpoint,
Antibiotic Name,Ime antibiotika,
Healthcare Administrator,Administrator zdravstva,
Laboratory User,Korisnik laboratorija,
Is Inpatient,Je li bolestan,
Default Duration (In Minutes),Zadano trajanje (u minutama),
Body Part,Dio tijela,
Body Part Link,Link dijela tijela,
HLC-CPR-.YYYY.-,FHP-CPR-.YYYY.-,
Procedure Template,Predložak za postupak,
Procedure Prescription,Postupak na recept,
Service Unit,Servisna jedinica,
Consumables,Potrošni,
Consume Stock,Potrošnja,
Invoice Consumables Separately,Potrošni materijal za fakture zasebno,
Consumption Invoiced,Potrošnja fakturirana,
Consumable Total Amount,Potrošni ukupni iznos,
Consumption Details,Pojedinosti o potrošnji,
Nursing User,Korisnik za njegu,
Clinical Procedure Item,Postupak kliničke procedure,
Invoice Separately as Consumables,Fakturiranje odvojeno kao potrošni materijal,
Transfer Qty,Količina prijenosa,
Actual Qty (at source/target),Stvarni Kol (na izvoru / ciljne),
Is Billable,Je naplativo,
Allow Stock Consumption,Dopusti potrošnju zaliha,
Sample UOM,Uzorak UOM,
Collection Details,Detalji zbirke,
Change In Item,Promjena stavke,
Codification Table,Tablica kodifikacije,
Complaints,pritužbe,
Dosage Strength,Snaga doziranja,
Strength,snaga,
Drug Prescription,Lijek na recept,
Drug Name / Description,Naziv / opis lijeka,
Dosage,Doziranje,
Dosage by Time Interval,Doziranje po vremenskom intervalu,
Interval,Interval,
Interval UOM,Interval UOM,
Hour,Sat,
Update Schedule,Ažuriraj raspored,
Exercise,Vježbajte,
Difficulty Level,Razina težine,
Counts Target,Broji meta,
Counts Completed,Brojanja dovršena,
Assistance Level,Razina pomoći,
Active Assist,Aktivna asistencija,
Exercise Name,Naziv vježbe,
Body Parts,Dijelovi tijela,
Exercise Instructions,Upute za vježbu,
Exercise Video,Video za vježbu,
Exercise Steps,Koraci vježbanja,
Steps Table,Tablica koraka,
Exercise Type Step,Vrsta vježbe Korak,
Max number of visit,Maksimalni broj posjeta,
Visited yet,Još posjetio,
Reference Appointments,Referentna imenovanja,
Valid till,Vrijedi do,
Fee Validity Reference,Referenca valjanosti naknade,
Basic Details,Osnovni detalji,
HLC-PRAC-.YYYY.-,FHP-PRAC-.GGGG.-,
Mobile,Mobilni,
Phone (R),Telefon (R),
Phone (Office),Telefon (ured),
Employee and User Details,Pojedinosti o zaposleniku i korisniku,
Hospital,Bolnica,
Appointments,imenovanja,
Practitioner Schedules,Praktični raspored,
Charges,Naknade,
Out Patient Consulting Charge,Naknada za savjetovanje izvan pacijenta,
Default Currency,Zadana valuta,
Healthcare Schedule Time Slot,Raspored sati za zdravstvenu skrb,
Parent Service Unit,Roditeljska jedinica,
Service Unit Type,Vrsta servisne jedinice,
Allow Appointments,Omogući imenovanja,
Allow Overlap,Dopusti preklapanje,
Inpatient Occupancy,Bolničko liječenje,
Occupancy Status,Status posjeda,
Vacant,prazan,
Occupied,okupiran,
Item Details,Detalji artikla,
UOM Conversion in Hours,UOM pretvorba u satima,
Rate / UOM,Ocijenite / UOM,
Change in Item,Promijeni stavku,
Out Patient Settings,Izvan pacijentskih postavki,
Patient Name By,Ime pacijenta po,
Patient Name,Ime pacijenta,
Link Customer to Patient,Povežite kupca s pacijentom,
"If checked, a customer will be created, mapped to Patient.\nPatient Invoices will be created against this Customer. You can also select existing Customer while creating Patient.","Ako je označeno, izradit će se kupac, mapiran pacijentu. Pacijentne fakture će biti stvorene protiv ovog klijenta. Također možete odabrati postojeći Korisnik tijekom izrade pacijenta.",
Default Medical Code Standard,Zadani standard medicinskog koda,
Collect Fee for Patient Registration,Prikupiti naknadu za registraciju pacijenata,
Checking this will create new Patients with a Disabled status by default and will only be enabled after invoicing the Registration Fee.,"Ako potvrdite ovo, prema zadanim postavkama stvorit će se novi pacijenti sa statusom onemogućenog i bit će omogućeni tek nakon fakturiranja naknade za registraciju.",
Registration Fee,Naknada za registraciju,
Automate Appointment Invoicing,Automatizirajte izdavanje računa,
Manage Appointment Invoice submit and cancel automatically for Patient Encounter,Upravljanje računom za imenovanje slati i poništiti automatski za Pacijentovo susret,
Enable Free Follow-ups,Omogućite besplatna praćenja,
Number of Patient Encounters in Valid Days,Broj susreta pacijenata u valjanim danima,
The number of free follow ups (Patient Encounters in valid days) allowed,Dopušten broj besplatnih praćenja (Susreti pacijenata u važećim danima),
Valid Number of Days,Vrijedi broj dana,
Time period (Valid number of days) for free consultations,Vremensko razdoblje (važeći broj dana) za besplatne konzultacije,
Default Healthcare Service Items,Zadane stavke zdravstvenih usluga,
"You can configure default Items for billing consultation charges, procedure consumption items and inpatient visits","Možete konfigurirati zadane stavke za troškove savjetovanja za naplatu, stavke potrošnje postupaka i stacionarne posjete",
Clinical Procedure Consumable Item,Potrošnja za kliničku proceduru,
Default Accounts,Zadani računi,
Default income accounts to be used if not set in Healthcare Practitioner to book Appointment charges.,Računi zadanih dohodaka koji će se koristiti ako nisu postavljeni u Zdravstvenom liječniku za rezerviranje pristojbi za imenovanje.,
Default receivable accounts to be used to book Appointment charges.,Zadani računi potraživanja koji će se koristiti za knjiženje troškova imenovanja.,
Out Patient SMS Alerts,Out Patient SMS obavijesti,
Patient Registration,Registracija pacijenata,
Registration Message,Poruka o registraciji,
Confirmation Message,Poruka o potvrdi,
Avoid Confirmation,Izbjegnite potvrdu,
Do not confirm if appointment is created for the same day,Nemojte potvrditi je li sastanak izrađen za isti dan,
Appointment Reminder,Podsjetnik za sastanak,
Reminder Message,Poruka podsjetnika,
Laboratory Settings,Laboratorijske postavke,
Create Lab Test(s) on Sales Invoice Submission,Stvorite laboratorijske testove na predaji fakture za prodaju,
Checking this will create Lab Test(s) specified in the Sales Invoice on submission.,"Ako označite ovo, stvorit će se laboratorijski testovi navedeni u Računu prodaje prilikom slanja.",
Create Sample Collection document for Lab Test,Stvorite dokument za prikupljanje uzoraka za laboratorijski test,
Checking this will create a Sample Collection document  every time you create a Lab Test,"Ako potvrdite ovo, stvorit će se dokument sakupljanja uzoraka svaki put kada kreirate laboratorijski test",
Employee name and designation in print,Ime i oznaka zaposlenika u tisku,
Check this if you want the Name and Designation of the Employee associated with the User who submits the document to be printed in the Lab Test Report.,Označite ovo ako želite da se ime i ime zaposlenika povezanog s korisnikom koji preda dokument ispišu u izvješću o laboratorijskom ispitivanju.,
Do not print or email Lab Tests without Approval,Ne ispisujte i ne šaljite laboratorijske testove bez odobrenja,
Checking this will restrict printing and emailing of Lab Test documents unless they have the status as Approved.,"Ako provjerite ovo, ograničit će se ispis i slanje dokumenata laboratorijskih testova po e-pošti, osim ako nemaju status Odobreno.",
Custom Signature in Print,Prilagođeni potpis u tisku,
Laboratory SMS Alerts,Laboratorijske SMS upozorenja,
Result Printed Message,Ispisana poruka rezultata,
Result Emailed Message,Poruka rezultata e-poštom,
Check In,Prijava,
Check Out,Provjeri,
HLC-INP-.YYYY.-,FHP-INP-.YYYY.-,
A Positive,Pozitivan,
A Negative,Negativan,
AB Positive,AB Pozitivan,
AB Negative,AB Negative,
B Positive,B Pozitivan,
B Negative,Negativan,
O Positive,O pozitivno,
O Negative,Negativan,
Date of birth,Datum rođenja,
Admission Scheduled,Zakazan ulaz,
Discharge Scheduled,Zakazano je iskrcavanje,
Discharged,Ispražnjen,
Admission Schedule Date,Datum rasporeda za upis,
Admitted Datetime,Prihvaćeno Datetime,
Expected Discharge,Očekivani iskrcaj,
Discharge Date,Datum izdavanja,
Lab Prescription,Lab Prescription,
Lab Test Name,Naziv laboratorijskog testa,
Test Created,Kreirano testiranje,
Submitted Date,Poslani datum,
Approved Date,Odobreni datum,
Sample ID,ID uzorka,
Lab Technician,Laboratorijski tehničar,
Report Preference,Prednost izvješća,
Test Name,Naziv testiranja,
Test Template,Predložak testa,
Test Group,Test grupa,
Custom Result,Prilagođeni rezultat,
LabTest Approver,LabTest odobrenje,
Add Test,Dodajte test,
Normal Range,Normalan raspon,
Result Format,Format rezultata,
Single,Singl,
Compound,Spoj,
Descriptive,Opisni,
Grouped,grupirane,
No Result,Nema rezultata,
This value is updated in the Default Sales Price List.,Ova je vrijednost ažurirana u zadanom cjeniku prodajnih cijena.,
Lab Routine,Laboratorijska rutina,
Result Value,Vrijednost rezultata,
Require Result Value,Zahtijevati vrijednost rezultata,
Normal Test Template,Predložak za normalan test,
Patient Demographics,Demografska pacijentica,
HLC-PAT-.YYYY.-,FHP-PAT-.YYYY.-,
Middle Name (optional),Srednje ime (izborno),
Inpatient Status,Status pacijenata,
"If ""Link Customer to Patient"" is checked in Healthcare Settings and an existing Customer is not selected then, a Customer will be created for this Patient for recording transactions in Accounts module.","Ako je u postavkama zdravstvene zaštite označeno &quot;Poveži kupca s pacijentom&quot; i ne odabere se postojeći kupac, za tog će se pacijenta stvoriti kupac za bilježenje transakcija u modulu Računi.",
Personal and Social History,Osobna i društvena povijest,
Marital Status,Bračni status,
Married,Oženjen,
Divorced,Rastavljen,
Widow,Udovica,
Patient Relation,Pacijentna veza,
"Allergies, Medical and Surgical History","Alergije, medicinska i kirurška povijest",
Allergies,Alergije,
Medication,liječenje,
Medical History,Povijest bolesti,
Surgical History,Kirurška povijest,
Risk Factors,Faktori rizika,
Occupational Hazards and Environmental Factors,Radna opasnost i čimbenici okoliša,
Other Risk Factors,Drugi čimbenici rizika,
Patient Details,Detalji pacijenta,
Additional information regarding the patient,Dodatne informacije o pacijentu,
HLC-APP-.YYYY.-,FHP-APP-.GGGG.-,
Patient Age,Pacijentovo doba,
Get Prescribed Clinical Procedures,Potražite propisane kliničke postupke,
Therapy,Terapija,
Get Prescribed Therapies,Nabavite propisane terapije,
Appointment Datetime,Imenovanje Datum i vrijeme,
Duration (In Minutes),Trajanje (u minutama),
Reference Sales Invoice,Referentna faktura prodaje,
More Info,Više informacija,
Referring Practitioner,Referentni praktičar,
HLC-PA-.YYYY.-,FHP-PA-.GGGG.-,
Assessment Template,Predložak procjene,
Assessment Datetime,Datum i vrijeme procjene,
Assessment Description,Opis procjene,
Assessment Sheet,Procjena lista,
Total Score Obtained,Ukupna postignuta ocjena,
Scale Min,Skala Min,
Scale Max,Skala Max,
Patient Assessment Detail,Pojedinosti o procjeni pacijenta,
Assessment Parameter,Parametar procjene,
Patient Assessment Parameter,Parametar procjene pacijenta,
Patient Assessment Sheet,List za procjenu bolesnika,
Patient Assessment Template,Predložak procjene pacijenta,
Assessment Parameters,Parametri procjene,
Parameters,parametri,
Assessment Scale,Skala procjene,
Scale Minimum,Ljestvica minimalna,
Scale Maximum,Ljestvica maksimum,
HLC-ENC-.YYYY.-,FHP-ENC-.YYYY.-,
Encounter Date,Datum susreta,
Encounter Time,Susret vrijeme,
Encounter Impression,Susret susreta,
Symptoms,Simptomi,
In print,U tisku,
Medical Coding,Medicinski kodiranje,
Procedures,Postupci,
Therapies,Terapije,
Review Details,Pojedinosti pregleda,
Patient Encounter Diagnosis,Dijagnoza susreta s pacijentom,
Patient Encounter Symptom,Simptom susreta s pacijentom,
HLC-PMR-.YYYY.-,FHP-PMR-.YYYY.-,
Attach Medical Record,Priložite medicinsku evidenciju,
Spouse,Suprug,
Family,Obitelj,
Schedule Details,Pojedinosti rasporeda,
Schedule Name,Raspored imena,
Time Slots,Vrijeme utora,
Practitioner Service Unit Schedule,Raspored,
Procedure Name,Naziv postupka,
Appointment Booked,Rezervirano za sastanak,
Procedure Created,Postupak izrađen,
HLC-SC-.YYYY.-,FHP-SC-.YYYY.-,
Collected By,Prikupljeno od strane,
Particulars,Pojedinosti,
Result Component,Rezultat Komponenta,
HLC-THP-.YYYY.-,FHP-THP-.GGGG.-,
Therapy Plan Details,Pojedinosti plana terapije,
Total Sessions,Ukupno zasjedanja,
Total Sessions Completed,Ukupno završenih sesija,
Therapy Plan Detail,Pojedinosti plana terapije,
No of Sessions,Broj sesija,
Sessions Completed,Sjednice dovršene,
Tele,Tele,
Exercises,Vježbe,
Therapy For,Terapija za,
Add Exercises,Dodajte vježbe,
Body Temperature,Temperatura tijela,
Presence of a fever (temp &gt; 38.5 °C/101.3 °F or sustained temp &gt; 38 °C/100.4 °F),Prisutnost povišene temperature (temperatura&gt; 38.5 ° C / 101.3 ° F ili trajanje temperature&gt; 38 ° C / 100.4 ° F),
Heart Rate / Pulse,Puls / srčane frekvencije,
Adults' pulse rate is anywhere between 50 and 80 beats per minute.,Pulsni broj odraslih je bilo gdje između 50 i 80 otkucaja u minuti.,
Respiratory rate,Brzina dišnog sustava,
Normal reference range for an adult is 16–20 breaths/minute (RCP 2012),Normalni referentni raspon za odraslu osobu je 16-20 udaha / min (RCP 2012),
Tongue,Jezik,
Coated,premazan,
Very Coated,Vrlo obložena,
Normal,Normalan,
Furry,Krznen,
Cuts,rezovi,
Abdomen,Trbuh,
Bloated,Otečen,
Fluid,tekućina,
Constipated,konstipovan,
Reflexes,refleksi,
Hyper,Hiper,
Very Hyper,Vrlo hiper,
One Sided,Jednostrano,
Blood Pressure (systolic),Krvni tlak (sistolički),
Blood Pressure (diastolic),Krvni tlak (dijastolički),
Blood Pressure,Krvni tlak,
"Normal resting blood pressure in an adult is approximately 120 mmHg systolic, and 80 mmHg diastolic, abbreviated ""120/80 mmHg""","Uobičajeni krvni tlak odrasle osobe u odrasloj dobi iznosi približno 120 mmHg sistolički i dijastolički od 80 mmHg, skraćeno &quot;120/80 mmHg&quot;",
Nutrition Values,Nutricionističke vrijednosti,
Height (In Meter),Visina (u mjeraču),
Weight (In Kilogram),Težina (u kilogramu),
BMI,BMI,
Hotel Room,Hotelska soba,
Hotel Room Type,Vrsta sobe hotela,
Capacity,Kapacitet,
Extra Bed Capacity,Dodatni krevetni kapacitet,
Hotel Manager,Voditelj hotela,
Hotel Room Amenity,Ugodnost hotela,
Billable,Naplativo,
Hotel Room Package,Soba paket hotela,
Amenities,Sadržaji,
Hotel Room Pricing,Cijene soba hotela,
Hotel Room Pricing Item,Cjelokupna cijena sobe hotela,
Hotel Room Pricing Package,Hotelski paket cijene za sobu,
Hotel Room Reservation,Rezervacija hotela,
Guest Name,Ime gosta,
Late Checkin,Kasni ček,
Booked,rezerviran,
Hotel Reservation User,Korisnik hotela rezervacije,
Hotel Room Reservation Item,Rezervacija hotela Soba,
Hotel Settings,Postavke hotela,
Default Taxes and Charges,Zadani poreza i naknada,
Default Invoice Naming Series,Zadana serija za imenovanje faktura,
HR,HR,
Date on which this component is applied,Datum primjene ove komponente,
Salary Slip,Plaća proklizavanja,
HR User,HR Korisnik,
Job Applicant,Posao podnositelj,
Body,Tijelo,
Appraisal Template,Procjena Predložak,
Parent Department,Odjel za roditelje,
Leave Block List,Popis neodobrenih odsustva,
Days for which Holidays are blocked for this department.,Dani za koje su praznici blokirani za ovaj odjel.,
Leave Approver,Osoba ovlaštena za odobrenje odsustva,
Expense Approver,Rashodi Odobritelj,
Required Skills,Potrebne vještine,
Skills,vještine,
Driver,Vozač,
HR-DRI-.YYYY.-,HR-DRI-.YYYY.-,
Suspended,suspendirana,
Transporter,Transporter,
Applicable for external driver,Primjenjivo za vanjske upravljačke programe,
Cellphone Number,broj mobitela,
License Details,Detalji licence,
License Number,Broj dozvole,
Issuing Date,Datum izdavanja,
Driving License Categories,Kategorije voznih dozvola,
Driving License Category,Kategorija licence za vožnju,
Fleet Manager,Fleet Manager,
Driver licence class,Klasa vozačke dozvole,
HR-EMP-,HR-Poslodavci,
Employment Type,Zapošljavanje Tip,
Emergency Contact,Kontakt hitne službe,
Emergency Contact Name,Ime kontakta za hitne slučajeve,
Emergency Phone,Telefon hitne službe,
ERPNext User,ERPNext korisnik,
"System User (login) ID. If set, it will become default for all HR forms.","ID korisnika sustava. Ako je postavljen, postat će zadani za sve HR oblike.",
Create User Permission,Izradi User Permission,
This will restrict user access to other employee records,To će ograničiti pristup korisniku drugim zapisima zaposlenika,
Joining Details,Pridruživanje pojedinosti,
Offer Date,Datum ponude,
Confirmation Date,potvrda Datum,
Contract End Date,Ugovor Datum završetka,
Notice (days),Obavijest (dani),
Date Of Retirement,Datum odlaska u mirovinu,
Department and Grade,Odjel i ocjena,
Reports to,Izvješća,
Attendance and Leave Details,Pojedinosti o posjetima i odlasci,
Attendance Device ID (Biometric/RF tag ID),ID uređaja za posjećenost (ID biometrijske / RF oznake),
Applicable Holiday List,Primjenjivo odmor Popis,
Default Shift,Zadana smjena,
Salary Mode,Plaća način,
Bank A/C No.,Bankovni  A/C br.,
Health Insurance,Zdravstveno osiguranje,
Health Insurance Provider,Davatelj zdravstvenog osiguranja,
Health Insurance No,Zdravstveno osiguranje br,
Prefered Email,Poželjni Email,
Personal Email,Osobni email,
Permanent Address Is,Stalna adresa je,
Rented,Iznajmljeno,
Owned,U vlasništvu,
Permanent Address,Stalna adresa,
Prefered Contact Email,Poželjni Kontakt E-mail,
Company Email,tvrtka E-mail,
Provide Email Address registered in company,Osigurati adresu e-pošte registriranu u društvu,
Current Address Is,Trenutni Adresa je,
Current Address,Trenutna adresa,
Personal Bio,Osobni biografija,
Bio / Cover Letter,Bio / Cover Letter,
Short biography for website and other publications.,Kratka biografija za web stranice i drugih publikacija.,
Passport Number,Broj putovnice,
Date of Issue,Datum izdavanja,
Place of Issue,Mjesto izdavanja,
Widowed,Udovički,
Family Background,Obitelj Pozadina,
"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",
Health Details,Zdravlje Detalji,
"Here you can maintain height, weight, allergies, medical concerns etc","Ovdje možete održavati visina, težina, alergije, medicinske brige itd.",
Educational Qualification,Obrazovne kvalifikacije,
Previous Work Experience,Radnog iskustva,
External Work History,Vanjski Povijest Posao,
History In Company,Povijest tvrtke,
Internal Work History,Unutarnja Povijest Posao,
Resignation Letter Date,Ostavka Pismo Datum,
Relieving Date,Rasterećenje Datum,
Reason for Leaving,Razlog za odlazak,
Leave Encashed?,Odsustvo naplaćeno?,
Encashment Date,Encashment Datum,
New Workplace,Novo radno mjesto,
Returned Amount,Povratni iznos,
Advance Account,Advance Account,
Benefits Applied,Prednosti primijenjene,
Benefit Type and Amount,Vrsta i iznos koristi,
Task Weight,Zadatak Težina,
Employee Education,Obrazovanje zaposlenika,
School/University,Škola / Sveučilište,
Graduate,Diplomski,
Post Graduate,Post diplomski,
Under Graduate,Preddiplomski,
Year of Passing,Godina Prolazeći,
Class / Percentage,Klasa / Postotak,
Major/Optional Subjects,Glavni / Izborni predmeti,
Employee External Work History,Zaposlenik Vanjski Rad Povijest,
Total Experience,Ukupno Iskustvo,
Default Leave Policy,Zadana pravila o napuštanju,
Employee Group Table,Tablica grupa zaposlenih,
ERPNext User ID,ERPNext User ID,
Employee Internal Work History,Zaposlenikova interna radna povijest,
Activities,djelatnost,
Employee Onboarding Activity,Djelatnost onboarding aktivnosti,
Employee Promotion Detail,Detaljan opis promocije zaposlenika,
Employee Transfer Property,Vlasništvo prijenosa zaposlenika,
Unclaimed amount,Neotkriveni iznos,
Holiday List Name,Ime popisa praznika,
Total Holidays,Ukupno praznici,
Add Weekly Holidays,Dodajte tjedne praznike,
Weekly Off,Tjedni Off,
Add to Holidays,Dodaj u praznike,
Holidays,Praznici,
Clear Table,Jasno Tablica,
Retirement Age,Umirovljenje Dob,
Enter retirement age in years,Unesite dob za umirovljenje u godinama,
Stop Birthday Reminders,Zaustavi Rođendan Podsjetnici,
Leave Settings,Napusti postavke,
Accepted,Prihvaćeno,
Printing Details,Ispis Detalji,
Job Title,Titula,
Allocation,namjena,
Select Employees,Odaberite Zaposlenici,
Allocate,Dodijeliti,
Max Leaves Allowed,Maksimalno dopušteno lišće,
Maximum Continuous Days Applicable,Maksimalni neprekidni dani primjenjivi,
Select Payroll Period,Odaberite Platne razdoblje,
Abbr,Kratica,
Condition and Formula,Stanje i Formula,
Total Working Hours,Ukupno Radno vrijeme,
Hour Rate,Cijena sata,
Bank Account No.,Žiro račun broj,
Earning & Deduction,Zarada &amp; Odbitak,
Loan repayment,Otplata kredita,
Employee Loan,zaposlenik kredita,
Total Principal Amount,Ukupni iznos glavnice,
Total Interest Amount,Ukupni iznos kamate,
Total Loan Repayment,Ukupno otplate kredita,
net pay info,Neto info plaća,
Gross Pay - Total Deduction - Loan Repayment,Bruto plaća - Ukupni odbitak - otplate kredita,
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.,
Staffing Plan Details,Detalji o planu osoblja,
Optional,neobavezan,
Costing,Koštanje,
Vehicle,Vozilo,
License Plate,registarska tablica,
Odometer Value (Last),Odometar vrijednost (zadnja),
Acquisition Date,Datum akvizicije,
Chassis No,šasija Ne,
Vehicle Value,Vrijednost vozila,
Insurance Details,Detalji osiguranje,
Insurance Company,Osiguravajuće društvo,
Policy No,politika Nema,
Additional Details,dodatni detalji,
Fuel Type,Vrsta goriva,
Petrol,Benzin,
Diesel,Dizel,
Natural Gas,Prirodni gas,
Electric,električni,
Fuel UOM,Gorivo UOM,
Last Carbon Check,Posljednja Carbon Check,
Wheels,kotači,
Doors,vrata,
last Odometer Value ,zadnja vrijednost odometra,
Service Detail,Detalj usluga,
Hub Tracked Item,Prikvačena stavka za središte,
Hub Node,Hub Node,
Image List,Popis slika,
Item Manager,Stavka Manager,
Hub User,Korisnik huba,
Hub Password,Zaporka huba,
Hub Users,Korisnici huba,
Marketplace Settings,Postavke tržnice,
Disable Marketplace,Onemogući tržište,
Marketplace URL (to hide and update label),URL tržišta (za sakrivanje i ažuriranje oznake),
Registered,zabilježen,
Sync in Progress,Sinkronizacija u tijeku,
Hub Seller Name,Naziv prodavača u centru,
Custom Data,Prilagođeni podaci,
Repay From Salary,Vrati iz plaće,
Regular Payment,Redovna uplata,
Loan Closure,Zatvaranje zajma,
Rate of Interest (%) Yearly,Kamatna stopa (%) godišnje,
MAT-MSH-.YYYY.-,MAT-MSH-.YYYY.-,
Generate Schedule,Generiranje Raspored,
Schedules,Raspored,
Maintenance Schedule Detail,Detalji rasporeda održavanja,
Scheduled Date,Planirano Datum,
Actual Date,Stvarni datum,
Maintenance Schedule Item,Stavka rasporeda održavanja,
Random,Slučajno,
No of Visits,Broj pregleda,
MAT-MVS-.YYYY.-,MAT-MVS-.YYYY.-,
Maintenance Date,Datum održavanje,
Maintenance Time,Vrijeme održavanja,
Completion Status,Završetak Status,
Partially Completed,Djelomično završeni,
Fully Completed,Potpuno Završeni,
Unscheduled,Neplanski,
Breakdown,Slom,
Purposes,Svrhe,
Customer Feedback,Kupac Ocjena,
Maintenance Visit Purpose,Održavanje Posjetite Namjena,
Work Done,Rad Done,
Against Document No,Protiv dokumentu nema,
Against Document Detail No,Protiv dokumenta Detalj No,
MFG-BLR-.YYYY.-,MFG-BLR-.YYYY.-,
Order Type,Vrsta narudžbe,
Blanket Order Item,Predmeti narudžbe,
Ordered Quantity,Naručena količina,
Item to be manufactured or repacked,Proizvod će biti proizveden ili prepakiran,
Quantity of item obtained after manufacturing / repacking from given quantities of raw materials,Količina proizvoda dobivena nakon proizvodnje / pakiranja od navedene količine sirovina,
Set rate of sub-assembly item based on BOM,Postavite stavku podsklopa na temelju BOM-a,
Allow Alternative Item,Dopusti alternativnu stavku,
Item UOM,Mjerna jedinica proizvoda,
Conversion Rate,Stopa pretvorbe,
Rate Of Materials Based On,Stopa materijali na temelju,
With Operations,Uz operacije,
Manage cost of operations,Uredi troškove poslovanja,
Transfer Material Against,Prijenos materijala protiv,
Routing,Usmjeravanje,
Materials,Materijali,
Quality Inspection Required,Potrebna provjera kvalitete,
Quality Inspection Template,Predložak inspekcije kvalitete,
Scrap,otpaci,
Scrap Items,otpad Predmeti,
Operating Cost,Operativni troškovi,
Raw Material Cost,Troškova sirovine,
Scrap Material Cost,Otpaci materijalni troškovi,
Operating Cost (Company Currency),Operativni trošak (Društvo valuta),
Raw Material Cost (Company Currency),Trošak sirovina (Društvena valuta),
Scrap Material Cost(Company Currency),Škarta Cijena (Društvo valuta),
Total Cost,Ukupan trošak,
Total Cost (Company Currency),Ukupni trošak (valuta tvrtke),
Materials Required (Exploded),Potrebna roba,
Exploded Items,Eksplodirani predmeti,
Show in Website,Prikaži na web mjestu,
Item Image (if not slideshow),Slika proizvoda (ako nije slide prikaz),
Thumbnail,Thumbnail,
Website Specifications,Web Specifikacije,
Show Items,Prikaži stavke,
Show Operations,Pokaži operacije,
Website Description,Opis web stranice,
BOM Explosion Item,BOM eksplozije artikla,
Qty Consumed Per Unit,Količina potrošena po jedinici mjere,
Include Item In Manufacturing,Uključi predmet u proizvodnju,
BOM Item,BOM proizvod,
Item operation,Radnja stavke,
Rate & Amount,Ocijenite i iznosite,
Basic Rate (Company Currency),Osnovna stopa (valuta tvrtke),
Scrap %,Otpad%,
Original Item,Izvorna stavka,
BOM Operation,BOM operacija,
Operation Time ,Vrijeme rada,
In minutes,Za nekoliko minuta,
Batch Size,Veličina serije,
Base Hour Rate(Company Currency),Baza Sat stopa (Društvo valuta),
Operating Cost(Company Currency),Operativni trošak (Društvo valuta),
BOM Scrap Item,BOM otpaci predmeta,
Basic Amount (Company Currency),Osnovni Iznos (Društvo valuta),
BOM Update Tool,Alat za ažuriranje BOM-a,
"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.\nIt also updates latest price in all the BOMs.","Zamijenite određeni BOM u svim ostalim BOM-ovima gdje se upotrebljava. Zamijenit će staru BOM vezu, ažurirati trošak i obnoviti tablicu &quot;BOM Explosion Item&quot; po novom BOM-u. Također ažurira najnoviju cijenu u svim BOM-ovima.",
Replace BOM,Zamijenite BOM,
Current BOM,Trenutni BOM,
The BOM which will be replaced,BOM koji će biti zamijenjen,
The new BOM after replacement,Novi BOM nakon zamjene,
Replace,Zamijeniti,
Update latest price in all BOMs,Ažuriranje najnovije cijene u svim BOM-ovima,
BOM Website Item,BOM web stranica predmeta,
BOM Website Operation,BOM Web Rad,
Operation Time,Operacija vrijeme,
PO-JOB.#####,PO-posao. #####,
Timing Detail,Detaljno vrijeme,
Time Logs,Vrijeme Trupci,
Total Time in Mins,Ukupno vrijeme u minima,
Operation ID,ID operacije,
Transferred Qty,prebačen Kol,
Job Started,Posao je započeo,
Started Time,Počelo vrijeme,
Current Time,Trenutno vrijeme,
Job Card Item,Radna mjesta za posao,
Job Card Time Log,Evidencija vremena radne kartice,
Time In Mins,Vrijeme u minima,
Completed Qty,Završen Kol,
Manufacturing Settings,Postavke proizvodnje,
Raw Materials Consumption,Potrošnja sirovina,
Allow Multiple Material Consumption,Omogući višestruku potrošnju materijala,
Backflush Raw Materials Based On,Jedinice za pranje sirovine na temelju,
Material Transferred for Manufacture,Materijal prenose Proizvodnja,
Capacity Planning,Planiranje kapaciteta,
Disable Capacity Planning,Onemogući planiranje kapaciteta,
Allow Overtime,Dopusti Prekovremeni,
Allow Production on Holidays,Dopustite proizvodnje na odmor,
Capacity Planning For (Days),Planiranje kapaciteta za (dani),
Default Warehouses for Production,Zadana skladišta za proizvodnju,
Default Work In Progress Warehouse,Zadana rad u tijeku Skladište,
Default Finished Goods Warehouse,Zadane gotovih proizvoda Skladište,
Default Scrap Warehouse,Zadana skladišta otpada,
Overproduction Percentage For Sales Order,Postotak prekomjerne proizvodnje za prodajni nalog,
Overproduction Percentage For Work Order,Postotak prekomjerne proizvodnje za radni nalog,
Other Settings,Ostale postavke,
Update BOM Cost Automatically,Ažurirajte automatski trošak BOM-a,
Material Request Plan Item,Stavka plana materijala,
Material Request Type,Tip zahtjeva za robom,
Material Issue,Materijal Issue,
Customer Provided,Kupci opskrbljeni,
Minimum Order Quantity,minimalna količina narudžbe,
Default Workstation,Zadana Workstation,
Production Plan,Plan proizvodnje,
MFG-PP-.YYYY.-,MFG-PP-.YYYY.-,
Get Items From,Nabavite stavke iz,
Get Sales Orders,Kreiraj narudžbe,
Material Request Detail,Detalji o zahtjevu za materijal,
Get Material Request,Dobiti materijala zahtjev,
Material Requests,Materijal Zahtjevi,
Get Items For Work Order,Preuzmite stavke za radni nalog,
Material Request Planning,Planiranje zahtjeva za materijal,
Include Non Stock Items,Uključi ostale artikle,
Include Subcontracted Items,Uključi podugovarane predmete,
Ignore Existing Projected Quantity,Zanemarite postojeću projiciranu količinu,
"To know more about projected quantity, <a href=""https://erpnext.com/docs/user/manual/en/stock/projected-quantity"" style=""text-decoration: underline;"" target=""_blank"">click here</a>.","Da biste saznali više o projektiranoj količini, <a href=""https://erpnext.com/docs/user/manual/en/stock/projected-quantity"" style=""text-decoration: underline;"" target=""_blank"">kliknite ovdje</a> .",
Download Required Materials,Preuzmite potrebne materijale,
Get Raw Materials For Production,Dobiti sirovine za proizvodnju,
Total Planned Qty,Ukupni planirani broj,
Total Produced Qty,Ukupna proizvodna količina,
Material Requested,Traženi materijal,
Production Plan Item,Proizvodnja plan artikla,
Make Work Order for Sub Assembly Items,Napravite radni nalog za predmete pod sastavljanja,
"If enabled, system will create the work order for the exploded items against which BOM is available.","Ako je omogućeno, sustav će stvoriti radni nalog za eksplodirane predmete protiv kojih je BOM dostupan.",
Planned Start Date,Planirani datum početka,
Quantity and Description,Količina i opis,
material_request_item,material_request_item,
Product Bundle Item,Proizvod bala predmeta,
Production Plan Material Request,Izrada plana materijala Zahtjev,
Production Plan Sales Order,Proizvodnja plan prodajnog naloga,
Sales Order Date,Datum narudžbe (kupca),
Routing Name,Naziv usmjeravanja,
MFG-WO-.YYYY.-,MFG-WO-.YYYY.-,
Item To Manufacture,Proizvod za proizvodnju,
Material Transferred for Manufacturing,Materijal Preneseni za Manufacturing,
Manufactured Qty,Proizvedena količina,
Use Multi-Level BOM,Koristite multi-level BOM,
Plan material for sub-assemblies,Plan materijal za pod-sklopova,
Skip Material Transfer to WIP Warehouse,Preskočite prijenos materijala u WIP skladište,
Check if material transfer entry is not required,Provjerite nije li unos prijenosa materijala potreban,
Backflush Raw Materials From Work-in-Progress Warehouse,Otpadne sirovine iz skladišta u tijeku rada,
Update Consumed Material Cost In Project,Ažuriranje troškova utrošenog materijala u projektu,
Warehouses,Skladišta,
This is a location where raw materials are available.,Ovo je mjesto na kojem su dostupne sirovine.,
Work-in-Progress Warehouse,Rad u tijeku Warehouse,
This is a location where operations are executed.,Ovo je mjesto na kojem se izvode operacije.,
This is a location where final product stored.,Ovo je mjesto na kojem se sprema krajnji proizvod.,
Scrap Warehouse,otpaci Skladište,
This is a location where scraped materials are stored.,Ovo je mjesto gdje se čuvaju strugani materijali.,
Required Items,potrebne stavke,
Actual Start Date,Stvarni datum početka,
Planned End Date,Planirani datum završetka,
Actual End Date,Stvarni datum završetka,
Operation Cost,Operacija troškova,
Planned Operating Cost,Planirani operativni trošak,
Actual Operating Cost,Stvarni operativni trošak,
Additional Operating Cost,Dodatni trošak,
Total Operating Cost,Ukupni trošak,
Manufacture against Material Request,Proizvodnja od materijala dogovoru,
Work Order Item,Radni nalog,
Available Qty at Source Warehouse,Dostupni broj u Izvornoj skladištu,
Available Qty at WIP Warehouse,Dostupni broj u WIP Warehouseu,
Work Order Operation,Radni nalog,
Operation Description,Operacija Opis,
Operation completed for how many finished goods?,Operacija završena za koliko gotovih proizvoda?,
Work in Progress,Radovi u tijeku,
Estimated Time and Cost,Procijenjeno vrijeme i trošak,
Planned Start Time,Planirani početak vremena,
Planned End Time,Planirani End Time,
in Minutes,U minuta,
Actual Time and Cost,Stvarnog vremena i troškova,
Actual Start Time,Stvarni Vrijeme početka,
Actual End Time,Stvarni End Time,
Updated via 'Time Log',Ažurirano putem 'Time Log',
Actual Operation Time,Stvarni Operacija vrijeme,
in Minutes\nUpdated via 'Time Log',U nekoliko minuta \n Ažurirano putem 'Time Log',
(Hour Rate / 60) * Actual Operation Time,(Broj sati / 60) * Stvarno trajanje operacije,
Workstation Name,Ime Workstation,
Production Capacity,Kapacitet proizvodnje,
Operating Costs,Operativni troškovi,
Electricity Cost,Troškovi struje,
per hour,na sat,
Consumable Cost,potrošni cost,
Rent Cost,Rent cost,
Wages,Plaće,
Wages per hour,Satnice,
Net Hour Rate,Neto sat cijena,
Workstation Working Hour,Workstation Radno vrijeme,
Certification Application,Potvrda prijave,
Name of Applicant,Naziv podnositelja zahtjeva,
Certification Status,Status certifikacije,
Yet to appear,Ipak se pojavi,
Certified,potvrđen,
Not Certified,Nije ovjerena,
USD,USD,
INR,INR,
Certified Consultant,Ovlašteni konzultant,
Name of Consultant,Naziv konzultanta,
Certification Validity,Valjanost certifikacije,
Discuss ID,Razgovarajte o ID-u,
GitHub ID,GitHub ID,
Non Profit Manager,Neprofitni menadžer,
Chapter Head,Glava poglavlja,
Meetup Embed HTML,Meetup Embed HTML,
chapters/chapter_name\nleave blank automatically set after saving chapter.,poglavlja / naziv poglavlja ostavite prazno automatski postavljeno nakon spremanja poglavlja.,
Chapter Members,Članovi poglavlja,
Members,članovi,
Chapter Member,Član poglavlja,
Website URL,Website URL,
Leave Reason,Ostavite razlog,
Donor Name,Naziv donatora,
Donor Type,Vrsta donatora,
Withdrawn,povučen,
Grant Application Details ,Pojedinosti o podnošenju zahtjeva,
Grant Description,Opis potpore,
Requested Amount,Zahtijevani iznos,
Has any past Grant Record,Ima li nekih prethodnih Grant Record,
Show on Website,Pokaži na web stranici,
Assessment  Mark (Out of 10),Ocjena ocjenjivanja (od 10),
Assessment  Manager,Voditelj procjene,
Email Notification Sent,Poslana obavijest e-pošte,
NPO-MEM-.YYYY.-,NPO-MEM-.YYYY.-,
Membership Expiry Date,Datum isteka članstva,
Razorpay Details,Pojedinosti o britvi,
Subscription ID,ID pretplate,
Customer ID,ID kupca,
Subscription Activated,Pretplata aktivirana,
Subscription Start ,Početak pretplate,
Subscription End,Kraj pretplate,
Non Profit Member,Neprofitna članica,
Membership Status,Status članstva,
Member Since,Član od,
Payment ID,ID plaćanja,
Membership Settings,Postavke članstva,
Enable RazorPay For Memberships,Omogućite RazorPay za članstva,
RazorPay Settings,Postavke RazorPay-a,
Billing Cycle,Ciklus naplate,
Billing Frequency,Učestalost naplate,
"The number of billing cycles for which the customer should be charged. For example, if a customer is buying a 1-year membership that should be billed on a monthly basis, this value should be 12.","Broj ciklusa naplate za koji bi se kupcu trebalo naplatiti. Na primjer, ako kupac kupuje jednogodišnje članstvo koje bi se trebalo naplaćivati mjesečno, ta bi vrijednost trebala biti 12.",
Razorpay Plan ID,ID plana za Razorpay,
Volunteer Name,Ime volontera,
Volunteer Type,Volonterski tip,
Availability and Skills,Dostupnost i vještine,
Availability,dostupnost,
Weekends,Vikendi,
Availability Timeslot,Dostupnost vremena,
Morning,Jutro,
Afternoon,Poslijepodne,
Evening,Večer,
Anytime,Bilo kada,
Volunteer Skills,Volonterske vještine,
Volunteer Skill,Volonterska vještina,
Homepage,Početna,
Hero Section Based On,Odjeljak hero na temelju,
Homepage Section,Odjeljak početne stranice,
Hero Section,Sekcija heroja,
Tag Line,Tag linija,
Company Tagline for website homepage,Tvrtka Opisna oznaka za web stranici,
Company Description for website homepage,Opis tvrtke za web stranici,
Homepage Slideshow,Prezentacija početne stranice,
"URL for ""All Products""",URL za &quot;sve proizvode&quot;,
Products to be shown on website homepage,Proizvodi koji će biti prikazan na web stranici početnu stranicu,
Homepage Featured Product,Početna Istaknuti Proizvodi,
route,ruta,
Section Based On,Odjeljak na temelju,
Section Cards,Karte odsjeka,
Number of Columns,Broj stupaca,
Number of columns for this section. 3 cards will be shown per row if you select 3 columns.,Broj stupaca za ovaj odjeljak. Po 3 kartice prikazat će se po retku ako odaberete 3 stupca.,
Section HTML,Odjeljak HTML,
Use this field to render any custom HTML in the section.,Upotrijebite ovo polje za prikaz bilo kojeg prilagođenog HTML-a u odjeljku.,
Section Order,Redoslijed odjeljka,
"Order in which sections should appear. 0 is first, 1 is second and so on.","Redoslijed u kojim će se odjeljcima pojaviti. 0 je prvo, 1 je drugo i tako dalje.",
Homepage Section Card,Kartica odjela početne stranice,
Subtitle,Titl,
Products Settings,proizvodi Postavke,
Home Page is Products,Početna stranica su proizvodi,
"If checked, the Home page will be the default Item Group for the website","Ako je označeno, početna stranica će biti zadana točka Grupa za web stranicu",
Show Availability Status,Prikaži stanje dostupnosti,
Product Page,Stranica proizvoda,
Products per Page,Proizvodi po stranici,
Enable Field Filters,Omogući filtre polja,
Item Fields,Polja predmeta,
Enable Attribute Filters,Omogući filtre atributa,
Attributes,Značajke,
Hide Variants,Sakrij varijante,
Website Attribute,Atributi web mjesta,
Attribute,Atribut,
Website Filter Field,Polje filtra web mjesta,
Activity Cost,Aktivnost troškova,
Billing Rate,Ocijenite naplate,
Costing Rate,Obračun troškova stopa,
title,titula,
Projects User,Projekti za korisnike,
Default Costing Rate,Zadana Obračun troškova stopa,
Default Billing Rate,Zadana naplate stopa,
Dependent Task,Ovisno zadatak,
Project Type,Vrsta projekta,
% Complete Method,% Kompletan postupak,
Task Completion,Zadatak Završetak,
Task Progress,Zadatak Napredak,
% Completed,% Kompletirano,
From Template,Iz Predloška,
Project will be accessible on the website to these users,Projekt će biti dostupan na web-stranici ovih korisnika,
Copied From,Kopiran iz,
Start and End Dates,Datumi početka i završetka,
Actual Time in Hours (via Timesheet),Stvarno vrijeme (u satima),
Costing and Billing,Obračun troškova i naplate,
Total Costing Amount (via Timesheet),Ukupni iznos troškova (putem vremenskih brojeva),
Total Expense Claim (via Expense Claim),Ukupni rashodi Zatraži (preko Rashodi potraživanja),
Total Purchase Cost (via Purchase Invoice),Ukupno troškovi nabave (putem kupnje proizvoda),
Total Sales Amount (via Sales Order),Ukupni iznos prodaje (putem prodajnog naloga),
Total Billable Amount (via Timesheet),Ukupan iznos koji se naplaćuje (putem vremenskih brojeva),
Total Billed Amount (via Sales Invoice),Ukupni iznos naplaćenog računa (putem faktura prodaje),
Total Consumed Material Cost (via Stock Entry),Ukupni trošak potrošenog materijala (putem stanja na burzi),
Gross Margin,Bruto marža,
Gross Margin %,Bruto marža %,
Monitor Progress,Monitor napredak,
Collect Progress,Prikupiti napredak,
Frequency To Collect Progress,Učestalost prikupljanja napretka,
Twice Daily,Dvaput dnevno,
First Email,Prva e-pošta,
Second Email,Druga e-pošta,
Time to send,Vrijeme je za slanje,
Day to Send,Dan za slanje,
Message will be sent to the users to get their status on the Project,Korisnicima će se poslati poruka da dobiju svoj status na Projektu,
Projects Manager,Projekti Manager,
Project Template,Predložak projekta,
Project Template Task,Zadatak predloška projekta,
Begin On (Days),Početak (dana),
Duration (Days),Trajanje (dani),
Project Update,Ažuriranje projekta,
Project User,Korisnik projekta,
View attachments,Pogledajte privitke,
Projects Settings,Postavke projekata,
Ignore Workstation Time Overlap,Zanemari vrijeme preklapanja radne stanice,
Ignore User Time Overlap,Zanemari Vrijeme preklapanja korisnika,
Ignore Employee Time Overlap,Zanemari vrijeme preklapanja zaposlenika,
Weight,Težina,
Parent Task,Roditeljska zadaća,
Timeline,Vremenska Crta,
Expected Time (in hours),Očekivani vrijeme (u satima),
% Progress,% Napredak,
Is Milestone,Je li Milestone,
Task Description,Opis zadatka,
Dependencies,ovisnosti,
Dependent Tasks,Zavisni zadaci,
Depends on Tasks,Ovisi o poslovima,
Actual Start Date (via Timesheet),Stvarni datum početka (putem vremenska tablica),
Actual Time in Hours (via Timesheet),Stvarno vrijeme (u satima),
Actual End Date (via Timesheet),Stvarni Datum završetka (putem vremenska tablica),
Total Expense Claim (via Expense Claim),Ukupni rashodi Zatraži (preko Rashodi Zahtjeva),
Review Date,Recenzija Datum,
Closing Date,Datum zatvaranja,
Task Depends On,Zadatak ovisi o,
Task Type,Vrsta zadatka,
TS-.YYYY.-,TS-.GGGG.-,
Employee Detail,Detalj zaposlenika,
Billing Details,Detalji o naplati,
Total Billable Hours,Ukupno naplatnih sati,
Total Billed Hours,Ukupno Naplaćene sati,
Total Costing Amount,Ukupno Obračun troškova Iznos,
Total Billable Amount,Ukupan iznos za naplatu,
Total Billed Amount,Ukupno naplaćeni iznos,
% Amount Billed,% Naplaćeni iznos,
Hrs,hrs,
Costing Amount,Obračun troškova Iznos,
Corrective/Preventive,Korektivna / Preventivna,
Corrective,korektiv,
Preventive,preventivan,
Resolution,Rezolucija,
Resolutions,rezolucije,
Quality Action Resolution,Kvalitetna rezolucija akcije,
Quality Feedback Parameter,Parametar povratne informacije o kvaliteti,
Quality Feedback Template Parameter,Parametar predloška za povratne informacije o kvaliteti,
Quality Goal,Cilj kvalitete,
Monitoring Frequency,Učestalost nadgledanja,
Weekday,radni dan,
Objectives,Ciljevi,
Quality Goal Objective,Cilj kvaliteta kvalitete,
Objective,Cilj,
Agenda,dnevni red,
Minutes,minuta,
Quality Meeting Agenda,Kvalitetni dnevni sastanak,
Quality Meeting Minutes,Zapisnici sa kvalitetnim sastankom,
Minute,Minuta,
Parent Procedure,Postupak roditelja,
Processes,procesi,
Quality Procedure Process,Postupak postupka kvalitete,
Process Description,Opis procesa,
Link existing Quality Procedure.,Povežite postojeći postupak kvalitete.,
Additional Information,dodatne informacije,
Quality Review Objective,Cilj pregleda kvalitete,
DATEV Settings,Postavke DATEV,
Regional,Regionalni,
Consultant ID,ID konzultanta,
GST HSN Code,GST HSN kod,
HSN Code,HSN kod,
GST Settings,Postavke GST-a,
GST Summary,GST Sažetak,
GSTIN Email Sent On,GSTIN e-pošta poslana,
GST Accounts,GST računi,
B2C Limit,B2C ograničenje,
Set Invoice Value for B2C. B2CL and B2CS calculated based on this invoice value.,Postavite vrijednost fakture za B2C. B2CL i B2CS izračunate na temelju ove vrijednosti fakture.,
GSTR 3B Report,Izvještaj GSTR 3B,
January,siječanj,
February,veljača,
March,ožujak,
April,travanj,
August,kolovoz,
September,rujan,
October,listopad,
November,studeni,
December,prosinac,
JSON Output,Izlaz JSON-a,
Invoices with no Place Of Supply,Računi bez mjesta opskrbe,
Import Supplier Invoice,Uvoz fakture dobavljača,
Invoice Series,Serija fakture,
Upload XML Invoices,Prenesite XML fakture,
Zip File,ZIP datoteka,
Import Invoices,Uvoz računa,
Click on Import Invoices button once the zip file has been attached to the document. Any errors related to processing will be shown in the Error Log.,Kliknite gumb Uvezi račune nakon što se dokument pridruži. Sve pogreške u vezi s obradom bit će prikazane u dnevniku pogrešaka.,
Lower Deduction Certificate,Potvrda o nižem odbitku,
Certificate Details,Pojedinosti o potvrdi,
194A,194A,
194C,194C,
194D,194D,
194H,194H,
194I,194I,
194J,194J,
194LA,194LA,
194LBB,194LBB,
194LBC,194LBC,
Certificate No,Potvrda br,
Deductee Details,Pojedinosti o odbitku,
PAN No,PAN br,
Validity Details,Podaci o valjanosti,
Rate Of TDS As Per Certificate,Stopa TDS-a prema certifikatu,
Certificate Limit,Ograničenje certifikata,
Invoice Series Prefix,Prefiks serije fakture,
Active Menu,Aktivni izbornik,
Restaurant Menu,Izbornik restorana,
Price List (Auto created),Cjenik (automatski izrađen),
Restaurant Manager,Voditelj restorana,
Restaurant Menu Item,Stavka izbornika restorana,
Restaurant Order Entry,Unos narudžbe restorana,
Restaurant Table,Tablica restorana,
Click Enter To Add,Kliknite Unesi za dodavanje,
Last Sales Invoice,Posljednja prodajna faktura,
Current Order,Trenutačna narudžba,
Restaurant Order Entry Item,Stavka unosa narudžbe restorana,
Served,Posluženo,
Restaurant Reservation,Rezervacija restorana,
Waitlisted,na listi čekanja,
No Show,Nema prikazivanja,
No of People,Ne od ljudi,
Reservation Time,Vrijeme rezervacije,
Reservation End Time,Vrijeme završetka rezervacije,
No of Seats,Nema sjedala,
Minimum Seating,Minimalna sjedala,
"Keep Track of Sales Campaigns. Keep track of Leads, Quotations, Sales Order etc from Campaigns to gauge Return on Investment. ","Pratite podatke o prodajnim kampanjama. Vodite zapise o potencijalima, ponudama, narudžbama itd kako bi ste procijenili povrat ulaganje ROI.",
SAL-CAM-.YYYY.-,SAL-CAM-.YYYY.-,
Campaign Schedules,Rasporedi kampanje,
Buyer of Goods and Services.,Kupac robe i usluga.,
CUST-.YYYY.-,Prilagodi-.YYYY.-,
Default Company Bank Account,Zadani bankovni račun tvrtke,
From Lead,Od Olovo,
Account Manager,Account Manager,
Allow Sales Invoice Creation Without Sales Order,Dopusti izradu fakture za prodaju bez prodajnog naloga,
Allow Sales Invoice Creation Without Delivery Note,Omogućiti stvaranje fakture za prodaju bez otpremnice,
Default Price List,Zadani cjenik,
Primary Address and Contact Detail,Primarna adresa i kontakt detalja,
"Select, to make the customer searchable with these fields","Odaberite, kako bi korisnik mogao pretraživati s tim poljima",
Customer Primary Contact,Primarni kontakt korisnika,
"Reselect, if the chosen contact is edited after save","Ponovno odaberite, ako je odabrani kontakt uređen nakon spremanja",
Customer Primary Address,Primarna adresa korisnika,
"Reselect, if the chosen address is edited after save",Ponovno odaberite ako je odabrana adresa uređena nakon spremanja,
Primary Address,Primarna adresa,
Mention if non-standard receivable account,Spomenuti ako nestandardni potraživanja račun,
Credit Limit and Payment Terms,Uvjeti ograničenja i plaćanja kredita,
Additional information regarding the customer.,Dodatne informacije o kupcu.,
Sales Partner and Commission,Prodaja partner i komisija,
Commission Rate,Komisija Stopa,
Sales Team Details,Detalji prodnog tima,
Customer POS id,Korisnički POS id,
Customer Credit Limit,Kreditni limit klijenta,
Bypass Credit Limit Check at Sales Order,Zaobilaženje ograničenja kreditnog ograničenja na prodajnom nalogu,
Industry Type,Industrija Tip,
MAT-INS-.YYYY.-,MAT-INS-.YYYY.-,
Installation Date,Instalacija Datum,
Installation Time,Vrijeme instalacije,
Installation Note Item,Napomena instalacije proizvoda,
Installed Qty,Instalirana kol,
Lead Source,Izvor potencijalnog kupca,
Period Start Date,Datum početka razdoblja,
Period End Date,Datum završetka razdoblja,
Cashier,Blagajnik,
Difference,Razlika,
Modes of Payment,Načini plaćanja,
Linked Invoices,Povezane fakture,
POS Closing Voucher Details,Detalji o voucheru za zatvaranje POS-a,
Collected Amount,Prikupljeni iznos,
Expected Amount,Očekivani iznos,
POS Closing Voucher Invoices,POS fakture zatvaranja bonova za POS,
Quantity of Items,Količina stavki,
"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**. \n\nThe package **Item** will have ""Is Stock Item"" as ""No"" and ""Is Sales Item"" as ""Yes"".\n\nFor Example: If you are selling Laptops and Backpacks separately and have a special price if the customer buys both, then the Laptop + Backpack will be a new Product Bundle Item.\n\nNote: BOM = Bill of Materials",Agregat skupina ** Opcije ** u drugom ** ** točke. To je korisno ako vezanje određene artikle ** ** u paketu i održavanje zalihe zapakiranom ** Opcije ** a ne zbroj ** ** stavke. Paket ** ** Stavka će imati &quot;Je kataloški Stavka&quot; kao &quot;ne&quot; i &quot;Je li prodaja predmeta&quot; kao &quot;Da&quot;. Na primjer: Ako se prodaje Prijenosna računala i ruksacima odvojeno i imaju posebnu cijenu ako kupac kupuje i onda laptop + ruksak će biti novi bala proizvoda predmeta. Napomena: BOM = Bill materijala,
Parent Item,Nadređeni proizvod,
List items that form the package.,Popis stavki koje čine paket.,
SAL-QTN-.YYYY.-,SAL-QTN-.YYYY.-,
Quotation To,Ponuda za,
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 Price list currency is converted to company's base currency,Stopa po kojoj Cjenik valute se pretvaraju u tvrtke bazne valute,
Additional Discount and Coupon Code,Dodatni popust i kod kupona,
Referral Sales Partner,Preporuka prodajni partner,
In Words will be visible once you save the Quotation.,U riječi će biti vidljiv nakon što spremite ponudu.,
Term Details,Oročeni Detalji,
Quotation Item,Proizvod iz ponude,
Against Doctype,Protiv DOCTYPE,
Against Docname,Protiv Docname,
Additional Notes,dodatne napomene,
SAL-ORD-.YYYY.-,SAL-ORD-.YYYY.-,
Skip Delivery Note,Preskočite dostavnicu,
In Words will be visible once you save the Sales Order.,U riječi će biti vidljiv nakon što spremite prodajnog naloga.,
Track this Sales Order against any Project,Prati ovu prodajni nalog protiv bilo Projekta,
Billing and Delivery Status,Naplate i isporuke status,
Not Delivered,Ne isporučeno,
Fully Delivered,Potpuno Isporučeno,
Partly Delivered,Djelomično isporučeno,
Not Applicable,Nije primjenjivo,
%  Delivered,% Isporučeno,
% of materials delivered against this Sales Order,% robe od ove narudžbe je isporučeno,
% of materials billed against this Sales Order,% robe od ove narudžbe je naplaćeno,
Not Billed,Nije naplaćeno,
Fully Billed,Potpuno Naplaćeno,
Partly Billed,Djelomično naplaćeno,
Ensure Delivery Based on Produced Serial No,Osigurajte dostavu na temelju proizvedenog serijskog br,
Supplier delivers to Customer,Dobavljač dostavlja Kupcu,
Delivery Warehouse,Isporuka Skladište,
Planned Quantity,Planirana količina,
For Production,Za proizvodnju,
Work Order Qty,Radni nalog,
Produced Quantity,Proizvedena količina,
Used for Production Plan,Koristi se za plan proizvodnje,
Sales Partner Type,Vrsta prodajnog partnera,
Contact No.,Kontakt broj,
Contribution (%),Doprinos (%),
Contribution to Net Total,Doprinos neto Ukupno,
Selling Settings,Postavke prodaje,
Settings for Selling Module,Postavke za prodaju modula,
Customer Naming By,Imenovanje kupca prema,
Campaign Naming By,Imenovanje kampanja po,
Default Customer Group,Zadana grupa kupaca,
Default Territory,Zadani teritorij,
Close Opportunity After Days,Zatvori Prilika Nakon dana,
Default Quotation Validity Days,Zadani rokovi valjanosti ponude,
Sales Update Frequency,Ažuriranje ažuriranja prodaje,
Each Transaction,Svaka transakcija,
SMS Center,SMS centar,
Send To,Pošalji,
All Contact,Svi kontakti,
All Customer Contact,Svi kontakti kupaca,
All Supplier Contact,Svi kontakti dobavljača,
All Sales Partner Contact,Kontakti prodajnog partnera,
All Lead (Open),Svi potencijalni kupci (aktualni),
All Employee (Active),Svi zaposlenici (aktivni),
All Sales Person,Svi prodavači,
Create Receiver List,Stvaranje Receiver popis,
Receiver List,Prijemnik Popis,
Messages greater than 160 characters will be split into multiple messages,Poruka veća od 160 karaktera bit će izdjeljena u više poruka,
Total Characters,Ukupno Likovi,
Total Message(s),Ukupno poruka ( i),
Authorization Control,Kontrola autorizacije,
Authorization Rule,Pravilo autorizacije,
Average Discount,Prosječni popust,
Customerwise Discount,Customerwise Popust,
Itemwise Discount,Itemwise popust,
Customer or Item,Kupac ili predmeta,
Customer / Item Name,Kupac / Stavka Ime,
Authorized Value,Ovlaštena vrijednost,
Applicable To (Role),Odnosi se na (uloga),
Applicable To (Employee),Odnosi se na (Radnik),
Applicable To (User),Odnosi se na (Upute),
Applicable To (Designation),Odnosi se na (Oznaka),
Approving Role (above authorized value),Odobravanje ulogu (iznad ovlaštenog vrijednosti),
Approving User  (above authorized value),Odobravanje korisnik (iznad ovlaštenog vrijednosti),
Brand Defaults,Zadane vrijednosti robne marke,
Legal Entity / Subsidiary with a separate Chart of Accounts belonging to the Organization.,Pravna cjelina / Podružnica s odvojenim kontnim planom pripada Organizaciji.,
Change Abbreviation,Promijeni naziv,
Parent Company,Matično društvo,
Default Values,Zadane vrijednosti,
Default Holiday List,Default odmor List,
Default Selling Terms,Zadani uvjeti prodaje,
Default Buying Terms,Zadani uvjeti kupnje,
Create Chart Of Accounts Based On,Izrada kontnog plana na temelju,
Standard Template,standardni predložak,
Existing Company,Postojeća tvrtka,
Chart Of Accounts Template,Kontni predložak,
Existing Company ,postojeće tvrtke,
Date of Establishment,Datum osnivanja,
Sales Settings,Prodajne postavke,
Monthly Sales Target,Mjesečni cilj prodaje,
Sales Monthly History,Mjesečna povijest prodaje,
Transactions Annual History,Transakcije Godišnja povijest,
Total Monthly Sales,Ukupna mjesečna prodaja,
Default Cash Account,Zadani novčani račun,
Default Receivable Account,Zadana Potraživanja račun,
Round Off Cost Center,Zaokružiti troška,
Discount Allowed Account,Dopušten popust,
Discount Received Account,Račun primljen na popust,
Exchange Gain / Loss Account,Razmjena Dobit / gubitka,
Unrealized Exchange Gain/Loss Account,Nerealizirani račun dobiti i gubitka,
Allow Account Creation Against Child Company,Omogući stvaranje računa protiv tvrtke Child,
Default Payable Account,Zadana Plaća račun,
Default Employee Advance Account,Zadani račun predujam zaposlenika,
Default Cost of Goods Sold Account,Zadana vrijednost prodane robe računa,
Default Income Account,Zadani račun prihoda,
Default Deferred Revenue Account,Zadani odgođeni račun prihoda,
Default Deferred Expense Account,Zadani odgođeni raćun rashoda,
Default Payroll Payable Account,Zadana plaće Plaća račun,
Default Expense Claim Payable Account,Zaduženi platni račun potraživanja za troškove,
Stock Settings,Postavke skladišta,
Enable Perpetual Inventory,Omogući trajnu zalihu,
Default Inventory Account,Zadani račun oglasnog prostora,
Stock Adjustment Account,Stock Adjustment račun,
Fixed Asset Depreciation Settings,Postavke Amortizacija osnovnog sredstva,
Series for Asset Depreciation Entry (Journal Entry),Serija za unos amortizacije imovine (unos dnevnika),
Gain/Loss Account on Asset Disposal,Dobitak / Gubitak računa na sredstva Odlaganje,
Asset Depreciation Cost Center,Imovina Centar Amortizacija troškova,
Budget Detail,Detalji proračuna,
Exception Budget Approver Role,Uloga odobravanja proračuna za izuzeće,
Company Info,Podaci o tvrtki,
For reference only.,Za samo kao referenca.,
Company Logo,Logo tvrtke,
Date of Incorporation,Datum ugradnje,
Date of Commencement,Datum početka,
Phone No,Telefonski broj,
Company Description,Opis Tvrtke,
Registration Details,Registracija Brodu,
Company registration numbers for your reference. Tax numbers etc.,Tvrtka registracijski brojevi za svoju referencu. Porezni brojevi itd.,
Delete Company Transactions,Brisanje transakcije tvrtke,
Currency Exchange,Mjenjačnica,
Specify Exchange Rate to convert one currency into another,Navedite Tečaj pretvoriti jedne valute u drugu,
From Currency,Od novca,
To Currency,Valutno,
For Buying,Za kupnju,
For Selling,Za prodaju,
Customer Group Name,Naziv grupe kupaca,
Parent Customer Group,Nadređena grupa kupaca,
Only leaf nodes are allowed in transaction,Samo lisni čvorovi su dozvoljeni u transakciji,
Mention if non-standard receivable account applicable,Spomenuti ako nestandardni potraživanja računa primjenjivo,
Credit Limits,Kreditna ograničenja,
Email Digest,E-pošta,
Send regular summary reports via Email.,Pošalji redovite sažetak izvješća putem e-maila.,
Email Digest Settings,E-pošta postavke,
How frequently?,Kako često?,
Next email will be sent on:,Sljedeći email će biti poslan na:,
Note: Email will not be sent to disabled users,Napomena: E-mail neće biti poslan nepostojećim korisnicima,
Profit & Loss,Gubitak profita,
New Income,Novi Prihod,
New Expenses,Novi troškovi,
Annual Income,Godišnji prihod,
Annual Expenses,Godišnji troškovi,
Bank Balance,Bankovni saldo,
Bank Credit Balance,Kreditno stanje banke,
Receivables,Potraživanja,
Payables,Plativ,
Sales Orders to Bill,Narudžbe za prodaju Bill,
Purchase Orders to Bill,Nalozi za kupnju,
New Sales Orders,Nove narudžbenice,
New Purchase Orders,Nova narudžba kupnje,
Sales Orders to Deliver,Prodajni nalozi za isporuku,
Purchase Orders to Receive,Narudžbenice za primanje,
New Purchase Invoice,Nova faktura za kupnju,
New Quotations,Nove ponude,
Open Quotations,Otvori citate,
Open Issues,Otvoreni problemi,
Open Projects,Otvoreni projekti,
Purchase Orders Items Overdue,Narudžbenice su stavke dospjele,
Upcoming Calendar Events,Nadolazeći kalendarski događaji,
Open To Do,Otvoreno za učiniti,
Add Quote,Dodaj ponudu,
Global Defaults,Globalne zadane postavke,
Default Company,Zadana tvrtka,
Current Fiscal Year,Tekuće fiskalne godine,
Default Distance Unit,Zadana jedinica udaljenosti,
Hide Currency Symbol,Sakrij simbol valute,
Do not show any symbol like $ etc next to currencies.,Ne pokazati nikakav simbol kao $ iza valute.,
"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",
Disable In Words,Onemogućavanje riječima,
"If disable, 'In Words' field will not be visible in any transaction","Ako onemogućite &quot;, riječima &#39;polja neće biti vidljiva u bilo koju transakciju",
Item Classification,Klasifikacija predmeta,
General Settings,Opće postavke,
Item Group Name,Proizvod - naziv grupe,
Parent Item Group,Nadređena grupa proizvoda,
Item Group Defaults,Defaults grupe stavke,
Item Tax,Porez proizvoda,
Check this if you want to show in website,Označi ovo ako želiš prikazati na webu,
Show this slideshow at the top of the page,Prikaži ovaj slideshow na vrhu stranice,
HTML / Banner that will show on the top of product list.,HTML / baner koji će se prikazivati na vrhu liste proizvoda.,
Set prefix for numbering series on your transactions,Postavite prefiks za numeriranje niza na svoje transakcije,
Setup Series,Postavljanje Serija,
Update Series,Update serija,
Change the starting / current sequence number of an existing series.,Promjena polaznu / tekući redni broj postojeće serije.,
Quotation Lost Reason,Razlog nerealizirane ponude,
A third party distributor / dealer / commission agent / affiliate / reseller who sells the companies products for a commission.,Vanjski distributer / trgovac / trgovački zastupnik / suradnik / prodavač koji prodaje proizvode tvrtke za proviziju.,
Sales Partner Name,Naziv prodajnog partnera,
Partner Type,Tip partnera,
Address & Contacts,Adresa i kontakti,
Address Desc,Adresa silazno,
Contact Desc,Kontakt ukratko,
Sales Partner Target,Prodajni plan prodajnog partnera,
Targets,Ciljevi,
Show In Website,Pokaži na web stranici,
Referral Code,referentni kod,
To Track inbound purchase,Kako biste pratili ulaznu kupnju,
Logo,Logo,
Partner website,website partnera,
All Sales Transactions can be tagged against multiple **Sales Persons** so that you can set and monitor targets.,"Sve prodajnih transakcija može biti označene protiv više osoba ** prodaje **, tako da možete postaviti i pratiti ciljeve.",
Name and Employee ID,Ime i ID zaposlenika,
Sales Person Name,Ime prodajne osobe,
Parent Sales Person,Nadređeni prodavač,
Select company name first.,Prvo odaberite naziv tvrtke.,
Sales Person Targets,Prodajni plan prodavača,
Set targets Item Group-wise for this Sales Person.,Set cilja predmet Grupa-mudar za ovaj prodavač.,
Supplier Group Name,Naziv grupe dobavljača,
Parent Supplier Group,Grupa dobavljača roditelja,
Target Detail,Ciljana Detalj,
Target Qty,Ciljana Kol,
Target  Amount,Ciljani iznos,
Target Distribution,Ciljana Distribucija,
"Standard Terms and Conditions that can be added to Sales and Purchases.\n\nExamples:\n\n1. Validity of the offer.\n1. Payment Terms (In Advance, On Credit, part advance etc).\n1. What is extra (or payable by the Customer).\n1. Safety / usage warning.\n1. Warranty if any.\n1. Returns Policy.\n1. Terms of shipping, if applicable.\n1. Ways of addressing disputes, indemnity, liability, etc.\n1. Address and Contact of your Company.","Standardni uvjeti koji se mogu dodati prodaje i kupnje.\n\n Primjeri: \n\n 1. Valjanost ponude.\n 1. Uvjeti plaćanja (unaprijed na kredit, dio unaprijed i sl).\n 1. Što je extra (ili plaća Kupac).\n 1. Sigurnost / upozorenje korištenja.\n 1. Jamstvo ako ih ima.\n 1. Vraća politike.\n 1. Uvjeti dostave, ako je potrebno.\n 1. Načini adresiranja sporova, naknade štete, odgovornosti, itd \n 1. Kontakt Vaše tvrtke.",
Applicable Modules,Primjenjivi moduli,
Terms and Conditions Help,Uvjeti za pomoć,
Classification of Customers by region,Klasifikacija korisnika po regiji,
Territory Name,Naziv teritorija,
Parent Territory,Nadređena teritorija,
Territory Manager,Upravitelj teritorija,
For reference,Za referencu,
Territory Targets,Prodajni plan prema teritoriju,
Set Item Group-wise budgets on this Territory. You can also include seasonality by setting the Distribution.,Postavite proračun za grupu proizvoda na ovom području. Također možete uključiti sezonalnost postavljanjem distribucije.,
UOM Name,UOM Ime,
Check this to disallow fractions. (for Nos),Provjerite to da ne dopušta frakcija. (Za br),
Website Item Group,Grupa proizvoda web stranice,
Cross Listing of Item in multiple groups,Križ Oglas pošiljke u više grupa,
Default settings for Shopping Cart,Zadane postavke za Košarica,
Enable Shopping Cart,Omogućite Košarica,
Display Settings,Prikaz postavki,
Show Public Attachments,Prikaži javne privitke,
Show Price,Pokaži cijenu,
Show Stock Availability,Prikaži raspoloživa roba,
Show Contact Us Button,Prikaži gumb Kontaktirajte nas,
Show Stock Quantity,Prikaži količinu proizvoda,
Show Apply Coupon Code,Prikaži Primijeni kod kupona,
Allow items not in stock to be added to cart,Dopustite dodavanje predmeta u košaricu za kupnju,
Prices will not be shown if Price List is not set,Cijene neće biti prikazana ako Cjenik nije postavljena,
Quotation Series,Ponuda serija,
Checkout Settings,Blagajna Postavke,
Enable Checkout,Omogući Checkout,
Payment Success Url,Plaćanje Uspjeh URL,
After payment completion redirect user to selected page.,Nakon završetka plaćanja preusmjeriti korisnika na odabranu stranicu.,
Batch Details,Pojedinosti o šarži,
Batch ID,ID serije,
image,slika,
Parent Batch,Roditeljska šarža,
Manufacturing Date,Datum proizvodnje,
Batch Quantity,Količina serije,
Batch UOM,Šaržirajte UOM,
Source Document Type,Izvorni tip dokumenta,
Source Document Name,Izvorni naziv dokumenta,
Batch Description,Batch Opis,
Bin,Kanta,
Reserved Quantity,Rezervirano Količina,
Actual Quantity,Stvarna količina,
Requested Quantity,Tražena količina,
Reserved Qty for sub contract,Rezervirani kvota za podugovor,
Moving Average Rate,Stopa prosječne ponderirane cijene,
FCFS Rate,FCFS Stopa,
Customs Tariff Number,Broj carinske tarife,
Tariff Number,Tarifni broj,
Delivery To,Dostava za,
MAT-DN-.YYYY.-,MAT-DN-.YYYY.-,
Is Return,Je li povratak,
Issue Credit Note,Issue Credit Note,
Return Against Delivery Note,Povratak Protiv izdatnice,
Customer's Purchase Order No,Kupca Narudžbenica br,
Billing Address Name,Naziv adrese za naplatu,
Required only for sample item.,Potrebna je samo za primjer stavke.,
"If you have created a standard template in Sales Taxes and Charges Template, select one and click on the button below.","Ako ste stvorili standardni predložak u prodaji poreze i troškove predložak, odaberite jednu i kliknite na gumb ispod.",
In Words will be visible once you save the Delivery Note.,Riječima će biti vidljivo nakon što spremite otpremnicu.,
In Words (Export) will be visible once you save the Delivery Note.,Riječima (izvoz) će biti vidljivo nakon što spremite otpremnicu.,
Transporter Info,Transporter Info,
Driver Name,Naziv upravljačkog programa,
Track this Delivery Note against any Project,Prati ovu napomenu isporuke protiv bilo Projekta,
Inter Company Reference,Inter Company Reference,
Print Without Amount,Ispis Bez visini,
% Installed,% Instalirano,
% of materials delivered against this Delivery Note,% robe od ove otpremnice je isporučeno,
Installation Status,Status instalacije,
Excise Page Number,Trošarina Broj stranice,
Instructions,Instrukcije,
From Warehouse,Iz skladišta,
Against Sales Order,Protiv prodajnog naloga,
Against Sales Order Item,Protiv prodaje reda točkom,
Against Sales Invoice,Protiv prodaje fakture,
Against Sales Invoice Item,Protiv prodaje dostavnice točke,
Available Batch Qty at From Warehouse,Dostupno Batch Količina u iz skladišta,
Available Qty at From Warehouse,Dostupno Količina u iz skladišta,
Delivery Settings,Postavke isporuke,
Dispatch Settings,Postavke za slanje,
Dispatch Notification Template,Predložak obavijesti o otpremi,
Dispatch Notification Attachment,Privitak obavijesti o otpremi,
Leave blank to use the standard Delivery Note format,Ostavite prazno da biste koristili standardni format isporuke Napomena,
Send with Attachment,Pošalji s privitkom,
Delay between Delivery Stops,Odgoda između isporuke prestaje,
Delivery Stop,Dostava zaustavljanja,
Lock,Zaključaj,
Visited,posjetila,
Order Information,Informacije o narudžbi,
Contact Information,Kontakt informacije,
Email sent to,Mail poslan,
Dispatch Information,Podaci o otpremi,
Estimated Arrival,Očekivani dolazak,
MAT-DT-.YYYY.-,MAT-DT-.YYYY.-,
Initial Email Notification Sent,Poslana obavijest o početnoj e-pošti,
Delivery Details,Detalji isporuke,
Driver Email,E-adresa vozača,
Driver Address,Adresa vozača,
Total Estimated Distance,Ukupna procijenjena udaljenost,
Distance UOM,Udaljenost UOM,
Departure Time,Vrijeme polaska,
Delivery Stops,Dostava prestaje,
Calculate Estimated Arrival Times,Izračunajte procijenjene vrijeme dolaska,
Use Google Maps Direction API to calculate estimated arrival times,Koristite API za Google Maps Direction za izračunavanje predviđenih vremena dolaska,
Optimize Route,Optimizirajte rutu,
Use Google Maps Direction API to optimize route,Za optimizaciju rute koristite API za usmjeravanje Google Maps,
In Transit,U tranzitu,
Fulfillment User,Korisnik ispunjavanja,
"A Product or a Service that is bought, sold or kept in stock.","Proizvod ili usluga koja je kupljena, prodana ili zadržana na lageru.",
STO-ITEM-.YYYY.-,STO-ITEM-.YYYY.-,
Variant Of,Varijanta Of,
"If item is a variant of another item then description, image, pricing, taxes etc will be set from the template unless explicitly specified","Ako predmet je varijanta drugom stavku zatim opis, slika, cijena, porezi itd će biti postavljena od predloška, osim ako je izričito navedeno",
Is Item from Hub,Je li stavka iz huba,
Default Unit of Measure,Zadana mjerna jedinica,
Maintain Stock,Upravljanje zalihama,
Standard Selling Rate,Standardni prodajni tečaj,
Auto Create Assets on Purchase,Automatski stvorite sredstva prilikom kupnje,
Asset Naming Series,Serija imenovanja imovine,
Over Delivery/Receipt Allowance (%),Naknada za dostavu / primanje (%),
Barcodes,Bar kodovi,
Shelf Life In Days,Rok trajanja u danima,
End of Life,Kraj života,
Default Material Request Type,Zadana Materijal Vrsta zahtjeva,
Valuation Method,Metoda vrednovanja,
FIFO,FIFO,
Moving Average,Prosječna ponderirana cijena,
Warranty Period (in days),Jamstveni period (u danima),
Auto re-order,Automatski reorganiziraj,
Reorder level based on Warehouse,Razina redoslijeda na temelju Skladište,
Will also apply for variants unless overrridden,Također će zatražiti varijante osim overrridden,
Units of Measure,Mjerne jedinice,
Will also apply for variants,Također će podnijeti zahtjev za varijante,
Serial Nos and Batches,Serijski brojevi i serije,
Has Batch No,Je Hrpa Ne,
Automatically Create New Batch,Automatski kreira novu seriju,
Batch Number Series,Serije brojeva serije,
"Example: ABCD.#####. If series is set and Batch No is not mentioned in transactions, then automatic batch number will be created based on this series. If you always want to explicitly mention Batch No for this item, leave this blank. Note: this setting will take priority over the Naming Series Prefix in Stock Settings.","Primjer: ABCD. #####. Ako je niz postavljen, a transakcije se ne navode u Batch No, tada će se automatski izračunati broj serije na temelju ove serije. Ako uvijek želite izričito spomenuti Nijednu seriju za ovu stavku, ostavite to prazno. Napomena: ta će postavka imati prednost pred Prefiksom serije naziva u Stock Settings.",
Has Expiry Date,Ima datum isteka,
Retain Sample,Zadrži uzorak,
Max Sample Quantity,Maksimalna količina uzorka,
Maximum sample quantity that can be retained,Maksimalna količina uzorka koja se može zadržati,
Has Serial No,Ima serijski br,
Serial Number Series,Serijski broj serije,
"Example: ABCD.#####\nIf 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 ##### \n Ako Serija je postavljena i serijski broj ne spominje u prometu, a zatim automatsko serijski broj će biti izrađen na temelju ove serije. Ako ste uvijek žele eksplicitno spomenuti serijski brojevi za tu stavku. ostavite praznim.",
Variants,Varijante,
Has Variants,Je Varijante,
"If this item has variants, then it cannot be selected in sales orders etc.","Ako ova stavka ima varijante, onda to ne može biti izabran u prodajnim nalozima itd",
Variant Based On,Varijanta na temelju,
Item Attribute,Stavka značajke,
"Sales, Purchase, Accounting Defaults","Prodaja, Kupnja, Računovodstvene vrijednosti",
Item Defaults,Stavke zadane vrijednosti,
"Purchase, Replenishment Details","Pojedinosti o kupnji, dopuni",
Is Purchase Item,Je dobavljivi proizvod,
Default Purchase Unit of Measure,Zadana jedinicna mjera kupnje,
Minimum Order Qty,Minimalna količina narudžbe,
Minimum quantity should be as per Stock UOM,Minimalna količina treba biti prema zalihama UOM,
Average time taken by the supplier to deliver,Prosječno vrijeme potrebno od strane dobavljača za isporuku,
Is Customer Provided Item,Je li predmet kupca,
Delivered by Supplier (Drop Ship),Dostavlja Dobavljač (Drop Ship),
Supplier Items,Dobavljač Stavke,
Foreign Trade Details,Vanjskotrgovinska Detalji,
Country of Origin,Zemlja podrijetla,
Sales Details,Prodajni detalji,
Default Sales Unit of Measure,Zadana prodajna jedinica mjere,
Is Sales Item,Je proizvod namijenjen prodaji,
Max Discount (%),Maksimalni popust (%),
No of Months,Broj mjeseci,
Customer Items,Korisnički Stavke,
Inspection Criteria,Inspekcijski Kriteriji,
Inspection Required before Purchase,Inspekcija Obavezno prije kupnje,
Inspection Required before Delivery,Inspekcija potrebno prije isporuke,
Default BOM,Zadani BOM,
Supply Raw Materials for Purchase,Nabava sirovine za kupnju,
If subcontracted to a vendor,Ako podugovoren dobavljaču,
Customer Code,Kupac Šifra,
Default Item Manufacturer,Zadani proizvođač predmeta,
Default Manufacturer Part No,Zadani broj dijela proizvođača,
Show in Website (Variant),Prikaži u Web (Variant),
Items with higher weightage will be shown higher,Stavke sa višim weightage će se prikazati više,
Show a slideshow at the top of the page,Prikaži slideshow na vrhu stranice,
Website Image,Slika web stranice,
Website Warehouse,Skladište web stranice,
"Show ""In Stock"" or ""Not in Stock"" based on stock available in this warehouse.","Pokaži ""raspoloživo"" ili ""nije raspoloživo"" na temelju trentnog stanja na skladištu.",
Website Item Groups,Grupe proizvoda web stranice,
List this Item in multiple groups on the website.,Prikaži ovu stavku u više grupa na web stranici.,
Copy From Item Group,Primjerak iz točke Group,
Website Content,Sadržaj web stranice,
You can use any valid Bootstrap 4 markup in this field. It will be shown on your Item Page.,U ovom polju možete koristiti bilo koje važeće oznake Bootstrap 4. To će se prikazati na vašoj stranici predmeta.,
Total Projected Qty,Ukupni predviđeni Kol,
Hub Publishing Details,Pojedinosti objavljivanja središta,
Publish in Hub,Objavi na Hub,
Publish Item to hub.erpnext.com,Objavi stavka to hub.erpnext.com,
Hub Category to Publish,Kategorija hub za objavljivanje,
Hub Warehouse,Skladište hubova,
"Publish ""In Stock"" or ""Not in Stock"" on Hub based on stock available in this warehouse.",Objavite &quot;na zalihi&quot; ili &quot;nije na zalihi&quot; na hubu na temelju dostupnih dionica u ovom skladištu.,
Synced With Hub,Sinkronizirati s Hub,
Item Alternative,Stavka Alternativna,
Alternative Item Code,Kôd alternativne stavke,
Two-way,Dvosmjeran,
Alternative Item Name,Alternativni naziv stavke,
Attribute Name,Ime atributa,
Numeric Values,Brojčane vrijednosti,
From Range,Iz raspona,
Increment,Pomak,
To Range,U rasponu,
Item Attribute Values,Stavka vrijednosti atributa,
Item Attribute Value,Stavka Vrijednost atributa,
Attribute Value,Vrijednost atributa,
Abbreviation,Skraćenica,
"This will be appended to the Item Code of the variant. For example, if your abbreviation is ""SM"", and the item code is ""T-SHIRT"", the item code of the variant will be ""T-SHIRT-SM""","To će biti dodan u šifra varijante. Na primjer, ako je vaš naziv je ""SM"", a točka kod ""T-shirt"", stavka kod varijante će biti ""T-SHIRT-SM""",
Item Barcode,Barkod proizvoda,
Barcode Type,Vrsta crtičnog koda,
EAN,EAN,
UPC-A,UPC-A,
Item Customer Detail,Proizvod - detalji kupca,
"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",
Ref Code,Ref. Šifra,
Item Default,Stavka je zadana,
Purchase Defaults,Zadane postavke kupnje,
Default Buying Cost Center,Zadani trošak kupnje,
Default Supplier,Glavni dobavljač,
Default Expense Account,Zadani račun rashoda,
Sales Defaults,Defaults prodaja,
Default Selling Cost Center,Zadani trošak prodaje,
Item Manufacturer,stavka Proizvođač,
Item Price,Cijena proizvoda,
Packing Unit,Jedinica za pakiranje,
Quantity  that must be bought or sold per UOM,Količina koja se mora kupiti ili prodati po UOM-u,
Item Quality Inspection Parameter,Parametar provjere kvalitete proizvoda,
Acceptance Criteria,Kriterij prihvaćanja,
Item Reorder,Ponovna narudžba proizvoda,
Check in (group),Check in (grupa),
Request for,Zahtjev za,
Re-order Level,Ponovno bi razini,
Re-order Qty,Re-order Kom,
Item Supplier,Dobavljač proizvoda,
Item Variant,Stavka Variant,
Item Variant Attribute,Stavka Varijanta Osobina,
Do not update variants on save,Ne ažurirajte inačice spremanja,
Fields will be copied over only at time of creation.,Polja će biti kopirana samo u trenutku stvaranja.,
Allow Rename Attribute Value,Dopusti Preimenuj Vrijednost atributa,
Rename Attribute Value in Item Attribute.,Preimenuj vrijednost svojstva u svojstvu stavke.,
Copy Fields to Variant,Kopiranje polja u inačicu,
Item Website Specification,Specifikacija web stranice proizvoda,
Table for Item that will be shown in Web Site,Tablica za proizvode koji će biti prikazani na web stranici,
Landed Cost Item,Stavka zavisnih troškova,
Receipt Document Type,Potvrda Document Type,
Receipt Document,Prijem dokumenata,
Applicable Charges,Troškove u,
Purchase Receipt Item,Stavka primke,
Landed Cost Purchase Receipt,Ulazni račun zavisnog troška,
Landed Cost Taxes and Charges,Porezi i pristojbe zavisnog troška,
Landed Cost Voucher,Nalog zavisnog troška,
MAT-LCV-.YYYY.-,MAT-lakih gospodarskih-.YYYY.-,
Purchase Receipts,Primke,
Purchase Receipt Items,Primka proizvoda,
Get Items From Purchase Receipts,Se predmeti od kupnje primitke,
Distribute Charges Based On,Distribuirati optužbi na temelju,
Landed Cost Help,Zavisni troškovi - Pomoć,
Manufacturers used in Items,Proizvođači se koriste u stavkama,
Limited to 12 characters,Ograničiti na 12 znakova,
MAT-MR-.YYYY.-,MAT-MR-.YYYY.-,
Partially Ordered,Djelomično uređeno,
Transferred,prebačen,
% Ordered,% Naručeno,
Terms and Conditions Content,Uvjeti sadržaj,
Quantity and Warehouse,Količina i skladišta,
Lead Time Date,Potencijalni kupac - datum,
Min Order Qty,Min naručena kol,
Packed Item,Pakirani proizvod,
To Warehouse (Optional),Za Warehouse (po izboru),
Actual Batch Quantity,Stvarna količina serije,
Prevdoc DocType,Prevdoc DOCTYPE,
Parent Detail docname,Nadređeni detalj docname,
"Generate packing slips for packages to be delivered. Used to notify package number, package contents and its weight.","Izradi pakiranje gaćice za pakete biti isporučena. Koristi se za obavijesti paket broj, sadržaj paketa i njegovu težinu.",
Indicates that the package is a part of this delivery (Only Draft),Ukazuje da je paket je dio ove isporuke (samo nacrti),
MAT-PAC-.YYYY.-,MAT-PAC-.YYYY.-,
From Package No.,Iz paketa broj,
Identification of the package for the delivery (for print),Identifikacija paketa za dostavu (za tisak),
To Package No.,Za Paket br,
If more than one package of the same type (for print),Ako je više od jedan paket od iste vrste (za tisak),
Package Weight Details,Težina paketa - detalji,
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),
Net Weight UOM,Težina mjerna jedinica,
Gross Weight,Bruto težina,
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),
Gross Weight UOM,Bruto težina UOM,
Packing Slip Item,Odreskom predmet,
DN Detail,DN detalj,
STO-PICK-.YYYY.-,STO-PICK-.YYYY.-,
Material Transfer for Manufacture,Prijenos materijala za izradu,
Qty of raw materials will be decided based on the qty of the Finished Goods Item,Količina sirovina odlučivat će se na osnovu količine proizvoda Gotove robe,
Parent Warehouse,Roditelj Skladište,
Items under this warehouse will be suggested,Predlozi ispod ovog skladišta bit će predloženi,
Get Item Locations,Dohvati lokacije predmeta,
Item Locations,Lokacije predmeta,
Pick List Item,Odaberi stavku popisa,
Picked Qty,Izabrani broj,
Price List Master,Cjenik Master,
Price List Name,Naziv cjenika,
Price Not UOM Dependent,Cijena nije UOM ovisna,
Applicable for Countries,Primjenjivo za zemlje,
Price List Country,Država cjenika,
MAT-PRE-.YYYY.-,MAT-PRE-.YYYY.-,
Supplier Delivery Note,Isporuka isporuke dobavljača,
Time at which materials were received,Vrijeme u kojem su materijali primili,
Return Against Purchase Receipt,Povratak na primku,
Rate at which supplier's currency is converted to company's base currency,Stopa po kojoj supplier valuta se pretvaraju u tvrtke bazne valute,
Sets 'Accepted Warehouse' in each row of the items table.,Postavlja &#39;Prihvaćeno skladište&#39; u svaki redak tablice stavki.,
Sets 'Rejected Warehouse' in each row of the items table.,Postavlja &#39;Odbijeno skladište&#39; u svaki redak tablice stavki.,
Raw Materials Consumed,Potrošena sirovina,
Get Current Stock,Kreiraj trenutne zalihe,
Consumed Items,Potrošeni predmeti,
Add / Edit Taxes and Charges,Dodaj / uredi porez i pristojbe,
Auto Repeat Detail,Automatski ponavljanje pojedinosti,
Transporter Details,Transporter Detalji,
Vehicle Number,Broj vozila,
Vehicle Date,Datum vozila,
Received and Accepted,Primljeni i prihvaćeni,
Accepted Quantity,Prihvaćena količina,
Rejected Quantity,Odbijen Količina,
Accepted Qty as per Stock UOM,Prihvaćena količina prema zalihi UOM,
Sample Quantity,Količina uzorka,
Rate and Amount,Kamatna stopa i iznos,
MAT-QA-.YYYY.-,MAT-QA-.YYYY.-,
Report Date,Prijavi Datum,
Inspection Type,Inspekcija Tip,
Item Serial No,Serijski broj proizvoda,
Sample Size,Veličina uzorka,
Inspected By,Pregledati,
Readings,Očitanja,
Quality Inspection Reading,Inspekcija kvalitete - čitanje,
Reading 1,Čitanje 1,
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,
Reading 10,Čitanje 10,
Quality Inspection Template Name,Naziv predloška inspekcije kvalitete,
Quick Stock Balance,Brzo stanje zaliha,
Available Quantity,Dostupna količina,
Distinct unit of an Item,Razlikuje jedinica stavku,
Warehouse can only be changed via Stock Entry / Delivery Note / Purchase Receipt,Skladište se može mijenjati samo preko Međuskladišnica / Otpremnica / Primka,
Purchase / Manufacture Details,Detalji nabave/proizvodnje,
Creation Document Type,Tip stvaranje dokumenata,
Creation Document No,Stvaranje dokumenata nema,
Creation Date,Datum stvaranja,
Creation Time,vrijeme kreiranja,
Asset Details,Pojedinosti o aktivi,
Asset Status,Status aktive,
Delivery Document Type,Dokument isporuke - tip,
Delivery Document No,Dokument isporuke br,
Delivery Time,Vrijeme isporuke,
Invoice Details,Pojedinosti fakture,
Warranty / AMC Details,Jamstveni / AMC Brodu,
Warranty Expiry Date,Datum isteka jamstva,
AMC Expiry Date,AMC Datum isteka,
Under Warranty,Pod jamstvom,
Out of Warranty,Od jamstvo,
Under AMC,Pod AMC,
Out of AMC,Od AMC,
Warranty Period (Days),Jamstveni period (dani),
Serial No Details,Serijski nema podataka,
MAT-STE-.YYYY.-,MAT-STE-.YYYY.-,
Stock Entry Type,Vrsta unosa dionica,
Stock Entry (Outward GIT),Unos dionica (vanjski GIT),
Material Consumption for Manufacture,Potrošnja materijala za proizvodnju,
Repack,Prepakiraj,
Send to Subcontractor,Pošaljite podizvođaču,
Delivery Note No,Otpremnica br,
Sales Invoice No,Prodajni račun br,
Purchase Receipt No,Primka br.,
Inspection Required,Inspekcija Obvezno,
From BOM,Od sastavnice,
For Quantity,Za Količina,
As per Stock UOM,Kao po burzi UOM,
Including items for sub assemblies,Uključujući predmeta za sub sklopova,
Default Source Warehouse,Zadano izvorno skladište,
Source Warehouse Address,Izvorna skladišna adresa,
Default Target Warehouse,Centralno skladište,
Target Warehouse Address,Adresa ciljne skladišta,
Update Rate and Availability,Brzina ažuriranja i dostupnost,
Total Incoming Value,Ukupno Dolazni vrijednost,
Total Outgoing Value,Ukupna odlazna vrijednost,
Total Value Difference (Out - In),Ukupna vrijednost razlika (Out - In),
Additional Costs,Dodatni troškovi,
Total Additional Costs,Ukupno Dodatni troškovi,
Customer or Supplier Details,Kupca ili dobavljača Detalji,
Per Transferred,Po prijenosu,
Stock Entry Detail,Detalji međuskladišnice,
Basic Rate (as per Stock UOM),Osnovna stopa (po burzi UOM),
Basic Amount,Osnovni iznos,
Additional Cost,Dodatni trošak,
Serial No / Batch,Serijski Ne / Batch,
BOM No. for a Finished Good Item,BOM broj za Gotovi Dobar točki,
Material Request used to make this Stock Entry,Zahtjev za robom korišten za izradu ovog ulaza robe,
Subcontracted Item,Podugovarana stavka,
Against Stock Entry,Protiv unosa dionica,
Stock Entry Child,Dijete za ulazak na zalihe,
PO Supplied Item,Predmet isporučenog predmeta,
Reference Purchase Receipt,Referentna kupnja,
Stock Ledger Entry,Upis u glavnu knjigu,
Outgoing Rate,Odlazni Ocijenite,
Actual Qty After Transaction,Stvarna količina nakon transakcije,
Stock Value Difference,Stock Vrijednost razlika,
Stock Queue (FIFO),Kataloški red (FIFO),
Is Cancelled,Je otkazan,
Stock Reconciliation,Kataloški pomirenje,
This tool helps you to update or fix the quantity and valuation of stock in the system. It is typically used to synchronise the system values and what actually exists in your warehouses.,Ovaj alat pomaže vam da ažurirate ili popraviti količinu i vrijednost zaliha u sustavu. To se obično koristi za sinkronizaciju vrijednosti sustava i što se zapravo postoji u svojim skladištima.,
MAT-RECO-.YYYY.-,MAT-Reco-.YYYY.-,
Reconciliation JSON,Pomirenje JSON,
Stock Reconciliation Item,Stock pomirenje točka,
Before reconciliation,Prije pomirenja,
Current Serial No,Trenutni serijski br,
Current Valuation Rate,Trenutno Vrednovanje Ocijenite,
Current Amount,Trenutni iznos,
Quantity Difference,Količina razlika,
Amount Difference,iznos razlika,
Item Naming By,Proizvod imenovan po,
Default Item Group,Zadana grupa proizvoda,
Default Stock UOM,Zadana kataloška mjerna jedinica,
Sample Retention Warehouse,Skladište za uzorkovanje uzoraka,
Default Valuation Method,Zadana metoda vrednovanja,
Show Barcode Field,Prikaži Barkod Polje,
Convert Item Description to Clean HTML,Pretvori opis stavke u čisti HTML,
Allow Negative Stock,Dopustite negativnu zalihu,
Automatically Set Serial Nos based on FIFO,Automatski Postavljanje Serijski broj na temelju FIFO,
Auto Material Request,Automatski zahtjev za materijalom,
Inter Warehouse Transfer Settings,Postavke prijenosa skladišta Inter,
Freeze Stock Entries,Zamrzavanje Stock Unosi,
Stock Frozen Upto,Kataloški Frozen Upto,
Batch Identification,Identifikacija serije,
Use Naming Series,Upotrijebite seriju naziva,
Naming Series Prefix,Imenujte prefiks serije,
UOM Category,Kategorija UOM,
UOM Conversion Detail,UOM pretvorbe Detalj,
Variant Field,Polje varijante,
A logical Warehouse against which stock entries are made.,Kreirano Skladište za ulazne stavke,
Warehouse Detail,Detalji o skladištu,
Warehouse Name,Naziv skladišta,
Warehouse Contact Info,Kontakt informacije skladišta,
PIN,PIN,
ISS-.YYYY.-,ISS-.GGGG.-,
Raised By (Email),Povišena Do (e),
Issue Type,Vrsta izdanja,
Issue Split From,Izdanje Split From,
Service Level,Razina usluge,
Response By,Odgovor By,
Response By Variance,Odgovor prema varijanci,
Ongoing,U tijeku,
Resolution By,Rezolucija po,
Resolution By Variance,Rezolucija po varijanti,
Service Level Agreement Creation,Izrada sporazuma o razini usluge,
First Responded On,Prvo Odgovorili Na,
Resolution Details,Rezolucija o Brodu,
Opening Date,Datum otvaranja,
Opening Time,Radno vrijeme,
Resolution Date,Rezolucija Datum,
Via Customer Portal,Putem portala kupca,
Support Team,Tim za podršku,
Issue Priority,Prioritet pitanja,
Service Day,Dan usluge,
Workday,Radni dan,
Default Priority,Zadani prioritet,
Priorities,prioriteti,
Support Hours,Sati podrške,
Support and Resolution,Podrška i rezolucija,
Default Service Level Agreement,Zadani ugovor o razini usluge,
Entity,entiteta,
Agreement Details,Pojedinosti o ugovoru,
Response and Resolution Time,Vrijeme odziva i rješavanja,
Service Level Priority,Prioritet na razini usluge,
Resolution Time,Vrijeme razlučivosti,
Support Search Source,Potražite izvor za podršku,
Source Type,Vrsta izvora,
Query Route String,Upit Stringa rute,
Search Term Param Name,Param Naziv pojma za pretraživanje,
Response Options,Opcije odgovora,
Response Result Key Path,Rezultat odgovora Ključni put,
Post Route String,Obaviti redak puta,
Post Route Key List,Popis ključeva za trasu popisa,
Post Title Key,Ključ postaje naslova,
Post Description Key,Ključ za opis post,
Link Options,Mogućnosti veze,
Source DocType,Izvor DocType,
Result Title Field,Polje naslova rezultata,
Result Preview Field,Polje pregleda rezultata,
Result Route Field,Polje rute rezultata,
Service Level Agreements,Ugovori o razini usluge,
Track Service Level Agreement,Sporazum o razini usluge praćenja,
Allow Resetting Service Level Agreement,Dopustite resetiranje sporazuma o razini usluge,
Close Issue After Days,Zatvori Issue Nakon dana,
Auto close Issue after 7 days,Automatski zatvori Pitanje nakon 7 dana,
Support Portal,Portal podrške,
Get Started Sections,Započnite s radom,
Show Latest Forum Posts,Prikaži najnovije postove na forumu,
Forum Posts,Forum postova,
Forum URL,URL foruma,
Get Latest Query,Dohvati najnoviji upit,
Response Key List,Popis ključeva za odgovor,
Post Route Key,Objavi ključ rute,
Search APIs,API-ji za pretraživanje,
SER-WRN-.YYYY.-,SER-wrn-.YYYY.-,
Issue Date,Datum Izazova,
Item and Warranty Details,Stavka i jamstvo Detalji,
Warranty / AMC Status,Jamstveni / AMC Status,
Resolved By,Riješen Do,
Service Address,Usluga Adresa,
If different than customer address,Ako se razlikuje od kupaca adresu,
Raised By,Povišena Do,
From Company,Iz Društva,
Rename Tool,Preimenovanje,
Utilities,Komunalne usluge,
Type of document to rename.,Vrsta dokumenta za promjenu naziva.,
File to Rename,Datoteka za Preimenovanje,
"Attach .csv file with two columns, one for the old name and one for the new name","Pričvrstite .csv datoteku s dva stupca, jedan za stari naziv i jedan za novim nazivom",
Rename Log,Preimenuj prijavu,
SMS Log,SMS Prijava,
Sender Name,Pošiljatelj Ime,
Sent On,Poslan Na,
No of Requested SMS,Nema traženih SMS-a,
Requested Numbers,Traženi brojevi,
No of Sent SMS,Broj poslanih SMS-a,
Sent To,Poslano Da,
Absent Student Report,Odsutni Student Report,
Assessment Plan Status,Status plana procjene,
Asset Depreciation Ledger,Imovine Amortizacija knjiga,
Asset Depreciations and Balances,Imovine deprecijacije i sredstva,
Available Stock for Packing Items,Raspoloživo stanje za pakirane proizvode,
Bank Clearance Summary,Razmak banka Sažetak,
Batch Item Expiry Status,Hrpa Stavka isteka Status,
Batch-Wise Balance History,Batch-Wise povijest bilance,
BOM Explorer,BOM Explorer,
BOM Search,BOM Pretraživanje,
BOM Stock Calculated,BOM zaliha izračunata,
BOM Variance Report,Izvješće o varijanti BOM,
Campaign Efficiency,Učinkovitost kampanje,
Cash Flow,Protok novca,
Completed Work Orders,Dovršeni radni nalozi,
To Produce,proizvoditi,
Produced,Proizvedeno,
Consolidated Financial Statement,Konsolidirano financijsko izvješće,
Course wise Assessment Report,Izvješće o procjeni studija,
Customer Acquisition and Loyalty,Stjecanje kupaca i lojalnost,
Customer Credit Balance,Kupac saldo,
Customer Ledger Summary,Sažetak knjige klijenta,
Customer-wise Item Price,Kupcima prilagođena cijena,
Customers Without Any Sales Transactions,Kupci bez ikakvih prodajnih transakcija,
Daily Timesheet Summary,Dnevni timesheet Sažetak,
DATEV,DATEV,
Delayed Item Report,Izvješće o odgođenom stavci,
Delayed Order Report,Izvješće o odgođenom nalogu,
Delivered Items To Be Billed,Isporučeni proizvodi za naplatiti,
Delivery Note Trends,Trend otpremnica,
Electronic Invoice Register,Registar elektroničkih računa,
Employee Billing Summary,Sažetak naplate zaposlenika,
Employee Birthday,Rođendan zaposlenika,
Employee Information,Informacije o zaposleniku,
Employee Leave Balance,Zaposlenik napuste balans,
Employee Leave Balance Summary,Sažetak stanja ravnoteže zaposlenika,
Eway Bill,Eway Bill,
Expiring Memberships,Istječe članstva,
Fichier des Ecritures Comptables [FEC],Fichier des Ecritures Comptables [FEC],
Final Assessment Grades,Konačna ocjena razreda,
Fixed Asset Register,Registar fiksne imovine,
Gross and Net Profit Report,Izvješće o bruto i neto dobiti,
GST Itemised Purchase Register,Registar kupnje artikala GST,
GST Itemised Sales Register,GST označeni prodajni registar,
GST Purchase Register,Registar kupnje GST-a,
GST Sales Register,GST registar prodaje,
GSTR-1,GSTR-1,
GSTR-2,GSTR 2,
Hotel Room Occupancy,Soba za boravak hotela,
HSN-wise-summary of outward supplies,HSN-mudar sažetak vanjske opskrbe,
Inactive Customers,Neaktivni korisnici,
Inactive Sales Items,Neaktivni predmeti prodaje,
IRS 1099,IRS 1099,
Issued Items Against Work Order,Izdane stavke protiv radnog naloga,
Projected Quantity as Source,Planirana količina kao izvor,
Item Balance (Simple),Stavka salda (jednostavna),
Item Price Stock,Cijena artikala,
Item Prices,Cijene proizvoda,
Item Shortage Report,Nedostatak izvješća za proizvod,
Item Variant Details,Pojedinosti varijante stavke,
Item-wise Price List Rate,Item-wise cjenik,
Item-wise Purchase History,Povjest nabave po stavkama,
Item-wise Purchase Register,Popis nabave po stavkama,
Item-wise Sales History,Pregled prometa po artiklu,
Item-wise Sales Register,Stavka-mudri prodaja registar,
Items To Be Requested,Potraživani proizvodi,
Reserved,Rezervirano,
Itemwise Recommended Reorder Level,Itemwise - preporučena razina ponovne narudžbe,
Lead Details,Detalji potenciajalnog kupca,
Lead Owner Efficiency,Učinkovitost voditelja,
Lost Opportunity,Izgubljena prilika,
Maintenance Schedules,Održavanja rasporeda,
Material Requests for which Supplier Quotations are not created,Zahtjevi za robom za koje dobavljačeve ponude nisu stvorene,
Open Work Orders,Otvorite radne narudžbe,
Qty to Deliver,Količina za otpremu,
Patient Appointment Analytics,Analitika imenovanja pacijenta,
Payment Period Based On Invoice Date,Razdoblje za naplatu po Datum fakture,
Pending SO Items For Purchase Request,Otvorene stavke narudžbe za zahtjev za kupnju,
Procurement Tracker,Tragač za nabavom,
Product Bundle Balance,Bilanca paketa proizvoda,
Production Analytics,Proizvodnja Analytics,
Profit and Loss Statement,Račun dobiti i gubitka,
Profitability Analysis,Analiza profitabilnosti,
Project Billing Summary,Sažetak naplate projekta,
Project wise Stock Tracking,Projektno mudro praćenje dionica,
Project wise Stock Tracking ,Projekt mudar Stock Praćenje,
Prospects Engaged But Not Converted,"Izgledi angažirani, ali nisu konvertirani",
Purchase Analytics,Analitika nabave,
Purchase Invoice Trends,Trendovi nabavnih računa,
Qty to Receive,Količina za primanje,
Received Qty Amount,Primljena količina u količini,
Billed Qty,Količina računa,
Purchase Order Trends,Trendovi narudžbenica kupnje,
Purchase Receipt Trends,Trend primki,
Purchase Register,Popis nabave,
Quotation Trends,Trend ponuda,
Received Items To Be Billed,Primljeni Proizvodi se naplaćuje,
Qty to Order,Količina za narudžbu,
Requested Items To Be Transferred,Traženi proizvodi spremni za transfer,
Qty to Transfer,Količina za prijenos,
Sales Analytics,Prodajna analitika,
Sales Invoice Trends,Trendovi prodajnih računa,
Sales Order Trends,Trend narudžbi kupca,
Sales Partner Commission Summary,Sažetak komisije za prodajne partnere,
Sales Partner Target Variance based on Item Group,Ciljna varijanta prodajnog partnera na temelju grupe proizvoda,
Sales Partner Transaction Summary,Sažetak transakcije prodajnog partnera,
Sales Partners Commission,Provizija prodajnih partnera,
Invoiced Amount (Exclusive Tax),Fakturirani iznos (bez poreza),
Average Commission Rate,Prosječna provizija,
Sales Payment Summary,Sažetak plaćanja prodaje,
Sales Person Commission Summary,Sažetak Povjerenstva za prodaju,
Sales Person Target Variance Based On Item Group,Prodajna ciljana varijanta za osobu na temelju grupe predmeta,
Sales Person-wise Transaction Summary,Pregled prometa po prodavaču,
Sales Register,Prodaja Registracija,
Serial No Service Contract Expiry,Istek ugovora za serijski broj usluge,
Serial No Status,Status serijskog broja,
Serial No Warranty Expiry,Istek jamstva serijskog broja,
Stock Ageing,Starost skladišta,
Stock and Account Value Comparison,Usporedba vrijednosti dionica i računa,
Stock Projected Qty,Stanje skladišta,
Student and Guardian Contact Details,Studentski i Guardian Kontaktni podaci,
Student Batch-Wise Attendance,Student šarže posjećenost,
Student Fee Collection,Studentski Naknada Collection,
Student Monthly Attendance Sheet,Studentski mjesečna posjećenost list,
Subcontracted Item To Be Received,Podugovarački predmet koji se prima,
Subcontracted Raw Materials To Be Transferred,Podugovaračke sirovine koje treba prenijeti,
Supplier Ledger Summary,Sažetak knjige dobavljača,
Supplier-Wise Sales Analytics,Supplier -mudar prodaje Analytics,
Support Hour Distribution,Distribucija rasporeda podrške,
TDS Computation Summary,TDS Computation Summary,
TDS Payable Monthly,TDS se plaća mjesečno,
Territory Target Variance Based On Item Group,Varijacija ciljne teritorija na temelju grupe predmeta,
Territory-wise Sales,Prodaja na teritoriji,
Total Stock Summary,Ukupni zbroj dionica,
Trial Balance,Pretresno bilanca,
Trial Balance (Simple),Probna ravnoteža (jednostavno),
Trial Balance for Party,Suđenje Stanje na stranku,
Warehouse wise Item Balance Age and Value,Skladište mudar Stavka Stanje Dob i vrijednost,
Work Order Stock Report,Izvješće o stanju na radnom mjestu,
Work Orders in Progress,Radni nalozi u tijeku,
Automatically Process Deferred Accounting Entry,Automatski obradi odgođeni knjigovodstveni unos,
Bank Clearance,Potvrda banke,
Bank Clearance Detail,Pojedinosti o odobrenju banke,
Update Cost Center Name / Number,Ažuriranje naziva / broja mjesta troška,
Journal Entry Template,Predložak za ulazak u časopis,
Template Title,Naslov predloška,
Journal Entry Type,Vrsta unosa u časopis,
Journal Entry Template Account,Račun predloška za unos u časopis,
Process Deferred Accounting,Obraditi odgođeno računovodstvo,
Manual entry cannot be created! Disable automatic entry for deferred accounting in accounts settings and try again,Nije moguće stvoriti ručni unos! Onemogućite automatski unos za odgođeno računovodstvo u postavkama računa i pokušajte ponovno,
End date cannot be before start date,Datum završetka ne može biti prije datuma početka,
Total Counts Targeted,Ukupno ciljano brojanje,
Total Counts Completed,Ukupno prebrojavanje završeno,
Counts Targeted: {0},Broj ciljanih brojeva: {0},
Material Request Warehouse,Skladište zahtjeva za materijal,
Select warehouse for material requests,Odaberite skladište za zahtjeve za materijalom,
Transfer Materials For Warehouse {0},Prijenos materijala za skladište {0},
Production Plan Material Request Warehouse,Skladište zahtjeva za planom proizvodnje,
Sets 'Source Warehouse' in each row of the items table.,Postavlja &#39;Izvorno skladište&#39; u svaki redak tablice stavki.,
Sets 'Target Warehouse' in each row of the items table.,Postavlja &#39;Ciljano skladište&#39; u svaki redak tablice stavki.,
Show Cancelled Entries,Prikaži otkazane unose,
Backdated Stock Entry,Unos dionica sa zadnjim datumom,
Row #{}: Currency of {} - {} doesn't matches company currency.,Redak {{}: Valuta od {} - {} ne podudara se s valutom tvrtke.,
{} Assets created for {},{} Sredstva stvorena za {},
{0} Number {1} is already used in {2} {3},{0} Broj {1} već se koristi u dokumentu {2} {3},
Update Bank Clearance Dates,Ažurirajte datume odobrenja za banke,
Healthcare Practitioner: ,Liječnik:,
Lab Test Conducted: ,Provedeno laboratorijsko ispitivanje:,
Lab Test Event: ,Događaj laboratorijskog ispitivanja:,
Lab Test Result: ,Rezultat laboratorijskog ispitivanja:,
Clinical Procedure conducted: ,Provedeni klinički postupak:,
Therapy Session Charges: {0},Troškovi sesije terapije: {0},
Therapy: ,Terapija:,
Therapy Plan: ,Plan terapije:,
Total Counts Targeted: ,Ukupno ciljano brojanje:,
Total Counts Completed: ,Ukupno izvršeno brojanje:,
Is Mandatory,Je obavezno,
Service Received But Not Billed,"Usluga primljena, ali ne i naplaćena",
Deferred Accounting Settings,Postavke odgođenog računovodstva,
Book Deferred Entries Based On,Rezervirajte unose na osnovi,
Days,Dana,
Months,Mjeseci,
Book Deferred Entries Via Journal Entry,Rezervirajte unose putem odlozaka,
Submit Journal Entries,Pošaljite članke u časopisu,
If this is unchecked Journal Entries will be saved in a Draft state and will have to be submitted manually,"Ako ovo nije označeno, unosi u dnevnik bit će spremljeni u stanje nacrta i morat će se slati ručno",
Enable Distributed Cost Center,Omogući distribuirano mjesto troškova,
Distributed Cost Center,Raspodijeljeno mjesto troškova,
Dunning,Dunning,
DUNN-.MM.-.YY.-,DUNN-.MM .-. YY.-,
Overdue Days,Zakašnjeli dani,
Dunning Type,Dunning Type,
Dunning Fee,Naknada za Dunning,
Dunning Amount,Iznos za izlazak,
Resolved,Riješen,
Unresolved,Neriješeno,
Printing Setting,Postavke ispisa,
Body Text,Tekst tijela,
Closing Text,Završni tekst,
Resolve,Odlučnost,
Dunning Letter Text,Dunningov tekst slova,
Is Default Language,Je zadani jezik,
Letter or Email Body Text,Tekst tijela pisma ili e-pošte,
Letter or Email Closing Text,Završni tekst pisma ili e-pošte,
Body and Closing Text Help,Pomoć za tekst i završni tekst,
Overdue Interval,Zakašnjeli interval,
Dunning Letter,Dunning Letter,
"This section allows the user to set the Body and Closing text of the Dunning Letter for the Dunning Type based on language, which can be used in Print.","Ovaj odjeljak omogućuje korisniku da postavi Tekst i završni tekst Pisma za upozoravanje za vrstu Dunning na temelju jezika, koji se može koristiti u Ispisu.",
Reference Detail No,Referentni detalj br,
Custom Remarks,Prilagođene napomene,
Please select a Company first.,Prvo odaberite tvrtku.,
"Row #{0}: Reference Document Type must be one of Sales Order, Sales Invoice, Journal Entry or Dunning","Redak {0}: vrsta referentnog dokumenta mora biti jedna od prodajnih naloga, prodajnih faktura, unosa u dnevnik ili Dunning",
POS Closing Entry,Zatvaranje ulaza u POS,
POS Opening Entry,POS otvaranje,
POS Transactions,POS transakcije,
POS Closing Entry Detail,Pojedinosti o zatvaranju POS-a,
Opening Amount,Iznos otvaranja,
Closing Amount,Završni iznos,
POS Closing Entry Taxes,POS porezi na zatvaranje ulaznica,
POS Invoice,POS račun,
ACC-PSINV-.YYYY.-,ACC-PSINV-.GGGG.-,
Consolidated Sales Invoice,Konsolidirana prodajna faktura,
Return Against POS Invoice,Povraćaj protiv POS fakture,
Consolidated,Konsolidirani,
POS Invoice Item,Stavka POS fakture,
POS Invoice Merge Log,Dnevnik spajanja POS računa,
POS Invoices,POS fakture,
Consolidated Credit Note,Konsolidirana kreditna bilješka,
POS Invoice Reference,Referenca POS računa,
Set Posting Date,Odredite datum knjiženja,
Opening Balance Details,Pojedinosti o početnom stanju,
POS Opening Entry Detail,Pojedinosti o otvaranju POS-a,
POS Payment Method,POS način plaćanja,
Payment Methods,Metode Plačanja,
Process Statement Of Accounts,Obraditi izvod računa,
General Ledger Filters,Filteri glavne knjige,
Customers,Kupci,
Select Customers By,Odaberite Kupce prema,
Fetch Customers,Dohvati kupce,
Send To Primary Contact,Pošalji primarnom kontaktu,
Print Preferences,Postavke ispisa,
Include Ageing Summary,Uključite sažetak starenja,
Enable Auto Email,Omogući automatsku e-poštu,
Filter Duration (Months),Trajanje filtra (mjeseci),
CC To,CC Za,
Help Text,Tekst pomoći,
Emails Queued,E-adrese u redu,
Process Statement Of Accounts Customer,Obradite izvod računa,
Billing Email,E-adresa za naplatu,
Primary Contact Email,Primarna adresa e-pošte za kontakt,
PSOA Cost Center,PSOA mjesto troška,
PSOA Project,Projekt PSOA,
ACC-PINV-RET-.YYYY.-,ACC-PINV-RET-.GGGG.-,
Supplier GSTIN,Dobavljač GSTIN,
Place of Supply,Mjesto isporuke,
Select Billing Address,Odaberite adresu za naplatu,
GST Details,Pojedinosti o porezu na dodatke,
GST Category,GST kategorija,
Registered Regular,Registrirani redovni,
Registered Composition,Registrirani sastav,
Unregistered,Neregistrirano,
SEZ,SEZ,
Overseas,Prekomorski,
UIN Holders,UIN držači,
With Payment of Tax,Uz plaćanje poreza,
Without Payment of Tax,Bez plaćanja poreza,
Invoice Copy,Kopija fakture,
Original for Recipient,Izvornik za primatelja,
Duplicate for Transporter,Duplikat za Transporter,
Duplicate for Supplier,Duplikat za dobavljača,
Triplicate for Supplier,Trostruki primjerak za dobavljača,
Reverse Charge,Obrnuti naboj,
Y,Y,
N,N,
E-commerce GSTIN,E-trgovina GSTIN,
Reason For Issuing document,Razlog za izdavanje dokumenta,
01-Sales Return,01-Povratak prodaje,
02-Post Sale Discount,Popust za prodaju nakon 02,
03-Deficiency in services,03-Nedostatak usluga,
04-Correction in Invoice,04-Ispravak na računu,
05-Change in POS,05-Promjena u POS-u,
06-Finalization of Provisional assessment,06-Završetak privremene procjene,
07-Others,07-Ostali,
Eligibility For ITC,Ispunjavanje uvjeta za ITC,
Input Service Distributor,Distributer usluge unosa,
Import Of Service,Uvoz usluge,
Import Of Capital Goods,Uvoz kapitalnih dobara,
Ineligible,Neprihvatljivo,
All Other ITC,Svi ostali ITC,
Availed ITC Integrated Tax,Iskoristivi ITC integrirani porez,
Availed ITC Central Tax,Dostupni središnji porez ITC-a,
Availed ITC State/UT Tax,Availed ITC State / UT porez,
Availed ITC Cess,Iskoristivi ITC Cess,
Is Nil Rated or Exempted,Je li Nil ocijenjen ili izuzet,
Is Non GST,Nije GST,
ACC-SINV-RET-.YYYY.-,ACC-SINV-RET-.GGGG.-,
E-Way Bill No.,E-Way Bill No.,
Is Consolidated,Je konsolidiran,
Billing Address GSTIN,Adresa za naplatu GSTIN,
Customer GSTIN,Kupac GSTIN,
GST Transporter ID,GST ID prijevoznika,
Distance (in km),Udaljenost (u km),
Road,Cesta,
Air,Zrak,
Rail,Željeznica,
Ship,Brod,
GST Vehicle Type,GST tip vozila,
Over Dimensional Cargo (ODC),Prekomjerni teret (ODC),
Consumer,Potrošač,
Deemed Export,Smatra se izvozom,
Port Code,Lučki kod,
 Shipping Bill Number,Broj računa za otpremu,
Shipping Bill Date,Datum računa za dostavu,
Subscription End Date,Datum završetka pretplate,
Follow Calendar Months,Slijedite kalendarske mjesece,
If this is checked subsequent new invoices will be created on calendar  month and quarter start dates irrespective of current invoice start date,"Ako je ovo potvrđeno, kreirat će se novi računi na datum početka kalendarskog mjeseca i tromjesečja, bez obzira na datum početka tekuće fakture",
Generate New Invoices Past Due Date,Generirajte nove fakture s rokom dospijeća,
New invoices will be generated as per schedule even if current invoices are unpaid or past due date,"Nove fakture generirat će se prema rasporedu, čak i ako su tekuće fakture neplaćene ili su istekle",
Document Type ,vrsta dokumenta,
Subscription Price Based On,Cijena pretplate na temelju,
Fixed Rate,Fiksna stopa,
Based On Price List,Na temelju cjenika,
Monthly Rate,Mjesečna stopa,
Cancel Subscription After Grace Period,Otkaži pretplatu nakon razdoblja milosti,
Source State,Izvorna država,
Is Inter State,Je li Inter State,
Purchase Details,Pojedinosti o kupnji,
Depreciation Posting Date,Datum knjiženja amortizacije,
"By default, the Supplier Name is set as per the Supplier Name entered. If you want Suppliers to be named by a  ","Prema zadanim postavkama, naziv dobavljača postavljeno je prema upisanom imenu dobavljača. Ako želite da dobavljače imenuje",
 choose the 'Naming Series' option.,odaberite opciju &#39;Naming Series&#39;.,
Configure the default Price List when creating a new Purchase transaction. Item prices will be fetched from this Price List.,Konfigurirajte zadani cjenik prilikom izrade nove transakcije kupnje. Cijene stavki dohvaćaju se iz ovog cjenika.,
"If this option is configured 'Yes', ERPNext will prevent you from creating a Purchase Invoice or Receipt without creating a Purchase Order first. This configuration can be overridden for a particular supplier by enabling the 'Allow Purchase Invoice Creation Without Purchase Order' checkbox in the Supplier master.","Ako je ova opcija konfigurirana kao &quot;Da&quot;, ERPNext će vas spriječiti u stvaranju fakture ili potvrde o kupnji bez prethodnog stvaranja narudžbenice. Ovu se konfiguraciju može nadjačati za određenog dobavljača omogućavanjem potvrdnog okvira &quot;Omogući izradu računa za narudžbu bez narudžbenice&quot; na glavnom mjestu dobavljača.",
"If this option is configured 'Yes', ERPNext will prevent you from creating a Purchase Invoice without creating a Purchase Receipt first. This configuration can be overridden for a particular supplier by enabling the 'Allow Purchase Invoice Creation Without Purchase Receipt' checkbox in the Supplier master.","Ako je ova opcija konfigurirana kao &quot;Da&quot;, ERPNext će vas spriječiti u stvaranju računa za kupnju bez prethodnog stvaranja potvrde o kupnji. Ovu se konfiguraciju može nadjačati za određenog dobavljača omogućavanjem potvrdnog okvira &quot;Dopusti izradu računa za kupnju bez primitka kupnje&quot; na glavnom računa dobavljača.",
Quantity & Stock,Količina i zalihe,
Call Details,Pojedinosti o pozivu,
Authorised By,Ovlašteno od,
Signee (Company),Potpisnik (tvrtka),
Signed By (Company),Potpisao (tvrtka),
First Response Time,Vrijeme prvog odgovora,
Request For Quotation,Zahtjev za ponudu,
Opportunity Lost Reason Detail,Pojedinosti izgubljenog razloga za priliku,
Access Token Secret,Pristupite tajni tokena,
Add to Topics,Dodaj u teme,
...Adding Article to Topics,... Dodavanje članka u teme,
Add Article to Topics,Dodajte članak u teme,
This article is already added to the existing topics,Ovaj je članak već dodan postojećim temama,
Add to Programs,Dodaj u programe,
Programs,Programi,
...Adding Course to Programs,... Dodavanje tečaja u programe,
Add Course to Programs,Dodajte tečaj programima,
This course is already added to the existing programs,Ovaj je tečaj već dodan postojećim programima,
Learning Management System Settings,Postavke sustava za upravljanje učenjem,
Enable Learning Management System,Omogućiti sustav upravljanja učenjem,
Learning Management System Title,Naslov sustava upravljanja učenjem,
...Adding Quiz to Topics,... Dodavanje kviza u teme,
Add Quiz to Topics,Dodajte kviz u teme,
This quiz is already added to the existing topics,Ovaj je kviz već dodan postojećim temama,
Enable Admission Application,Omogućite prijavu,
EDU-ATT-.YYYY.-,EDU-ATT-.GGGG.-,
Marking attendance,Označavanje prisutnosti,
Add Guardians to Email Group,Dodajte skrbnike u grupu e-pošte,
Attendance Based On,Prisustvo na temelju,
Check this to mark the student as present in case the student is not attending the institute to participate or represent the institute in any event.\n\n,Označite ovo da biste studenta označili kao prisutnog u slučaju da student u bilo kojem slučaju ne pohađa institut da bi sudjelovao ili predstavljao institut.,
Add to Courses,Dodaj u tečajeve,
...Adding Topic to Courses,... Dodavanje teme u tečajeve,
Add Topic to Courses,Dodaj temu u tečajeve,
This topic is already added to the existing courses,Ova je tema već dodana u postojeće tečajeve,
"If Shopify does not have a customer in the order, then while syncing the orders, the system will consider the default customer for the order","Ako Shopify nema kupca u narudžbi, tada će tijekom sinkronizacije narudžbi sistem uzeti u obzir zadanog kupca za narudžbu.",
The accounts are set by the system automatically but do confirm these defaults,"Račune sustav postavlja automatski, ali potvrđuje ove zadane postavke",
Default Round Off Account,Zadani zaokruženi račun,
Failed Import Log,Dnevnik uvoza nije uspio,
Fixed Error Log,Ispravljeni zapisnik pogrešaka,
Company {0} already exists. Continuing will overwrite the Company and Chart of Accounts,Tvrtka {0} već postoji. Nastavak će prebrisati tvrtku i kontni plan,
Meta Data,Meta podaci,
Unresolve,Nerazriješiti,
Create Document,Stvori dokument,
Mark as unresolved,Označi kao neriješeno,
TaxJar Settings,Postavke TaxJar-a,
Sandbox Mode,Način pješčanika,
Enable Tax Calculation,Omogući obračun poreza,
Create TaxJar Transaction,Stvorite TaxJar transakciju,
Credentials,Vjerodajnice,
Live API Key,Ključ API-ja uživo,
Sandbox API Key,API ključ pješčanika,
Configuration,Konfiguracija,
Tax Account Head,Voditelj poreznog računa,
Shipping Account Head,Voditelj računa otpreme,
Practitioner Name,Ime liječnika,
Enter a name for the Clinical Procedure Template,Unesite naziv za obrazac kliničkog postupka,
Set the Item Code which will be used for billing the Clinical Procedure.,Postavite kod predmeta koji će se koristiti za naplatu kliničkog postupka.,
Select an Item Group for the Clinical Procedure Item.,Odaberite grupu predmeta za stavku kliničkog postupka.,
Clinical Procedure Rate,Stopa kliničkog postupka,
Check this if the Clinical Procedure is billable and also set the rate.,Provjerite je li klinički postupak naplativ i također postavite stopu.,
Check this if the Clinical Procedure utilises consumables. Click ,Provjerite to ako klinički postupak koristi potrošni materijal. Klik,
 to know more,znati više,
"You can also set the Medical Department for the template. After saving the document, an Item will automatically be created for billing this Clinical Procedure. You can then use this template while creating Clinical Procedures for Patients. Templates save you from filling up redundant data every single time. You can also create templates for other operations like Lab Tests, Therapy Sessions, etc.","Za predložak možete postaviti i Medicinski odjel. Nakon spremanja dokumenta, automatski će se stvoriti stavka za naplatu ovog kliničkog postupka. Tada možete upotrijebiti ovaj obrazac tijekom stvaranja kliničkih postupaka za pacijente. Predlošci vas štede od popunjavanja suvišnih podataka svaki put. Također možete stvoriti predloške za druge operacije poput laboratorijskih testova, terapijskih sesija itd.",
Descriptive Test Result,Opisni rezultat ispitivanja,
Allow Blank,Dopusti prazno,
Descriptive Test Template,Opisni testni obrazac,
"If you want to track Payroll and other HRMS operations for a Practitoner, create an Employee and link it here.","Ako želite pratiti obračun plaća i druge HRMS operacije za praktičara, stvorite zaposlenika i povežite ga ovdje.",
Set the Practitioner Schedule you just created. This will be used while booking appointments.,Postavite raspored praktičara koji ste upravo kreirali. To će se koristiti prilikom rezerviranja termina.,
Create a service item for Out Patient Consulting.,Stvorite stavku usluge za izvanbolničko savjetovanje.,
"If this Healthcare Practitioner works for the In-Patient Department, create a service item for Inpatient Visits.","Ako ovaj liječnik radi za stacionar, stvorite uslugu za stacionarne posjete.",
Set the Out Patient Consulting Charge for this Practitioner.,Postavite naknadu za savjetovanje s pacijentom za ovog liječnika.,
"If this Healthcare Practitioner also works for the In-Patient Department, set the inpatient visit charge for this Practitioner.","Ako ovaj zdravstveni radnik radi i za stacionarni odjel, postavite mu troškove stacionarnog posjeta.",
"If checked, a customer will be created for every Patient. Patient Invoices will be created against this Customer. You can also select existing Customer while creating a Patient. This field is checked by default.","Ako se označi, stvorit će se kupac za svakog pacijenta. Računi za pacijenta stvorit će se protiv ovog kupca. Također možete odabrati postojećeg kupca tijekom stvaranja pacijenta. Ovo je polje standardno označeno.",
Collect Registration Fee,Naplati naknadu za registraciju,
"If your Healthcare facility bills registrations of Patients, you can check this and set the Registration Fee in the field below. Checking this will create new Patients with a Disabled status by default and will only be enabled after invoicing the Registration Fee.","Ako vaša zdravstvena ustanova obračunava registraciju pacijenata, to možete provjeriti i u donjem polju postaviti naknadu za registraciju. Ako potvrdite ovo, prema zadanim postavkama stvorit će se novi pacijenti sa statusom onemogućenog i bit će omogućeni tek nakon fakturiranja naknade za registraciju.",
Checking this will automatically create a Sales Invoice whenever an appointment is booked for a Patient.,"Ako označite ovo, automatski će se stvoriti Račun prodaje kad god se za pacijenta rezervira sastanak.",
Healthcare Service Items,Predmeti zdravstvene zaštite,
"You can create a service item for Inpatient Visit Charge and set it here. Similarly, you can set up other Healthcare Service Items for billing in this section. Click ","Možete stvoriti stavku usluge za naplatu stacionarnog posjeta i postaviti je ovdje. Slično tome, u ovom odjeljku možete postaviti druge stavke zdravstvenih usluga za naplatu. Klik",
Set up default Accounts for the Healthcare Facility,Postavite zadane račune za zdravstvenu ustanovu,
"If you wish to override default accounts settings and configure the Income and Receivable accounts for Healthcare, you can do so here.","Ako želite poništiti zadane postavke računa i konfigurirati račune prihoda i potraživanja za zdravstvo, to možete učiniti ovdje.",
Out Patient SMS alerts,Upozorenja za van pacijenta,
"If you want to send SMS alert on Patient Registration, you can enable this option. Similary, you can set up Out Patient SMS alerts for other functionalities in this section. Click ","Ako želite poslati SMS upozorenje o registraciji pacijenta, možete omogućiti ovu opciju. Slično tome, u ovom odjeljku možete postaviti upozorenja za SMS pacijenta za druge funkcije. Klik",
Admission Order Details,Detalji narudžbe za upis,
Admission Ordered For,Ulaz naručen za,
Expected Length of Stay,Očekivana dužina boravka,
Admission Service Unit Type,Vrsta jedinice usluge prijema,
Healthcare Practitioner (Primary),Liječnik (primarni),
Healthcare Practitioner (Secondary),Zdravstveni radnik (sekundarni),
Admission Instruction,Uputa za upis,
Chief Complaint,Glavni prigovor,
Medications,Lijekovi,
Investigations,Istrage,
Discharge Detials,Ponude za pražnjenje,
Discharge Ordered Date,Datum otpuštanja,
Discharge Instructions,Upute za pražnjenje,
Follow Up Date,Datum praćenja,
Discharge Notes,Napomene o ispuštanju,
Processing Inpatient Discharge,Obrada otpusta iz bolnice,
Processing Patient Admission,Obrada prijema pacijenta,
Check-in time cannot be greater than the current time,Vrijeme prijave ne može biti duže od trenutnog vremena,
Process Transfer,Prijenos procesa,
HLC-LAB-.YYYY.-,FHP-LAB-.GGGG.-,
Expected Result Date,Očekivani datum rezultata,
Expected Result Time,Očekivano vrijeme rezultata,
Printed on,Tiskano dalje,
Requesting Practitioner,Zahtjev za praktičarom,
Requesting Department,Odjel za podnošenje zahtjeva,
Employee (Lab Technician),Zaposlenik (laboratorijski tehničar),
Lab Technician Name,Ime laboratorijskog tehničara,
Lab Technician Designation,Određivanje laboratorijskog tehničara,
Compound Test Result,Rezultat složenog testa,
Organism Test Result,Rezultat testa organizma,
Sensitivity Test Result,Rezultat ispitivanja osjetljivosti,
Worksheet Print,Ispis radnog lista,
Worksheet Instructions,Upute za radni list,
Result Legend Print,Rezultat Legenda Ispis,
Print Position,Položaj ispisa,
Both,Oba,
Result Legend,Legenda rezultata,
Lab Tests,Laboratorijski testovi,
No Lab Tests found for the Patient {0},Nisu pronađeni laboratorijski testovi za pacijenta {0},
"Did not send SMS, missing patient mobile number or message content.","Nisam poslao SMS, broj mobilnog telefona pacijenta ili sadržaj poruke.",
No Lab Tests created,Nisu stvorena laboratorijska ispitivanja,
Creating Lab Tests...,Izrada laboratorijskih testova ...,
Lab Test Group Template,Predložak grupe za laboratorijske testove,
Add New Line,Dodaj novu liniju,
Secondary UOM,Sekundarni UOM,
"<b>Single</b>: Results which require only a single input.\n<br>\n<b>Compound</b>: Results which require multiple event inputs.\n<br>\n<b>Descriptive</b>: Tests which have multiple result components with manual result entry.\n<br>\n<b>Grouped</b>: Test templates which are a group of other test templates.\n<br>\n<b>No Result</b>: Tests with no results, can be ordered and billed but no Lab Test will be created. e.g.. Sub Tests for Grouped results","<b>Pojedinačno</b> : Rezultati koji zahtijevaju samo jedan unos.<br> <b>Složeni</b> : Rezultati koji zahtijevaju višestruke unose događaja.<br> <b>Opisno</b> : Ispitivanja koja imaju više komponenata rezultata s ručnim unosom rezultata.<br> <b>Grupirano</b> : Ispitni predlošci koji su skupina ostalih ispitnih predložaka.<br> <b>Nema rezultata</b> : testovi bez rezultata, mogu se naručiti i naplatiti, ali neće se stvoriti laboratorijski test. npr. Podtestovi za grupirane rezultate",
"If unchecked, the item will not be available in Sales Invoices for billing but can be used in group test creation. ","Ako se ne označi, stavka neće biti dostupna u fakturama prodaje za naplatu, ali se može koristiti u stvaranju grupnog testa.",
Description ,Opis,
Descriptive Test,Opisni test,
Group Tests,Grupni testovi,
Instructions to be printed on the worksheet,Upute za ispis na radnom listu,
"Information to help easily interpret the test report, will be printed as part of the Lab Test result.",Informacije koje će vam olakšati tumačenje izvještaja o ispitivanju bit će tiskane kao dio rezultata laboratorijskog testa.,
Normal Test Result,Uobičajeni rezultat ispitivanja,
Secondary UOM Result,Sekundarni rezultat UOM-a,
Italic,Kurziv,
Underline,Naglasiti,
Organism,Organizam,
Organism Test Item,Predmet ispitivanja organizma,
Colony Population,Stanovništvo kolonije,
Colony UOM,Kolonija UOM,
Tobacco Consumption (Past),Potrošnja duhana (prošlost),
Tobacco Consumption (Present),Konzumacija duhana (danas),
Alcohol Consumption (Past),Konzumacija alkohola (prošlost),
Alcohol Consumption (Present),Konzumacija alkohola (danas),
Billing Item,Predmet naplate,
Medical Codes,Medicinski kodovi,
Clinical Procedures,Klinički postupci,
Order Admission,Naručite prijem,
Scheduling Patient Admission,Zakazivanje prijema pacijenta,
Order Discharge,Ispuštanje narudžbe,
Sample Details,Pojedinosti uzorka,
Collected On,Prikupljeno dana,
No. of prints,Broj otisaka,
Number of prints required for labelling the samples,Broj otisaka potrebnih za označavanje uzoraka,
HLC-VTS-.YYYY.-,FHP-VTS-.GGGG.-,
Payroll Cost Center,Mjesto troška plaća,
Approvers,Odobrivači,
The first Approver in the list will be set as the default Approver.,Prvi odobravatelj s popisa postavit će se kao zadani odobravatelj.,
Shift Request Approver,Odobritelj zahtjeva za smjenom,
PAN Number,PAN broj,
Provident Fund Account,Račun osiguravajućeg fonda,
MICR Code,MICR kod,
Repay unclaimed amount from salary,Otplatite neiskorišteni iznos iz plaće,
Deduction from salary,Odbitak od plaće,
Expired Leaves,Isteklo lišće,
If this is not checked the loan by default will be considered as a Demand Loan,"Ako se ovo ne potvrdi, zajam će se prema zadanim postavkama smatrati zajmom na zahtjev",
This account is used for booking loan repayments from the borrower and also disbursing loans to the borrower,Ovaj se račun koristi za rezerviranje otplate zajma od zajmoprimca i za isplatu zajmova zajmoprimcu,
This account is capital account which is used to allocate capital for loan disbursal account ,Ovaj račun je račun kapitala koji se koristi za raspodjelu kapitala za račun izdvajanja zajma,
This account will be used for booking loan interest accruals,Ovaj će se račun koristiti za rezerviranje obračunatih kamata,
This account will be used for booking penalties levied due to delayed repayments,Ovaj će se račun koristiti za rezerviranje kazni nametnutih zbog kašnjenja s otplatom,
Variant BOM,Varijanta BOM,
Template Item,Predložak,
Select template item,Odaberite stavku predloška,
Select variant item code for the template item {0},Odaberite varijantni kod stavke za predložak {0},
Downtime Entry,Ulazak u stanke,
DT-,DT-,
Workstation / Machine,Radna stanica / Stroj,
Operator,Operater,
In Mins,U Minima,
Downtime Reason,Razlog zastoja,
Stop Reason,Stop razumu,
Excessive machine set up time,Pretjerano vrijeme postavljanja stroja,
Unplanned machine maintenance,Neplanirano održavanje stroja,
On-machine press checks,Provjere tiska na stroju,
Machine operator errors,Pogreške rukovatelja stroja,
Machine malfunction,Neispravnost stroja,
Electricity down,Ispala struja,
Operation Row Number,Broj reda operacije,
Operation {0} added multiple times in the work order {1},Operacija {0} dodana više puta u radnom nalogu {1},
"If ticked, multiple materials can be used for a single Work Order. This is useful if one or more time consuming products are being manufactured.","Ako se označi, za jedan radni nalog može se koristiti više materijala. To je korisno ako se proizvode jedan ili više dugotrajnih proizvoda.",
Backflush Raw Materials,Sirovine za povratno ispiranje,
"The Stock Entry of type 'Manufacture' is known as backflush. Raw materials being consumed to manufacture finished goods is known as backflushing. <br><br> When creating Manufacture Entry, raw-material items are backflushed based on BOM of production item. If you want raw-material items to be backflushed based on Material Transfer entry made against that Work Order instead, then you can set it under this field.","Unos zaliha tipa &quot;Proizvodnja&quot; poznat je kao povratno ispiranje. Sirovine koje se troše za proizvodnju gotovih proizvoda poznate su kao povratno ispiranje.<br><br> Prilikom stvaranja stavke o proizvodnji, sirovinski proizvodi se vraćaju prema BOM proizvodnom proizvodu. Ako želite da se sirovinske stavke naknadno ispiru na temelju unosa prijenosa materijala izvršenog prema tom radnom nalogu, tada ga možete postaviti u ovom polju.",
Work In Progress Warehouse,Skladište u tijeku,
This Warehouse will be auto-updated in the Work In Progress Warehouse field of Work Orders.,Ovo skladište će se automatski ažurirati u polju Skladište u tijeku u radnim nalozima.,
Finished Goods Warehouse,Skladište gotove robe,
This Warehouse will be auto-updated in the Target Warehouse field of Work Order.,Ovo skladište će se automatski ažurirati u polju ciljanog skladišta radnog naloga.,
"If ticked, the BOM cost will be automatically updated based on Valuation Rate / Price List Rate / last purchase rate of raw materials.","Ako se označi, BOM trošak automatski će se ažurirati na temelju stope procjene / stope cjenika / posljednje stope otkupa sirovina.",
Source Warehouses (Optional),Izvorna skladišta (po izboru),
"System will pickup the materials from the selected warehouses. If not specified, system will create material request for purchase.","Sustav će preuzeti materijale iz odabranih skladišta. Ako nije navedeno, sustav će stvoriti zahtjev za materijalom za kupnju.",
Lead Time,Vrijeme izvođenja,
PAN Details,Pojedinosti o PAN-u,
Create Customer,Stvori kupca,
Invoicing,Fakturiranje,
Enable Auto Invoicing,Omogući automatsko fakturiranje,
Send Membership Acknowledgement,Pošaljite potvrdu o članstvu,
Send Invoice with Email,Pošaljite fakturu e-poštom,
Membership Print Format,Format ispisa članstva,
Invoice Print Format,Format ispisa fakture,
Revoke <Key></Key>,Opozvati&lt;Key&gt;&lt;/Key&gt;,
You can learn more about memberships in the manual. ,U članku možete saznati više o članstvima.,
ERPNext Docs,ERPNext Docs,
Regenerate Webhook Secret,Obnovite tajnu Webhook-a,
Generate Webhook Secret,Stvori tajnu Webhook-a,
Copy Webhook URL,Kopirajte URL webhooka,
Linked Item,Povezana stavka,
Feedback By,Povratne informacije od,
Manufacturing Section,Odjel za proizvodnju,
"By default, the Customer Name is set as per the Full Name entered. If you want Customers to be named by a ","Prema zadanim postavkama, ime kupca postavlja se prema unesenom punom imenu. Ako želite da kupce imenuje",
Configure the default Price List when creating a new Sales transaction. Item prices will be fetched from this Price List.,Konfigurirajte zadani cjenik prilikom izrade nove prodajne transakcije. Cijene stavki dohvaćaju se iz ovog cjenika.,
"If this option is configured 'Yes', ERPNext will prevent you from creating a Sales Invoice or Delivery Note without creating a Sales Order first. This configuration can be overridden for a particular Customer by enabling the 'Allow Sales Invoice Creation Without Sales Order' checkbox in the Customer master.","Ako je ova opcija konfigurirana kao &quot;Da&quot;, ERPNext će vas spriječiti u stvaranju prodajne fakture ili dostavnice bez prethodnog kreiranja prodajnog naloga. Ovu se konfiguraciju može nadjačati za određenog Kupca omogućavanjem potvrdnog okvira &quot;Dopusti izradu fakture za prodaju bez prodajnog naloga&quot; u masteru kupca.",
"If this option is configured 'Yes', ERPNext will prevent you from creating a Sales Invoice without creating a Delivery Note first. This configuration can be overridden for a particular Customer by enabling the 'Allow Sales Invoice Creation Without Delivery Note' checkbox in the Customer master.","Ako je ova opcija konfigurirana kao &quot;Da&quot;, ERPNext će vas spriječiti da stvorite fakturu prodaje bez da ste prethodno kreirali dostavnicu. Ovu se konfiguraciju može nadjačati za određenog kupca omogućavanjem potvrdnog okvira &quot;Omogući izradu fakture za prodaju bez napomene o isporuci&quot; u masteru kupca.",
Default Warehouse for Sales Return,Zadani skladište za povrat prodaje,
Default In Transit Warehouse,Zadano u tranzitnom skladištu,
Enable Perpetual Inventory For Non Stock Items,Omogućite vječni inventar za stavke koje nisu na zalihi,
HRA Settings,Postavke HRA,
Basic Component,Osnovna komponenta,
HRA Component,Komponenta HRA,
Arrear Component,Komponenta zaostatka,
Please enter the company name to confirm,Unesite naziv tvrtke za potvrdu,
Quotation Lost Reason Detail,Pojedinosti izgubljenog razloga ponude,
Enable Variants,Omogući varijante,
Save Quotations as Draft,Spremi citate kao skicu,
MAT-DN-RET-.YYYY.-,MAT-DN-RET-.GGGG.-,
Please Select a Customer,Molimo odaberite kupca,
Against Delivery Note Item,Protiv stavke s dostavnicom,
Is Non GST ,Nije GST,
Image Description,Opis slike,
Transfer Status,Status prijenosa,
MAT-PR-RET-.YYYY.-,MAT-PR-RET-.GGGG.-,
Track this Purchase Receipt against any Project,Pratite ovu potvrdu o kupnji prema bilo kojem projektu,
Please Select a Supplier,Molimo odaberite dobavljača,
Add to Transit,Dodaj u tranzit,
Set Basic Rate Manually,Ručno postavite osnovnu stopu,
"By default, the Item Name is set as per the Item Code entered. If you want Items to be named by a ","Prema zadanim postavkama, naziv predmeta je postavljen prema unesenom kodu artikla. Ako želite da stavke imenuje",
Set a Default Warehouse for Inventory Transactions. This will be fetched into the Default Warehouse in the Item master.,Postavite zadano skladište za transakcije zalihama. Ovo će se dohvatiti u Zadano skladište u masteru predmeta.,
"This will allow stock items to be displayed in negative values. Using this option depends on your use case. With this option unchecked, the system warns before obstructing a transaction that is causing negative stock.","To će omogućiti prikazivanje zaliha u negativnim vrijednostima. Korištenje ove opcije ovisi o vašem slučaju korištenja. Ako ova opcija nije potvrđena, sustav upozorava prije nego što ometa transakciju koja uzrokuje negativne zalihe.",
Choose between FIFO and Moving Average Valuation Methods. Click ,Odaberite između metoda FIFO i metoda procjene pokretnog prosjeka. Klik,
 to know more about them.,znati više o njima.,
Show 'Scan Barcode' field above every child table to insert Items with ease.,Pokažite polje &quot;Skeniraj crtični kôd&quot; iznad svake podređene tablice da biste s lakoćom umetnuli predmete.,
"Serial numbers for stock will be set automatically based on the Items entered based on first in first out in transactions like Purchase/Sales Invoices, Delivery Notes, etc.","Serijski brojevi za dionice automatski će se postaviti na temelju stavki koje se unose na temelju first in first out u transakcijama poput faktura kupnje / prodaje, otpremnica itd.",
"If blank, parent Warehouse Account or company default will be considered in transactions","Ako je prazno, u transakcijama će se uzeti u obzir matični račun skladišta ili zadana vrijednost tvrtke",
Service Level Agreement Details,Pojedinosti sporazuma o razini usluge,
Service Level Agreement Status,Status sporazuma o razini usluge,
On Hold Since,Na čekanju od,
Total Hold Time,Ukupno vrijeme zadržavanja,
Response Details,Pojedinosti odgovora,
Average Response Time,Prosječno vrijeme odziva,
User Resolution Time,Vrijeme razlučivanja korisnika,
SLA is on hold since {0},SLA je na čekanju od {0},
Pause SLA On Status,Pauzirajte SLA na statusu,
Pause SLA On,Pauzirajte SLA Uključeno,
Greetings Section,Pozdravni dio,
Greeting Title,Naslov pozdrava,
Greeting Subtitle,Pozdravni podnaslov,
Youtube ID,Youtube ID,
Youtube Statistics,Youtube statistika,
Views,Pogledi,
Dislikes,Ne sviđa mi se,
Video Settings,Postavke videozapisa,
Enable YouTube Tracking,Omogućite YouTube praćenje,
30 mins,30 min,
1 hr,1 sat,
6 hrs,6 sati,
Patient Progress,Napredak pacijenta,
Targetted,Ciljano,
Score Obtained,Dobivena ocjena,
Sessions,Sjednice,
Average Score,Prosječni rezultat,
Select Assessment Template,Odaberite Predložak procjene,
 out of ,od,
Select Assessment Parameter,Odaberite parametar procjene,
Gender: ,Spol:,
Contact: ,Kontakt:,
Total Therapy Sessions: ,Ukupno terapijskih sesija:,
Monthly Therapy Sessions: ,Mjesečne terapijske sesije:,
Patient Profile,Profil pacijenta,
Point Of Sale,Prodajno mjesto,
Email sent successfully.,E-pošta je uspješno poslana.,
Search by invoice id or customer name,Pretražite prema ID-u fakture ili imenu kupca,
Invoice Status,Status fakture,
Filter by invoice status,Filtriraj prema statusu fakture,
Select item group,Odaberite grupu stavki,
No items found. Scan barcode again.,Nije pronađen nijedan predmet. Ponovno skenirajte crtični kod.,
"Search by customer name, phone, email.","Pretražujte po imenu kupca, telefonu, e-pošti.",
Enter discount percentage.,Unesite postotak popusta.,
Discount cannot be greater than 100%,Popust ne može biti veći od 100%,
Enter customer's email,Unesite e-adresu kupca,
Enter customer's phone number,Unesite telefonski broj kupca,
Customer contact updated successfully.,Kontakt s kupcem uspješno je ažuriran.,
Item will be removed since no serial / batch no selected.,Stavka će biti uklonjena jer nije odabrana nijedna serijska / serija.,
Discount (%),Popust (%),
You cannot submit the order without payment.,Narudžbu ne možete predati bez plaćanja.,
You cannot submit empty order.,Ne možete poslati praznu narudžbu.,
To Be Paid,Biti plaćen,
Create POS Opening Entry,Stvorite ulaz za otvaranje POS-a,
Please add Mode of payments and opening balance details.,Molimo dodajte detalje o načinu plaćanja i početnom stanju.,
Toggle Recent Orders,Uključi / isključi nedavne narudžbe,
Save as Draft,Spremi kao skicu,
You must add atleast one item to save it as draft.,Morate dodati najmanje jednu stavku da biste je spremili kao skicu.,
There was an error saving the document.,Došlo je do pogreške prilikom spremanja dokumenta.,
You must select a customer before adding an item.,Morate odabrati kupca prije dodavanja stavke.,
Please Select a Company,Molimo odaberite tvrtku,
Active Leads,Aktivni vodi,
Please Select a Company.,Molimo odaberite tvrtku.,
BOM Operations Time,BOM operativno vrijeme,
BOM ID,BOM ID,
BOM Item Code,Šifra predmeta BOM,
Time (In Mins),Vrijeme (u minutama),
Sub-assembly BOM Count,Broj sastavnih dijelova podsklopa,
View Type,Vrsta prikaza,
Total Delivered Amount,Ukupni isporučeni iznos,
Downtime Analysis,Analiza zastoja,
Machine,Mašina,
Downtime (In Hours),Zastoji (u satima),
Employee Analytics,Analitika zaposlenika,
"""From date"" can not be greater than or equal to ""To date""",&quot;Od datuma&quot; ne može biti veći ili jednak &quot;Do danas&quot;,
Exponential Smoothing Forecasting,Eksponencijalno izglađivanje predviđanja,
First Response Time for Issues,Prvo vrijeme odgovora na izdanja,
First Response Time for Opportunity,Prvo vrijeme odgovora za priliku,
Depreciatied Amount,Amortizirani iznos,
Period Based On,Razdoblje temeljeno na,
Date Based On,Datum zasnovan na,
{0} and {1} are mandatory,{0} i {1} su obvezni,
Consider Accounting Dimensions,Razmotrite računovodstvene dimenzije,
Reserved Quantity for Production,Rezervirana količina za proizvodnju,
Projected Quantity,Predviđena količina,
 Total Sales Amount,Ukupni iznos prodaje,
Job Card Summary,Sažetak kartice posla,
Id,Iskaznica,
Time Required (In Mins),Potrebno vrijeme (u minutama),
From Posting Date,Od datuma knjiženja,
To Posting Date,Do datuma knjiženja,
No records found,Nije pronađen nijedan zapis,
Customer/Lead Name,Ime kupca / potencijalnog kupca,
Production Planning Report,Izvješće o planiranju proizvodnje,
Order Qty,Količina narudžbe,
Raw Material Code,Šifra sirovine,
Raw Material Name,Naziv sirovine,
Allotted Qty,Dodijeljena količina,
Expected Arrival Date,Očekivani datum dolaska,
Arrival Quantity,Količina dolaska,
Raw Material Warehouse,Skladište sirovina,
Order By,Naruči po,
Include Sub-assembly Raw Materials,Uključite sirovine podsklopa,
Program wise Fee Collection,Programsko prikupljanje naknada,
Fees Collected,Naplaćene naknade,
Project Summary,Sažetak projekta,
Total Tasks,Ukupno zadataka,
Tasks Completed,Zadaci izvršeni,
Tasks Overdue,Zadaci kasne,
Completion,Završetak,
Purchase Order Analysis,Analiza narudžbenice,
From and To Dates are required.,Potrebni su datumi od i do.,
To Date cannot be before From Date.,Do datuma ne može biti prije od datuma.,
Qty to Bill,Količina za Billa,
Group by Purchase Order,Grupiraj prema narudžbenici,
 Purchase Value,Nabavna vrijednost,
Total Received Amount,Ukupni primljeni iznos,
Quality Inspection Summary,Sažetak inspekcije kvalitete,
 Quoted Amount,Navedeni iznos,
Lead Time (Days),Vrijeme izvedbe (dani),
Include Expired,Uključi Isteklo,
Requested Items to Order and Receive,Tražene stavke za naručivanje i primanje,
Sales Order Analysis,Analiza prodajnih naloga,
Amount Delivered,Isporučeni iznos,
Delay (in Days),Kašnjenje (u danima),
Group by Sales Order,Grupiraj po prodajnom nalogu,
 Sales Value,Vrijednost prodaje,
Stock Qty vs Serial No Count,Količina zaliha u odnosu na serijski broj,
Serial No Count,Broj serijskih brojeva,
Work Order Summary,Sažetak radnog naloga,
Produce Qty,Proizvedite količinu,
Lead Time (in mins),Vrijeme izvođenja (u minutama),
Charts Based On,Grafikoni temeljeni na,
YouTube Interactions,YouTube interakcije,
Published Date,Datum objave,
Barnch,Barnch,
Select a Company,Odaberite tvrtku,
Opportunity {0} created,Stvorena prilika {0},
Kindly select the company first,"Molimo, najprije odaberite tvrtku",
Please enter From Date and To Date to generate JSON,Unesite From Date i To Date da biste generirali JSON,
Download DATEV File,Preuzmite datoteku DATEV,
Numero has not set in the XML file,Numero nije postavljen u XML datoteku,
Inward Supplies(liable to reverse charge),Unutarnje zalihe (podložne storniranju),
This is based on the course schedules of this Instructor,To se temelji na rasporedu tečajeva ovog instruktora,
Course and Assessment,Tečaj i ocjenjivanje,
Course {0} has been added to all the selected programs successfully.,Predmet {0} uspješno je dodan svim odabranim programima.,
Programs updated,Programi ažurirani,
Program and Course,Program i tečaj,
{0} or {1} is mandatory,{0} ili {1} je obavezno,
Mandatory Fields,Obavezna polja,
Student {0}: {1} does not belong to Student Group {2},Student {0}: {1} ne pripada studentskoj grupi {2},
Student Attendance record {0} already exists against the Student {1},Evidencija o posjećenosti učenika {0} već postoji protiv učenika {1},
Course and Fee,Tečaj i naknada,
Not eligible for the admission in this program as per Date Of Birth,Ne ispunjava uvjete za prijavu u ovaj program prema datumu rođenja,
Topic {0} has been added to all the selected courses successfully.,Tema {0} uspješno je dodana u sve odabrane tečajeve.,
Courses updated,Tečajevi ažurirani,
{0} {1} has been added to all the selected topics successfully.,{0} {1} uspješno je dodan u sve odabrane teme.,
Topics updated,Teme ažurirane,
Academic Term and Program,Akademski pojam i program,
Please remove this item and try to submit again or update the posting time.,Uklonite ovu stavku i pokušajte je ponovo poslati ili ažurirajte vrijeme objavljivanja.,
Failed to Authenticate the API key.,Autentifikacija API ključa nije uspjela.,
Invalid Credentials,Nevažeće vjerodajnice,
URL can only be a string,URL može biti samo niz,
"Here is your webhook secret, this will be shown to you only once.","Evo vaše tajne webhook-a, ovo će vam biti prikazano samo jednom.",
The payment for this membership is not paid. To generate invoice fill the payment details,"Plaćanje za ovo članstvo nije plaćeno. Da biste generirali račun, popunite podatke o plaćanju",
An invoice is already linked to this document,Račun je već povezan s ovim dokumentom,
No customer linked to member {},Nijedan kupac nije povezan s članom {},
You need to set <b>Debit Account</b> in Membership Settings,<b>Debitni račun</b> morate postaviti u postavkama članstva,
You need to set <b>Default Company</b> for invoicing in Membership Settings,U postavkama članstva morate postaviti <b>zadanu tvrtku</b> za fakturiranje,
You need to enable <b>Send Acknowledge Email</b> in Membership Settings,U postavkama članstva morate omogućiti <b>e-poštu</b> za <b>slanje potvrde</b>,
Error creating membership entry for {0},Pogreška pri stvaranju unosa za članstvo za {0},
A customer is already linked to this Member,Kupac je već povezan s ovim članom,
End Date must not be lesser than Start Date,Datum završetka ne smije biti manji od datuma početka,
Employee {0} already has Active Shift {1}: {2},Zaposlenik {0} već ima aktivnu smjenu {1}: {2},
 from {0},od {0},
 to {0},do {0},
Please set {0} for the Employee or for Department: {1},Postavite {0} za zaposlenika ili za odjel: {1},
Employee Onboarding: {0} is already for Job Applicant: {1},Ukrcaj zaposlenika: {0} već je kandidat za posao: {1},
Asset Value Analytics,Analitika vrijednosti imovine,
Category-wise Asset Value,Vrijednost imovine po kategorijama,
Total Assets,Ukupna imovina,
New Assets (This Year),Nova imovina (ove godine),
Row #{}: Depreciation Posting Date should not be equal to Available for Use Date.,Redak {{}: Datum knjiženja amortizacije ne bi trebao biti jednak datumu Dostupno za upotrebu.,
Incorrect Date,Netočan datum,
Invalid Gross Purchase Amount,Nevažeći bruto iznos kupnje,
There are active maintenance or repairs against the asset. You must complete all of them before cancelling the asset.,Aktivno se održavaju ili popravljaju sredstva. Morate ih ispuniti prije nego što otkažete sredstvo.,
% Complete,% Dovršeno,
Back to Course,Povratak na tečaj,
Finish Topic,Završi temu,
Mins,Min,
by,po,
Back to,Natrag na,
Enrolling...,Upis ...,
You have successfully enrolled for the program ,Uspješno ste se prijavili za program,
Enrolled,Upisan,
Watch Intro,Pogledajte uvod,
We're here to help!,Ovdje smo da vam pomognemo!,
Frequently Read Articles,Članci koji se često čitaju,
Please set a default company address,Molimo postavite zadanu adresu tvrtke,
{0} is not a valid state! Check for typos or enter the ISO code for your state.,{0} nije važeće stanje! Provjerite ima li pogrešaka pri upisu ili unesite ISO kôd za svoje stanje.,
Error occured while parsing Chart of Accounts: Please make sure that no two accounts have the same name,Došlo je do pogreške prilikom raščlanjivanja kontnog plana: Pazite da niti jedan račun nema isto ime,
Plaid invalid request error,Pogreška nevažećeg zahtjeva za karirano,
Please check your Plaid client ID and secret values,Molimo provjerite svoj ID klijenta i tajne vrijednosti,
Bank transaction creation error,Pogreška pri stvaranju bankovne transakcije,
Unit of Measurement,Jedinica mjere,
Fiscal Year {0} Does Not Exist,Fiskalna godina {0} ne postoji,
Row # {0}: Returned Item {1} does not exist in {2} {3},Redak {0}: Vraćena stavka {1} ne postoji u {2} {3},
Valuation type charges can not be marked as Inclusive,Naknade vrste procjene ne mogu se označiti kao Uključujuće,
You do not have permissions to {} items in a {}.,Nemate dozvole za {} stavki u {}.,
Insufficient Permissions,Nedovoljna dopuštenja,
You are not allowed to update as per the conditions set in {} Workflow.,Nije vam dopušteno ažuriranje prema uvjetima postavljenim u {} Tijek rada.,
Expense Account Missing,Račun troškova nedostaje,
{0} is not a valid Value for Attribute {1} of Item {2}.,{0} nije važeća vrijednost za atribut {1} stavke {2}.,
Invalid Value,Nevažeća vrijednost,
The value {0} is already assigned to an existing Item {1}.,Vrijednost {0} već je dodijeljena postojećoj stavci {1}.,
"To still proceed with editing this Attribute Value, enable {0} in Item Variant Settings.","Da biste i dalje nastavili s uređivanjem ove vrijednosti atributa, omogućite {0} u Postavkama varijante stavke.",
Edit Not Allowed,Uređivanje nije dopušteno,
Row #{0}: Item {1} is already fully received in Purchase Order {2},Redak {0}: Stavka {1} već je u cijelosti primljena u narudžbenici {2},
You cannot create or cancel any accounting entries with in the closed Accounting Period {0},Ne možete stvoriti ili otkazati nijedan knjigovodstveni zapis u zatvorenom obračunskom razdoblju {0},
POS Invoice should have {} field checked.,POS faktura trebala bi imati označeno polje {}.,
Invalid Item,Nevažeća stavka,
Row #{}: You cannot add postive quantities in a return invoice. Please remove item {} to complete the return.,Red # {}: Ne možete dodati pozitivne količine u fakturu za povrat. Uklonite stavku {} da biste dovršili povrat.,
The selected change account {} doesn't belongs to Company {}.,Odabrani račun za promjenu {} ne pripada tvrtki {}.,
Atleast one invoice has to be selected.,Mora biti odabrana najmanje jedna faktura.,
Payment methods are mandatory. Please add at least one payment method.,Načini plaćanja su obvezni. Dodajte barem jedan način plaćanja.,
Please select a default mode of payment,Odaberite zadani način plaćanja,
You can only select one mode of payment as default,Kao zadani možete odabrati samo jedan način plaćanja,
Missing Account,Nedostaje račun,
Customers not selected.,Kupci nisu odabrani.,
Statement of Accounts,Izvod računa,
Ageing Report Based On ,Izvještaj o starenju na temelju,
Please enter distributed cost center,Unesite raspodijeljeno mjesto troškova,
Total percentage allocation for distributed cost center should be equal to 100,Ukupna postotna alokacija za raspodijeljeno mjesto troškova trebala bi biti jednaka 100,
Cannot enable Distributed Cost Center for a Cost Center already allocated in another Distributed Cost Center,Ne može se omogućiti raspodijeljeno mjesto troškova za mjesto troškova koje je već dodijeljeno u drugom raspodijeljenom mjestu troškova,
Parent Cost Center cannot be added in Distributed Cost Center,Nadređeno mjesto troškova ne može se dodati u raspodijeljeno mjesto troškova,
A Distributed Cost Center cannot be added in the Distributed Cost Center allocation table.,Distribuirano mjesto troškova ne može se dodati u tablicu raspodjele mjesta troškova.,
Cost Center with enabled distributed cost center can not be converted to group,Mjesto troškova s omogućenim raspodijeljenim mjestom troškova ne može se pretvoriti u grupu,
Cost Center Already Allocated in a Distributed Cost Center cannot be converted to group,Već postavljeno mjesto troška u distribuiranom mjestu troška ne može se pretvoriti u grupu,
Trial Period Start date cannot be after Subscription Start Date,Datum početka probnog razdoblja ne može biti nakon datuma početka pretplate,
Subscription End Date must be after {0} as per the subscription plan,Datum završetka pretplate mora biti nakon {0} prema planu pretplate,
Subscription End Date is mandatory to follow calendar months,Datum završetka pretplate obvezan je slijediti kalendarske mjesece,
Row #{}: POS Invoice {} is not against customer {},Red # {}: POS faktura {} nije protiv kupca {},
Row #{}: POS Invoice {} is not submitted yet,Redak {{}: POS račun {} još nije poslan,
Row #{}: POS Invoice {} has been {},Redak {{}: POS faktura {} je {},
No Supplier found for Inter Company Transactions which represents company {0},Nije pronađen dobavljač za transakcije među tvrtkama koji predstavljaju tvrtku {0},
No Customer found for Inter Company Transactions which represents company {0},Nije pronađen nijedan kupac za transakcije među tvrtkama koje predstavljaju tvrtku {0},
Invalid Period,Nevažeće razdoblje,
Selected POS Opening Entry should be open.,Odabrani ulaz za otvaranje POS-a trebao bi biti otvoren.,
Invalid Opening Entry,Nevažeći uvodni unos,
Please set a Company,Molimo postavite tvrtku,
"Sorry, this coupon code's validity has not started","Nažalost, valjanost ovog koda kupona nije započela",
"Sorry, this coupon code's validity has expired","Nažalost, valjanost ovog koda kupona je istekla",
"Sorry, this coupon code is no longer valid","Nažalost, ovaj kôd kupona više nije valjan",
For the 'Apply Rule On Other' condition the field {0} is mandatory,Za uvjet &quot;Primjena pravila na ostalo&quot; polje {0} je obavezno,
{1} Not in Stock,{1} Nije na zalihi,
Only {0} in Stock for item {1},Samo {0} na zalihi za artikl {1},
Please enter a coupon code,Unesite kod kupona,
Please enter a valid coupon code,Unesite važeći kôd kupona,
Invalid Child Procedure,Nevažeći postupak za dijete,
Import Italian Supplier Invoice.,Uvoz fakture talijanskog dobavljača.,
"Valuation Rate for the Item {0}, is required to do accounting entries for {1} {2}.",Stopa procjene za stavku {0} potrebna je za knjiženje računovodstvenih evidencija za stavku {1} {2}.,
 Here are the options to proceed:,Evo opcija za nastavak:,
"If the item is transacting as a Zero Valuation Rate item in this entry, please enable 'Allow Zero Valuation Rate' in the {0} Item table.","Ako stavka trguje kao stavka nulte stope vrednovanja u ovom unosu, omogućite &quot;Dopusti nultu stopu vrednovanja&quot; u tablici {0} Stavka.",
"If not, you can Cancel / Submit this entry ","Ako nije, možete otkazati / poslati ovaj unos",
 performing either one below:,izvodeći bilo koji od dolje:,
Create an incoming stock transaction for the Item.,Stvorite dolaznu dionicku transakciju za Stavku.,
Mention Valuation Rate in the Item master.,Spomnite stopu vrednovanja u glavnom predmetu.,
Valuation Rate Missing,Nedostaje stopa procjene,
Serial Nos Required,Potrebni su serijski brojevi,
Quantity Mismatch,Količina neusklađenosti,
"Please Restock Items and Update the Pick List to continue. To discontinue, cancel the Pick List.","Molimo vas da ponovno nastavite sa proizvodima i ažurirate popis za odabir da biste nastavili. Da biste prekinuli, otkažite popis za odabir.",
Out of Stock,Nema na skladištu,
{0} units of Item {1} is not available.,{0} jedinica stavke {1} nije dostupno.,
Item for row {0} does not match Material Request,Stavka za redak {0} ne podudara se sa zahtjevom za materijal,
Warehouse for row {0} does not match Material Request,Skladište za redak {0} ne odgovara zahtjevu za materijalom,
Accounting Entry for Service,Knjigovodstveni unos za uslugu,
All items have already been Invoiced/Returned,Sve stavke su već fakturirane / vraćene,
All these items have already been Invoiced/Returned,Sve ove stavke već su fakturirane / vraćene,
Stock Reconciliations,Pomirbe dionica,
Merge not allowed,Spajanje nije dopušteno,
The following deleted attributes exist in Variants but not in the Template. You can either delete the Variants or keep the attribute(s) in template.,"Sljedeći izbrisani atributi postoje u varijantama, ali ne i u predlošku. Možete izbrisati inačice ili zadržati atribut (e) u predlošku.",
Variant Items,Predmeti varijante,
Variant Attribute Error,Pogreška varijante atributa,
The serial no {0} does not belong to item {1},Serijski broj {0} ne pripada stavci {1},
There is no batch found against the {0}: {1},Nije pronađena serija protiv {0}: {1},
Completed Operation,Završena operacija,
Work Order Analysis,Analiza radnog naloga,
Quality Inspection Analysis,Analiza inspekcije kvalitete,
Pending Work Order,Na čekanju radni nalog,
Last Month Downtime Analysis,Analiza zastoja posljednjeg mjeseca,
Work Order Qty Analysis,Analiza količine radnog naloga,
Job Card Analysis,Analiza radnih mjesta,
Monthly Total Work Orders,Mjesečni ukupni radni nalozi,
Monthly Completed Work Orders,Mjesečno izvršeni nalozi za rad,
Ongoing Job Cards,Kartice za posao u tijeku,
Monthly Quality Inspections,Mjesečni pregledi kvalitete,
(Forecast),(Prognoza),
Total Demand (Past Data),Ukupna potražnja (prošli podaci),
Total Forecast (Past Data),Ukupna prognoza (prošli podaci),
Total Forecast (Future Data),Ukupna prognoza (budući podaci),
Based On Document,Na temelju dokumenta,
Based On Data ( in years ),Na temelju podataka (u godinama),
Smoothing Constant,Konstanta zaglađivanja,
Please fill the Sales Orders table,Molimo ispunite tablicu Prodajni nalozi,
Sales Orders Required,Potrebni prodajni nalozi,
Please fill the Material Requests table,Molimo ispunite tablicu Zahtjevi za materijalom,
Material Requests Required,Zahtjevi za materijal,
Items to Manufacture are required to pull the Raw Materials associated with it.,Proizvodi za proizvodnju obvezni su povući sirovine povezane s tim.,
Items Required,Predmeti potrebni,
Operation {0} does not belong to the work order {1},Operacija {0} ne pripada radnom nalogu {1},
Print UOM after Quantity,Ispis UOM-a nakon količine,
Set default {0} account for perpetual inventory for non stock items,Postavite zadani {0} račun za vječni inventar za stavke koje nisu na zalihi,
Row #{0}: Child Item should not be a Product Bundle. Please remove Item {1} and Save,Redak {0}: Podređena stavka ne smije biti paket proizvoda. Uklonite stavku {1} i spremite,
Credit limit reached for customer {0},Dosegnuto je kreditno ograničenje za kupca {0},
Could not auto create Customer due to the following missing mandatory field(s):,Nije moguće automatski stvoriti kupca zbog sljedećih obaveznih polja koja nedostaju:,
Please create Customer from Lead {0}.,Kreirajte kupca od potencijalnog klijenta {0}.,
Mandatory Missing,Obavezno nedostaje,
From Date can not be greater than To Date.,Od datuma ne može biti veći od datuma.,
Row #{0}: Please enter the result value for {1},Redak {0}: unesite vrijednost rezultata za {1},
Mandatory Results,Obavezni rezultati,
Sales Invoice or Patient Encounter is required to create Lab Tests,Za izradu laboratorijskih testova potreban je prodajni račun ili susret s pacijentom,
Insufficient Data,Nedovoljno podataka,
Lab Test(s) {0} created successfully,Laboratorijski testovi {0} uspješno su stvoreni,
Test :,Test:,
Sample Collection {0} has been created,Zbirka uzoraka {0} je stvorena,
Normal Range: ,Uobičajeni domet:,
Row #{0}: Check Out datetime cannot be less than Check In datetime,Redak {0}: datum odjave ne može biti manji od datuma do vremena prijave,
"Missing required details, did not create Inpatient Record","Nedostaju potrebni detalji, nije stvorena stacionarna evidencija",
Unbilled Invoices,Nefakturirane fakture,
Standard Selling Rate should be greater than zero.,Standardna stopa prodaje trebala bi biti veća od nule.,
Conversion Factor is mandatory,Faktor pretvorbe je obvezan,
Row #{0}: Conversion Factor is mandatory,Redak {0}: faktor konverzije je obvezan,
Sample Quantity cannot be negative or 0,Količina uzorka ne može biti negativna ili 0,
Invalid Quantity,Nevažeća količina,
"Please set defaults for Customer Group, Territory and Selling Price List in Selling Settings","Molimo postavite zadane vrijednosti za grupu kupaca, teritorij i prodajni cjenik u postavkama prodaje",
{0} on {1},{0} na {1},
{0} with {1},{0} s {1},
Appointment Confirmation Message Not Sent,Poruka o potvrdi imenovanja nije poslana,
"SMS not sent, please check SMS Settings","SMS nije poslan, provjerite postavke SMS-a",
Healthcare Service Unit Type cannot have both {0} and {1},Vrsta jedinice zdravstvene službe ne može imati i {0} i {1},
Healthcare Service Unit Type must allow atleast one among {0} and {1},Vrsta jedinice zdravstvene zaštite mora dopuštati najmanje jednu između {0} i {1},
Set Response Time and Resolution Time for Priority {0} in row {1}.,Postavite vrijeme odziva i vrijeme razlučivanja za prioritet {0} u retku {1}.,
Response Time for {0} priority in row {1} can't be greater than Resolution Time.,Vrijeme odziva za {0} prioritet u retku {1} ne može biti veće od vremena razlučivanja.,
{0} is not enabled in {1},{0} nije omogućen u {1},
Group by Material Request,Grupiraj prema zahtjevu za materijal,
Email Sent to Supplier {0},E-pošta poslana dobavljaču {0},
"The Access to Request for Quotation From Portal is Disabled. To Allow Access, Enable it in Portal Settings.","Pristup zahtjevu za ponudu s portala je onemogućen. Da biste omogućili pristup, omogućite ga u postavkama portala.",
Supplier Quotation {0} Created,Ponuda dobavljača {0} Izrađena,
Valid till Date cannot be before Transaction Date,Važi do Datum ne može biti prije datuma transakcije,
Unlink Advance Payment on Cancellation of Order,Prekinite vezu s predujmom pri otkazivanju narudžbe,
"Simple Python Expression, Example: territory != 'All Territories'","Jednostavan Python izraz, Primjer: teritorij! = &#39;Svi teritoriji&#39;",
Sales Contributions and Incentives,Doprinosi prodaji i poticaji,
Sourced by Supplier,Izvor dobavljača,
Total weightage assigned should be 100%.<br>It is {0},Ukupna dodijeljena težina trebala bi biti 100%.<br> {0} je,
Account {0} exists in parent company {1}.,Račun {0} postoji u matičnoj tvrtki {1}.,
"To overrule this, enable '{0}' in company {1}","Da biste to poništili, omogućite &quot;{0}&quot; u tvrtki {1}",
Invalid condition expression,Nevažeći izraz stanja,
Please Select a Company First,Prvo odaberite tvrtku,
Please Select Both Company and Party Type First,Molimo odaberite prvo vrstu tvrtke i stranke,
Provide the invoice portion in percent,Dio fakture navedite u postocima,
Give number of days according to prior selection,Navedite broj dana prema prethodnom odabiru,
Email Details,Pojedinosti e-pošte,
"Select a greeting for the receiver. E.g. Mr., Ms., etc.","Odaberite pozdrav za slušalicu. Npr. Gospodin, gospođa itd.",
Preview Email,Pregled e-pošte,
Please select a Supplier,Molimo odaberite dobavljača,
Supplier Lead Time (days),Vrijeme isporuke dobavljača (dana),
"Home, Work, etc.","Kuća, posao itd.",
Exit Interview Held On,Izlazni intervju održan,
Sets 'Target Warehouse' in each row of the Items table.,Postavlja &#39;Ciljano skladište&#39; u svaki redak tablice Stavke.,
Sets 'Source Warehouse' in each row of the Items table.,Postavlja &#39;Izvorno skladište&#39; u svaki redak tablice Stavke.,
POS Register,POS registar,
"Can not filter based on POS Profile, if grouped by POS Profile",Ne može se filtrirati na temelju POS profila ako je grupirano po POS profilu,
"Can not filter based on Customer, if grouped by Customer",Ne može se filtrirati na temelju kupca ako ga je grupirao kupac,
"Can not filter based on Cashier, if grouped by Cashier","Ne može se filtrirati na temelju blagajne, ako je grupirana po blagajni",
Payment Method,Način plaćanja,
"Can not filter based on Payment Method, if grouped by Payment Method",Nije moguće filtrirati na temelju načina plaćanja ako je grupirano prema načinu plaćanja,
Supplier Quotation Comparison,Usporedba ponuda dobavljača,
Price per Unit (Stock UOM),Cijena po jedinici (dionica UOM),
Group by Supplier,Grupiraj prema dobavljaču,
Group by Item,Grupiraj po stavkama,
Remember to set {field_label}. It is required by {regulation}.,Ne zaboravite postaviti {field_label}. To zahtijeva {propis}.,
Enrollment Date cannot be before the Start Date of the Academic Year {0},Datum upisa ne može biti prije datuma početka akademske godine {0},
Enrollment Date cannot be after the End Date of the Academic Term {0},Datum upisa ne može biti nakon datuma završetka akademskog roka {0},
Enrollment Date cannot be before the Start Date of the Academic Term {0},Datum upisa ne može biti prije datuma početka akademskog roka {0},
Future Posting Not Allowed,Objavljivanje u budućnosti nije dozvoljeno,
"To enable Capital Work in Progress Accounting, ","Da biste omogućili računovodstvo kapitalnog rada u tijeku,",
you must select Capital Work in Progress Account in accounts table,u tablici računa morate odabrati račun kapitalnog rada u tijeku,
You can also set default CWIP account in Company {},Također možete postaviti zadani CWIP račun u tvrtki {},
The Request for Quotation can be accessed by clicking on the following button,Zahtjevu za ponudu možete pristupiti klikom na sljedeći gumb,
Regards,Pozdrav,
Please click on the following button to set your new password,Kliknite sljedeći gumb za postavljanje nove lozinke,
Update Password,Ažuriraj lozinku,
Row #{}: Selling rate for item {} is lower than its {}. Selling {} should be atleast {},Redak {{}: Stopa prodaje stavke {} niža je od {}. Prodaja {} trebala bi biti najmanje {},
You can alternatively disable selling price validation in {} to bypass this validation.,Alternativno možete onemogućiti provjeru prodajne cijene u {} da biste zaobišli ovu provjeru.,
Invalid Selling Price,Nevažeća prodajna cijena,
Address needs to be linked to a Company. Please add a row for Company in the Links table.,Adresa mora biti povezana s tvrtkom. U tablici veza dodajte redak za tvrtku.,
Company Not Linked,Tvrtka nije povezana,
Import Chart of Accounts from CSV / Excel files,Uvoz kontnog plana iz CSV / Excel datoteka,
Completed Qty cannot be greater than 'Qty to Manufacture',Završena količina ne može biti veća od „Količina za proizvodnju“,
"Row {0}: For Supplier {1}, Email Address is Required to send an email",Redak {0}: Za dobavljača {1} adresa e-pošte potrebna je za slanje e-pošte,
"If enabled, the system will post accounting entries for inventory automatically","Ako je omogućeno, sustav će automatski knjižiti knjigovodstvene evidencije zaliha",
Accounts Frozen Till Date,Računi zamrznuti do datuma,
Accounting entries are frozen up to this date. Nobody can create or modify entries except users with the role specified below,Računovodstvene stavke su zamrznute do danas. Nitko ne može stvarati ili mijenjati unose osim korisnika s ulogom navedenom u nastavku,
Role Allowed to Set Frozen Accounts and Edit Frozen Entries,Dopuštena uloga za postavljanje zamrznutih računa i uređivanje zamrznutih unosa,
Address used to determine Tax Category in transactions,Adresa koja se koristi za određivanje porezne kategorije u transakcijama,
"The percentage you are allowed to bill more against the amount ordered. For example, if the order value is $100 for an item and tolerance is set as 10%, then you are allowed to bill up to $110 ","Postotak koji smijete naplatiti više u odnosu na naručeni iznos. Na primjer, ako vrijednost narudžbe iznosi 100 USD za artikl, a tolerancija je postavljena na 10%, tada možete naplatiti do 110 USD",
This role is allowed to submit transactions that exceed credit limits,Ovom je ulogom dopušteno podnošenje transakcija koje premašuju kreditna ograničenja,
"If ""Months"" is selected, a fixed amount will be booked as deferred revenue or expense for each month irrespective of the number of days in a month. It will be prorated if deferred revenue or expense is not booked for an entire month","Ako je odabrano &quot;Mjeseci&quot;, fiksni iznos knjižiti će se kao odgođeni prihod ili rashod za svaki mjesec, bez obzira na broj dana u mjesecu. Bit će proporcionalno ako odgođeni prihodi ili rashodi ne budu knjiženi cijeli mjesec",
"If this is unchecked, direct GL entries will be created to book deferred revenue or expense","Ako ovo nije označeno, stvorit će se izravni GL unosi za knjiženje odgođenih prihoda ili rashoda",
Show Inclusive Tax in Print,Prikaži uključeni porez u tiskanom obliku,
Only select this if you have set up the Cash Flow Mapper documents,Odaberite ovo samo ako ste postavili dokumente Mape tokova gotovine,
Payment Channel,Kanal plaćanja,
Is Purchase Order Required for Purchase Invoice & Receipt Creation?,Je li narudžbenica potrebna za izradu fakture i potvrde o kupnji?,
Is Purchase Receipt Required for Purchase Invoice Creation?,Je li za izradu računa za kupovinu potrebna potvrda o kupnji?,
Maintain Same Rate Throughout the Purchase Cycle,Održavajte istu cijenu tijekom ciklusa kupnje,
Allow Item To Be Added Multiple Times in a Transaction,Dopusti dodavanje predmeta u transakciji više puta,
Suppliers,Dobavljači,
Send Emails to Suppliers,Pošaljite e-poštu dobavljačima,
Select a Supplier,Odaberite dobavljača,
Cannot mark attendance for future dates.,Nije moguće označiti prisustvo za buduće datume.,
Do you want to update attendance? <br> Present: {0} <br> Absent: {1},Želite li ažurirati prisustvo?<br> Prisutno: {0}<br> Odsutan: {1},
Mpesa Settings,Postavke Mpesa,
Initiator Name,Ime inicijatora,
Till Number,Do broja,
Sandbox,Pješčanik,
 Online PassKey,Online PassKey,
Security Credential,Vjerodajnica o sigurnosti,
Get Account Balance,Nabavite stanje računa,
Please set the initiator name and the security credential,Molimo postavite ime inicijatora i sigurnosne vjerodajnice,
Inpatient Medication Entry,Stacionarni unos lijekova,
HLC-IME-.YYYY.-,FHP-IME-.GGGG.-,
Item Code (Drug),Šifra artikla (lijek),
Medication Orders,Narudžbe lijekova,
Get Pending Medication Orders,Primajte narudžbe lijekova na čekanju,
Inpatient Medication Orders,Stacionarni lijekovi,
Medication Warehouse,Skladište lijekova,
Warehouse from where medication stock should be consumed,Skladište odakle treba potrošiti zalihe lijekova,
Fetching Pending Medication Orders,Preuzimanje naloga za lijekove na čekanju,
Inpatient Medication Entry Detail,Pojedinosti o ulazu u stacionarne lijekove,
Medication Details,Pojedinosti o lijekovima,
Drug Code,Kod lijekova,
Drug Name,Naziv lijeka,
Against Inpatient Medication Order,Protiv naloga za bolničko liječenje,
Against Inpatient Medication Order Entry,Protiv ulaza u stacionarne lijekove,
Inpatient Medication Order,Stacionarni lijek,
HLC-IMO-.YYYY.-,FHP-IMO-.GGGG.-,
Total Orders,Ukupno narudžbi,
Completed Orders,Izvršene narudžbe,
Add Medication Orders,Dodajte narudžbe za lijekove,
Adding Order Entries,Dodavanje unosa u narudžbu,
{0} medication orders completed,Dovršeno je {0} narudžbi lijekova,
{0} medication order completed,{0} narudžba lijekova dovršena,
Inpatient Medication Order Entry,Unos naloga za stacionarne lijekove,
Is Order Completed,Je li narudžba dovršena,
Employee Records to Be Created By,Zapisi o zaposlenicima koje će stvoriti,
Employee records are created using the selected field,Evidencija o zaposlenicima kreira se pomoću odabranog polja,
Don't send employee birthday reminders,Ne šaljite podsjetnike za rođendan zaposlenika,
Restrict Backdated Leave Applications,Ograničite aplikacije za napuštanje sa zadnjim datumom,
Sequence ID,ID sekvence,
Sequence Id,Slijed Id,
Allow multiple material consumptions against a Work Order,Omogućite višestruku potrošnju materijala prema radnom nalogu,
Plan time logs outside Workstation working hours,Planirajte evidenciju vremena izvan radnog vremena radne stanice,
Plan operations X days in advance,Planirajte operacije X dana unaprijed,
Time Between Operations (Mins),Vrijeme između operacija (minuta),
Default: 10 mins,Zadano: 10 min,
Overproduction for Sales and Work Order,Prekomjerna proizvodnja za prodaju i radni nalog,
"Update BOM cost automatically via scheduler, based on the latest Valuation Rate/Price List Rate/Last Purchase Rate of raw materials","Ažurirajte BOM trošak automatski putem planera, na temelju najnovije stope procjene / stope cjenika / stope zadnje kupnje sirovina",
Purchase Order already created for all Sales Order items,Narudžbenica je već stvorena za sve stavke narudžbenice,
Select Items,Odaberite stavke,
Against Default Supplier,Protiv zadanog dobavljača,
Auto close Opportunity after the no. of days mentioned above,Automatsko zatvaranje Prilika nakon br. dana gore spomenutih,
Is Sales Order Required for Sales Invoice & Delivery Note Creation?,Da li je narudžbenica potrebna za izradu fakture za prodaju i otpremnice?,
Is Delivery Note Required for Sales Invoice Creation?,Je li za izradu računa za prodaju potrebna dostavnica?,
How often should Project and Company be updated based on Sales Transactions?,Koliko često projekt i tvrtka trebaju biti ažurirani na temelju prodajnih transakcija?,
Allow User to Edit Price List Rate in Transactions,Omogućite korisniku da uređuje cijenu cjenika u transakcijama,
Allow Item to Be Added Multiple Times in a Transaction,Dopusti dodavanje predmeta u transakciji više puta,
Allow Multiple Sales Orders Against a Customer's Purchase Order,Omogućite više narudžbi za prodaju u odnosu na narudžbenice kupca,
Validate Selling Price for Item Against Purchase Rate or Valuation Rate,Provjerite prodajnu cijenu za stavku naspram stope nabave ili stope procjene,
Hide Customer's Tax ID from Sales Transactions,Sakrijte porezni broj kupca iz prodajnih transakcija,
"The 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 koji smijete primiti ili isporučiti više u odnosu na naručenu količinu. Na primjer, ako ste naručili 100 jedinica, a Vaš dodatak iznosi 10%, tada možete primiti 110 jedinica.",
Action If Quality Inspection Is Not Submitted,Postupak ako se inspekcija kvalitete ne podnese,
Auto Insert Price List Rate If Missing,Automatsko umetanje cijene cjenika ako nedostaje,
Automatically Set Serial Nos Based on FIFO,Automatski postavi serijske brojeve na temelju FIFO-a,
Set Qty in Transactions Based on Serial No Input,Postavi količinu u transakcijama na temelju serijskog unosa,
Raise Material Request When Stock Reaches Re-order Level,Podignite zahtjev za materijal kada zalihe dosegnu razinu ponovnog naručivanja,
Notify by Email on Creation of Automatic Material Request,Obavijestite e-poštom o stvaranju automatskog zahtjeva za materijalom,
Allow Material Transfer from Delivery Note to Sales Invoice,Omogućite prijenos materijala s otpremnice na fakturu prodaje,
Allow Material Transfer from Purchase Receipt to Purchase Invoice,Omogućite prijenos materijala s potvrde o kupnji na fakturu kupnje,
Freeze Stocks Older Than (Days),Zamrznite zalihe starije od (dana),
Role Allowed to Edit Frozen Stock,Dopuštena uloga za uređivanje smrznutih zaliha,
The unallocated amount of Payment Entry {0} is greater than the Bank Transaction's unallocated amount,Neraspoređeni iznos Unosa za plaćanje {0} veći je od neraspoređenog iznosa Bankovne transakcije,
Payment Received,Primljena uplata,
Attendance cannot be marked outside of Academic Year {0},Prisutnost se ne može označiti izvan akademske godine {0},
Student is already enrolled via Course Enrollment {0},Student je već upisan putem upisa na predmet {0},
Attendance cannot be marked for future dates.,Prisustvo se ne može označiti za buduće datume.,
Please add programs to enable admission application.,Dodajte programe kako biste omogućili prijavu.,
The following employees are currently still reporting to {0}:,Sljedeći zaposlenici trenutno se još uvijek prijavljuju {0}:,
Please make sure the employees above report to another Active employee.,Molimo osigurajte da se gore navedeni zaposlenici prijave drugom aktivnom djelatniku.,
Cannot Relieve Employee,Ne mogu olakšati zaposlenika,
Please enter {0},Unesite {0},
Please select another payment method. Mpesa does not support transactions in currency '{0}',Odaberite drugi način plaćanja. Mpesa ne podržava transakcije u valuti &quot;{0}&quot;,
Transaction Error,Pogreška transakcije,
Mpesa Express Transaction Error,Pogreška Mpesa Express Transakcije,
"Issue detected with Mpesa configuration, check the error logs for more details","Otkriven je problem s Mpesa konfiguracijom, za više detalja provjerite zapisnike pogrešaka",
Mpesa Express Error,Pogreška Mpesa Expressa,
Account Balance Processing Error,Pogreška pri obradi stanja računa,
Please check your configuration and try again,Provjerite svoju konfiguraciju i pokušajte ponovo,
Mpesa Account Balance Processing Error,Pogreška pri obradi stanja računa Mpesa,
Balance Details,Pojedinosti stanja,
Current Balance,Trenutno stanje,
Available Balance,Dostupno Stanje,
Reserved Balance,Rezervirano stanje,
Uncleared Balance,Nerazjašnjena ravnoteža,
Payment related to {0} is not completed,Isplata vezana uz {0} nije dovršena,
Row #{}: Item Code: {} is not available under warehouse {}.,Redak {{}: Šifra artikla: {} nije dostupan u skladištu {}.,
Row #{}: Stock quantity not enough for Item Code: {} under warehouse {}. Available quantity {}.,Redak {{}: Količina zaliha nije dovoljna za šifru artikla: {} ispod skladišta {}. Dostupna količina {}.,
Row #{}: Please select a serial no and batch against item: {} or remove it to complete transaction.,Redak {{}: Odaberite serijski broj i skup prema stavci: {} ili ga uklonite da biste dovršili transakciju.,
Row #{}: No serial number selected against item: {}. Please select one or remove it to complete transaction.,Redak {{}: Nije odabran serijski broj za stavku: {}. Odaberite jedan ili ga uklonite da biste dovršili transakciju.,
Row #{}: No batch selected against item: {}. Please select a batch or remove it to complete transaction.,Redak {{}: Nije odabrana serija za stavku: {}. Odaberite skup ili ga uklonite da biste dovršili transakciju.,
Payment amount cannot be less than or equal to 0,Iznos plaćanja ne može biti manji ili jednak 0,
Please enter the phone number first,Prvo unesite telefonski broj,
Row #{}: {} {} does not exist.,Redak {{}: {} {} ne postoji.,
Row #{0}: {1} is required to create the Opening {2} Invoices,Redak {0}: {1} potreban je za stvaranje uvodnih {2} faktura,
You had {} errors while creating opening invoices. Check {} for more details,Imali ste {} pogrešaka prilikom izrade faktura za otvaranje. Više pojedinosti potražite u {},
Error Occured,Dogodila se pogreška,
Opening Invoice Creation In Progress,Otvaranje izrade fakture u tijeku,
Creating {} out of {} {},Izrada {} od {} {},
(Serial No: {0}) cannot be consumed as it's reserverd to fullfill Sales Order {1}.,(Serijski broj: {0}) ne može se potrošiti jer je rezerviran za punjenje prodajnog naloga {1}.,
Item {0} {1},Stavka {0} {1},
Last Stock Transaction for item {0} under warehouse {1} was on {2}.,Posljednja transakcija zaliha za artikl {0} u skladištu {1} bila je {2}.,
Stock Transactions for Item {0} under warehouse {1} cannot be posted before this time.,Transakcije dionicama za stavku {0} u skladištu {1} ne mogu se objaviti prije ovog vremena.,
Posting future stock transactions are not allowed due to Immutable Ledger,Knjiženje budućih transakcija dionicama nije dopušteno zbog Nepromjenjive knjige,
A BOM with name {0} already exists for item {1}.,BOM s imenom {0} već postoji za stavku {1}.,
{0}{1} Did you rename the item? Please contact Administrator / Tech support,{0} {1} Jeste li preimenovali stavku? Molimo kontaktirajte administratora / tehničku podršku,
At row #{0}: the sequence id {1} cannot be less than previous row sequence id {2},U retku # {0}: ID sekvence {1} ne može biti manji od ID-a sekvence prethodnog retka {2},
The {0} ({1}) must be equal to {2} ({3}),{0} ({1}) mora biti jednako {2} ({3}),
"{0}, complete the operation {1} before the operation {2}.","{0}, dovršite operaciju {1} prije operacije {2}.",
Cannot ensure delivery by Serial No as Item {0} is added with and without Ensure Delivery by Serial No.,Ne možemo osigurati dostavu serijskim brojem jer se dodaje stavka {0} sa i bez osiguranja isporuke serijskim br.,
Item {0} has no Serial No. Only serilialized items can have delivery based on Serial No,Stavka {0} nema serijski broj. Samo serilizirane stavke mogu isporučivati na temelju serijskog broja,
No active BOM found for item {0}. Delivery by Serial No cannot be ensured,Nije pronađena aktivna specifikacija za stavku {0}. Dostava serijskim brojem ne može se osigurati,
No pending medication orders found for selected criteria,Nije pronađena nijedna narudžba lijekova za odabrane kriterije,
From Date cannot be after the current date.,Od datuma ne može biti nakon trenutnog datuma.,
To Date cannot be after the current date.,Do datuma ne može biti nakon trenutnog datuma.,
From Time cannot be after the current time.,Iz vremena ne može biti nakon trenutnog vremena.,
To Time cannot be after the current time.,To Time ne može biti nakon trenutnog vremena.,
Stock Entry {0} created and ,Unos dionica {0} stvoren i,
Inpatient Medication Orders updated successfully,Nalozi za stacionarne lijekove uspješno su ažurirani,
Row {0}: Cannot create Inpatient Medication Entry against cancelled Inpatient Medication Order {1},Redak {0}: Nije moguće stvoriti unos stacionarnih lijekova protiv otkazane narudžbe stacionarnih lijekova {1},
Row {0}: This Medication Order is already marked as completed,Redak {0}: Ova je narudžba lijekova već označena kao ispunjena,
Quantity not available for {0} in warehouse {1},Količina nije dostupna za {0} u skladištu {1},
Please enable Allow Negative Stock in Stock Settings or create Stock Entry to proceed.,U nastavku omogućite Dopusti negativnu zalihu ili stvorite unos dionica.,
No Inpatient Record found against patient {0},Nije pronađena bolnička evidencija protiv pacijenta {0},
An Inpatient Medication Order {0} against Patient Encounter {1} already exists.,Nalog za stacionarne lijekove {0} protiv susreta s pacijentima {1} već postoji.,
Allow In Returns,Dopusti povratak,
Hide Unavailable Items,Sakrij nedostupne stavke,
Apply Discount on Discounted Rate,Primijenite popust na sniženu stopu,
Therapy Plan Template,Predložak plana terapije,
Fetching Template Details,Dohvaćanje pojedinosti predloška,
Linked Item Details,Povezani detalji stavke,
Therapy Types,Vrste terapije,
Therapy Plan Template Detail,Pojedinosti predloška plana terapije,
Non Conformance,Neusklađenost,
Process Owner,Vlasnik procesa,
Corrective Action,Korektivne mjere,
Preventive Action,Preventivna akcija,
Problem,Problem,
Responsible,Odgovoran,
Completion By,Završetak,
Process Owner Full Name,Puno ime vlasnika postupka,
Right Index,Desni indeks,
Left Index,Lijevi indeks,
Sub Procedure,Potprocedura,
Passed,Prošao,
Print Receipt,Ispisnica,
Edit Receipt,Uredi potvrdu,
Focus on search input,Usredotočite se na unos pretraživanja,
Focus on Item Group filter,Usredotočite se na filter grupe predmeta,
Checkout Order / Submit Order / New Order,Narudžba za plaćanje / Predaja naloga / Nova narudžba,
Add Order Discount,Dodajte popust za narudžbu,
Item Code: {0} is not available under warehouse {1}.,Šifra artikla: {0} nije dostupno u skladištu {1}.,
Serial numbers unavailable for Item {0} under warehouse {1}. Please try changing warehouse.,Serijski brojevi nisu dostupni za artikl {0} u skladištu {1}. Pokušajte promijeniti skladište.,
Fetched only {0} available serial numbers.,Dohvaćeno samo {0} dostupnih serijskih brojeva.,
Switch Between Payment Modes,Prebacivanje između načina plaćanja,
Enter {0} amount.,Unesite iznos od {0}.,
You don't have enough points to redeem.,Nemate dovoljno bodova za iskorištavanje.,
You can redeem upto {0}.,Možete iskoristiti do {0}.,
Enter amount to be redeemed.,Unesite iznos koji treba iskoristiti.,
You cannot redeem more than {0}.,Ne možete iskoristiti više od {0}.,
Open Form View,Otvorite prikaz obrasca,
POS invoice {0} created succesfully,POS račun {0} uspješno je stvoren,
Stock quantity not enough for Item Code: {0} under warehouse {1}. Available quantity {2}.,Količina zaliha nije dovoljna za šifru artikla: {0} ispod skladišta {1}. Dostupna količina {2}.,
Serial No: {0} has already been transacted into another POS Invoice.,Serijski broj: {0} već je pretvoren u drugu POS fakturu.,
Balance Serial No,Serijski br,
Warehouse: {0} does not belong to {1},Skladište: {0} ne pripada tvrtki {1},
Please select batches for batched item {0},Odaberite serije za skupljenu stavku {0},
Please select quantity on row {0},Odaberite količinu u retku {0},
Please enter serial numbers for serialized item {0},Unesite serijske brojeve za serijsku stavku {0},
Batch {0} already selected.,Skupina {0} već je odabrana.,
Please select a warehouse to get available quantities,Odaberite skladište da biste dobili dostupne količine,
"For transfer from source, selected quantity cannot be greater than available quantity","Za prijenos iz izvora, odabrana količina ne može biti veća od dostupne količine",
Cannot find Item with this Barcode,Ne mogu pronaći predmet s ovim crtičnim kodom,
{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2},{0} je obavezan. Možda zapis mjenjačnice nije stvoren za {1} do {2},
{} has submitted assets linked to it. You need to cancel the assets to create purchase return.,{} je poslao elemente povezane s tim. Morate otkazati imovinu da biste stvorili povrat kupnje.,
Cannot cancel this document as it is linked with submitted asset {0}. Please cancel it to continue.,Ovaj dokument nije moguće otkazati jer je povezan s poslanim materijalom {0}. Otkažite ga da biste nastavili.,
Row #{}: Serial No. {} has already been transacted into another POS Invoice. Please select valid serial no.,Redak {{}: Serijski broj {} je već prebačen na drugu POS fakturu. Odaberite valjani serijski br.,
Row #{}: Serial Nos. {} has already been transacted into another POS Invoice. Please select valid serial no.,Redak {{}: Serijski brojevi. {} Već su prebačeni u drugu POS fakturu. Odaberite valjani serijski br.,
Item Unavailable,Predmet nije dostupan,
Row #{}: Serial No {} cannot be returned since it was not transacted in original invoice {},Redak {{}: serijski broj {} ne može se vratiti jer nije izvršen u izvornoj fakturi {},
Please set default Cash or Bank account in Mode of Payment {},Postavite zadani gotovinski ili bankovni račun u načinu plaćanja {},
Please set default Cash or Bank account in Mode of Payments {},Postavite zadani gotovinski ili bankovni račun u načinu plaćanja {},
Please ensure {} account is a Balance Sheet account. You can change the parent account to a Balance Sheet account or select a different account.,Molimo provjerite je li račun {} račun bilance. Možete promijeniti roditeljski račun u račun bilance ili odabrati drugi račun.,
Please ensure {} account is a Payable account. Change the account type to Payable or select a different account.,Molimo provjerite je li račun {} račun koji se plaća. Promijenite vrstu računa u Plativo ili odaberite drugi račun.,
Row {}: Expense Head changed to {} ,Red {}: Glava rashoda promijenjena je u {},
because account {} is not linked to warehouse {} ,jer račun {} nije povezan sa skladištem {},
or it is not the default inventory account,ili nije zadani račun zaliha,
Expense Head Changed,Promijenjena glava rashoda,
because expense is booked against this account in Purchase Receipt {},jer je trošak knjižen na ovaj račun u potvrdi o kupnji {},
as no Purchase Receipt is created against Item {}. ,jer se prema stavci {} ne stvara potvrda o kupnji.,
This is done to handle accounting for cases when Purchase Receipt is created after Purchase Invoice,To se radi radi obračunavanja slučajeva kada se potvrda o kupnji kreira nakon fakture za kupnju,
Purchase Order Required for item {},Narudžbenica potrebna za stavku {},
To submit the invoice without purchase order please set {} ,"Da biste predali račun bez narudžbenice, postavite {}",
as {} in {},kao {} u {},
Mandatory Purchase Order,Obavezna narudžbenica,
Purchase Receipt Required for item {},Potvrda o kupnji potrebna za stavku {},
To submit the invoice without purchase receipt please set {} ,"Da biste predali račun bez potvrde o kupnji, postavite {}",
Mandatory Purchase Receipt,Potvrda o obaveznoj kupnji,
POS Profile {} does not belongs to company {},POS profil {} ne pripada tvrtki {},
User {} is disabled. Please select valid user/cashier,Korisnik {} je onemogućen. Odaberite valjanog korisnika / blagajnika,
Row #{}: Original Invoice {} of return invoice {} is {}. ,Redak {{}: Izvorna faktura {} fakture za povrat {} je {}.,
Original invoice should be consolidated before or along with the return invoice.,Izvorni račun treba objediniti prije ili zajedno s povratnim računom.,
You can add original invoice {} manually to proceed.,"Da biste nastavili, možete ručno dodati {} fakturu {}.",
Please ensure {} account is a Balance Sheet account. ,Molimo provjerite je li račun {} račun bilance.,
You can change the parent account to a Balance Sheet account or select a different account.,Možete promijeniti roditeljski račun u račun bilance ili odabrati drugi račun.,
Please ensure {} account is a Receivable account. ,Molimo provjerite je li račun} račun potraživanja.,
Change the account type to Receivable or select a different account.,Promijenite vrstu računa u Potraživanje ili odaberite drugi račun.,
{} can't be cancelled since the Loyalty Points earned has been redeemed. First cancel the {} No {},{} se ne može otkazati jer su iskorišteni bodovi za lojalnost. Prvo otkažite {} Ne {},
already exists,već postoji,
POS Closing Entry {} against {} between selected period,Zatvaranje unosa POS-a {} protiv {} između odabranog razdoblja,
POS Invoice is {},POS račun je {},
POS Profile doesn't matches {},POS profil se ne podudara s {},
POS Invoice is not {},POS faktura nije {},
POS Invoice isn't created by user {},POS račun ne izrađuje korisnik {},
Row #{}: {},Red # {}: {},
Invalid POS Invoices,Nevažeći POS računi,
Please add the account to root level Company - {},Dodajte račun korijenskoj tvrtki - {},
"While creating account for Child Company {0}, parent account {1} not found. Please create the parent account in corresponding COA","Tijekom stvaranja računa za podređenu tvrtku {0}, nadređeni račun {1} nije pronađen. Molimo stvorite roditeljski račun u odgovarajućem COA",
Account Not Found,Račun nije pronađen,
"While creating account for Child Company {0}, parent account {1} found as a ledger account.","Tijekom stvaranja računa za podređenu tvrtku {0}, nadređeni račun {1} pronađen je kao račun glavne knjige.",
Please convert the parent account in corresponding child company to a group account.,Molimo pretvorite roditeljski račun u odgovarajućoj podređenoj tvrtki u grupni račun.,
Invalid Parent Account,Nevažeći roditeljski račun,
"Renaming it is only allowed via parent company {0}, to avoid mismatch.","Preimenovanje je dopušteno samo putem matične tvrtke {0}, kako bi se izbjegla neusklađenost.",
"If you {0} {1} quantities of the item {2}, the scheme {3} will be applied on the item.","Ako {0} {1} količinu predmeta {2}, na proizvod će primijeniti shema {3}.",
"If you {0} {1} worth item {2}, the scheme {3} will be applied on the item.","Ako {0} {1} vrijedite stavku {2}, shema {3} primijenit će se na stavku.",
"As the field {0} is enabled, the field {1} is mandatory.","Kako je polje {0} omogućeno, polje {1} je obavezno.",
"As the field {0} is enabled, the value of the field {1} should be more than 1.","Kako je polje {0} omogućeno, vrijednost polja {1} trebala bi biti veća od 1.",
Cannot deliver Serial No {0} of item {1} as it is reserved to fullfill Sales Order {2},Nije moguće isporučiti serijski broj {0} stavke {1} jer je rezerviran za puni prodajni nalog {2},
"Sales Order {0} has reservation for the item {1}, you can only deliver reserved {1} against {0}.","Prodajni nalog {0} ima rezervaciju za artikl {1}, a možete dostaviti samo rezervirani {1} u odnosu na {0}.",
{0} Serial No {1} cannot be delivered,{0} Serijski broj {1} nije moguće isporučiti,
Row {0}: Subcontracted Item is mandatory for the raw material {1},Redak {0}: Predmet podugovaranja obvezan je za sirovinu {1},
"As there are sufficient raw materials, Material Request is not required for Warehouse {0}.","Budući da ima dovoljno sirovina, zahtjev za materijal nije potreban za Skladište {0}.",
" If you still want to proceed, please enable {0}.","Ako i dalje želite nastaviti, omogućite {0}.",
The item referenced by {0} - {1} is already invoiced,Stavka na koju se poziva {0} - {1} već je fakturirana,
Therapy Session overlaps with {0},Sjednica terapije preklapa se s {0},
Therapy Sessions Overlapping,Preklapajuće se terapijske sesije,
Therapy Plans,Planovi terapije,
"Item Code, warehouse, quantity are required on row {0}","Šifra artikla, skladište, količina potrebni su na retku {0}",
Get Items from Material Requests against this Supplier,Nabavite stavke iz materijalnih zahtjeva protiv ovog dobavljača,
Enable European Access,Omogućiti europski pristup,
Creating Purchase Order ...,Izrada narudžbenice ...,
"Select a Supplier from the Default Suppliers of the items below. On selection, a Purchase Order will be made against items belonging to the selected Supplier only.","Odaberite dobavljača od zadanih dobavljača dolje navedenih stavki. Nakon odabira, narudžbenica će se izvršiti samo za proizvode koji pripadaju odabranom dobavljaču.",
Row #{}: You must select {} serial numbers for item {}.,Redak {{}: Morate odabrati {} serijske brojeve za stavku {}.,
Add Comment,Dodaj komentar,
More...,Više...,
Notes,Zabilješke,
Payment Gateway,Payment Gateway,
Payment Gateway Name,Ime platnog prolaza,
Payments,Plaćanja,
Plan Name,Naziv plana,
Portal,Portal,
Scan Barcode,Skenirajte crtični kod,
Some information is missing,Neki podaci nedostaju,
Successful,uspješan,
Tools,Alati,
Use Sandbox,Sandbox,
Busy,Zaposlen,
Completed By,Završio,
Payment Failed,Plaćanje nije uspjelo,
Column {0},Stupac {0},
Field Mapping,Kartiranje polja,
Not Specified,Nije specificirano,
Update Type,Vrsta ažuriranja,
Dr,Doktor,
End Time,Kraj vremena,
Fetching...,Preuzimanje u tijeku ...,
"It seems that there is an issue with the server's stripe configuration. In case of failure, the amount will get refunded to your account.","Čini se da postoji problem s konfiguracijom trake poslužitelja. U slučaju neuspjeha, iznos će biti vraćen na vaš račun.",
Looks like someone sent you to an incomplete URL. Please ask them to look into it.,Izgleda da ti je netko poslao nepotpune URL. Zamolite ih gledati u nju.,
Master,Master,
Pay,Platiti,
You can also copy-paste this link in your browser,Također možete kopirati ovaj link u Vaš preglednik,
Verified By,Ovjeren od strane,
Invalid naming series (. missing) for {0},Nevažeća serija imenovanja (. Nedostaje) za {0},
Phone Number,Broj telefona,
Account SID,SID računa,
Global Defaults,Globalne zadane postavke,
Is Mandatory,Je obavezno,
WhatsApp,Što ima,
Make a call,Uputi poziv,
