 (Half Day),(Pola dana),
 Currently no stock available in any warehouse,Trenutno nema zaliha u skladištu,
 From Date can not be greater than To Date,Datum ne može biti veći od datuma,
 Group Roll No,Grupni broj br,
 or ,ili,
" {0} Retain Sample is based on batch, please check Has Batch No to retain sample of item","{0} Zadržavanje uzorka se zasniva na seriji, provjerite Ima li serijski broj da zadrži uzorak stavke",
"""Customer Provided Item"" cannot be Purchase Item also",&quot;Korisnički dostavljena stavka&quot; ne može biti i predmet kupovine,
"""Customer Provided Item"" cannot have Valuation Rate",&quot;Stavka dostavljena od strane korisnika&quot; ne može imati stopu procjene,
"""Is Fixed Asset"" cannot be unchecked, as Asset record exists against the item","&quot;Is Fixed Asset&quot; se ne može poništiti, jer evidencija imovine postoji protiv stavke",
'Based On' and 'Group By' can not be same,&#39;Based On&#39; i &#39;Group By&#39; ne mogu biti isti,
'Days Since Last Order' must be greater than or equal to zero,&#39;Dani od zadnjeg reda&#39; moraju biti veći ili jednaki nuli,
'Entries' cannot be empty,&#39;Unosi&#39; ne mogu biti prazni,
'From Date' is required,&quot;Od datuma&quot; je obavezno,
'From Date' must be after 'To Date',&#39;Od datuma&#39; mora biti nakon &#39;Datum&#39;,
'Has Serial No' can not be 'Yes' for non-stock item,&#39;Ima serijski broj&#39; ne može biti &#39;Da&#39; za ne-zalihu stavku,
'Opening',&#39;Otvaranje&#39;,
'To Case No.' cannot be less than 'From Case No.',&#39;Za slučaj br.&#39; ne može biti manja od &quot;Iz slučaja br.&quot;,
'To Date' is required,&#39;To Date&#39; je obavezno,
'Total',&#39;Ukupno&#39;,
'Update Stock' can not be checked because items are not delivered via {0},&quot;Ažuriranje zaliha&quot; ne može se provjeriti jer se stavke ne isporučuju putem {0},
'Update Stock' cannot be checked for fixed asset sale,&#39;Update Stock&#39; ne može se proveriti za prodaju fiksne imovine,
) for {0},) za {0},
1 exact match.,1 točno podudaranje.,
90-Above,90-Iznad,
A Customer Group exists with same name please change the Customer name or rename the Customer Group,"Postoji korisnička grupa sa istim imenom, promijenite ime klijenta ili preimenujte korisničku grupu",
A Default Service Level Agreement already exists.,Uobičajeni ugovor o nivou usluge već postoji.,
A Lead requires either a person's name or an organization's name,Olovo zahtijeva ili ime osobe ili ime organizacije,
A customer with the same name already exists,Korisnik s istim imenom već postoji,
A question must have more than one options,Pitanje mora imati više od jedne opcije,
A qustion must have at least one correct options,Pitanje mora imati barem jednu ispravnu opciju,
A {0} exists between {1} and {2} (,Postoji {0} između {1} i {2} (,
Abbr can not be blank or space,Abbr ne može biti prazan ili prazan,
Abbreviation already used for another company,Skraćenica koja se već koristi za drugu kompaniju,
Abbreviation cannot have more than 5 characters,Skraćenica ne može imati više od 5 znakova,
Abbreviation is mandatory,Skraćenica je obavezna,
About the Company,O kompaniji,
About your company,O vašoj kompaniji,
Above,Iznad,
Absent,Absent,
Academic Term,Akademski mandat,
Academic Term: ,Akademski mandat:,
Academic Year,Akademska godina,
Academic Year: ,Akademska godina:,
Accepted + Rejected Qty must be equal to Received quantity for Item {0},Prihvaćena + Odbijena količina mora biti jednaka primljenoj količini za stavku {0},
Accessable Value,Dostupna vrijednost,
Account,Račun,
Account Number,Broj računa,
Account Number {0} already used in account {1},Broj računa {0} je već korišten u računu {1},
Account Pay Only,Account Pay Only,
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 Kreditu, nije vam dozvoljeno da postavite &quot;Stanje mora biti&quot; kao &quot;Zaduženje&quot;",
"Account balance already in Debit, you are not allowed to set 'Balance Must Be' as 'Credit'","Stanje računa već u dugu, nije vam dozvoljeno da postavite &quot;Stanje mora biti&quot; kao &quot;Kredit&quot;",
Account number for account {0} is not available.<br> Please setup your Chart of Accounts correctly.,Broj računa za račun {0} nije dostupan. <br> Molimo vas da ispravno postavite svoj Kontni plan.,
Account with child nodes cannot be converted to ledger,Račun sa čvorovima za dijete ne može se pretvoriti u knjigu,
Account with child nodes cannot be set as ledger,Račun sa čvorovima za dijete ne može se postaviti kao knjiga,
Account with existing transaction can not be converted to group.,Račun sa postojećom transakcijom ne može se pretvoriti u grupu.,
Account with existing transaction can not be deleted,Račun sa postojećom transakcijom ne može se izbrisati,
Account with existing transaction cannot be converted to ledger,Račun sa postojećom transakcijom ne može se pretvoriti u 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 tvrtki {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} se ne podudara sa kompanijom {1} u načinu korisničkog računa: {2},
Account {0} has been entered multiple times,Račun {0} je unesen više puta,
Account {0} is added in the child company {1},Račun {0} se dodaje u podređenu tvrtku {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}: Roditeljski račun {1} ne može biti knjiga,
Account {0}: Parent account {1} does not belong to company: {2},Račun {0}: Roditeljski račun {1} ne pripada tvrtki: {2},
Account {0}: Parent account {1} does not exist,Račun {0}: Roditeljski račun {1} ne postoji,
Account {0}: You can not assign itself as parent account,Račun {0}: Ne možete se dodijeliti kao nadređeni račun,
Account: {0} can only be updated via Stock Transactions,Račun: {0} se može ažurirati samo putem transakcija dionicama,
Account: {0} with currency: {1} can not be selected,Račun: {0} sa valutom: {1} nije moguće odabrati,
Accountant,Računovođa,
Accounting,Računovodstvo,
Accounting Entry for Asset,Računovodstveni unos za imovinu,
Accounting Entry for Stock,Računovodstveni unos za dionice,
Accounting Entry for {0}: {1} can only be made in currency: {2},Računovodstveni unos za {0}: {1} može biti samo u valuti: {2},
Accounting Ledger,Knjigovodstvena knjiga,
Accounting entries have already been made in currency {0} for company {1}. Please select a receivable or payable account with currency {0}.,Računovodstveni unosi su već izvršeni u valuti {0} za preduzeće {1}. Molimo izaberite račun za potraživanje ili plaćanje sa valutom {0}.,
Accounting journal entries.,Računovodstveni unosi u dnevnik.,
Accounts,Računi,
Accounts Payable,Dugovanja,
Accounts Payable Summary,Sažetak obaveza prema računima,
Accounts Receivable,Potraživanja,
Accounts Receivable Summary,Pregled računa potraživanja,
Accounts table cannot be blank.,Tabela računa ne može biti prazna.,
Accrual Journal Entry for salaries from {0} to {1},Unos dnevnog obračuna za plate od {0} do {1},
Accumulated Depreciation,Akumuliranu amortizaciju,
Accumulated Depreciation Amount,Iznos akumulirane amortizacije,
Accumulated Depreciation as on,Akumulirana amortizacija kao na,
Accumulated Monthly,Accumulated Monthly,
Accumulated Values,Akumulirane vrijednosti,
Accumulated Values in Group Company,Akumulirane vrijednosti u Grupi,
Achieved ({}),Postignuto ({}),
Action,Akcija,
Action Initialised,Postupak inicijalizovan,
Actions,Akcije,
Active,Aktivno,
Active Leads / Customers,Aktivni korisnici / klijenti,
Activity Cost exists for Employee {0} against Activity Type - {1},Troškovi aktivnosti postoje za zaposlenika {0} u odnosu na vrstu aktivnosti - {1},
Activity Cost per Employee,Troškovi aktivnosti po zaposlenom,
Activity Type,Vrsta aktivnosti,
Actual Cost,Stvarna cijena,
Actual Delivery Date,Stvarni datum isporuke,
Actual Qty,Actual Qty,
Actual Qty is mandatory,Stvarna količina je obavezna,
Actual Qty {0} / Waiting Qty {1},Stvarna količina {0} / količina čekanja {1},
Actual Qty: Quantity available in the warehouse.,Stvarna količina: Količina dostupna u skladištu.,
Actual qty in stock,Stvarna količina na lageru,
Actual type tax cannot be included in Item rate in row {0},Porez na stvarnu vrstu ne može biti uključen u stavku stavke u redu {0},
Add,Dodati,
Add / Edit Prices,Dodaj / uredi cijene,
Add All Suppliers,Dodaj sve dobavljače,
Add Comment,Add Comment,
Add Customers,Dodaj klijente,
Add Employees,Add Employees,
Add Item,Dodaj stavku,
Add Items,Add Items,
Add Leads,Add Leads,
Add Multiple Tasks,Dodajte više zadataka,
Add Row,Add Row,
Add Sales Partners,Dodajte prodajne partnere,
Add Serial No,Dodaj serijski broj,
Add Students,Dodaj studente,
Add Suppliers,Dodaj dobavljače,
Add Time Slots,Dodajte vremenske slotove,
Add Timesheets,Add Timesheets,
Add Timeslots,Add Timeslots,
Add Users to Marketplace,Dodajte korisnike na tržište,
Add a new address,Dodajte novu adresu,
Add cards or custom sections on homepage,Dodajte kartice ili prilagođene sekcije na početnu stranicu,
Add more items or open full form,Dodajte još stavki ili otvorite pun obrazac,
Add notes,Dodajte napomene,
Add the rest of your organization as your users. You can also add invite Customers to your portal by adding them from Contacts,Dodajte ostatak organizacije kao svoje korisnike. Klijente možete pozvati i na svoj portal tako što ćete ih dodati iz Kontakata,
Add to Details,Dodaj u Detalji,
Add/Remove Recipients,Dodaj / ukloni primaoce,
Added,Dodano,
Added to details,Dodano detaljima,
Added {0} users,Dodato je {0} korisnika,
Additional Salary Component Exists.,Dodatna komponenta plaća postoji.,
Address,Adresa,
Address Line 2,Adresa 2,
Address Name,Address Name,
Address Title,Address Title,
Address Type,vrsta adrese,
Administrative Expenses,Administrativni troškovi,
Administrative Officer,Administrativni službenik,
Admission,Prijem,
Admission and Enrollment,Prijem i upis,
Admissions for {0},Prijave za {0},
Admit,Priznati,
Admitted,Prihvaćeno,
Advance Amount,Advance Amount,
Advance Payments,Advance Payments,
Advance account currency should be same as company currency {0},Valuta računa avansa mora biti ista kao i valuta kompanije {0},
Advance amount cannot be greater than {0} {1},Iznos avansa ne može biti veći od {0} {1},
Advertising,Oglašavanje,
Aerospace,Aerospace,
Against,Protiv,
Against Account,Protiv računa,
Against Journal Entry {0} does not have any unmatched {1} entry,Protiv unosa dnevnika {0} nema unata bez podudaranja {1},
Against Journal Entry {0} is already adjusted against some other voucher,Protiv unosa dnevnika {0} je već podešen prema nekom drugom vaučeru,
Against Supplier Invoice {0} dated {1},Protiv fakture dobavljača {0} od {1},
Against Voucher,Against Voucher,
Against Voucher Type,Against Voucher Type,
Age,Age,
Age (Days),Dob (Dani),
Ageing Based On,Aging Based On,
Ageing Range 1,Raspon starenja 1,
Ageing Range 2,Raspon starenja 2,
Ageing Range 3,Raspon starenja 3,
Agriculture,Poljoprivreda,
Agriculture (beta),Poljoprivreda (beta),
Airline,Airline,
All Accounts,Svi računi,
All Addresses.,Sve adrese.,
All Assessment Groups,Sve grupe za procjenu,
All BOMs,Sve BOM-ove,
All Contacts.,Svi kontakti.,
All Customer Groups,Sve korisničke grupe,
All Day,Cijeli dan,
All Departments,All Departments,
All Healthcare Service Units,Sve jedinice zdravstvene službe,
All Item Groups,Sve grupe stavki,
All Jobs,All Jobs,
All Products,Svi proizvodi,
All Products or Services.,Svi proizvodi ili usluge.,
All Student Admissions,Sve studentske prijave,
All Supplier Groups,Sve grupe dobavljača,
All Supplier scorecards.,Sve kartice dobavljača.,
All Territories,Sve teritorije,
All Warehouses,All Warehouses,
All communications including and above this shall be moved into the new Issue,Sva komunikacija koja uključuje i iznad toga će biti premještena u novo izdanje,
All items have already been invoiced,Sve stavke su već fakturirane,
All items have already been transferred for this Work Order.,Sve stavke su već prebačene za ovaj radni nalog.,
All other ITC,Svi ostali ITC,
All the mandatory Task for employee creation hasn't been done yet.,Svi obavezni zadaci za kreiranje zaposlenika još nisu obavljeni.,
All these items have already been invoiced,Sve ove stavke su već fakturirane,
Allocate Payment Amount,Rasporedite iznos uplate,
Allocated Amount,Dodijeljeni iznos,
Allocated Leaves,Dodijeljeni listovi,
Allocating leaves...,Dodeljivanje 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 default u pos profilu {0} za korisnika {1}, ljubazno onemogućili default",
Alternate Item,Alternativna stavka,
Alternative item must not be same as item code,Alternativna stavka ne smije biti ista kao kod stavke,
Amount,Iznos,
Amount After Depreciation,Iznos nakon amortizacije,
Amount of Integrated Tax,Iznos integrisanog poreza,
Amount of TDS Deducted,Iznos TDS-a,
Amount should not be less than zero.,Iznos ne treba da bude manji od nule.,
Amount to Bill,Iznos za Bill,
Amount {0} {1} against {2} {3},Iznos {0} {1} u odnosu na {2} {3},
Amount {0} {1} deducted against {2},Iznos {0} {1} odbijen 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","Grupa proizvoda postoji sa istim imenom, promijenite naziv stavke ili preimenujte grupu stavki",
An academic term with this 'Academic Year' {0} and 'Term Name' {1} already exists. Please modify these entries and try again.,Akademski termin sa ovom &#39;akademskom godinom&#39; {0} i &#39;Ime termina&#39; {1} već postoji. Izmijenite ove unose i pokušajte ponovo.,
An error occurred during the update process,Došlo je do greške tokom procesa 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}), promijenite naziv grupe stavki ili preimenujte stavku",
Analyst,Analitičar,
Analytics,Analitika,
Annual Billing: {0},Godišnja naplata: {0},
Annual Salary,Godišnja plata,
Anonymous,Anonimno,
Another Budget record '{0}' already exists against {1} '{2}' and account '{3}' for fiscal year {4},Još jedan proračunski zapis &quot;{0}&quot; već postoji za {1} &#39;{2}&#39; i račun &#39;{3}&#39; za fiskalnu godinu {4},
Another Period Closing Entry {0} has been made after {1},Drugi unos zatvaranja perioda {0} je izvršen nakon {1},
Another Sales Person {0} exists with the same Employee id,Druga prodajna osoba {0} postoji s istim ID-om zaposlenika,
Antibiotic,Antibiotik,
Apparel & Accessories,Apparel &amp; Accessories,
"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 društvo s ograničenom odgovornošću,
Applicable if the company is an Individual or a Proprietorship,Može se primeniti ako je kompanija individualna ili vlasništvo,
Applicant,Podnosilac prijave,
Applicant Type,Tip podnosioca,
Application of Funds (Assets),Primjena sredstava (imovine),
Application period cannot be across two allocation records,Period primene ne može biti na dve evidencije o dodeli,
Application period cannot be outside leave allocation period,Period za podnošenje zahtjeva ne može biti izvan perioda dodjele dopusta,
Applied,Applied,
Apply Now,Apply Now,
Appointment Analytics,Appointment Analytics,
Appointment Confirmation,Potvrda o sastanku,
Appointment Duration (mins),Trajanje sastanka (min),
Appointment Type,Tip sastanka,
Appointment cancelled,Sastanak otkazan,
"Appointment cancelled, Please review and cancel the invoice {0}","Sastanak otkazan, pregledajte i otkažite fakturu {0}",
Appointment {0} and Sales Invoice {1} cancelled,Sastanak {0} i faktura prodaje {1} otkazana,
Appointments and Encounters,Sastanci i susreti,
Appointments and Patient Encounters,Sastanci i susreti sa pacijentima,
Appraisal {0} created for Employee {1} in the given date range,Procjena {0} kreirana za zaposlenika {1} u danom rasponu datuma,
Apprentice,Apprentice,
Approval Status must be 'Approved' or 'Rejected',Status odobrenja mora biti &quot;odobren&quot; ili &quot;odbijen&quot;,
Approve,Odobri,
Approving Role cannot be same as role the rule is Applicable To,Uloga odobravanja ne može biti ista kao uloga za koju se primenjuje pravilo,
Approving User cannot be same as user the rule is Applicable To,Odobravanje korisnika ne može biti isto što i pravilo koje se primjenjuje na,
"Apps using current key won't be able to access, are you sure?","Aplikacije koje koriste trenutni ključ neće moći pristupiti, jeste li sigurni?",
Are you sure you want to cancel this appointment?,Jeste li sigurni da želite da otkažete ovaj sastanak?,
Arrear,Arrear,
As Examiner,Kao ispitivač,
As On Date,Kao 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),Po članu 17 (5),
"As per the Buying Settings if Purchase Order Required == 'YES', then for creating Purchase Invoice, user need to create Purchase Order first for item {0}","Prema postavkama za kupovinu ako je potrebna narudžbenica == &#39;DA&#39;, onda za kreiranje fakture kupovine, korisnik treba da kreira narudžbenicu za stavku {0}",
"As per the Buying Settings if Purchase Reciept Required == 'YES', then for creating Purchase Invoice, user need to create Purchase Receipt first for item {0}","Prema postavkama za kupovinu ako je kupovina potrebna == &#39;DA&#39;, onda za kreiranje fakture kupovine, korisnik treba da kreira račun za kupovinu prvo za stavku {0}",
As per your assigned Salary Structure you cannot apply for benefits,Prema vašoj dodijeljenoj strukturi plata ne možete podnijeti zahtjev za povlastice,
Assessment,Procjena,
Assessment Criteria,Kriteriji ocjenjivanja,
Assessment Group,Grupa za procenu,
Assessment Group: ,Grupa za procenu:,
Assessment Plan,Plan procjene,
Assessment Plan Name,Naziv plana procjene,
Assessment Report,Izveštaj o proceni,
Assessment Reports,Izvještaji o procjeni,
Assessment Result,Rezultat ocjenjivanja,
Assessment Result record {0} already exists.,Zapis rezultata procjene {0} već postoji.,
Asset,Asset,
Asset Category,Kategorija imovine,
Asset Category is mandatory for Fixed Asset item,Kategorija imovine je obavezna za stavku fiksnog sredstva,
Asset Maintenance,Održavanje imovine,
Asset Movement,Pokret imovine,
Asset Movement record {0} created,Zapis pokreta snimljenog materijala {0} je kreiran,
Asset Name,Asset Name,
Asset Received But Not Billed,"Primljeno sredstvo, ali nije naplaćeno",
Asset Value Adjustment,Podešavanje vrednosti imovine,
"Asset cannot be cancelled, as it is already {0}","Sredstvo se ne može otkazati, jer je već {0}",
Asset scrapped via Journal Entry {0},Sredstvo je otpisano putem unosa dnevnika {0},
"Asset {0} cannot be scrapped, as it is already {1}","Imovina {0} ne može biti otpisana, jer je već {1}",
Asset {0} does not belong to company {1},Imovina {0} ne pripada tvrtki {1},
Asset {0} must be submitted,Imovina {0} mora biti poslata,
Assets,Imovina,
Assign,Assign,
Assign Salary Structure,Dodeli strukturu plata,
Assign to Employees,Dodeli zaposlenima,
Assigning Structures...,Dodjeljivanje struktura ...,
Associate,Associate,
At least one mode of payment is required for POS invoice.,Za POS račun je potreban najmanje jedan način plaćanja.,
Atleast one item should be entered with negative quantity in return document,Najmanje jedna stavka treba da se unese sa negativnom količinom u povratnom dokumentu,
Atleast one of the Selling or Buying must be selected,"U svakom slučaju, mora se odabrati jedna od prodaja ili kupovina",
Atleast one warehouse is mandatory,Najmanje jedno skladište je obavezno,
Attach Logo,Priloži logotip,
Attachments,Prilozi,
Attendance,Prisustvo,
Attendance From Date and Attendance To Date is mandatory,Prisustvo od datuma i prisustva do datuma je obavezno,
Attendance Record {0} exists against Student {1},Zapisnik o prisustvu {0} postoji protiv studenta {1},
Attendance can not be marked for future dates,Prisustvo ne može biti označeno za buduće datume,
Attendance date can not be less than employee's joining date,Datum prisustvovanja ne može biti manji od datuma pridruživanja zaposlenog,
Attendance for employee {0} is already marked,Pohađanje zaposlenika {0} je već označeno,
Attendance for employee {0} is already marked for this day,Pohađanje zaposlenika {0} već je označeno za ovaj dan,
Attendance has been marked successfully.,Prisustvo je uspešno obeleženo.,
Attendance not submitted for {0} as it is a Holiday.,Pohađanje nije predato za {0} jer je to praznik.,
Attendance not submitted for {0} as {1} on leave.,Prisustvovanje nije predato za {0} kao {1} na odsustvu.,
Attribute table is mandatory,Tablica atributa je obavezna,
Attribute {0} selected multiple times in Attributes Table,Atribut {0} je izabran više puta u tabeli atributa,
Authorized Signatory,Ovlašteni potpisnik,
Auto Material Requests Generated,Generisano automatsko traženje materijala,
Auto repeat document updated,Ažuriran je automatski dokument,
Automotive,Automotive,
Available,Dostupno,
Available Leaves,Available Leaves,
Available Qty,Available Qty,
Available Selling,Available Selling,
Available for use date is required,Potreban je datum raspoloživ za upotrebu,
Available slots,Dostupni slotovi,
Available {0},Dostupno {0},
Available-for-use Date should be after purchase date,Datum dostupnosti za upotrebu treba da bude nakon datuma kupovine,
Average Age,Prosečno doba,
Average Rate,Average Rate,
Avg Daily Outgoing,Avg Daily Outgoing,
Avg. Buying Price List Rate,Avg. Kupovna cijena,
Avg. Selling Price List Rate,Avg. Stopa prodajne cijene,
Avg. Selling Rate,Avg. Stopa prodaje,
BOM,BOM,
BOM #{0}: Raw material cannot be same as main Item,BOM # {0}: Sirovina ne može biti ista kao glavna stavka,
BOM Browser,BOM Browser,
BOM No,BOM br,
BOM Rate,BOM Rate,
BOM Stock Report,BOM Stock Report,
BOM and Manufacturing Quantity are required,Potrebna je sastavnica i količina proizvodnje,
BOM does not contain any stock item,Sastav ne sadrži nijednu stavku zaliha,
BOM {0} does not belong to Item {1},BOM {0} ne pripada stavci {1},
BOM {0} must be active,BOM {0} mora biti aktivan,
BOM {0} must be submitted,BOM {0} mora biti dostavljen,
Balance,Balans,
Balance (Dr - Cr),Balans (Dr - Cr),
Balance ({0}),Stanje ({0}),
Balance Qty,Balance Qty,
Balance Sheet,Bilans,
Balance Value,Balance Value,
Balance for Account {0} must always be {1},Stanje za račun {0} mora uvijek biti {1},
Bank,Bank,
Bank Account,Bankovni račun,
Bank Accounts,Bankovni računi,
Bank Draft,Bank Draft,
Bank Entries,Bank Entries,
Bank Name,Ime banke,
Bank Overdraft Account,Račun prekoračenja banaka,
Bank Reconciliation,Bankovno pomirenje,
Bank Reconciliation Statement,Izjava o pomirenju banke,
Bank Statement,Izjava banke,
Bank Statement Settings,Postavke bankovnog izvoda,
Bank Statement balance as per General Ledger,Bilans bankovnog izvoda prema glavnoj knjizi,
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,Banke / Gotovinske transakcije protiv stranke ili za interni transfer,
Banking,Bankarstvo,
Banking and Payments,Bankarstvo i plaćanja,
Barcode {0} already used in Item {1},Barkod {0} koji se već koristi u stavci {1},
Barcode {0} is not a valid {1} code,Barkod {0} nije važeći {1} kôd,
Base,Base,
Based On,Based On,
Based On Payment Terms,Na osnovu uslova plaćanja,
Basic,Basic,
Batch,Batch,
Batch Entries,Batch Entries,
Batch ID is mandatory,ID serije je obavezan,
Batch Inventory,Batch Inventory,
Batch Name,Naziv serije,
Batch No,Serijski br,
Batch number is mandatory for Item {0},Broj serije je obavezan za stavku {0},
Batch {0} of Item {1} has expired.,Serija {0} stavke {1} je istekla.,
Batch {0} of Item {1} is disabled.,Paket {0} stavke {1} je onemogućen.,
Batch: ,Batch:,
Batches,Serije,
Become a Seller,Postanite prodavac,
Bill,Bill,
Bill Date,Datum naplate,
Bill No,Bill No,
Bill of Materials,Bill of Materials,
Bill of Materials (BOM),Sastavnica (BOM),
Billable Hours,Billable Hours,
Billed,Naplaćeno,
Billed Amount,Iznos naplate,
Billing,Naplata,
Billing Address,Adresa računa,
Billing Address is same as Shipping Address,Adresa za naplatu je ista kao i adresa za dostavu,
Billing Amount,Iznos naplate,
Billing Status,Status naplate,
Billing currency must be equal to either default company's currency or party account currency,Valuta za naplatu mora biti jednaka ili zadanoj valuti kompanije ili valuti stranaka računa,
Bills raised by Suppliers.,Računi koje podnose dobavljači.,
Bills raised to Customers.,Računi podignuti kupcima.,
Biotechnology,Biotechnology,
Birthday Reminder,Podsetnik za rođendan,
Black,Crna,
Blanket Orders from Costumers.,Narudžbenice od kupaca.,
Block Invoice,Blokiranje fakture,
Boms,Boms,
Bonus Payment Date cannot be a past date,Datum isplate bonusa ne može biti prošli datum,
Both Trial Period Start Date and Trial Period End Date must be set,Moraju se postaviti i početni datum probnog perioda i datum završetka probnog perioda,
Both Warehouse must belong to same Company,Oba skladišta moraju pripadati istoj kompaniji,
Branch,Branch,
Broadcasting,Broadcasting,
Brokerage,Brokerage,
Browse BOM,Browse BOM,
Budget Against,Budget Against,
Budget List,Spisak budžeta,
Budget Variance Report,Izvještaj o odstupanju budžeta,
Budget cannot be assigned against Group Account {0},Budžet ne može biti dodijeljen grupi računa {0},
"Budget cannot be assigned against {0}, as it's not an Income or Expense account","Budžet se ne može dodijeliti protiv {0}, jer to nije račun prihoda ili rashoda",
Buildings,Zgrade,
Bundle items at time of sale.,U paketu stavke u vrijeme prodaje.,
Business Development Manager,Menadžer za razvoj poslovanja,
Buy,Buy,
Buying,Kupovina,
Buying Amount,Kupovni iznos,
Buying Price List,Kupovina cjenika,
Buying Rate,Buying Rate,
"Buying must be checked, if Applicable For is selected as {0}","Kupnja mora biti provjerena, ako je Primjenjivo za odabrano kao {0}",
By {0},Do {0},
Bypass credit check at Sales Order ,Zaobiđite provjeru kredita kod prodajnog naloga,
C-Form records,Zapisi C-Forma,
C-form is not applicable for Invoice: {0},C-obrazac nije primjenjiv za fakturu: {0},
CEO,CEO,
CESS Amount,CESS iznos,
CGST Amount,CGST Iznos,
CRM,CRM,
CWIP Account,CWIP račun,
Calculated Bank Statement balance,Izračunati bilans stanja na računu,
Calls,Pozivi,
Campaign,Kampanja,
Can be approved by {0},Može biti odobren od strane {0},
"Can not filter based on Account, if grouped by Account","Nije moguće filtrirati na osnovu računa, ako je grupisano po računu",
"Can not filter based on Voucher No, if grouped by Voucher","Ne može se filtrirati na osnovu No vaučera, ako je grupisano po vaučeru",
"Can not mark Inpatient Record Discharged, there are Unbilled Invoices {0}","Ne može da se označi ispražnjena bolnička evidencija, postoje neobračunate fakture {0}",
Can only make payment against unbilled {0},Moguće je izvršiti plaćanje samo za neplaćene {0},
Can refer row only if the charge type is 'On Previous Row Amount' or 'Previous Row Total',Može uputiti redak samo ako je tip naplate &quot;Na prethodni redak iznos&quot; ili &quot;Prethodni redak ukupno&quot;,
"Can't change valuation method, as there are transactions against some items which does not have it's own valuation method","Ne može se mijenjati metoda vrednovanja, jer postoje transakcije protiv nekih stavki koje nemaju vlastiti metod procjene",
Can't create standard criteria. Please rename the criteria,Ne mogu da kreiram standardne kriterijume. Molimo preimenujte kriterije,
Cancel,Odustani,
Cancel Material Visit {0} before cancelling this Warranty Claim,Otkazivanje materijala Posetite {0} pre otkazivanja ovog zahteva za garanciju,
Cancel Material Visits {0} before cancelling this Maintenance Visit,Otkazivanje materijala Posjeta {0} prije otkazivanja ove posjete održavanja,
Cancel Subscription,Otkaži pretplatu,
Cancel the journal entry {0} first,Prvo poništite stavku dnevnika {0},
Canceled,Otkazano,
"Cannot Submit, Employees left to mark attendance","Ne može se poslati, Zaposlenici su ostavljeni da obilježe prisustvo",
Cannot be a fixed asset item as Stock Ledger is created.,Ne može biti fiksna stavka stavke kada je kreirana Stock Ledger.,
Cannot cancel because submitted Stock Entry {0} exists,Ne može se otkazati jer postoji poslata stavka za unos dionica {0},
Cannot cancel transaction for Completed Work Order.,Ne može se otkazati transakcija za Kompletiran radni nalog.,
Cannot cancel {0} {1} because Serial No {2} does not belong to the warehouse {3},Nije moguće otkazati {0} {1} jer serijski broj {2} ne pripada skladištu {3},
Cannot change Attributes after stock transaction. Make a new Item and transfer stock to the new Item,Nije moguće promijeniti atribute nakon transakcije dionica. Napravite novu stavku i prenesite zalihe u novu stavku,
Cannot change Fiscal Year Start Date and Fiscal Year End Date once the Fiscal Year is saved.,Nije moguće promijeniti datum početka fiskalne godine i datum završetka fiskalne godine nakon spremanja fiskalne godine.,
Cannot change Service Stop Date for item in row {0},Nije moguće promijeniti Service Stop Date 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 promijeniti svojstva varijante nakon transakcije dionica. Morat ćete napraviti novu stavku da biste to učinili.,
"Cannot change company's default currency, because there are existing transactions. Transactions must be cancelled to change the default currency.","Nije moguće promijeniti zadanu valutu tvrtke, jer postoje postojeće transakcije. Transakcije moraju biti otkazane da biste promenili podrazumevanu valutu.",
Cannot change status as student {0} is linked with student application {1},Nije moguće promijeniti status studenta {0} je povezan sa prijavom učenika {1},
Cannot convert Cost Center to ledger as it has child nodes,Nije moguće pretvoriti Centar troška u knjigu jer ima dječje čvorove,
Cannot covert to Group because Account Type is selected.,Nije moguće preći u grupu jer je izabran tip naloga.,
Cannot create Retention Bonus for left Employees,Ne može se stvoriti bonus za zadržavanje za lijeve zaposlenike,
Cannot create a Delivery Trip from Draft documents.,Nije moguće kreirati put isporuke iz nacrta dokumenata.,
Cannot deactivate or cancel BOM as it is linked with other BOMs,BOM nije moguće deaktivirati ili otkazati jer je povezan s drugim sastavnicama,
"Cannot declare as lost, because Quotation has been made.",Ne može se proglasiti izgubljenim jer je napravljena kotacija.,
Cannot deduct when category is for 'Valuation' or 'Valuation and Total',Ne može se odbiti kada je kategorija za &#39;Vrednovanje&#39; ili &#39;Vrednovanje i Ukupno&#39;,
Cannot deduct when category is for 'Valuation' or 'Vaulation and Total',Ne može se odbiti kada je kategorija za &#39;Vrednovanje&#39; ili &#39;Vaulation i Total&#39;,
"Cannot delete Serial No {0}, as it is used in stock transactions","Nije moguće obrisati serijski broj {0}, jer se koristi u transakcijama sa zalihama",
Cannot enroll more than {0} students for this student group.,Ne može se upisati više od {0} učenika za ovu studentsku grupu.,
Cannot find Item with this barcode,Nije moguće pronaći stavku sa ovim barkodom,
Cannot find active Leave Period,Nije moguće pronaći aktivni period odlaska,
Cannot produce more Item {0} than Sales Order quantity {1},Nije moguće proizvesti više stavke {0} nego količina narudžbenice {1},
Cannot promote Employee with status Left,Nije moguće promovirati zaposlenika sa statusom lijevo,
Cannot refer row number greater than or equal to current row number for this Charge type,Ne može se pozvati broj reda veći ili jednak broju tekućeg reda za ovaj tip naplate,
Cannot select charge type as 'On Previous Row Amount' or 'On Previous Row Total' for first row,Nije moguće izabrati vrstu naplate kao &quot;Na prethodni iznos reda&quot; ili &quot;Na prethodni redak ukupno&quot; za prvi red,
Cannot set a received RFQ to No Quote,Nije moguće podesiti primljeni RFQ na No Quote,
Cannot set as Lost as Sales Order is made.,Nije moguće postaviti kao Izgubljeno kao prodajni nalog.,
Cannot set authorization on basis of Discount for {0},Nije moguće postaviti ovlaštenje na temelju Popusta za {0},
Cannot set multiple Item Defaults for a company.,Nije moguće postaviti višestruke zadane postavke za tvrtku.,
Cannot set quantity less than delivered quantity,Nije moguće postaviti količinu manju od isporučene količine,
Cannot set quantity less than received quantity,Nije moguće postaviti količinu manju od primljene količine,
Cannot set the field <b>{0}</b> for copying in variants,Nije moguće postaviti polje <b>{0}</b> za kopiranje u varijantama,
Cannot transfer Employee with status Left,Nije moguće prenijeti zaposlenika sa statusom lijevo,
Cannot {0} {1} {2} without any negative outstanding invoice,Nije moguće {0} {1} {2} bez negativne nepodmirene fakture,
Capital Equipments,Kapitalna oprema,
Capital Stock,Capital Stock,
Capital Work in Progress,Kapitalni rad u toku,
Cart,Cart,
Cart is Empty,Košarica je prazna,
Case No(s) already in use. Try from Case No {0},Broj predmeta koji se već koriste. Pokušajte iz Case No {0},
Cash,Gotovina,
Cash Flow Statement,Izvještaj o novčanom toku,
Cash Flow from Financing,Novčani tok iz finansiranja,
Cash Flow from Investing,Novčani tok od ulaganja,
Cash Flow from Operations,Novčani tok iz poslovanja,
Cash In Hand,Cash In Hand,
Cash or Bank Account is mandatory for making payment entry,Novac ili bankovni račun je obavezan za uplatu,
Cashier Closing,Zatvaranje blagajnika,
Casual Leave,Casual Leave,
Caution,Oprez,
Central Tax,Central Tax,
Certification,Certifikat,
Cess,Cess,
Change Amount,Change Amount,
Change Code,Promijeni kod,
Change Item Code,Promijenite šifru artikla,
Change POS Profile,Promijenite POS profil,
Change Release Date,Promijeni datum izdavanja,
Change Template Code,Promijenite šifru predloška,
Changing Customer Group for the selected Customer is not allowed.,Promjena grupe korisnika za odabranog kupca nije dopuštena.,
Chapter,Poglavlje,
Chapter information.,Informacije o poglavlju.,
Charge of type 'Actual' in row {0} cannot be included in Item Rate,Naknada tipa &#39;Actual&#39; u redu {0} ne može biti uključena u stavku Rate Rate,
Chargeble,Chargeble,
Charges are updated in Purchase Receipt against each item,Troškovi se ažuriraju u Potvrdi kupovine za svaku stavku,
"Charges will be distributed proportionately based on item qty or amount, as per your selection","Troškovi će biti distribuirani proporcionalno na osnovu količine ili iznosa stavke, prema vašem izboru",
Chart Of Accounts,Chart of Accounts,
Chart of Cost Centers,Grafikon centara troškova,
Check all,Provjeri sve,
Checkout,Provjeri,
Chemical,Hemijski,
Cheque,Provjeri,
Cheque/Reference No,Provjera / referenca br,
Cheques Required,Potrebni čekovi,
Cheques and Deposits incorrectly cleared,Provjere i depoziti su pogrešno izbrisani,
Child Item should not be a Product Bundle. Please remove item `{0}` and save,Child Item ne bi trebao biti skup proizvoda. Molimo uklonite stavku `{0}` i spremite,
Child Task exists for this Task. You can not delete this Task.,Zadatak djeteta postoji za ovaj zadatak. Ovaj zadatak ne možete izbrisati.,
Child nodes can be only created under 'Group' type nodes,Dječji čvorovi mogu biti kreirani samo pod čvorovima tipa &#39;Grupa&#39;,
Child warehouse exists for this warehouse. You can not delete this warehouse.,Za ovo skladište postoji dječje skladište. Ne možete izbrisati ovo skladište.,
Circular Reference Error,Kružna referentna greška,
City,Grad,
City/Town,Grad / mjesto,
Claimed Amount,Potraženi iznos,
Clay,Clay,
Clear filters,Obriši filtere,
Clear values,Clear values,
Clearance Date,Datum odobrenja,
Clearance Date not mentioned,Datum odobrenja nije naveden,
Clearance Date updated,Datum odobrenja je ažuriran,
Clinical Procedure,Klinički postupak,
Clinical Procedure Template,Obrazac kliničkog postupka,
Close Balance Sheet and book Profit or Loss.,Zatvorite bilans stanja i rezervišite dobit ili gubitak.,
Close Loan,Close Loan,
Close the POS,Zatvorite POS,
Closed,Zatvoreno,
Closed order cannot be cancelled. Unclose to cancel.,Zatvorena narudžba se ne može otkazati. Zatvorite da biste otkazali.,
Closing (Cr),Zatvaranje (Cr),
Closing (Dr),Zatvaranje (Dr),
Closing (Opening + Total),Zatvaranje (otvaranje + ukupno),
Closing Account {0} must be of type Liability / Equity,Završni račun {0} mora biti tipa Liability / Equity,
Closing Balance,Završni bilans,
Code {0} already exist,Kod {0} već postoji,
Collapse All,Skupi sve,
Colour,Boja,
Combined invoice portion must equal 100%,Dio kombinirane fakture mora biti jednak 100%,
Commercial,Komercijalno,
Commission,Komisija,
Commission Rate %,Stopa provizije%,
Commission on Sales,Komisija za prodaju,
Commission rate cannot be greater than 100,Stopa Komisije ne može biti veća od 100,
Community Forum,Community Forum,
Company (not Customer or Supplier) master.,Preduzeće (ne kupac ili dobavljač).,
Company Abbreviation,Skraćenica kompanije,
Company Abbreviation cannot have more than 5 characters,Skraćenica kompanije ne može imati više od 5 znakova,
Company Name,Ime kompanije,
Company Name cannot be Company,Naziv kompanije ne može biti Kompanija,
Company currencies of both the companies should match for Inter Company Transactions.,Valute kompanija oba preduzeća treba da se podudaraju za transakcije između kompanija.,
Company is manadatory for company account,Kompanija je podređena računu kompanije,
Company name not same,Ime kompanije nije isto,
Company {0} does not exist,Kompanija {0} ne postoji,
"Company, Payment Account, From Date and To Date is mandatory","Preduzeće, račun za plaćanje, datum i datum je obavezno",
Compensatory Off,Compensatory Off,
Compensatory leave request days not in valid holidays,Zahtjev za kompenzacijsko odsustvo nije važeći,
Complaint,Žalba,
Completed Qty can not be greater than 'Qty to Manufacture',Završena količina ne može biti veća od &#39;Količina za proizvodnju&#39;,
Completion Date,datum završetka,
Computer,Computer,
Configure,Configure,
"Configure Item Fields like UOM, Item Group, Description and No of Hours.","Konfigurišite polja stavki kao što su UOM, Grupa predmeta, Opis i broj sati.",
Configure {0},Konfiguriraj {0},
Confirmed orders from Customers.,Potvrđene narudžbe od kupaca.,
Connect Amazon with ERPNext,Povežite Amazon sa ERPNext,
Connect Shopify with ERPNext,Povežite Shopify sa ERPNext,
Connect to Quickbooks,Povežite se s QuickBook-ovima,
Connected to QuickBooks,Povezan na QuickBooks,
Connecting to QuickBooks,Povezivanje na QuickBooks,
Consultation,Konsultacije,
Consultations,Konsultacije,
Consulting,Consulting,
Consumable,Potrošni,
Consumed,Consumed,
Consumed Amount,Potrošeni iznos,
Consumed Qty,Potrošena količina,
Consumer Products,Consumer Products,
Contact Number,Kontakt broj,
Contact Us,Kontaktiraj nas,
Content Masters,Masters sadržaja,
Continue Configuration,Nastavi konfiguraciju,
Contract,Ugovor,
Contract End Date must be greater than Date of Joining,Datum završetka ugovora mora biti veći od datuma pridruživanja,
Contribution %,Doprinos%,
Contribution Amount,Iznos doprinosa,
Conversion factor for default Unit of Measure must be 1 in row {0},Faktor konverzije za zadanu jedinicu mjere mora biti 1 u redu {0},
Conversion rate cannot be 0 or 1,Stopa konverzije ne može biti 0 ili 1,
Convert to Group,Pretvori u grupu,
Convert to Non-Group,Pretvori u ne-grupu,
Cosmetics,Kozmetika,
Cost Center,Centar troškova,
Cost Center Number,Broj mjesta troška,
Cost Center and Budgeting,Centar troškova i budžetiranje,
Cost Center is required in row {0} in Taxes table for type {1},Centar troškova je potreban u redu {0} u tabeli Porezi za tip {1},
Cost Center with existing transactions can not be converted to group,Centar troškova s postojećim transakcijama ne može se pretvoriti u grupu,
Cost Center with existing transactions can not be converted to ledger,Centar troškova s postojećim transakcijama ne može se pretvoriti u knjigu,
Cost Centers,Centri troškova,
Cost Updated,Cost Updated,
Cost as on,Cost as on,
Cost center is required to book an expense claim,Mjesto troška je potrebno za knjiženje troškova potraživanja,
Cost of Delivered Items,Troškovi isporučenih artikala,
Cost of Goods Sold,Troškovi prodane robe,
Cost of Issued Items,Troškovi izdatih artikala,
Cost of New Purchase,Troškovi nove kupovine,
Cost of Purchased Items,Troškovi kupljenih artikala,
Cost of Scrapped Asset,Troškovi rashodovane imovine,
Cost of Sold Asset,Trošak prodate imovine,
Cost of various activities,Troškovi različitih aktivnosti,
"Could not create Credit Note automatically, please uncheck 'Issue Credit Note' and submit again","Automatsko kreiranje kreditne beleške nije moguće, uklonite kvačicu iz &quot;Napomena o izdavanju kredita&quot; i pošaljite ponovo",
Could not generate Secret,Nije moguće generisati tajnu,
Could not retrieve information for {0}.,Nije moguće dohvatiti informacije za {0}.,
Could not solve criteria score function for {0}. Make sure the formula is valid.,Nije moguće riješiti funkciju ocjene kriterija za {0}. Proverite da li je formula validna.,
Could not solve weighted score function. Make sure the formula is valid.,Nije moguće riješiti funkciju vaganja. Proverite da li je formula validna.,
Could not submit some Salary Slips,Nisam mogao da podnesem neke plate,
"Could not update stock, invoice contains drop shipping item.","Nije moguće ažurirati zalihe, faktura sadrži pošiljku za isporuku.",
Country wise default Address Templates,Podrazumevani predlošci adresa za zemlju,
Course,Kurs,
Course Code: ,Šifra predmeta:,
Course Enrollment {0} does not exists,Upis na kurs {0} ne postoji,
Course Schedule,Raspored kursa,
Course: ,Kurs:,
Cr,Cr,
Create,Stvoriti,
Create BOM,Napravite BOM,
Create Delivery Trip,Napravite put isporuke,
Create Disbursement Entry,Kreirajte unos isplate,
Create Employee,Create Employee,
Create Employee Records,Napravite evidenciju zaposlenika,
"Create Employee records to manage leaves, expense claims and payroll","Kreirajte evidenciju zaposlenika za upravljanje lišćem, potraživanjima troškova i platnim spiskom",
Create Fee Schedule,Napravite raspored naknada,
Create Fees,Create Fees,
Create Inter Company Journal Entry,Kreirajte inter unos dnevnika,
Create Invoice,Napravite fakturu,
Create Invoices,Napravite fakture,
Create Job Card,Napravite radnu karticu,
Create Journal Entry,Kreirajte unos dnevnika,
Create Lab Test,Napravite laboratorijski test,
Create Lead,Create Lead,
Create Leads,Create Leads,
Create Maintenance Visit,Kreirajte posjetu za održavanje,
Create Material Request,Kreirajte zahtev za materijal,
Create Multiple,Napravite više,
Create Opening Sales and Purchase Invoices,Napravite otvaranje faktura prodaje i kupovine,
Create Payment Entries,Kreirajte unose za plaćanje,
Create Payment Entry,Kreirajte unos plaćanja,
Create Print Format,Kreirajte format za štampanje,
Create Purchase Order,Napravite narudžbenicu,
Create Purchase Orders,Kreirajte narudžbenice,
Create Quotation,Napravite ponudu,
Create Salary Slip,Napravite ispis plata,
Create Salary Slips,Napravite isplate plata,
Create Sales Invoice,Kreirajte fakturu prodaje,
Create Sales Order,Kreirajte prodajni nalog,
Create Sales Orders to help you plan your work and deliver on-time,Napravite narudžbe za prodaju kako biste lakše planirali svoj rad i isporučili ga na vrijeme,
Create Sample Retention Stock Entry,Napravite unos zaliha uzorka,
Create Student,Kreirajte Student,
Create Student Batch,Kreirajte studentsku seriju,
Create Student Groups,Kreirajte grupe studenata,
Create Supplier Quotation,Kreirajte ponudu dobavljača,
Create Tax Template,Napravite šablon poreza,
Create Timesheet,Create Timesheet,
Create User,Kreiranje korisnika,
Create Users,Create Users,
Create Variant,Napravite varijantu,
Create Variants,Create Varijante,
Create a new Customer,Kreirajte novog korisnika,
"Create and manage daily, weekly and monthly email digests.","Kreirajte i upravljajte dnevnim, nedeljnim i mesečnim pregledima e-pošte.",
Create customer quotes,Kreirajte ponude za kupce,
Create rules to restrict transactions based on values.,Kreirajte pravila za ograničavanje transakcija na osnovu vrijednosti.,
Created {0} scorecards for {1} between: ,Napravljeno je {0} kartica rezultata za {1} između:,
Creating Company and Importing Chart of Accounts,Kreiranje kompanijskog i uvoznog kontnog plana,
Creating Fees,Creating Fees,
Creating Payment Entries......,Kreiranje unosa za plaćanje ......,
Creating Salary Slips...,Kreiranje isplata plata ...,
Creating student groups,Kreiranje studentskih grupa,
Creating {0} Invoice,Kreiranje {0} fakture,
Credit,Kredit,
Credit ({0}),Kredit ({0}),
Credit Account,Kreditni račun,
Credit Balance,Stanje kredita,
Credit Card,Kreditna kartica,
Credit Days cannot be a negative number,Dani kredita ne mogu biti negativni brojevi,
Credit Limit,Kreditni limit,
Credit Note,Napomena o kreditu,
Credit Note Amount,Iznos kredita,
Credit Note Issued,Kreditna oznaka izdata,
Credit Note {0} has been created automatically,Kreditna bilješka {0} je kreirana automatski,
Credit To account must be a Balance Sheet account,Kredit Za račun mora biti račun stanja,
Credit To account must be a Payable account,Kredit na račun mora biti račun za plaćanje,
Credit limit has been crossed for customer {0} ({1}/{2}),Prekoračen je kreditni limit za klijenta {0} ({1} / {2}),
Creditors,Kreditori,
Criteria weights must add up to 100%,Utezi kriterijuma moraju biti 100%,
Crop Cycle,Crop Cycle,
Crops & Lands,Crops &amp; Lands,
Currency Exchange must be applicable for Buying or for Selling.,Mjenjačnica mora biti primjenjiva za kupovinu ili prodaju.,
Currency can not be changed after making entries using some other currency,Valuta se ne može mijenjati nakon unosa neke druge valute,
Currency exchange rate master.,Master deviznog kursa.,
Currency for {0} must be {1},Valuta za {0} mora biti {1},
Currency is required for Price List {0},Valuta je potrebna za Cjenovnik {0},
Currency of the Closing Account must be {0},Valuta završnog 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 mora biti ista kao i cjenovnik: {0},
Current,Current,
Current Assets,Tekuća imovina,
Current BOM and New BOM can not be same,Trenutni BOM i New BOM ne mogu biti isti,
Current Job Openings,Current Job Openings,
Current Liabilities,Tekuće obaveze,
Current Odometer reading entered should be greater than initial Vehicle Odometer {0},Uneseno trenutno očitavanje odometra treba da bude veće od početnog kilometrača vozila {0},
Current Qty,Current Qty,
Current invoice {0} is missing,Nedostaje trenutna faktura {0},
Customer,Kupac,
Customer Addresses And Contacts,Adrese i kontakti kupaca,
Customer Contact,Kontakt sa kupcima,
Customer Database.,Baza podataka klijenata.,
Customer Group,Customer Group,
Customer Group is Required in POS Profile,Korisnička grupa je potrebna u POS profilu,
Customer LPO,Customer LPO,
Customer LPO No.,Korisnički LPO broj,
Customer Name,Ime korisnika,
Customer POS Id,ID POS klijenta,
Customer Service,Korisnička podrška,
Customer and Supplier,Kupac i dobavljač,
Customer is required,Korisnik je obavezan,
Customer isn't enrolled in any Loyalty Program,Korisnik nije uključen u bilo koji program lojalnosti,
Customer required for 'Customerwise Discount',Korisnik potreban za &#39;Customerwise Discount&#39;,
Customer {0} does not belong to project {1},Korisnik {0} ne pripada projektu {1},
Customer {0} is created.,Korisnik {0} je kreiran.,
Customers in Queue,Kupci u redu,
Customize Homepage Sections,Prilagodite odjeljke početne stranice,
Customizing Forms,Prilagođavanje obrazaca,
Daily Project Summary for {0},Dnevni sažetak projekta za {0},
Daily Reminders,Daily Reminders,
Daily Work Summary,Dnevni pregled rada,
Daily Work Summary Group,Dnevna grupa za pregled rada,
Data Import and Export,Uvoz i izvoz podataka,
Data Import and Settings,Uvoz podataka i postavke,
Database of potential customers.,Baza potencijalnih kupaca.,
Date Of Retirement must be greater than Date of Joining,Datum odlaska u penziju mora biti veći od datuma pridruživanja,
Date is repeated,Datum se ponavlja,
Date of Birth,Datum rođenja,
Date of Birth cannot be greater than today.,Datum rođenja ne može biti veći od danas.,
Date of Commencement should be greater than Date of Incorporation,Datum početka treba da bude veći od datuma osnivanja,
Date of Joining,Datum pridruživanja,
Date of Joining must be greater than Date of Birth,Datum pridruživanja mora biti veći od datuma rođenja,
Date of Transaction,Datum transakcije,
Debit,Debit,
Debit ({0}),Zaduženje ({0}),
Debit A/C Number,Debitni A / C broj,
Debit Account,Debit račun,
Debit Note,Debit Note,
Debit Note Amount,Iznos duga,
Debit Note Issued,Izdata je zadužnica,
Debit To account must be a Balance Sheet account,Zaduženje Račun mora biti račun računa,
Debit To account must be a Receivable account,Zaduženje Račun mora biti račun potraživanja,
Debit To is required,Obavezno je zaduženje,
Debit and Credit not equal for {0} #{1}. Difference is {2}.,Debit i Kredit nisu jednaki za {0} # {1}. Razlika je {2}.,
Debtors,Dužnici,
Debtors ({0}),Dužnici ({0}),
Declare Lost,Declare Lost,
Deduction,Odbijanje,
Default Activity Cost exists for Activity Type - {0},Osnovni trošak aktivnosti postoji za vrstu aktivnosti - {0},
Default BOM ({0}) must be active for this item or its template,Zadana BOM ({0}) mora biti aktivna za ovu stavku ili njen predložak,
Default BOM for {0} not found,Default BOM za {0} nije pronađen,
Default BOM not found for Item {0} and Project {1},Zadana BOM nije pronađena za stavku {0} i Project {1},
Default Tax Template,Default Tax Template,
Default Unit of Measure for Item {0} cannot be changed directly because you have already made some transaction(s) with another UOM. You will need to create a new Item to use a different Default UOM.,Podrazumevana jedinica mjere za stavku {0} ne može se direktno promijeniti jer ste već izvršili neku transakciju s drugom UOM-om. Potrebno je da kreirate novu stavku da biste koristili različitu Default UOM.,
Default Unit of Measure for Variant '{0}' must be same as in Template '{1}',Zadana jedinica mjere za varijantu &#39;{0}&#39; mora biti ista kao u predlošku &#39;{1}&#39;,
Default settings for buying transactions.,Podrazumevana podešavanja za kupovinu transakcija.,
Default settings for selling transactions.,Podrazumevane postavke za transakcije prodaje.,
Default tax templates for sales and purchase are created.,Kreirani su predlošci poreza za prodaju i kupnju.,
Default warehouse is required for selected item,Podrazumevano skladište je potrebno za odabranu stavku,
Defense,Odbrana,
Define Project type.,Definirajte tip projekta.,
Define budget for a financial year.,Definišite budžet za finansijsku godinu.,
Define various loan types,Definišite različite vrste kredita,
Del,Del,
Delay in payment (Days),Odlaganje plaćanja (Dani),
Delete all the Transactions for this Company,Obrišite sve transakcije za ovu kompaniju,
Delete permanently?,Želite li trajno izbrisati?,
Deletion is not permitted for country {0},Brisanje nije dopušteno za zemlju {0},
Delivered,Isporučeno,
Delivered Amount,Isporučeni iznos,
Delivered Qty,Delivered Qty,
Delivered: {0},Isporučeno: {0},
Delivery,Dostava,
Delivery Date,Datum dostave,
Delivery Note,Napomena o isporuci,
Delivery Note {0} is not submitted,Napomena za isporuku {0} nije poslata,
Delivery Note {0} must not be submitted,Napomena za isporuku {0} ne smije biti poslana,
Delivery Notes {0} must be cancelled before cancelling this Sales Order,Napomene o isporuci {0} moraju biti otkazane prije otkazivanja ovog prodajnog naloga,
Delivery Notes {0} updated,Napomene o isporuci {0} su ažurirane,
Delivery Status,Status isporuke,
Delivery Trip,Trip Trip,
Delivery warehouse required for stock item {0},Potrebno skladište dostave za stavku zaliha {0},
Department,Department,
Department Stores,Robne kuće,
Depreciation,Amortizacija,
Depreciation Amount,Amortizacija Iznos,
Depreciation Amount during the period,Amortizacija Iznos tokom perioda,
Depreciation Date,Datum amortizacije,
Depreciation Eliminated due to disposal of assets,Amortizacija se otpisuje zbog otuđenja imovine,
Depreciation Entry,Unos amortizacije,
Depreciation Method,Metoda amortizacije,
Depreciation Row {0}: Depreciation Start Date is entered as past date,Redosled amortizacije {0}: Početni datum amortizacije se unosi kao datum prethodnog datuma,
Depreciation Row {0}: Expected value after useful life must be greater than or equal to {1},Redosled amortizacije {0}: Očekivana vrednost nakon korisnog veka mora biti veća ili jednaka {1},
Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,Redoslijed amortizacije {0}: Sljedeći datum amortizacije ne može biti prije datuma dostupnosti za upotrebu,
Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,Redoslijed amortizacije {0}: Sljedeći datum amortizacije ne može biti prije datuma kupovine,
Designer,Dizajner,
Detailed Reason,Detaljan razlog,
Details,Detalji,
Details of Outward Supplies and inward supplies liable to reverse charge,Detalji o spoljnim snabdevanjima i unutrašnjim snabdevanjima koja podležu obrnutoj naplati,
Details of the operations carried out.,Pojedinosti o izvršenim operacijama.,
Diagnosis,Dijagnoza,
Did not find any item called {0},Nije pronađena nijedna stavka 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","Račun različitosti mora biti račun vrste imovine / odgovornosti, budući da je ovo usklađivanje dionica uvodni unos",
Difference Amount,Iznos razlike,
Difference Amount must be zero,Razlika Iznos mora biti nula,
Different UOM for items will lead to incorrect (Total) Net Weight value. Make sure that Net Weight of each item is in the same UOM.,Različiti UOM za stavke će dovesti do netačne (ukupne) neto težine. Uvjerite se da je neto težina svake stavke u istom UOM-u.,
Direct Expenses,Direktni troškovi,
Direct Income,Direktni prihodi,
Disable,Onemogući,
Disable Template,Onemogući predložak,
Disabled template must not be default template,Onemogućeni predložak ne smije biti zadani predložak,
Disburse Loan,Kredit za isplatu,
Disbursed,Isplaceno,
Disc,Disc,
Discharge,Ispuštanje,
Discount,Popust,
Discount Percentage can be applied either against a Price List or for all Price List.,Procenat popusta se može primijeniti ili na cjenovnik ili na cjenik.,
Discount amount cannot be greater than 100%,Iznos popusta ne može biti veći od 100%,
Discount must be less than 100,Popust mora biti manji od 100,
Diseases & Fertilizers,Bolesti i đubriva,
Dispatch,Dispatch,
Dispatch Notification,Dispatch Notification,
Dispatch State,Dispatch State,
Distance,Razdaljina,
Distribution,Distribucija,
Distributor,Distributer,
Dividends Paid,Dividend Paid,
Do you really want to restore this scrapped asset?,Da li zaista želite da vratite ovu aktivnu imovinu?,
Do you really want to scrap this asset?,Da li stvarno želite da napišete ovu imovinu?,
Do you want to notify all the customers by email?,Želite li obavijestiti sve kupce putem e-pošte?,
Doc Date,Datum,
Doc Name,Naziv dokumenta,
Doc Type,Doc Type,
Docs Search,Pretraživanje dokumenata,
Document Status,Status dokumenta,
Document Type,Vrsta dokumenta,
Documentation,Dokumentacija,
Domains,Domains,
Done,Gotovo,
Donor,Donator,
Donor Type information.,Informacije o tipu donatora.,
Donor information.,Informacije o donatorima.,
Download JSON,Download JSON,
Draft,Draft,
Drop Ship,Drop Ship,
Drug,Lijek,
Due / Reference Date cannot be after {0},Datum / referentni datum ne može biti nakon {0},
Due Date cannot be before Posting / Supplier Invoice Date,Datum dospijeća ne može biti prije knjiženja / datuma fakture dobavljača,
Due Date is mandatory,Datum dospijeća je obavezan,
Duplicate Entry. Please check Authorization Rule {0},Duplicate Entry. Molimo proverite Pravilo autorizacije {0},
Duplicate Serial No entered for Item {0},Dvostruki serijski broj unesen za stavku {0},
Duplicate Tax Declaration of {0} for period {1},Duplicirana porezna deklaracija {0} za period {1},
Duplicate customer group found in the cutomer group table,Udvostručena grupa kupaca pronađena u tablici grupnih cutomera,
Duplicate entry,Duplicate entry,
Duplicate item group found in the item group table,Udvostručena grupa stavki pronađena u tablici grupe stavki,
Duplicate roll number for student {0},Duplicirani broj role za studenta {0},
Duplicate row {0} with same {1},Dvostruki 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,Dužnosti i porezi,
E-Invoicing Information Missing,Informacije o elektronskom fakturiranju nedostaju,
ERPNext Demo,ERPNext Demo,
ERPNext Settings,Postavke ERPNext,
Earliest,Najranije,
Earnest Money,Earnest Money,
Earning,Sticanje,
Edit,Uredi,
Edit Publishing Details,Uredi detalje objavljivanja,
"Edit in full page for more options like assets, serial nos, batches etc.","Uredite cijelu stranicu za više opcija kao što su sredstva, serijski brojevi, serije itd.",
Education,Obrazovanje,
Either location or employee must be required,Moraju se tražiti lokacija ili zaposlenik,
Either target qty or target amount is mandatory,Ciljna količina ili ciljni iznos je obavezan,
Either target qty or target amount is mandatory.,Ciljna količina ili ciljni iznos je obavezan.,
Electrical,Električni,
Electronic Equipments,Elektronska oprema,
Electronics,Elektronika,
Eligible ITC,Prihvatljivi ITC,
"Email Address must be unique, already exists for {0}","Adresa e-pošte mora biti jedinstvena, već postoji za {0}",
Email Digest: ,Email Digest:,
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 not found in default contact,E-pošta nije pronađena u zadanom kontaktu,
Email sent to supplier {0},E-pošta poslata dobavljaču {0},
Email sent to {0},E-pošta poslana na {0},
Employee,Zaposleni,
Employee A/C Number,Broj A / C zaposlenika,
Employee Advances,Predujmi zaposlenika,
Employee Benefits,Benefits za zaposlene,
Employee Grade,Ocjena 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 podnijeti prije datuma promocije,
Employee Referral,Referral zaposlenika,
Employee Transfer cannot be submitted before Transfer Date ,Prenos zaposlenika ne može se podnijeti prije datuma prijenosa,
Employee cannot report to himself.,Zaposleni se ne može prijaviti sebi.,
Employee relieved on {0} must be set as 'Left',Zaposleni oslobođen od {0} mora biti postavljen kao &quot;Lijevo&quot;,
Employee status cannot be set to 'Left' as following employees are currently reporting to this employee:&nbsp;,Status zaposlenika ne može biti postavljen na &quot;Lijevo&quot; jer sljedeći zaposlenici trenutno prijavljuju ovom zaposleniku:,
Employee {0} already submited an apllication {1} for the payroll period {2},Zaposleni {0} je već poslao aplikaciju {1} za period obračuna plaća {2},
Employee {0} has already applied for {1} between {2} and {3} : ,Zaposleni {0} se već prijavio za {1} između {2} i {3}:,
Employee {0} has already applied for {1} on {2} : ,Zaposleni {0} se već prijavio za {1} dana {2}:,
Employee {0} has no maximum benefit amount,Zaposlenik {0} nema maksimalni iznos naknade,
Employee {0} is not active or does not exist,Zaposlenik {0} nije aktivan ili ne postoji,
Employee {0} is on Leave on {1},Zaposleni {0} je na ostavi na {1},
Employee {0} of grade {1} have no default leave policy,Zaposlenik {0} razreda {1} nema pravilnik o zadanom ostavljanju,
Employee {0} on Half day on {1},Zaposleni {0} na pola dana {1},
Enable,Omogući,
Enable / disable currencies.,Omogućite / onemogućite valute.,
Enable Template,Omogući predložak,
"Enabling 'Use for Shopping Cart', as Shopping Cart is enabled and there should be at least one Tax Rule for Shopping Cart","Omogućavanjem opcije &quot;Koristi za korpe za kupovinu&quot;, kada je korpa za kupovinu omogućena i treba da postoji najmanje jedno poresko pravilo za korpe za kupovinu",
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,Završna godina,
End Year cannot be before Start Year,Kraj godine ne može biti prije početka godine,
End on,End on,
End time cannot be before start time,Vrijeme završetka ne može biti prije vremena početka,
Ends On date cannot be before Next Contact Date.,Završava na datum ne može biti prije sljedećeg datuma kontakta.,
Energy,Energija,
Engineer,Inženjer,
Enough Parts to Build,Dovoljno delova za izgradnju,
Enroll,Upišite se,
Enrolling student,Upis učenika,
Enrolling students,Upis studenata,
Enter depreciation details,Unesite detalje 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 podnošenja.,
Enter the name of the bank or lending institution before submittting.,Unesite ime banke ili kreditne institucije prije podnošenja prijave.,
Enter value betweeen {0} and {1},Unesite vrijednost između {0} i {1},
Enter value must be positive,Unesite vrijednost mora biti pozitivna,
Entertainment & Leisure,Zabava i slobodno vrijeme,
Entertainment Expenses,Troškovi zabave,
Equity,Equity,
Error evaluating the criteria formula,Pogreška pri ocjeni formule kriterija,
Error in formula or condition: {0},Greška u formuli ili uslovu: {0},
Error while processing deferred accounting for {0},Pogreška pri obradi odgođenog računovodstva za {0},
Error: Not a valid id?,Greška: Nije važeći ID?,
Estimated Cost,Procjena troškova,
Evaluation,Evaluacija,
"Even if there are multiple Pricing Rules with highest priority, then following internal priorities are applied:","Čak i ako postoji više pravila za određivanje cijena s najvišim prioritetom, primjenjuju se sljedeći interni prioriteti:",
Event Location,Lokacija događaja,
Event Name,Naziv događaja,
Exchange Gain/Loss,Exchange Gain / Loss,
Exchange Rate Revaluation master.,Master revalorizacije kursa.,
Exchange Rate must be same as {0} {1} ({2}),Tečaj mora biti isti kao i {0} {1} ({2}),
Excise Invoice,Akcizna faktura,
Execution,Izvršenje,
Executive Search,Executive Search,
Expand All,Expand All,
Expected Delivery Date,Očekivani datum isporuke,
Expected Delivery Date should be after Sales Order Date,Očekivani datum isporuke trebao bi biti nakon datuma prodajnog naloga,
Expected End Date,Očekivani krajnji datum,
Expected Hrs,Očekivani sati,
Expected Start Date,Očekivani datum početka,
Expense,Expense,
Expense / Difference account ({0}) must be a 'Profit or Loss' account,Račun rashoda / razlike ({0}) mora biti račun profita ili gubitka,
Expense Account,Račun troškova,
Expense Claim,Expense Claim,
Expense Claim for Vehicle Log {0},Zahtev za rashodom za dnevnik vozila {0},
Expense Claim {0} already exists for the Vehicle Log,Tvrdnja rashoda {0} već postoji za Dnevnik vozila,
Expense Claims,Troškovi potraživanja,
Expense account is mandatory for item {0},Račun troškova je obavezan za stavku {0},
Expense or Difference account is mandatory for Item {0} as it impacts overall stock value,Račun troškova ili razlike je obavezan za stavku {0} jer utječe na ukupnu vrijednost dionica,
Expenses,Troškovi,
Expenses Included In Asset Valuation,Troškovi uključeni u procjenu imovine,
Expenses Included In Valuation,Troškovi uključeni u procjenu,
Expired Batches,Istekle serije,
Expires On,Ističe na,
Expiring On,Expiring On,
Expiry (In Days),Istek (u danima),
Explore,Istražiti,
Export E-Invoices,Izvoz E-računa,
Extra Large,Ekstra veliki,
Extra Small,Extra Small,
Failed,Failed,
Failed to create website,Kreiranje web lokacije nije uspjelo,
Failed to install presets,Nije uspjelo instaliranje predpodešavanja,
Failed to login,Prijava nije uspela,
Failed to setup company,Nije uspjelo postavljanje tvrtke,
Failed to setup defaults,Nije uspjelo postavljanje zadanih postavki,
Failed to setup post company fixtures,Nije uspelo da se postave instalacije post kompanije,
Fee,Fee,
Fee Created,Fee Created,
Fee Creation Failed,Kreiranje naknade nije uspelo,
Fee Creation Pending,Stvaranje naknade na čekanju,
Fee Records Created - {0},Snimljeni troškovi - {0},
Feedback,Povratna informacija,
Fees,Naknade,
Fetch Data,Fetch Data,
Fetch Subscription Updates,Dohvati ažuriranja pretplate,
Fetch based on FIFO,Fetch na osnovu FIFO-a,
Fetch exploded BOM (including sub-assemblies),Dohvatite eksplodiranu sastavnicu (uključujući podsklopove),
Fetching records......,Dohvaćanje zapisa ......,
Fill the form and save it,Popunite obrazac i sačuvajte ga,
Filter Employees By (Optional),Filtrirajte zaposlenike prema (neobavezno),
"Filter Fields Row #{0}: Fieldname <b>{1}</b> must be of type ""Link"" or ""Table MultiSelect""",Polja filtra Red # {0}: Ime polja <b>{1}</b> mora biti tipa &quot;Link&quot; ili &quot;Table MultiSelect&quot;,
Filter Total Zero Qty,Filtrirajte ukupan broj nula,
Finance Book,Finance Book,
Financial / accounting year.,Finansijska / obračunska godina.,
Financial Services,Finansijske usluge,
Financial Statements,Finansijski izvještaji,
Financial Year,Finansijska godina,
Finish,Završi,
Finished Good,Gotovo dobro,
Finished Good Item Code,Gotova šifra artikla,
Finished Goods,Gotovih proizvoda,
Finished Item {0} must be entered for Manufacture type entry,Završena stavka {0} mora biti unesena za unos tipa proizvodnje,
Finished product quantity <b>{0}</b> and For Quantity <b>{1}</b> cannot be different,Količina gotovog proizvoda <b>{0}</b> i Za količinu <b>{1}</b> ne može biti različita,
"Fiscal Regime is mandatory, kindly set the fiscal regime in the company {0}","Fiskalni režim je obavezan, ljubazno odredite fiskalni režim u preduzeću {0}",
Fiscal Year,Fiskalna godina,
Fiscal Year End Date should be one year after Fiscal Year Start Date,Datum završetka fiskalne godine treba da bude godinu dana nakon datuma početka fiskalne godine,
Fiscal Year Start Date and Fiscal Year End Date are already set in Fiscal Year {0},Početni datum fiskalne godine i datum završetka fiskalne godine već su postavljeni u fiskalnoj godini {0},
Fiscal Year Start Date should be one year earlier than Fiscal Year End Date,Datum početka fiskalne godine treba da bude jedna godina ranije od datuma završetka fiskalne godine,
Fiscal Year {0} does not exist,Fiskalna godina {0} ne postoji,
Fiscal Year {0} is required,Potrebna je fiskalna godina {0},
Fiscal Year {0} not found,Fiskalna godina {0} nije pronađena,
Fiscal Year: {0} does not exists,Fiskalna godina: {0} ne postoji,
Fixed Asset,Fixed Asset,
Fixed Asset Item must be a non-stock item.,Stavka fiksnog sredstva mora biti stavka koja nije na zalihama.,
Fixed Assets,Fiksna sredstva,
Following Material Requests have been raised automatically based on Item's re-order level,Sledeći zahtevi za materijal su podignuti automatski na osnovu re-narudžbine na stavci,
Following accounts might be selected in GST Settings:,Sljedeći računi mogu biti odabrani u GST postavkama:,
Following course schedules were created,Kreirani su sledeći rasporedi kursa,
Following item {0} is not marked as {1} item. You can enable them as {1} item from its Item master,Sljedeća stavka {0} nije označena kao {1} stavka. Možete ih omogućiti kao {1} stavku iz matične stavke,
Following items {0} are not marked as {1} item. You can enable them as {1} item from its Item master,Sljedeće stavke {0} nisu označene kao {1} stavka. Možete ih omogućiti kao {1} stavku iz matične stavke,
Food,Hrana,
"Food, Beverage & Tobacco","Hrana, piće i duhan",
For,For,
"For 'Product Bundle' items, Warehouse, Serial No and Batch No will be considered from the 'Packing List' table. If Warehouse and Batch No are same for all packing items for any 'Product Bundle' item, those values can be entered in the main Item table, values will be copied to 'Packing List' table.","Za stavke &#39;Product Bundle&#39;, Warehouse, Serial No i Batch No će se razmatrati iz tabele &#39;Packing List&#39;. Ako su Skladište i Serijski broj isti za sve pakirne stavke za bilo koju stavku „Paket proizvoda“, te vrijednosti se mogu unijeti u glavnu tablicu artikala, vrijednosti će se kopirati u tablicu „Spisak pakiranja“.",
For Employee,Za zaposlenika,
For Quantity (Manufactured Qty) is mandatory,Za količinu (proizvedena količina) je obavezno,
For Supplier,Za dobavljača,
For Warehouse,Za skladište,
For Warehouse is required before Submit,Za skladište je potrebno prije slanja,
"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 karticu posla {0} možete izvršiti samo unos zaliha &#39;Transfer materijala za proizvodnju&#39;,
"For row {0} in {1}. To include {2} in Item rate, rows {3} must also be included","Za red {0} u {1}. Da biste uključili {2} u stavku stavke, redovi {3} također moraju biti uključeni",
For row {0}: Enter Planned Qty,Za redak {0}: Unesite planiranu količinu,
"For {0}, only credit accounts can be linked against another debit entry",Za {0} samo kreditni računi mogu biti povezani s drugim debitnim unosom,
"For {0}, only debit accounts can be linked against another credit entry","Za {0}, samo debitni računi mogu biti povezani s drugim unosom kredita",
Form View,Form View,
Forum Activity,Forum Activity,
Free item code is not selected,Kôd slobodne stavke nije odabran,
Freight and Forwarding Charges,Troškovi špedicije i špedicije,
Friday,Petak,
From,Od,
From Address 1,From Address 1,
From Address 2,From Address 2,
From Currency and To Currency cannot be same,Iz valute i valute ne može biti isto,
From Date and To Date lie in different Fiscal Year,Od datuma do datuma leže u različitoj fiskalnoj godini,
From Date cannot be greater than To Date,Datum ne može biti veći od datuma,
From Date must be before To Date,Od datuma mora biti prije datuma,
From Date should be within the Fiscal Year. Assuming From Date = {0},Od datuma treba da bude u okviru fiskalne godine. Pretpostavljajući od datuma = {0},
From Date {0} cannot be after employee's relieving Date {1},Od datuma {0} ne može biti nakon datuma slanja zaposlenika {1},
From Date {0} cannot be before employee's joining Date {1},Od datuma {0} ne može biti prije datuma pridruživanja zaposlenika {1},
From Datetime,From Datetime,
From Delivery Note,Od dostavnice,
From Fiscal Year,Od fiskalne godine,
From GSTIN,From GSTIN,
From Party Name,Od imena stranke,
From Pin Code,Iz Pin koda,
From Place,From Place,
From Range has to be less than To Range,Iz dometa mora biti manji od To Range,
From State,From State,
From Time,From Time,
From Time Should Be Less Than To Time,Od vremena treba da bude manje od vremena,
From Time cannot be greater than To Time.,Iz vremena ne može biti veće od vremena.,
"From a supplier under composition scheme, Exempt and Nil rated","Od dobavljača po shemi kompozicije, izuzeti i Nil ocijenjeni",
From and To dates required,Od i do potrebnih datuma,
From date can not be less than employee's joining date,Od datuma ne može biti manji od datuma pridruživanja zaposlenog,
From value must be less than to value in row {0},Iz vrijednosti mora biti manja od vrijednosti u redu {0},
From {0} | {1} {2},Od {0} | {1} {2},
Fuel Price,Cijena goriva,
Fuel Qty,Količina goriva,
Fulfillment,Ispunjenje,
Full Name,Puno ime,
Full-time,Puno vrijeme,
Fully Depreciated,Fully Depreciated,
Furnitures and Fixtures,Nameštaj i pribor,
"Further accounts can be made under Groups, but entries can be made against non-Groups","Dodatni računi mogu se vršiti u grupi, ali unosi se mogu vršiti protiv ne-grupa",
Further cost centers can be made under Groups but entries can be made against non-Groups,"Dodatni troškovni centri mogu se napraviti u okviru Grupe, ali unosi se mogu vršiti protiv ne-grupa",
Further nodes can be only created under 'Group' type nodes,Ostali čvorovi mogu biti kreirani samo pod čvorovima tipa &#39;Grupa&#39;,
Future dates not allowed,Budući datumi nisu dozvoljeni,
GSTIN,GSTIN,
GSTR3B-Form,GSTR3B-Form,
Gain/Loss on Asset Disposal,Dobitak / gubitak na raspolaganju,
Gantt Chart,Gantt Chart,
Gantt chart of all tasks.,Gantov dijagram svih zadataka.,
Gender,Rod,
General,General,
General Ledger,Glavna knjiga,
Generate Material Requests (MRP) and Work Orders.,Generirajte materijalne zahtjeve (MRP) i radne naloge.,
Generate Secret,Generate Secret,
Get Details From Declaration,Saznajte detalje iz deklaracije,
Get Employees,Get Employees,
Get Invocies,Get Invocies,
Get Invoices,Get Invoices,
Get Invoices based on Filters,Nabavite fakture na osnovu filtera,
Get Items from BOM,Nabavite stavke iz BOM-a,
Get Items from Healthcare Services,Nabavite artikle iz zdravstvenih usluga,
Get Items from Prescriptions,Nabavite stavke iz recepta,
Get Items from Product Bundle,Nabavite artikle iz paketa proizvoda,
Get Suppliers,Get Suppliers,
Get Suppliers By,Get Dobavljači By,
Get Updates,Get Updates,
Get customers from,Odvedite klijente,
Get from,Get from,
Get from Patient Encounter,Dođi od susreta sa pacijentom,
Getting Started,Počinjemo,
Global settings for all manufacturing processes.,Globalne postavke za sve proizvodne procese.,
Go to the Desktop and start using ERPNext,Idite na radnu površinu i počnite koristiti ERPNext,
GoCardless SEPA Mandate,GoCardless SEPA Mandat,
GoCardless payment gateway settings,GoCardless postavke šifre plaćanja,
Goal and Procedure,Cilj i procedura,
Goals cannot be empty,Ciljevi ne mogu biti prazni,
Goods In Transit,Roba u tranzitu,
Goods Transferred,Prenesena roba,
Goods and Services Tax (GST India),Porez na robu i usluge (GST Indija),
Goods are already received against the outward entry {0},Roba je već primljena u odnosu na ulazni ulaz {0},
Government,Vlada,
Grand Total,Grand Total,
Grant,Grant,
Grant Application,Grant Application,
Grant Leaves,Grant Leaves,
Grant information.,Grant information.,
Grocery,Namirnica,
Gross Pay,Gross Pay,
Gross Profit,Bruto dobit,
Gross Profit %,Bruto dobit%,
Gross Profit / Loss,Bruto dobit / gubitak,
Gross Purchase Amount,Bruto iznos kupovine,
Gross Purchase Amount is mandatory,Bruto iznos kupovine je obavezan,
Group by Account,Grupa po računu,
Group by Party,Grupa po partiji,
Group by Voucher,Grupa po vaučeru,
Group by Voucher (Consolidated),Grupisanje po vaučeru (Konsolidovano),
Group node warehouse is not allowed to select for transactions,Skladište čvora grupe nije dozvoljeno da bira transakcije,
Group to Non-Group,Grupa u grupi koja nije grupa,
Group your students in batches,Grupirajte učenike u grupama,
Groups,Grupe,
Guardian1 Email ID,Guardian1 Email ID,
Guardian1 Mobile No,Guardian1 Mobile No,
Guardian1 Name,Guardian1 Name,
Guardian2 Email ID,Guardian2 Email ID,
Guardian2 Mobile No,Guardian2 Mobile No,
Guardian2 Name,Ime Guardian2,
HR Manager,menadzer ljudskih resursa,
HSN,HSN,
HSN/SAC,HSN / SAC,
Half Day Date is mandatory,Datum polu-dana je obavezan,
Half Day Date should be between From Date and To Date,Datum polu-dana treba da bude između datuma i datuma,
Half Day Date should be in between Work From Date and Work End Date,Datum polu-dana treba da bude između radnog datuma i datuma završetka posla,
Half day date should be in between from date and to date,Poludnevni datum treba da bude između između datuma i datuma,
Half-Yearly,Pola godine,
Hardware,Hardver,
Head of Marketing and Sales,Voditelj marketinga i prodaje,
Health Care,Health Care,
Healthcare,Zdravstvo,
Healthcare (beta),Zdravstvena zaštita (beta),
Healthcare Practitioner,Healthcare Practitioner,
Healthcare Practitioner not available on {0},Zdravstveni radnik nije dostupan na {0},
Healthcare Practitioner {0} not available on {1},Zdravstveni radnik {0} nije dostupan na {1},
Healthcare Service Unit,Služba za zdravstvenu zaštitu,
Healthcare Service Unit Tree,Stablo jedinice zdravstvene službe,
Healthcare Service Unit Type,Vrsta jedinice zdravstvene službe,
Healthcare Services,Zdravstvene usluge,
Healthcare Settings,Postavke zdravstvene zaštite,
Hello,zdravo,
Help Results for,Rezultati pomoći za,
High,Visoko,
High Sensitivity,High Sensitivity,
Hold,Držite,
Hold Invoice,Zadržite fakturu,
Holiday,Holiday,
Holiday List,Holiday List,
Hotel Rooms of type {0} are unavailable on {1},Hotelske sobe tipa {0} nisu dostupne na {1},
Hotels,Hoteli,
Hours,Hours,
House rent paid days overlapping with {0},Iznajmljivanje plaćenih dana za kuće koje se preklapaju s {0},
House rented dates required for exemption calculation,Datumi iznajmljivanja kuće potrebni za obračun izuzeća,
House rented dates should be atleast 15 days apart,Datumi iznajmljivanja kuća trebali bi biti najmanje 15 dana,
How Pricing Rule is applied?,Kako se primjenjuje Pravilo određivanja cijena?,
Hub Category,Hub Category,
Human Resource,Ljudski resursi,
Human Resources,Ljudski resursi,
IFSC Code,IFSC Code,
IGST Amount,IGST Iznos,
ITC Available (whether in full op part),ITC Raspoloživo (bilo u punom op dijelu),
ITC Reversed,ITC Reversed,
Identifying Decision Makers,Identifikovanje odluka,
"If Auto Opt In is checked, then the customers will be automatically linked with the concerned Loyalty Program (on save)","Ako je označena opcija Auto Opt In, klijenti će se automatski povezati sa dotičnim programom lojalnosti (ušteda)",
"If multiple Pricing Rules continue to prevail, users are asked to set Priority manually to resolve conflict.","Ako preovlađuju višestruka pravila za određivanje cijena, od korisnika se traži da ručno podesi prioritet da bi riješio sukob.",
"If selected Pricing Rule is made for 'Rate', it will overwrite Price List. Pricing Rule rate is the final rate, so no further discount should be applied. Hence, in transactions like Sales Order, Purchase Order etc, it will be fetched in 'Rate' field, rather than 'Price List Rate' field.","Ako je odabrano pravilo za određivanje cijene za &#39;Rate&#39;, on će zamijeniti cjenik. Cenovnik Pravila o cenama je konačna stopa, tako da ne treba primenjivati dodatni popust. Prema tome, u transakcijama kao što su prodajni nalog, narudžbenica i sl., Ona će biti preuzeta u polju &#39;Rate&#39;, a ne u polju &#39;Price List Rate&#39;.",
"If two or more Pricing Rules are found based on the above conditions, Priority is applied. Priority is a number between 0 to 20 while default value is zero (blank). Higher number means it will take precedence if there are multiple Pricing Rules with same conditions.","Ako se na osnovu gore navedenih uslova nađu dva ili više Pravila za određivanje cijena, primjenjuje se Prioritet. Prioritet je broj između 0 i 20, dok je zadana vrijednost nula (prazno). Veći broj znači da će imati prednost ako postoje višestruka pravila za određivanje cijena sa istim uvjetima.",
"If unlimited expiry for the Loyalty Points, keep the Expiry Duration empty or 0.","Ako neograničeno isteče za bodove lojalnosti, zadržite prazno trajanje isteka ili 0.",
"If you have any questions, please get back to us.","Ako imate bilo kakvih pitanja, molimo Vas da nam se javite.",
Ignore Existing Ordered Qty,Zanemari postojeći naručeni broj,
Import Data,Uvoz podataka,
Import Day Book Data,Uvoz podataka o knjizi,
Import Master Data,Uvezite glavne podatke,
Import Successfull,Import Successfull,
Import in Bulk,Import in Bulk,
Import of goods,Uvoz robe,
Import of services,Uvoz usluga,
Importing Items and UOMs,Uvoz stavki i UOM-ova,
Importing Parties and Addresses,Uvozne strane i adrese,
In Maintenance,In Maintenance,
In Production,In Production,
In Qty,In Qty,
In Stock Qty,In Stock Qty,
In Stock: ,In Stock: \ t,
In Value,U vrijednosti,
"In the case of multi-tier program, Customers will be auto assigned to the concerned tier as per their spent","U slučaju višeslojnog programa, korisnici će biti automatski dodijeljeni dotičnom nivou prema njihovim utrošenim troškovima",
Incentives,Incentives,
Include Default Book Entries,Uključi zadane unose u knjigu,
Include Exploded Items,Uključi eksplodirane stavke,
Include POS Transactions,Uključi POS transakcije,
Include UOM,Uključi UOM,
Included in Gross Profit,Uključeno u bruto profit,
Income,Prihod,
Income Account,Račun prihoda,
Income Tax,Porez na prihod,
Incoming,Dolazni,
Incoming Rate,Incoming Rate,
Incorrect number of General Ledger Entries found. You might have selected a wrong Account in the transaction.,Neispravan broj pronađenih unosa glavne knjige. Možda ste u transakciji izabrali pogrešan račun.,
Increment cannot be 0,Povećanje ne može biti 0,
Increment for Attribute {0} cannot be 0,Povećanje za atribut {0} ne može biti 0,
Indirect Expenses,Indirektni troškovi,
Indirect Income,Indirektni prihodi,
Individual,Individualno,
Ineligible ITC,Neprihvatljivi ITC,
Initiated,Inicirano,
Inpatient Record,Inpatient Record,
Insert,Umetni,
Installation Note,Napomena za instalaciju,
Installation Note {0} has already been submitted,Napomena za instalaciju {0} je već poslana,
Installation date cannot be before delivery date for Item {0},Datum instalacije ne može biti prije datuma isporuke za stavku {0},
Installing presets,Instaliranje preseta,
Institute Abbreviation,Kratica Instituta,
Institute Name,Naziv Instituta,
Instructor,Instruktor,
Insufficient Stock,Nedovoljna zaliha,
Insurance Start date should be less than Insurance End date,Datum početka osiguranja mora biti manji od datuma završetka osiguranja,
Integrated Tax,Integrated Tax,
Inter-State Supplies,Interdržavni pribor,
Interest Amount,Iznos kamate,
Intern,Intern,
Internet Publishing,Internet Publishing,
Intra-State Supplies,Unutrašnja oprema,
Invalid Attribute,Nevažeći atribut,
Invalid Blanket Order for the selected Customer and Item,Nevažeća narudžbenica za odabrani kupac i stavku,
Invalid Company for Inter Company Transaction.,Nevažeća kompanija za međubankarsku transakciju.,
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 2 cifre GSTIN-a bi se trebale podudarati s brojem države {0}.,
Invalid GSTIN! The input you've entered doesn't match the format of GSTIN.,Nevažeći GSTIN! Unos koji ste uneli ne odgovara formatu GSTIN-a.,
Invalid Posting Time,Nevažeće vrijeme slanja,
Invalid attribute {0} {1},Nevažeći atribut {0} {1},
Invalid quantity specified for item {0}. Quantity should be greater than 0.,Nevažeća količina navedena za stavku {0}. Količina bi trebala biti veća od 0.,
Invalid reference {0} {1},Nevažeća referenca {0} {1},
Invalid {0},Nevažeće {0},
Invalid {0} for Inter Company Transaction.,Nevažeći {0} za internu transakciju kompanije.,
Invalid {0}: {1},Nevažeći {0}: {1},
Inventory,Inventar,
Investment Banking,Investment Banking,
Investments,Investicije,
Invoice,Faktura,
Invoice Created,Račun je izrađen,
Invoice Discounting,Faktura Popust,
Invoice Patient Registration,Registracija računa pacijenta,
Invoice Posting Date,Datum knjiženja fakture,
Invoice Type,Tip fakture,
Invoice already created for all billing hours,Faktura je već kreirana za sve obračunske sate,
Invoice can't be made for zero billing hour,Faktura se ne može izvršiti za nulti sat obračuna,
Invoice {0} no longer exists,Faktura {0} više ne postoji,
Invoiced,Fakturirano,
Invoiced Amount,Iznos fakture,
Invoices,Fakture,
Invoices for Costumers.,Fakture za kupce.,
Inward Supplies(liable to reverse charge,Unutrašnji dobavljači (podložni obrnutoj naplati),
Inward supplies from ISD,Unutrašnje isporuke iz ISD-a,
Inward supplies liable to reverse charge (other than 1 & 2 above),Unutrašnje isporuke koje podležu obrnutoj naplati (osim gore navedenih 1 i 2),
Is Existing Asset,Postoji postojeća imovina,
Is Frozen,Is Frozen,
Is Group,Is Group,
Issue,Problem,
Issue Material,Materijali za izdavanje,
Issued,Izdato,
Issues,Problemi,
It is needed to fetch Item Details.,Potrebno je dohvatiti detalje stavke.,
Item,Stavka,
Item 1,Tačka 1,
Item 2,Tačka 2,
Item 3,Tačka 3,
Item 4,Tačka 4,
Item 5,Tačka 5,
Item Cart,Item Cart,
Item Code,Šifra artikla,
Item Code cannot be changed for Serial No.,Šifra artikla se ne može mijenjati za serijski broj.,
Item Code required at Row No {0},Šifra artikla potrebna u redu broj {0},
Item Description,Opis stavke,
Item Group,Grupa proizvoda,
Item Group Tree,Tree Group Tree,
Item Group not mentioned in item master for item {0},Grupa stavki koja nije navedena u glavnom stavku za stavku {0},
Item Name,Naziv predmeta,
Item Price added for {0} in Price List {1},Stavka Cijena je 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 se pojavljuje više puta na temelju cjenika, dobavljača / kupca, valute, predmeta, UOM-a, broja i datuma.",
Item Price updated for {0} in Price List {1},Stavka Cijena ažurirana za {0} u cjeniku {1},
Item Row {0}: {1} {2} does not exist in above '{1}' table,Red retka {0}: {1} {2} ne postoji u tabeli iznad {{1} &#39;,
Item Tax Row {0} must have account of type Tax or Income or Expense or Chargeable,Redak poreske stavke {0} mora imati račun tipa Porez ili Prihod ili Trošak ili Trošak,
Item Template,Predložak predmeta,
Item Variant Settings,Postavka varijante stavke,
Item Variant {0} already exists with same attributes,Stavka Variant {0} već postoji sa istim atributima,
Item Variants,Item Varijante,
Item Variants updated,Stavka Varijante su ažurirane,
Item has variants.,Stavka ima varijante.,
Item must be added using 'Get Items from Purchase Receipts' button,Stavka mora biti dodana pomoću gumba &quot;Preuzmi stavke iz kupovine&quot;,
Item or Warehouse for row {0} does not match Material Request,Stavka ili skladište za redak {0} ne odgovara upitu materijala,
Item valuation rate is recalculated considering landed cost voucher amount,Stopa vrednovanja pozicije se preračunava uzimajući u obzir iznos vaučera za zemljišne troškove,
Item variant {0} exists with same attributes,Varijanta stavke {0} postoji sa istim atributima,
Item {0} does not exist,Stavka {0} ne postoji,
Item {0} does not exist in the system or has expired,Stavka {0} ne postoji u sistemu ili je istekla,
Item {0} has already been returned,Stavka {0} je već vraćena,
Item {0} has been disabled,Stavka {0} je onemogućena,
Item {0} has reached its end of life on {1},Stavka {0} je završila svoj život na {1},
Item {0} ignored since it is not a stock item,Stavka {0} je zanemarena jer nije stavka dionice,
"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,Stavka {0} je otkazana,
Item {0} is disabled,Stavka {0} je onemogućena,
Item {0} is not a serialized Item,Stavka {0} nije serijalizirana stavka,
Item {0} is not a stock Item,Stavka {0} nije dionica,
Item {0} is not active or end of life has been reached,Stavka {0} nije aktivna ili je dostignut kraj života,
Item {0} is not setup for Serial Nos. Check Item master,Stavka {0} nije podešena za serijske brojeve,
Item {0} is not setup for Serial Nos. Column must be blank,Stavka {0} nije postavljena za serijske brojeve. Stupac mora biti prazan,
Item {0} must be a Fixed Asset Item,Stavka {0} mora biti fiksna stavka imovine,
Item {0} must be a Sub-contracted Item,Stavka {0} mora biti podugovorena stavka,
Item {0} must be a non-stock item,Stavka {0} mora biti stavka koja nije na zalihama,
Item {0} must be a stock Item,Stavka {0} mora biti dionica,
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 tabeli &#39;Isporučeni materijali&#39; u narudžbenici {1},
Item {0}: Ordered qty {1} cannot be less than minimum order qty {2} (defined in Item).,Stavka {0}: Naručena količina {1} ne može biti manja od minimalne količine narudžbe {2} (definirana u stavci).,
Item: {0} does not exist in the system,Stavka: {0} ne postoji u sistemu,
Items,Stavke,
Items Filter,Items Filter,
Items and Pricing,Stavke i cijene,
Items for Raw Material Request,Stavke za zahtjev za sirovinu,
Job Card,Job Card,
Job Description,Opis posla,
Job Offer,Ponudu za posao,
Job card {0} created,Napravljena je kartica posla {0},
Jobs,Poslovi,
Join,Join,
Journal Entries {0} are un-linked,Unosi dnevnika {0} nisu povezani,
Journal Entry,Unos časopisa,
Journal Entry {0} does not have account {1} or already matched against other voucher,Unos dnevnika {0} nema nalog {1} ili se već podudara sa drugim vaučerima,
Kanban Board,Kanban Board,
Key Reports,Ključni izvještaji,
LMS Activity,LMS Activity,
Lab Test,Lab Test,
Lab Test Prescriptions,Lab Test Prescriptions,
Lab Test Report,Lab Test Report,
Lab Test Sample,Lab Test Sample,
Lab Test Template,Lab Test Template,
Lab Test UOM,Lab Test UOM,
Lab Tests and Vital Signs,Laboratorijski testovi i Vitalni Znaci,
Lab result datetime cannot be before testing datetime,Datetime rezultat laboratorijskog rezultata ne može biti prije testiranja datetime,
Lab testing datetime cannot be before collection datetime,Datetime testiranje laboratorijskog testa ne može biti prije datuma prikupljanja,
Laboratory,Laboratorija,
Large,Veliko,
Last Communication,Last Communication,
Last Communication Date,Datum zadnje komunikacije,
Last Order Amount,Iznos posljednje narudžbe,
Last Order Date,Datum poslednjeg naloga,
Last Purchase Price,Poslednja kupovna cijena,
Last Purchase Rate,Poslednja stopa kupovine,
Latest,Najnoviji,
Latest price updated in all BOMs,Najnovija cijena ažurirana u svim sastavnicama,
Lead,Lead,
Lead Count,Lead Count,
Lead Owner,Vodeći vlasnik,
Lead Owner cannot be same as the Lead,Vodeći vlasnik ne može biti isti kao i vođa,
Lead Time Days,Dani vremena vođenja,
Lead to Quotation,Vodite na ponudu,
"Leads help you get business, add all your contacts and more as your leads","Vode vam pomažu da dobijete posao, dodate sve svoje kontakte i još mnogo toga kao svoje vodeće",
Learn,Learn,
Leave Approval Notification,Obavijest o odobrenju,
Leave Blocked,Ostavi blokirano,
Leave Encashment,Leave Encashment,
Leave Management,Leave Management,
Leave Status Notification,Ostavite obaveštenje o statusu,
Leave Type,Leave Type,
Leave Type is madatory,Tip napuštanja je madatory,
Leave Type {0} cannot be allocated since it is leave without pay,Tip ostavljanja {0} ne može biti dodijeljen jer je to dopust bez plaćanja,
Leave Type {0} cannot be carry-forwarded,Tip ostavljanja {0} se ne može prenositi,
Leave Type {0} is not encashable,Tip ostavljanja {0} nije moguće prebaciti,
Leave Without Pay,Ostavi bez plaćanja,
Leave Without Pay does not match with approved Leave Application records,Ostavi bez plaćanja ne podudara se sa odobrenim zapisima o aplikaciji,
Leave and Attendance,Odlazak i prisustvo,
Leave application {0} already exists against the student {1},Ostavi aplikaciju {0} već postoji protiv studenta {1},
"Leave cannot be allocated before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}","Ostaviti se ne može dodijeliti prije {0}, jer je ravnoteža dopusta već prenesena u evidenciji budućeg izdvajanja za odsustvo {1}",
"Leave cannot be applied/cancelled before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}","Ostaviti se ne može primijeniti / otkazati prije {0}, jer je balans dopusta već prenesen u budućem zapisu za dodjelu dopusta {1}",
Leave of type {0} cannot be longer than {1},Ostavljanje tipa {0} ne može biti duže od {1},
Leave the field empty to make purchase orders for all suppliers,Ostavite polje prazno kako biste napravili narudžbenice za sve dobavljače,
Leaves,Leaves,
Leaves Allocated Successfully for {0},Uspješno ostavlja za {0},
Leaves has been granted sucessfully,Lišće je uspješno izdano,
Leaves must be allocated in multiples of 0.5,"Lišće se mora rasporediti u višekratnicima od 0,5",
Leaves per Year,Lišće godišnje,
Ledger,Ledger,
Legal,Legal,
Legal Expenses,Pravni troškovi,
Letter Heads for print templates.,Letter Heads za predloške za ispis.,
Liability,Odgovornost,
License,Licenca,
Lifecycle,Životni ciklus,
Limit Crossed,Limit 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,Spisak dostupnih akcionara sa brojevima brojeva,
Loading Payment System,Učitavanje platnog sistema,
Loan,Zajam,
Loan Amount cannot exceed Maximum Loan Amount of {0},Iznos kredita ne može premašiti maksimalni iznos kredita od {0},
Loan Application,Zahtjev za kredit,
Loan Management,Upravljanje kreditima,
Loan Repayment,Otplata kredita,
Loan Start Date and Loan Period are mandatory to save the Invoice Discounting,Datum početka kredita i period kredita su obavezni za čuvanje fakture diskontiranja,
Loans (Liabilities),Krediti (obaveze),
Loans and Advances (Assets),Krediti i avansi (imovina),
Local,Lokalno,
"LocalStorage is full , did not save","LocalStorage je pun, nije spasio",
"LocalStorage is full, did not save","LocalStorage je pun, nije spasio",
Log,Log,
Logs for maintaining sms delivery status,Zapisi za održavanje statusa slanja SMS-a,
Lost,Izgubljen,
Lost Reasons,Lost Reasons,
Low,Low,
Low Sensitivity,Low Sensitivity,
Lower Income,Lower Income,
Loyalty Amount,Iznos lojalnosti,
Loyalty Point Entry,Unos bodova lojalnosti,
Loyalty Points,Bodovi lojalnosti,
"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.","Bodovi lojalnosti će se obračunavati od izvršenog iznosa (preko fakture prodaje), na osnovu navedenog faktora naplate.",
Loyalty Points: {0},Bodovi lojalnosti: {0},
Loyalty Program,Program lojalnosti,
Main,Main,
Maintenance,Održavanje,
Maintenance Log,Dnevnik održavanja,
Maintenance Schedule,Raspored održavanja,
Maintenance Schedule is not generated for all the items. Please click on 'Generate Schedule',Raspored održavanja se ne generira za sve stavke. Molimo kliknite na &#39;Generiraj raspored&#39;,
Maintenance Schedule {0} exists against {1},Raspored održavanja {0} postoji u odnosu na {1},
Maintenance Schedule {0} must be cancelled before cancelling this Sales Order,Raspored održavanja {0} mora biti poništen prije otkazivanja ovog prodajnog naloga,
Maintenance Status has to be Cancelled or Completed to Submit,Status održavanja mora biti poništen ili dovršen za slanje,
Maintenance Visit,Maintenance Visit,
Maintenance Visit {0} must be cancelled before cancelling this Sales Order,Poseta za održavanje {0} mora biti otkazana pre otkazivanja ovog prodajnog naloga,
Maintenance start date can not be before delivery date for Serial No {0},Datum početka održavanja ne može biti prije datuma isporuke za serijski broj {0},
Make,Make,
Make Payment,Plaćanje,
Make project from a template.,Napravite projekat iz predloška.,
Making Stock Entries,Making Stock Entries,
Manage Customer Group Tree.,Upravljanje stablom grupe korisnika.,
Manage Sales Partners.,Upravljanje prodajnim partnerima.,
Manage Sales Person Tree.,Upravljanje stablom prodavača.,
Manage Territory Tree.,Upravljanje stablom teritorije.,
Manage your orders,Upravljajte svojim narudžbama,
Management,Management,
Manager,Menadžer,
Managing Projects,Upravljanje projektima,
Managing Subcontracting,Upravljanje podugovaranjem,
Mandatory field - Academic Year,Obavezno polje - akademska godina,
Mandatory field - Get Students From,Obavezno polje - Odvedi studente,
Mandatory field - Program,Obavezno polje - Program,
Manufacture,Proizvodnja,
Manufacturer,Proizvođač,
Manufacturer Part Number,Broj dijela proizvođača,
Manufacturing,Proizvodnja,
Manufacturing Quantity is mandatory,Količina proizvodnje je obavezna,
Mark Absent,Mark Absent,
Mark Attendance,Mark Attendance,
Mark Half Day,Označi pola dana,
Mark Present,Mark Present,
Marketing,Marketing,
Marketing Expenses,Troškovi marketinga,
Marketplace,Marketplace,
Marketplace Error,Greška na tržištu,
"Master data syncing, it might take some time",Sinhronizacija glavnih podataka može potrajati,
Masters,Masters,
Match Payments with Invoices,Uskladite plaćanja sa fakturama,
Match non-linked Invoices and Payments.,Odgovaraju nepovezanim fakturama i plaćanjima.,
Material,Materijal,
Material Consumption,Potrošnja materijala,
Material Consumption is not set in Manufacturing Settings.,Potrošnja materijala nije postavljena u Postavkama proizvodnje.,
Material Receipt,Prijem materijala,
Material Request,Material Request,
Material Request Date,Datum zahtjeva za materijal,
Material Request No,Zahtjev za materijal 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 materijala od maksimalno {0} može se napraviti za stavku {1} protiv prodajnog naloga {2},
Material Request to Purchase Order,Materijalni zahtjev za narudžbenicu,
Material Request {0} is cancelled or stopped,Zahtjev za materijal {0} je otkazan ili zaustavljen,
Material Request {0} submitted.,Podnesen je zahtev za materijal {0}.,
Material Transfer,Transfer materijala,
Material Transferred,Preneseni materijal,
Material to Supplier,Materijal za dobavljača,
Max Exemption Amount cannot be greater than maximum exemption amount {0} of Tax Exemption Category {1},Maksimalni iznos izuzeća ne može biti veći od maksimalne iznosa izuzeća {0} od kategorije oslobođenja od poreza {1},
Max benefits should be greater than zero to dispense benefits,Maksimalne beneficije bi trebale biti veće od nule da bi se izostavile koristi,
Max discount allowed for item: {0} is {1}%,Najveći dopušteni popust za stavku: {0} je {1}%,
Max: {0},Max: {0},
Maximum Samples - {0} can be retained for Batch {1} and Item {2}.,Maksimalni uzorci - {0} mogu se zadržati za Batch {1} i stavku {2}.,
Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,Maksimalni uzorci - {0} su već zadržani za Batch {1} i stavku {2} u Batch {3}.,
Maximum amount eligible for the component {0} exceeds {1},Maksimalni iznos koji odgovara komponenti {0} premašuje {1},
Maximum benefit amount of component {0} exceeds {1},Maksimalni iznos naknade komponente {0} premašuje {1},
Maximum benefit amount of employee {0} exceeds {1},Maksimalni iznos naknade zaposlenika {0} premašuje {1},
Maximum discount for Item {0} is {1}%,Maksimalni popust za stavku {0} je {1}%,
Maximum leave allowed in the leave type {0} is {1},Maksimalno dopušteno odsustvo u tipu odsustva {0} je {1},
Medical,Medicinski,
Medical Code,Medical Code,
Medical Code Standard,Standard medicinskog koda,
Medical Department,Medical Department,
Medical Record,Medical Record,
Medium,Srednje,
Meeting,Sastanak,
Member Activity,Member Activity,
Member ID,Member ID,
Member Name,Ime člana,
Member information.,Informacije o članovima.,
Membership,Članstvo,
Membership Details,Detalji o članstvu,
Membership ID,ID članstva,
Membership Type,Vrsta članstva,
Memebership Details,Memebership Details,
Memebership Type Details,Memebership Type Details,
Merge,Spoji,
Merge Account,Merge Account,
Merge with Existing Account,Spajanje sa 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 su slijedeća svojstva u oba zapisa ista. Da li je Grupa, Root Type, Company",
Message Sent,Poruka poslata,
Middle Income,Middle Income,
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,Min. Količina ne može biti veća od Max Qty,
Minimum Lead Age (Days),Minimum Lead Age (Dani),
Miscellaneous Expenses,Razni troškovi,
Missing Currency Exchange Rates for {0},Nedostaje kursna lista valuta za {0},
Missing email template for dispatch. Please set one in Delivery Settings.,Nedostaje predložak e-pošte za slanje. Postavite ga u Postavke isporuke.,
"Missing value for Password, API Key or Shopify URL","Nedostaje vrijednost za lozinku, API ključ ili Shopify URL",
Mode of Payment,Način plaćanja,
Mode of Payments,Način plaćanja,
Mode of Transport,Način transporta,
Mode of Transportation,Način transporta,
Mode of payment is required to make a payment,Način plaćanja je potreban za plaćanje,
Model,Model,
Moderate Sensitivity,Moderate Sensitivity,
Monday,Ponedeljak,
Monthly,Mjesečno,
Monthly Distribution,Monthly Distribution,
Monthly Repayment Amount cannot be greater than Loan Amount,Iznos mjesečne otplate ne može biti veći od iznosa zajma,
More,Još,
More Information,Više informacija,
More than one selection for {0} not allowed,Više od jedne selekcije za {0} nije dozvoljeno,
More...,Više ...,
Motion Picture & Video,Film i video,
Move,Pokreni se,
Move Item,Move Item,
Multi Currency,Multi Valuta,
Multiple Item prices.,Višestruke cijene stavke.,
Multiple Loyalty Program found for the Customer. Please select manually.,Pronašli smo više programa lojalnosti za klijenta. Odaberite ručno.,
"Multiple Price Rules exists with same criteria, please resolve conflict by assigning priority. Price Rules: {0}","Pravila višestrukih cijena postoje s istim kriterijima, razriješite sukob dodjeljivanjem prioriteta. Pravila cijena: {0}",
Multiple Variants,Višestruke varijante,
Multiple default mode of payment is not allowed,Višestruki podrazumevani način plaćanja nije dozvoljen,
Multiple fiscal years exist for the date {0}. Please set company in Fiscal Year,Postoji više fiskalnih godina za datum {0}. Podesite preduzeće u fiskalnoj godini,
Music,Muzika,
Name error: {0},Greška imena: {0},
Name of new Account. Note: Please don't create accounts for Customers and Suppliers,Ime novog računa. Napomena: Molimo vas da ne stvarate račune za kupce i dobavljače,
Name or Email is mandatory,Ime ili Email je obavezno,
Nature Of Supplies,Nature of Supplies,
Navigating,Navigacija,
Needs Analysis,Analiza potreba,
Negative Quantity is not allowed,Negativna količina nije dozvoljena,
Negative Valuation Rate is not allowed,Negativna stopa procene nije dozvoljena,
Negotiation/Review,Pregovaranje / pregled,
Net Asset value as on,Neto vrijednost imovine kao i na,
Net Cash from Financing,Neto gotovina iz finansiranja,
Net Cash from Investing,Neto gotovina od ulaganja,
Net Cash from Operations,Neto gotovina iz poslovanja,
Net Change in Accounts Payable,Neto promjena na računima,
Net Change in Accounts Receivable,Neto promjena 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 osnovnog sredstva,
Net Change in Inventory,Neto promjena u inventaru,
Net ITC Available(A) - (B),Neto ITC dostupan (A) - (B),
Net Pay,Net Pay,
Net Pay cannot be less than 0,Neto plata ne može biti manja od 0,
Net Profit,Neto profit,
Net Salary Amount,Iznos neto zarade,
Net Total,Neto Ukupno,
Net pay cannot be negative,Neto plata ne može biti negativna,
New Account Name,Novi naziv računa,
New Address,New Address,
New BOM,New BOM,
New Batch ID (Optional),Novi ID serije (opcionalno),
New Batch Qty,New Batch Qty,
New Cart,New Cart,
New Company,New Company,
New Contact,Novi kontakt,
New Cost Center Name,Novo ime centra troška,
New Customer Revenue,Novi prihod od kupaca,
New Customers,Novi klijenti,
New Department,New Department,
New Employee,New Employee,
New Location,New Location,
New Quality Procedure,Nova procedura kvaliteta,
New Sales Invoice,Nova prodajna faktura,
New Sales Person Name,Ime novog prodajnog lica,
New Serial No cannot have Warehouse. Warehouse must be set by Stock Entry or Purchase Receipt,Novi serijski broj ne može imati skladište. Skladište mora biti postavljeno putem unosa zaliha ili kupovine,
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 manji od tekućeg iznosa za klijenta. Kreditni limit mora biti atleast {0},
New task,Novi zadatak,
New {0} pricing rules are created,Stvorena su nova {0} pravila za određivanje cijena,
Newsletters,Newsletters,
Newspaper Publishers,Newspaper Publishers,
Next,Sledeće,
Next Contact By cannot be same as the Lead Email Address,Sljedeći kontakt ne može biti isti kao i glavna adresa e-pošte,
Next Contact Date cannot be in the past,Datum sljedećeg kontakta 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 {},Nije odabrana isporuka za klijenta {},
No Employee Found,Nije pronađen nijedan zaposlenik,
No Item with Barcode {0},Nema stavke sa barkodom {0},
No Item with Serial No {0},Nema stavke sa serijskim brojem {0},
No Items added to cart,Nema stavki u košaricu,
No Items available for transfer,Nema dostupnih stavki za prenos,
No Items selected for transfer,Nema odabranih stavki za prijenos,
No Items to pack,Nema stavki za pakovanje,
No Items with Bill of Materials to Manufacture,Nema artikala sa materijalom za proizvodnju,
No Items with Bill of Materials.,Nema stavki sa materijalom.,
No Lab Test created,Nije napravljen laboratorijski test,
No Permission,No Permission,
No Quote,No Quote,
No Remarks,No Remarks,
No Result to submit,Nema rezultata za slanje,
No Salary Structure assigned for Employee {0} on given date {1},Struktura plata nije dodeljena zaposlenom {0} na navedeni datum {1},
No Staffing Plans found for this Designation,Za ovu oznaku nisu pronađeni planovi zapošljavanja,
No Student Groups created.,Nije formirana nijedna studentska grupa.,
No Students in,Nema studenata u,
No Tax Withholding data found for the current Fiscal Year.,Nema podataka o zadržavanju poreza za tekuću fiskalnu godinu.,
No Work Orders created,Nije kreiran nijedan radni nalog,
No accounting entries for the following warehouses,Nema računovodstvenih unosa za sljedeća skladišta,
No active or default Salary Structure found for employee {0} for the given dates,Nema aktivne ili zadane strukture plaća za zaposlenika {0} za zadane datume,
No address added yet.,Još nijedna adresa nije dodana.,
No contacts added yet.,Još nije dodan nijedan kontakt.,
No contacts with email IDs found.,Nisu pronađeni kontakti sa ID-ovima e-pošte.,
No data for this period,Nema podataka za ovaj period,
No description given,Opis nije dat,
No employees for the mentioned criteria,Nema zaposlenih za navedene kriterije,
No gain or loss in the exchange rate,Nema dobitka ili gubitka u kursu,
No items listed,Nema stavki,
No items to be received are overdue,Nema stavki koje treba primiti,
No leave record found for employee {0} for {1},Nije pronađen zapis za zaposlenika {0} za {1},
No material request created,Nije napravljen nikakav zahtjev za materijal,
No more updates,Nema više ažuriranja,
No of Interactions,Broj interakcija,
No of Shares,Broj dionica,
No pending Material Requests found to link for the given items.,Nije pronađen nijedan zahtjev za materijalom za povezivanje za date stavke.,
No products found,Nema pronađenih proizvoda,
No products found.,Nema pronađenih proizvoda.,
No record found,Nije pronađen nijedan zapis,
No records found in the Invoice table,Nema zapisa u tabeli fakture,
No records found in the Payment table,U tabeli plaćanja nema zapisa,
No replies from,Nema odgovora od,
No salary slip found to submit for the above selected criteria OR salary slip already submitted,Nije utvrđeno da se plaća podnosi za gore odabrane kriterije ILI listić plata koji je već dostavljen,
No tasks,Nema zadataka,
No time sheets,Nema vremenskih listova,
No values,Nema vrijednosti,
No {0} found for Inter Company Transactions.,Nije pronađeno {0} za transakcije između kompanija.,
Non GST Inward Supplies,Non GST Inward Supplies,
Non Profit,Non Profit,
Non Profit (beta),Neprofitna (beta),
Non-GST outward supplies,Ne-GST vanjske zalihe,
Non-Group to Group,Ne-grupa u grupu,
None of the items have any change in quantity or value.,Nijedna stavka nema nikakvu promjenu u količini ili vrijednosti.,
Nos,Nos,
Not Available,Nije dostupno,
Not Expired,Not Expired,
Not Marked,Not Marked,
Not Paid and Not Delivered,Nije plaćeno i nije isporučeno,
Not Permitted,Nije dozvoljeno,
Not Started,Nije počelo,
Not active,Nije aktivno,
Not allow to set alternative item for the item {0},Nije dozvoljeno postaviti alternativnu stavku za stavku {0},
Not allowed to update stock transactions older than {0},Nije dozvoljeno ažurirati transakcije zalihama starije od {0},
Not authorized to edit frozen Account {0},Nije ovlašteno za uređivanje zamrznutog računa {0},
Not authroized since {0} exceeds limits,Nije autorizovano jer {0} premašuje ograničenja,
Not eligible for the admission in this program as per DOB,Ne ispunjava uvjete za upis u ovaj program prema DOB,
Not items found,Nije pronađena nijedna stavka,
Not permitted for {0},Nije dopušteno za {0},
"Not permitted, configure Lab Test Template as required","Nije dozvoljeno, konfigurirajte Lab Lab Template prema potrebi",
Not permitted. Please disable the Service Unit Type,Nije dozvoljeno. Isključite tip servisne jedinice,
Note: Due / Reference Date exceeds allowed customer credit days by {0} day(s),Napomena: Datum / referentni datum premašuje dozvoljene kreditne dane klijenta do {0} dana (a),
Note: Item {0} entered multiple times,Napomena: Stavka {0} je unesena više puta,
Note: Payment Entry will not be created since 'Cash or Bank Account' was not specified,Napomena: unos za plaćanje neće biti kreiran jer nije naveden &quot;Novčani ili bankovni račun&quot;,
Note: System will not check over-delivery and over-booking for Item {0} as quantity or amount is 0,Napomena: Sistem neće proveravati over-delivery i over-booking za stavku {0} jer je količina ili iznos 0,
Note: There is not enough leave balance for Leave Type {0},Napomena: Nema dovoljno preostalog balansa za vrstu ostavljanja {0},
Note: This Cost Center is a Group. Cannot make accounting entries against groups.,Napomena: Ovaj centar troškova je grupa. Nije moguće izvršiti računovodstvene stavke za grupe.,
Note: {0},Napomena: {0},
Notes,Notes,
Nothing is included in gross,Ništa nije uključeno u bruto,
Nothing more to show.,Ništa više za pokazati.,
Nothing to change,Ništa za promjenu,
Notice Period,Otkazni rok,
Notify Customers via Email,Obavijestite klijente putem e-pošte,
Number of Depreciations Booked cannot be greater than Total Number of Depreciations,Broj knjiženih amortizacija ne može biti veći od ukupnog broja amortizacije,
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, on će biti uključen u ime računa kao prefiks",
"Number of new Cost Center, it will be included in the cost center name as a prefix","Broj novog troškovnog centra, on će biti uključen u naziv mjesta troška kao prefiks",
Number of root accounts cannot be less than 4,Broj korijenskih računa ne može biti manji od 4,
Odometer,Odometer,
Office Equipments,Uredska oprema,
Office Maintenance Expenses,Troškovi održavanja ureda,
Office Rent,Office Rent,
On Hold,Na čekanju,
On Net Total,On Net Total,
One customer can be part of only single Loyalty Program.,Jedan korisnik može biti dio samo jednog programa lojalnosti.,
Online,Online,
Online Auctions,Online Auctions,
Only Leave Applications with status 'Approved' and 'Rejected' can be submitted,Mogu se poslati samo aplikacije koje imaju status &quot;Odobreno&quot; i &quot;Odbijeno&quot;,
"Only the Student Applicant with the status ""Approved"" will be selected in the table below.",U tabeli ispod biće izabran samo kandidat sa statusom &quot;Odobreno&quot;.,
Only users with {0} role can register on Marketplace,Samo korisnici sa {0} ulogom mogu se registrirati na Marketplace-u,
Only {0} in stock for item {1},Samo {0} na lageru za stavku {1},
Open BOM {0},Otvori BOM {0},
Open Item {0},Otvori stavku {0},
Open Notifications,Otvori obaveštenja,
Open Orders,Open Orders,
Open a new ticket,Otvori novu kartu,
Opening,Otvaranje,
Opening (Cr),Otvaranje (Cr) \ t,
Opening (Dr),Otvaranje (Dr),
Opening Accounting Balance,Otvaranje salda računovodstva,
Opening Accumulated Depreciation,Otvaranje akumulirane amortizacije,
Opening Accumulated Depreciation must be less than equal to {0},Otvaranje akumulirane amortizacije mora biti manje od {0},
Opening Balance,Otvaranje balansa,
Opening Balance Equity,Početni bilans stanja,
Opening Date and Closing Date should be within same Fiscal Year,Datum otvaranja i datum zatvaranja treba da budu u istoj fiskalnoj godini,
Opening Date should be before Closing Date,Datum otvaranja treba da bude pre datuma zatvaranja,
Opening Entry Journal,Otvaranje dnevnika upisa,
Opening Invoice Creation Tool,Otvaranje alata za kreiranje fakture,
Opening Invoice Item,Otvaranje stavke fakture,
Opening Invoices,Otvaranje faktura,
Opening Invoices Summary,Sažetak otvorenih faktura,
Opening Qty,Opening Qty,
Opening Stock,Opening Stock,
Opening Stock Balance,Opening Stock Balance,
Opening Value,Opening Value,
Opening {0} Invoice created,Otvaranje {0} Napravljena faktura,
Operation,Operacija,
Operation Time must be greater than 0 for Operation {0},Vrijeme rada mora biti veće od 0 za rad {0},
"Operation {0} longer than any available working hours in workstation {1}, break down the operation into multiple operations","Rad {0} duži od bilo kojeg raspoloživog radnog vremena na radnoj stanici {1}, razbiti operaciju u više operacija",
Operations,Operations,
Operations cannot be left blank,Operacije se ne mogu ostaviti prazne,
Opp Count,Opp Count,
Opp/Lead %,Opp / Lead% \ t,
Opportunities,Mogućnosti,
Opportunities by lead source,Mogućnosti od izvora vode,
Opportunity,Opportunity,
Opportunity Amount,Opportunity Amount,
Optional Holiday List not set for leave period {0},Neobavezna lista praznika nije postavljena za period odlaska {0},
"Optional. Sets company's default currency, if not specified.","Opcionalno. Postavlja zadanu valutu kompanije, ako nije navedena.",
Optional. This setting will be used to filter in various transactions.,Opcionalno. Ova postavka će se koristiti za filtriranje različitih transakcija.,
Order Count,Broj naloga,
Order Entry,Order Entry,
Order Value,Vrijednost narudžbe,
Order rescheduled for sync,Narudžba je reprogramirana za sinhronizaciju,
Order/Quot %,Narudžba / kvota%,
Ordered,Naručeno,
Ordered Qty,Naređen kom,
"Ordered Qty: Quantity ordered for purchase, but not received.","Naručena količina: Količina naručena za kupovinu, ali nije primljena.",
Orders,Orders,
Orders released for production.,Nalozi izdati za proizvodnju.,
Organization,Organizacija,
Organization Name,Ime organizacije,
Other Reports,Other Reports,
"Other outward supplies(Nil rated,Exempted)","Ostali spoljni potrošni materijal (Nil ocijenjeno, Izuzeto)",
Others,Others,
Out Qty,Out Qty,
Out Value,Out Value,
Out of Order,Ne radi,
Outgoing,Outgoing,
Outstanding,Izvanredno,
Outstanding Amount,Preostali iznos,
Outstanding Amt,Outstanding Amt,
Outstanding Cheques and Deposits to clear,Izvanredni čekovi i depoziti za brisanje,
Outstanding for {0} cannot be less than zero ({1}),Izvanredno za {0} ne može biti manja od nule ({1}),
"Outward taxable supplies(other than zero rated, nil rated and exempted","Spoljne oporezive isporuke (osim nultih, nultih i oslobođenih)",
Outward taxable supplies(zero rated),Spoljne oporezive isporuke (nulto),
Overdue,Zakasnio,
Overlap in scoring between {0} and {1},Preklapanje u bodovanju između {0} i {1},
Overlapping conditions found between:,Uslovi preklapanja pronađeni između:,
Owner,Vlasnik,
PAN,PAN,
PO already created for all sales order items,PO je već kreirana za sve stavke prodajnog naloga,
POS,POS,
POS Closing Voucher alreday exists for {0} between date {1} and {2},Naknada za kupovinu POS-a postoji za {0} između datuma {1} i {2},
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 potreban za POS ulaz,
POS Settings,POS Settings,
Packed quantity must equal quantity for Item {0} in row {1},Pakirana količina mora biti jednaka količini za stavku {0} u redu {1},
Packing Slip,Otpremnici,
Packing Slip(s) cancelled,Listić (i) pakovanja je poništen,
Paid,Plaćeno,
Paid Amount,Plaćeni iznos,
Paid Amount cannot be greater than total negative outstanding amount {0},Plaćeni iznos ne može biti veći od ukupnog negativnog iznosa nepodmirenog iznosa {0},
Paid amount + Write Off Amount can not be greater than Grand Total,Plaćeni iznos + Piši Iznos ne može biti veći od ukupnog iznosa,
Paid and Not Delivered,Plaćeno i nije isporučeno,
Parent Item {0} must not be a Stock Item,Roditeljska stavka {0} ne smije biti dionica,
Parents Teacher Meeting Attendance,Prisustvo sastancima roditelja,
Part-time,Pola radnog vremena,
Partially Depreciated,Delimično amortizovana,
Partially Received,Delimično primljeno,
Party,Party,
Party Name,Ime stranke,
Party Type,Party Type,
Party Type and Party is mandatory for {0} account,Tip stranke i stranka je obavezna za {0} račun,
Party Type is mandatory,Tip stranke je obavezan,
Party is mandatory,Stranka je obavezna,
Password policy for Salary Slips is not set,Politika lozinki za isplate plata nije postavljena,
Past Due Date,Past Due Date,
Patient,Pacijent,
Patient Appointment,Imenovanje pacijenta,
Patient Encounter,Pacijentski susret,
Patient not found,Pacijent nije pronađen,
Pay Remaining,Pay Remaining,
Pay {0} {1},Plati {0} {1},
Payable,Plaća se,
Payable Account,Plaćeni račun,
Payable Amount,Plaćeni iznos,
Payment,Plaćanje,
Payment Cancelled. Please check your GoCardless Account for more details,Plaćanje otkazano. Molimo Vas da provjerite svoj GoCardless račun za više detalja,
Payment Confirmation,Potvrda plaćanja,
Payment Date,Datum plaćanja,
Payment Days,Dani plaćanja,
Payment Document,Dokument o plaćanju,
Payment Due Date,Rok plaćanja,
Payment Entries {0} are un-linked,Unosi za plaćanje {0} nisu povezani,
Payment Entry,Uplata plaćanja,
Payment Entry already exists,Unos za plaćanje već postoji,
Payment Entry has been modified after you pulled it. Please pull it again.,"Unos plaćanja je izmijenjen nakon što ste ga izvukli. Molim vas, povucite ga ponovo.",
Payment Entry is already created,Unos za plaćanje je već kreiran,
Payment Failed. Please check your GoCardless Account for more details,Plaćanje nije uspelo. Molimo Vas da provjerite svoj GoCardless račun za više detalja,
"Payment Gateway Account not created, please create one manually.","Račun za Gateway plaćanja nije kreiran, kreirajte ga ručno.",
Payment Mode,Način plaćanja,
"Payment Mode is not configured. Please check, whether account has been set on Mode of Payments or on POS Profile.",Način plaćanja nije konfiguriran. Molimo provjerite da li je račun postavljen na način plaćanja ili na POS profil.,
Payment Receipt Note,Napomena o primanju plaćanja,
Payment Request,Zahtev za plaćanje,
Payment Request for {0},Zahtjev za plaćanje za {0},
Payment Tems,Payment Tems,
Payment Term,Rok plaćanja,
Payment Terms,Uslovi plaćanja,
Payment Terms Template,Uvjeti plaćanja,
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 jedna od vrsta primanja, plaćanja i internog prenosa",
Payment against {0} {1} cannot be greater than Outstanding Amount {2},Plaćanje za {0} {1} ne može biti veće od nepodmirenog iznosa {2},
Payment of {0} from {1} to {2},Plaćanje od {0} od {1} do {2},
Payment request {0} created,Napravljen je zahtjev za plaćanje {0},
Payments,Plaćanja,
Payroll,Platni spisak,
Payroll Number,Broj plata,
Payroll Payable,Payroll Payable,
Payroll date can not be less than employee's joining date,Datum na platnom spisku ne može biti manji od datuma pridruživanja zaposlenog,
Payslip,Payslip,
Pending Activities,Aktivnosti na čekanju,
Pending Amount,Iznos na čekanju,
Pending Leaves,Pending Leaves,
Pending Qty,Pending Qty,
Pending Quantity,Pending Quantity,
Pending Review,Pending Review,
Pending activities for today,Predstojeće aktivnosti za danas,
Pension Funds,Penzioni fondovi,
Percentage Allocation should be equal to 100%,Raspodela procenta treba da bude 100%,
Perception Analysis,Analiza percepcije,
Period,Period,
Period Closing Entry,Unos za zatvaranje perioda,
Period Closing Voucher,Period za zatvaranje vaučera,
Periodicity,Periodicity,
Personal Details,Lični podaci,
Pharmaceutical,Pharmaceutical,
Pharmaceuticals,Pharmaceuticals,
Physician,Lekar,
Piecework,Piecework,
Pin Code,Pin code,
Place Of Supply (State/UT),Mjesto opskrbe (država / UT),
Place Order,Place Order,
Plan for maintenance visits.,Plan za posjete održavanju.,
Planned Qty,Planirana količina,
"Planned Qty: Quantity, for which, Work Order has been raised, but is pending to be manufactured.","Planirana količina: Količina, za koju je radni nalog podignut, ali čeka na proizvodnju.",
Planning,Planiranje,
Plants and Machineries,Postrojenja i strojevi,
Please Set Supplier Group in Buying Settings.,Podesite grupu dobavljača u postavkama kupovine.,
Please add a Temporary Opening account in Chart of Accounts,Dodajte Privremeni otvarajući račun u Kontni plan,
Please add the account to root level Company - ,Dodajte nalog na korijenski nivo Preduzeće -,
Please add the remaining benefits {0} to any of the existing component,Molimo dodajte preostale koristi {0} bilo kojoj od postojećih komponenti,
Please check Multi Currency option to allow accounts with other currency,Molimo provjerite opciju Multi Currency da biste omogućili račune s drugom valutom,
Please click on 'Generate Schedule',Molimo kliknite na &#39;Generiraj raspored&#39;,
Please click on 'Generate Schedule' to fetch Serial No added for Item {0},Kliknite na &#39;Generiraj raspored&#39; da biste dohvatili serijski broj dodan za stavku {0},
Please click on 'Generate Schedule' to get schedule,Kliknite na &#39;Generiraj raspored&#39; da biste dobili raspored,
Please confirm once you have completed your training,Potvrdite nakon što završite obuku,
Please contact to the user who have Sales Master Manager {0} role,Obratite se korisniku koji ima ulogu Sales Master Managera {0},
Please create Customer from Lead {0},Molimo kreirajte klijenta od Lead {0},
Please create purchase receipt or purchase invoice for the item {0},Izradite račun kupovine ili račun za kupovinu stavke {0},
Please define grade for Threshold 0%,Molimo vas da definišete ocenu za Threshold 0%,
Please enable Applicable on Booking Actual Expenses,Molimo vas da omogućite Primjenjivo za rezervacije stvarnih troškova,
Please enable Applicable on Purchase Order and Applicable on Booking Actual Expenses,Molimo omogućite Primjenjivo na narudžbenici i primjenjive na stvarne troškove rezervacije,
Please enable default incoming account before creating Daily Work Summary Group,Omogućite podrazumevani dolazni račun pre kreiranja Dnevne radne grupe,
Please enable pop-ups,Omogućite iskačuće prozore,
Please enter 'Is Subcontracted' as Yes or No,Molimo vas da unesete &#39;Da li je podugovor&#39; kao Da ili Ne,
Please enter API Consumer Key,Unesite API Consumer Key,
Please enter API Consumer Secret,Unesite tajnu API potrošača,
Please enter Account for Change Amount,Unesite račun za iznos izmjene,
Please enter Approving Role or Approving User,Molimo vas da unesete uloga za odobravanje ili korisnika odobrenja,
Please enter Cost Center,Unesite Centar troškova,
Please enter Delivery Date,Unesite datum isporuke,
Please enter Employee Id of this sales person,Molimo vas da unesete ID zaposlenika ovog prodavača,
Please enter Expense Account,Unesite račun troška,
Please enter Item Code to get Batch Number,Molimo unesite šifru artikla da dobijete serijski broj,
Please enter Item Code to get batch no,Molimo unesite Šifru artikla da dobijete serijski br,
Please enter Item first,Molimo prvo unesite stavku,
Please enter Maintaince Details first,Molimo prvo unesite Maintaince Details,
Please enter Material Requests in the above table,Molimo vas da u gornju tabelu unesete Upit za materijal,
Please enter Planned Qty for Item {0} at row {1},Unesite Plansku količinu za stavku {0} u redu {1},
Please enter Preferred Contact Email,Unesite Preferred Contact Email,
Please enter Production Item first,Prvo unesite proizvodnu stavku,
Please enter Purchase Receipt first,Prvo unesite Potvrda o kupnji,
Please enter Receipt Document,Molimo vas da unesete dokument o prijemu,
Please enter Reference date,Unesite referentni datum,
Please enter Repayment Periods,Unesite Rok otplate,
Please enter Reqd by Date,Molimo unesite zahtjev po datumu,
Please enter Sales Orders in the above table,Molimo vas da unesete prodajne narudžbe u gornju tabelu,
Please enter Woocommerce Server URL,Unesite URL adrese Woocommerce servera,
Please enter Write Off Account,Molimo Vas da unesete Account Off,
Please enter atleast 1 invoice in the table,Molimo vas da u tabeli unesete najmanje 1 fakturu,
Please enter company first,Prvo unesite firmu,
Please enter company name first,Prvo unesite ime kompanije,
Please enter default currency in Company Master,Molimo Vas da unesete valutu valuta u default,
Please enter message before sending,Unesite poruku prije slanja,
Please enter parent cost center,Unesite matično troškovno mjesto,
Please enter quantity for Item {0},Unesite količinu za stavku {0},
Please enter relieving date.,Unesite datum oslobađanja.,
Please enter repayment Amount,Unesite iznos otplate,
Please enter valid Financial Year Start and End Dates,Unesite važeći datum početka i završetka finansijske godine,
Please enter valid email address,Unesite važeću adresu e-pošte,
Please enter {0} first,Unesite prvo {0},
Please fill in all the details to generate Assessment Result.,Molimo Vas da popunite sve detalje za izradu rezultata ocjenjivanja.,
Please identify/create Account (Group) for type - {0},Prepoznajte / kreirajte račun (grupu) za vrstu - {0},
Please identify/create Account (Ledger) for type - {0},Molimo identifikujte / kreirajte račun (knjiga) za tip - {0},
Please input all required Result Value(s),Molimo unesite sve tražene vrijednosti rezultata,
Please login as another user to register on Marketplace,Prijavite se kao drugi korisnik da biste se registrirali na Marketplace-u,
Please make sure you really want to delete all the transactions for this company. Your master data will remain as it is. This action cannot be undone.,Provjerite da li zaista želite izbrisati sve transakcije za ovu tvrtku. Vaši matični podaci ostaju onakvi kakvi jesu. Ova akcija se ne može poništiti.,
Please mention Basic and HRA component in Company,Navedite osnovnu i HRA komponentu u kompaniji,
Please mention Round Off Account in Company,Molimo navedite Round Off račun u kompaniji,
Please mention Round Off Cost Center in Company,Molimo vas da navedete Okrugli centar troškova u kompaniji,
Please mention no of visits required,Navedite broj potrebnih posjeta,
Please mention the Lead Name in Lead {0},Navedite ime olova u olovu {0},
Please pull items from Delivery Note,"Molimo, izvucite artikle iz isporuke",
Please re-type company name to confirm,Molimo da ponovo potvrdite ime kompanije,
Please register the SIREN number in the company information file,Molimo vas da registrujete SIREN broj u datoteci s informacijama o kompaniji,
Please remove this Invoice {0} from C-Form {1},Uklonite ovaj račun {0} iz C-obrasca {1},
Please save before assigning task.,Molimo Vas da sačuvate pre dodeljivanja zadatka.,
Please save the patient first,Prvo sačuvajte pacijenta,
Please save the report again to rebuild or update,Sačuvajte ponovo izveštaj da biste ponovo izgradili ili ažurirali,
"Please select Allocated Amount, Invoice Type and Invoice Number in atleast one row","Molimo vas da odaberete Dodeljeni iznos, vrstu fakture i broj fakture u najmanje jednom redu",
Please select Apply Discount On,Odaberite Apply Discount On,
Please select BOM against item {0},Odaberite BOM protiv stavke {0},
Please select BOM for Item in Row {0},Odaberite BOM za stavku u retku {0},
Please select BOM in BOM field for Item {0},Odaberite BOM u polju BOM za stavku {0},
Please select Category first,Prvo izaberite kategoriju,
Please select Charge Type first,Prvo odaberite Vrsta punjenja,
Please select Company,Molimo odaberite Društvo,
Please select Company and Designation,Molimo odaberite Društvo i oznaku,
Please select Company and Party Type first,Prvo izaberite Company and Party Type,
Please select Company and Posting Date to getting entries,Molimo odaberite Društvo i Datum knjiženja za dobivanje unosa,
Please select Company first,Prvo izaberite preduzeće,
Please select Completion Date for Completed Asset Maintenance Log,Molimo odaberite Datum završetka završenog dnevnika održavanja imovine,
Please select Completion Date for Completed Repair,Odaberite Datum završetka za dovršenu popravku,
Please select Course,Molimo izaberite Kurs,
Please select Drug,Izaberite Drug,
Please select Employee,Molimo odaberite zaposlenika,
Please select Employee Record first.,Prvo odaberite Zapis zaposlenika.,
Please select Existing Company for creating Chart of Accounts,Molimo odaberite postojeću kompaniju za kreiranje kontnog plana,
Please select Healthcare Service,Molimo Vas da odaberete 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 gdje je &quot;Je li stavka&quot; &quot;Ne&quot; i &quot;Je li prodajna stavka&quot; je &quot;Da&quot; i nema drugog paketa proizvoda,
Please select Maintenance Status as Completed or remove Completion Date,Odaberite Status održavanja kao dovršen ili uklonite datum završetka,
Please select Party Type first,Prvo odaberite tip benda,
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,Molimo odaberite Datum knjiženja prije odabira Stranke,
Please select Posting Date first,Prvo odaberite Datum knjiženja,
Please select Price List,Odaberite Cjenik,
Please select Program,Molimo odaberite Program,
Please select Qty against item {0},Odaberite Količina od stavke {0},
Please select Sample Retention Warehouse in Stock Settings first,Prvo izaberite Skladište uzorka zadržavanja u postavkama zaliha,
Please select Start Date and End Date for Item {0},Odaberite Datum početka i Datum završetka za stavku {0},
Please select Student Admission which is mandatory for the paid student applicant,Molimo odaberite Prijem studenata koji je obavezan za plaćenog studenta,
Please select a BOM,Odaberite sastavnicu,
Please select a Batch for Item {0}. Unable to find a single batch that fulfills this requirement,Odaberite Batch for Item {0}. Nije moguće pronaći niti jedan paket koji ispunjava ovaj zahtjev,
Please select a Company,Molimo izaberite kompaniju,
Please select a batch,Molimo odaberite paket,
Please select a csv file,Odaberite csv datoteku,
Please select a customer,Izaberite klijenta,
Please select a field to edit from numpad,Odaberite polje za uređivanje iz numeričke tipkovnice,
Please select a table,Odaberite tablicu,
Please select a valid Date,Odaberite važeći datum,
Please select a value for {0} quotation_to {1},Odaberite vrijednost za {0} quotation_to {1},
Please select a warehouse,Molimo odaberite skladište,
Please select an item in the cart,Molimo odaberite stavku u košarici,
Please select at least one domain.,Odaberite barem jedan domen.,
Please select correct account,Odaberite ispravan račun,
Please select customer,Molimo odaberite kupca,
Please select date,Odaberite datum,
Please select item code,Odaberite kôd stavke,
Please select month and year,Odaberite mjesec i godinu,
Please select prefix first,Prvo odaberite prefiks,
Please select the Company,Molimo izaberite Društvo,
Please select the Company first,Prvo izaberite kompaniju,
Please select the Multiple Tier Program type for more than one collection rules.,Molimo izaberite tip višestrukog programa za više pravila prikupljanja.,
Please select the assessment group other than 'All Assessment Groups',Molimo izaberite grupu za procenu osim &quot;Sve grupe za procenu&quot;,
Please select the document type first,Prvo izaberite tip dokumenta,
Please select weekly off day,Molimo da izaberete nedeljni dan,
Please select {0},Odaberite {0},
Please select {0} first,Prvo odaberite {0},
Please set 'Apply Additional Discount On',Postavite &#39;Primijeni dodatni popust na&#39;,
Please set 'Asset Depreciation Cost Center' in Company {0},Postavite &#39;Središte troškova amortizacije imovine&#39; u kompaniji {0},
Please set 'Gain/Loss Account on Asset Disposal' in Company {0},Molimo vas da postavite &#39;Gain / Gubitak računa na raspolaganje imovinom&#39; u kompaniji {0},
Please set Account in Warehouse {0} or Default Inventory Account in Company {1},Postavite račun na skladištu {0} ili zadani račun inventara u tvrtki {1},
Please set B2C Limit in GST Settings.,Postavite B2C granicu u GST postavkama.,
Please set Company,Molimo postavite kompaniju,
Please set Company filter blank if Group By is 'Company',Postavite filtar tvrtke prazan ako je Grupa po &quot;Tvrtka&quot;,
Please set Default Payroll Payable Account in Company {0},Molimo postavite Default Payroll Payable Payable Account u preduzeću {0},
Please set Depreciation related Accounts in Asset Category {0} or Company {1},Postavite račune za amortizaciju u kategoriji imovine {0} ili tvrtku {1},
Please set Email Address,Postavite adresu e-pošte,
Please set GST Accounts in GST Settings,Postavite GST račune u GST postavkama,
Please set Hotel Room Rate on {},Molimo vas da postavite cijenu za hotelsku sobu na {},
Please set Number of Depreciations Booked,Postavite broj knjiženih amortizacija,
Please set Unrealized Exchange Gain/Loss Account in Company {0},Molimo postavite nerealizirani račun dobiti i gubitka na burzi u poduzeću {0},
Please set User ID field in an Employee record to set Employee Role,Postavite polje ID korisnika u zapis zaposlenika da biste postavili ulogu zaposlenika,
Please set a default Holiday List for Employee {0} or Company {1},Postavite zadanu listu praznika za zaposlenika {0} ili tvrtku {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 kategoriji zadržavanja poreza {0} protiv tvrtke {1},
Please set at least one row in the Taxes and Charges Table,Postavite najmanje jedan red u tabeli Porezi i naknade,
Please set default Cash or Bank account in Mode of Payment {0},Molimo vas da postavite uobičajeni novčani ili bankovni račun u načinu plaćanja {0},
Please set default account in Expense Claim Type {0},Postavite zadani račun u vrsti zahtjeva za troškove {0},
Please set default account in Salary Component {0},Molimo vas da postavite podrazumevani račun u Komponenti plata {0},
Please set default customer group and territory in Selling Settings,Molimo vas da postavite podrazumevanu grupu kupaca i teritoriju u postavkama prodaje,
Please set default customer in Restaurant Settings,Postavite zadanog korisnika u postavkama restorana,
Please set default template for Leave Approval Notification in HR Settings.,Molimo postavite zadani predložak za Leave Approval Notification u HR Settings.,
Please set default template for Leave Status Notification in HR Settings.,Molimo postavite zadani predložak za Obavijest o ostavljanju statusa u HR postavkama.,
Please set default {0} in Company {1},Unesite {0} u tvrtku {1},
Please set filter based on Item or Warehouse,Postavite filter na osnovu stavke ili skladišta,
Please set leave policy for employee {0} in Employee / Grade record,Postavite politiku ostavljanja za zaposlenika {0} u evidenciji o zaposleniku / razredu,
Please set recurring after saving,Podesite ponavljanje nakon spremanja,
Please set the Company,Molimo postavite kompaniju,
Please set the Customer Address,Postavite adresu klijenta,
Please set the Date Of Joining for employee {0},Postavite datum pridruživanja za zaposlenika {0},
Please set the Default Cost Center in {0} company.,Podesite Default Cost Center u kompaniji {0}.,
Please set the Email ID for the Student to send the Payment Request,Molimo vas da postavite ID e-pošte kako bi učenik mogao poslati zahtjev za plaćanje,
Please set the Item Code first,Prvo postavite šifru predmeta,
Please set the Payment Schedule,Postavite raspored plaćanja,
Please set the series to be used.,Podesite seriju koja će se koristiti.,
Please set {0} for address {1},Postavite {0} za adresu {1},
Please setup Students under Student Groups,Molimo vas da podesite učenike u okviru studentskih grupa,
Please share your feedback to the training by clicking on 'Training Feedback' and then 'New',"Molimo vas da podijelite svoje povratne informacije sa obukom klikom na &#39;Povratna informacija treninga&#39;, a zatim &#39;Novo&#39; \ t",
Please specify Company,Navedite kompaniju,
Please specify Company to proceed,Molimo navedite tvrtku za nastavak,
Please specify a valid 'From Case No.',Molimo Vas da navedete važeću &#39;From Case No.&#39;,
Please specify a valid Row ID for row {0} in table {1},Navedite važeći ID retka za redak {0} u tablici {1},
Please specify at least one attribute in the Attributes table,Navedite najmanje jedan atribut u tablici Atributi,
Please specify currency in Company,Navedite valutu u kompaniji,
Please specify either Quantity or Valuation Rate or both,Navedite količinu ili stopu procjene ili oboje,
Please specify from/to range,Navedite od / do raspona,
Please supply the specified items at the best possible rates,Molimo Vas da dostavite navedene artikle po najboljoj mogućoj cijeni,
Please update your status for this training event,Ažurirajte svoj status za ovaj trening događaj,
Please wait 3 days before resending the reminder.,Pričekajte 3 dana prije slanja podsjetnika.,
Point of Sale,Mjestu prodaje,
Point-of-Sale,Mjestu prodaje,
Point-of-Sale Profile,Profil prodajnog mjesta,
Portal,Portal,
Possible Supplier,Mogući dobavljač,
Postal Expenses,Poštanski troškovi,
Posting Date,Datum objave,
Posting Date cannot be future date,Datum knjiženja ne može biti datum u budućnosti,
Posting Time,Vrijeme slanja,
Posting date and posting time is mandatory,Datum i vrijeme knjiženja su obavezni,
Posting timestamp must be after {0},Vremenska oznaka knjiženja mora biti nakon {0},
Potential opportunities for selling.,Potencijalne mogućnosti za prodaju.,
Practitioner Schedule,Raspored praktičara,
Pre Sales,Pre Sales,
Preference,Preference,
Prescribed Procedures,Propisane procedure,
Prescription,Prescription,
Prescription Dosage,Doziranje na recept,
Prescription Duration,Trajanje recepta,
Prescriptions,Prescriptions,
Present,Present,
Prev,Prev,
Preview Salary Slip,Preview Salary Slip,
Previous Financial Year is not closed,Prethodna finansijska godina nije zatvorena,
Price,Price,
Price List,Cjenovnik,
Price List Currency not selected,Cjenik Valuta nije odabrana,
Price List Rate,Price List Rate,
Price List master.,Cjenovnik Master.,
Price List must be applicable for Buying or Selling,Cenovnik mora biti primjenjiv za kupovinu ili prodaju,
Price List not found or disabled,Cenovnik nije pronađen ili onemogućen,
Price List {0} is disabled or does not exist,Cenovnik {0} je onemogućen ili ne postoji,
Price or product discount slabs are required,Potrebne su ploče s popustom za cijenu ili proizvod,
Pricing,Cijene,
Pricing Rule,Pravilo o cenama,
"Pricing Rule is first selected based on 'Apply On' field, which can be Item, Item Group or Brand.","Pravilo određivanja cijena se prvo bira na osnovu polja &quot;Primijeni na&quot;, koje može biti Grupa, Grupa predmeta ili Marka.",
"Pricing Rule is made to overwrite Price List / define discount percentage, based on some criteria.","Pravilo određivanja cijena je napravljeno kako bi se prepisao cjenik / definisao postotak popusta, na osnovu nekih kriterija.",
Pricing Rule {0} is updated,Pravilo određivanja cijena {0} je ažurirano,
Pricing Rules are further filtered based on quantity.,Pravila određivanja cijena se dalje filtriraju na osnovu količine.,
Primary,Primary,
Primary Address Details,Detalji primarne adrese,
Primary Contact Details,Primary Contact Details,
Principal Amount,Glavni iznos,
Print IRS 1099 Forms,Ispis IRS 1099 Obrasci,
Print Report Card,Print Report Card,
Print and Stationery,Print and Stationery,
Print settings updated in respective print format,Postavke ispisa ažurirane u odgovarajućem formatu ispisa,
Print taxes with zero amount,Štampajte poreze sa nultim iznosom,
Printing and Branding,Štampanje i brendiranje,
Private Equity,Private Equity,
Privilege Leave,Privilege Leave,
Probation,Probation,
Probationary Period,Probnog perioda,
Procedure,Procedura,
Process Day Book Data,Podaci o danu knjige procesa,
Process Master Data,Glavni podaci procesa,
Processing Chart of Accounts and Parties,Obrada kontnog plana i strana,
Processing Items and UOMs,Stavke obrade i UOM-ovi,
Processing Party Addresses,Obrađuje adrese adresa,
Processing Vouchers,Obrada vaučera,
Procurement,Nabavka,
Produced Qty,Proizveden kom,
Product,Proizvod,
Product Bundle,Paket proizvoda,
Product Search,Pretraživanje proizvoda,
Production,Proizvodnja,
Production Item,Proizvodna stavka,
Productions Orders cannot be raised for:,Porudžbine za proizvodnju se ne mogu podići za:,
Products,Proizvodi,
Profit and Loss,Dobitak i gubitak,
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} su različiti.,
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 veći od 100.,
Project Collaboration Invitation,Poziv za saradnju na projektu,
Project Id,Id projekta,
Project Manager,Project Manager,
Project Name,ime projekta,
Project Start Date,Datum početka projekta,
Project Status,Status projekta,
Project Summary for {0},Sažetak projekta za {0},
Project Update.,Project Update.,
Project Value,Vrijednost projekta,
Project activity / task.,Projektna aktivnost / zadatak.,
Project master.,Master projekta.,
Project-wise data is not available for Quotation,Podaci o projektu nisu dostupni za ponudu,
Projected,Projected,
Projected Qty,Projected Qty,
Projected Quantity Formula,Formula projicirane količine,
Projects,Projekti,
Property already added,Vlasništvo je već dodano,
Proposal Writing,Pisanje predloga,
Proposal/Price Quote,Prijedlog / cijena citat,
Prospecting,Prospecting,
Provisional Profit / Loss (Credit),Privremeni profit / gubitak (kredit),
Publications,Publikacije,
Publish Items on Website,Objavite stavke na web-lokaciji,
Publishing,Publishing,
Purchase,Kupovina,
Purchase Amount,Iznos kupovine,
Purchase Date,Datum kupovine,
Purchase Invoice,Faktura kupovine,
Purchase Invoice {0} is already submitted,Faktura kupovine {0} je već poslana,
Purchase Order,Narudžbenica,
Purchase Order Amount,Iznos narudžbenice,
Purchase Order Amount(Company Currency),Iznos narudžbenice (valuta kompanije),
Purchase Order Date,Datum narudžbenice,
Purchase Order Items not received on time,Stavke narudžbenice nisu primljene na vrijeme,
Purchase Order number required for Item {0},Broj narudžbenice potreban za stavku {0},
Purchase Order to Payment,Narudžbenica za plaćanje,
Purchase Order {0} is not submitted,Nalog za kupovinu {0} nije dostavljen,
Purchase Orders are not allowed for {0} due to a scorecard standing of {1}.,Nalozi za kupnju nisu dozvoljeni za {0} zbog stanja bodova {1}.,
Purchase Orders given to Suppliers.,Narudžbenice za dobavljače.,
Purchase Price List,Cjenik kupnje,
Purchase Receipt,Potvrda o kupnji,
Purchase Receipt {0} is not submitted,Potvrda o kupnji {0} nije poslana,
Purchase Tax Template,Šablon poreza za kupovinu,
Purchase orders help you plan and follow up on your purchases,Narudžbenice vam pomažu u planiranju i praćenju kupovine,
Purchasing,Purchasing,
Purpose must be one of {0},Svrha mora biti jedna od {0},
Qty,Kol,
Qty To Manufacture,Količina za proizvodnju,
Qty Total,Ukupno ukupno,
Qty for {0},Količina za {0},
Qty per BOM Line,Količina po liniji BOM,
Qualification,Kvalifikacija,
Quality,Kvalitet,
Quality Action,Quality Action,
Quality Goal.,Cilj kvaliteta.,
Quality Inspection,Inspekcija kvaliteta,
Quality Inspection: {0} is not submitted for the item: {1} in row {2},Inspekcija kvalitete: {0} nije poslana za stavku: {1} u redu {2},
Quality Management,Upravljanje kvalitetom,
Quality Meeting,Quality Meeting,
Quality Procedure,Procedura kvaliteta,
Quality Procedure.,Procedura kvaliteta.,
Quality Review,Quality Review,
Quantity,Količina,
Quantity ({0}) cannot be a fraction in row {1},Količina ({0}) ne može biti frakcija u redu {1},
Quantity for Item {0} must be less than {1},Količina za stavku {0} mora biti manja od {1},
Quantity in row {0} ({1}) must be same as manufactured quantity {2},Količina u redu {0} ({1}) mora biti ista kao proizvedena količina {2},
Quantity must be less than or equal to {0},Količina mora biti manja ili jednaka {0},
Quantity must be positive,Količina mora biti pozitivna,
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 stavku {0} u redu {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ća 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 nule,
Queued for replacing the BOM. It may take a few minutes.,U redu za zamjenu sastavnice. Može potrajati nekoliko minuta.,
Queued for updating latest price in all Bill of Materials. It may take a few minutes.,U redu za ažuriranje najnovije cijene u svim materijalima. Može potrajati nekoliko minuta.,
Quick Journal Entry,Quick Journal Entry,
Quot Count,Quot Count,
Quot/Lead %,Quot / Lead%,
Quotation,Citiranje,
Quotation {0} is cancelled,Ponuda {0} je otkazana,
Quotation {0} not of type {1},Ponuda {0} nije tipa {1},
Quotations,Citati,
"Quotations are proposals, bids you have sent to your customers","Ponude su ponude, ponude koje ste poslali svojim klijentima",
Quotations received from Suppliers.,Ponude dobijene od dobavljača.,
Quotations: ,Citati:,
Quotes to Leads or Customers.,Citati za vode ili klijente.,
RFQs are not allowed for {0} due to a scorecard standing of {1},RFQ-ovi nisu dozvoljeni za {0} zbog stanja rezultata {1},
Range,Range,
Rate,Rate,
Rate:,Ocijeni:,
Raw Material,Sirovina,
Raw Materials,Sirovine,
Raw Materials cannot be blank.,Sirovine ne mogu biti prazne.,
Re-open,Ponovo otvorite,
Read blog,Pročitajte blog,
Read the ERPNext Manual,Pročitajte ERPNext priručnik,
Reading Uploaded File,Reading Uploaded File,
Real Estate,Nekretnina,
Reason For Putting On Hold,Razlog za stavljanje na čekanje,
Reason for Hold,Razlog za zadržavanje,
Reason for hold: ,Razlog za zadržavanje:,
Receipt,Receipt,
Receipt document must be submitted,Dokument o prijemu mora biti dostavljen,
Receivable,Potraživanja,
Receivable Account,Račun potraživanja,
Receive at Warehouse Entry,Primite na ulazu u skladište,
Received,Primljeno,
Received On,Received On,
Received Quantity,Primljena količina,
Received Stock Entries,Received Stock Entries,
Receiver List is empty. Please create Receiver List,Lista prijemnika je prazna. Kreirajte listu prijemnika,
Reconcile,Reconcile,
Record Patient Vitals,Zabilježite pacijentove vitale,
"Record of all communications of type email, phone, chat, visit, etc.","Snimanje svih komunikacija tipa e-pošte, telefona, razgovora, posjeta, itd.",
Records,Records,
Ref,Ref,
Ref Date,Ref Date,
Reference,Reference,
Reference #{0} dated {1},Reference # {0} sa datumom {1},
Reference Date,Referentni datum,
Reference Doctype must be one of {0},Reference Doctype mora biti jedna od {0},
Reference Document,Referentni dokument,
Reference No & Reference Date is required for {0},Referentni broj i referentni datum je potreban za {0},
Reference No and Reference Date is mandatory for Bank transaction,Referentni broj i referentni datum su obavezni za transakciju Banke,
Reference No is mandatory if you entered Reference Date,Referentni broj je obavezan ako ste unijeli referentni datum,
Reference No.,Referentni broj,
Reference Number,Referentni broj,
"Reference: {0}, Item Code: {1} and Customer: {2}","Referenca: {0}, šifra artikla: {1} i klijent: {2}",
References,Reference,
Register,Register,
Registration fee can not be Zero,Kotizacija ne može biti Zero,
Reject,Odbaci,
Rejected,Odbijeno,
Related,Povezano,
Relation with Guardian1,Odnos sa Guardian-om1,
Relation with Guardian2,Odnos sa Guardian2,
Release Date,Datum izdavanja,
Reload Linked Analysis,Reload Linked Analysis,
Remaining,Preostalo,
Remaining Balance,Preostali iznos,
Remarks,Napomene,
Reminder to update GSTIN Sent,Podsetnik za ažuriranje GSTIN-a,
Remove item if charges is not applicable to that item,Uklonite stavku ako naplata nije primjenjiva na tu stavku,
Removed items with no change in quantity or value.,Uklonjene stavke bez promjene u količini ili vrijednosti.,
Reopen,Ponovo otvori,
Reorder Level,Reorder Level,
Reorder Qty,Reorder Qty,
Repeat Customer Revenue,Ponovite prihode klijenata,
Repeat Customers,Ponovi klijente,
Replace BOM and update latest price in all BOMs,Zamijenite BOM i ažurirajte najnoviju cijenu u svim sastavnicama,
Replies,Odgovori,
Report,Report,
Report Builder,Report Builder,
Report Type is mandatory,Tip izveštaja je obavezan,
Report an Issue,Prijavite problem,
Reports,Izvještaji,
Reqd By Date,Reqd By Date,
Reqd Qty,Reqd Qty,
Request for Quotation,Zahtev za ponudu,
"Request for Quotation is disabled to access from portal, for more check portal settings.","Zahtjev za ponudu je onemogućen za pristup s portala, za više provjera postavki portala.",
Request for Quotations,Zahtev za ponudu,
Request for Raw Materials,Zahtjev za sirovine,
Request for purchase.,Zahtjev za kupovinu.,
Request for quotation.,Request for quotation.,
Requested Qty,Requested Qty,
"Requested Qty: Quantity requested for purchase, but not ordered.","Tražena količina: Količina koja se traži za kupovinu, ali nije naručena.",
Requesting Site,Requesting Site,
Requesting payment against {0} {1} for amount {2},Zahtjev za plaćanje u iznosu od {0} {1} za iznos {2},
Requestor,Requestor,
Required On,Obavezno Uključeno,
Required Qty,Potreban kom,
Required Quantity,Potrebna količina,
Reschedule,Reschedule,
Research,Istraživanje,
Research & Development,istraživanje i razvoj,
Researcher,Istraživač,
Resend Payment Email,Ponovno pošalji e-poruku za plaćanje,
Reserve Warehouse,Reserve Warehouse,
Reserved Qty,Reserved Qty,
Reserved Qty for Production,Rezervisana količina za proizvodnju,
Reserved Qty for Production: Raw materials quantity to make manufacturing items.,Rezervisana količina za proizvodnju: Količina sirovina za izradu proizvodnih predmeta.,
"Reserved Qty: Quantity ordered for sale, but not delivered.","Rezervirano Količina: Količina naručena za prodaju, ali ne isporučena.",
Reserved Warehouse is mandatory for Item {0} in Raw Materials supplied,Rezervirano skladište je obavezno za stavku {0} u isporučenim sirovinama,
Reserved for manufacturing,Rezervirano za proizvodnju,
Reserved for sale,Rezervirano za prodaju,
Reserved for sub contracting,Rezervisano za podugovaranje,
Resistant,Otporan,
Resolve error and upload again.,Rješavanje greške i ponovno učitavanje.,
Responsibilities,Odgovornosti,
Rest Of The World,Ostatak svijeta,
Restart Subscription,Restart Subscription,
Restaurant,Restoran,
Result Date,Datum rezultata,
Result already Submitted,Rezultat je već poslan,
Resume,Nastavi,
Retail,Maloprodaja,
Retail & Wholesale,Retail &amp; Wholesale,
Retail Operations,Maloprodajne operacije,
Retained Earnings,Zadržana zarada,
Retention Stock Entry,Retention Stock Entry,
Retention Stock Entry already created or Sample Quantity not provided,Zadržavanje zaliha Unos već kreiran ili uzorak količine nije dostavljen,
Return,Povratak,
Return / Credit Note,Povratna / kreditna napomena,
Return / Debit Note,Povratna / debitna napomena,
Returns,Returns,
Reverse Journal Entry,Reverse Journal Entry,
Review Invitation Sent,Pozivnica za pregled je poslata,
Review and Action,Pregled i akcija,
Rooms Booked,Sobe Rezervirano,
Root Account must be a group,Root račun mora biti grupa,
Root Company,Root Company,
Root Type,Root Type,
Root Type is mandatory,Tip Root je obavezan,
Root cannot be edited.,Root se ne može uređivati.,
Root cannot have a parent cost center,Root ne može imati matično mjesto troška,
Round Off,Zaokružiti,
Rounded Total,Rounded Total,
Row # {0}: ,Red # {0}:,
Row # {0}: Batch No must be same as {1} {2},Red # {0}: Serijski broj mora biti isti kao i {1} {2},
Row # {0}: Cannot return more than {1} for Item {2},Red # {0}: Nije moguće vratiti više od {1} za stavku {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 koja se koristi u {1} {2},
Row # {0}: Returned Item {1} does not exists in {2} {3},Red # {0}: Vraćena stavka {1} ne postoji u {2} {3},
Row # {0}: Serial No is mandatory,Red # {0}: Serijski broj je obavezan,
Row # {0}: Serial No {1} does not match with {2} {3},Red # {0}: Serijski broj {1} se ne podudara s {2} {3},
Row #{0} (Payment Table): Amount must be negative,Red # {0} (Tabela plaćanja): Iznos mora biti negativan,
Row #{0} (Payment Table): Amount must be positive,Red # {0} (Tabela plaćanja): Iznos mora biti pozitivan,
Row #{0}: Account {1} does not belong to company {2},Red # {0}: Korisnički 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}: Svojstvo {1} ne može se poslati, već je {2}",
Row #{0}: Cannot set Rate if amount is greater than billed amount for Item {1}.,Red # {0}: Ne može se postaviti stopa ako je iznos veći od obračunatog iznosa za stavku {1}.,
Row #{0}: Clearance date {1} cannot be before Cheque Date {2},Red # {0}: Datum odobrenja {1} ne može biti prije datuma provjere {2},
Row #{0}: Duplicate entry in References {1} {2},Red # {0}: Dvostruki unos u Reference {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,Red # {0}: stavka je dodata,
Row #{0}: Journal Entry {1} does not have account {2} or already matched against another voucher,Red # {0}: Unos dnevnika {1} nema nalog {2} ili se već podudara sa drugim vaučerima,
Row #{0}: Not allowed to change Supplier as Purchase Order already exists,Red # {0}: Nije dozvoljeno menjati dobavljača jer narudžbenica već postoji,
Row #{0}: Please set reorder quantity,Red # {0}: Molimo vas da postavite količinu redosleda,
Row #{0}: Please specify Serial No for Item {1},Red # {0}: navedite serijski broj za stavku {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}: Stopa mora biti ista kao {1}: {2} ({3} / {4}),
Row #{0}: Reference Document Type must be one of Expense Claim or Journal Entry,Red # {0}: Vrsta referentnog dokumenta mora biti jedna od tvrdnji o troškovima ili unosa dnevnika,
"Row #{0}: Reference Document Type must be one of Purchase Order, Purchase Invoice or Journal Entry","Red # {0}: Vrsta referentnog dokumenta mora biti jedna od narudžbenice, fakture kupovine ili unosa dnevnika",
"Row #{0}: Reference Document Type must be one of Sales Order, Sales Invoice or Journal Entry","Red # {0}: Vrsta referentnog dokumenta mora biti jedna od prodajnog naloga, fakture prodaje ili unosa dnevnika",
Row #{0}: Rejected Qty can not be entered in Purchase Return,Red # {0}: Odbijeni broj se ne može unijeti u Povratak kupovine,
Row #{0}: Rejected Warehouse is mandatory against rejected Item {1},Red # {0}: Odbijena skladišta je obavezna za odbijenu stavku {1},
Row #{0}: Reqd by Date cannot be before Transaction Date,Red # {0}: Reqd by Date ne može biti prije datuma transakcije,
Row #{0}: Set Supplier for item {1},Red # {0}: Postavi dobavljača za stavku {1},
Row #{0}: Status must be {1} for Invoice Discounting {2},Red # {0}: Status mora biti {1} za sniženje dostavnice {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}: Serija {1} ima samo {2} kom. Molimo odaberite drugi paket koji ima dostupnu količinu {3} ili podijelite red na više redova, kako biste isporučili / izdali više paketa",
Row #{0}: Timings conflicts with row {1},Red # {0}: Vremenski razmaci su u sukobu s retkom {1},
Row #{0}: {1} can not be negative for item {2},Red # {0}: {1} ne može biti negativan za stavku {2},
Row No {0}: Amount cannot be greater than Pending Amount against Expense Claim {1}. Pending Amount is {2},Red No {0}: Iznos ne može biti veći od iznosa na čekanju u odnosu na potraživanje rashoda {1}. Iznos na čekanju je {2},
Row {0} : Operation is required against the raw material item {1},Red {0}: Potrebna je operacija prema sirovinskoj stavci {1},
Row {0}# Allocated amount {1} cannot be greater than unclaimed amount {2},Red {0} # Dodijeljeni iznos {1} ne može biti veći od neplaćenog iznosa {2},
Row {0}# Item {1} cannot be transferred more than {2} against Purchase Order {3},Red {0} # Stavka {1} ne može se prenijeti više od {2} na narudžbenicu narudžbe {3},
Row {0}# Paid Amount cannot be greater than requested advance amount,Red {0} # Plaćeni iznos ne može biti veći od traženog iznosa avansa,
Row {0}: Activity Type is mandatory.,Red {0}: Vrsta aktivnosti je obavezna.,
Row {0}: Advance against Customer must be credit,Red {0}: avans protiv klijenta mora biti kredit,
Row {0}: Advance against Supplier must be debit,Red {0}: avans protiv dobavljača mora biti zadužen,
Row {0}: Allocated amount {1} must be less than or equals to Payment Entry amount {2},Red {0}: dodijeljeni iznos {1} mora biti manji ili jednak iznosu upisa za uplatu {2},
Row {0}: Allocated amount {1} must be less than or equals to invoice outstanding amount {2},Red {0}: dodijeljeni iznos {1} mora biti manji ili jednak iznosu nepodmirene fakture {2},
Row {0}: An Reorder entry already exists for this warehouse {1},Red {0}: stavka za promjenu redoslijeda već postoji za ovo skladište {1},
Row {0}: Bill of Materials not found for the Item {1},Red {0}: Materijal koji nije pronađen za stavku {1},
Row {0}: Conversion Factor is mandatory,Red {0}: faktor konverzije je obavezan,
Row {0}: Cost center is required for an item {1},Red {0}: Mjesto troška je potrebno za stavku {1},
Row {0}: Credit entry can not be linked with a {1},Red {0}: unos kredita ne može se povezati s {1},
Row {0}: Currency of the BOM #{1} should be equal to the selected currency {2},Red {0}: Valuta sastavnice # {1} treba da bude jednaka odabranoj valuti {2},
Row {0}: Debit entry can not be linked with a {1},Red {0}: debitna stavka se ne može povezati s {1},
Row {0}: Depreciation Start Date is required,Red {0}: Datum početka amortizacije je obavezan,
Row {0}: Due Date cannot be before posting date,Red {0}: Datum dospijeća ne može biti prije datuma knjiženja,
Row {0}: Enter location for the asset item {1},Red {0}: unesite lokaciju za stavku imovine {1},
Row {0}: Exchange Rate is mandatory,Red {0}: Tečaj je obavezan,
Row {0}: Expected Value After Useful Life must be less than Gross Purchase Amount,Red {0}: Očekivana vrijednost nakon korisnog vijeka trajanja mora biti manja od bruto iznosa kupovine,
Row {0}: For supplier {0} Email Address is required to send email,Red {0}: Za dobavljača {0} Email adresa je potrebna za slanje e-pošte,
Row {0}: From Time and To Time is mandatory.,Red {0}: Od vremena i do vremena je obavezan.,
Row {0}: From Time and To Time of {1} is overlapping with {2},Red {0}: od vremena do vremena od {1} se preklapa sa {2},
Row {0}: From time must be less than to time,Red {0}: Od vremena mora biti manje od vremena,
Row {0}: Hours value must be greater than zero.,Red {0}: Vrijednost sata mora biti veća od nule.,
Row {0}: Invalid reference {1},Red {0}: nevažeća referenca {1},
Row {0}: Party / Account does not match with {1} / {2} in {3} {4},Red {0}: Partija / Račun se ne podudara s {1} / {2} u {3} {4},
Row {0}: Party Type and Party is required for Receivable / Payable account {1},Red {0}: Vrsta stranke i stranka su potrebni za račun potraživanja {1},
Row {0}: Payment against Sales/Purchase Order should always be marked as advance,Red {0}: Plaćanje prema prodaji / narudžbenici uvijek treba označiti kao unaprijed,
Row {0}: Please check 'Is Advance' against Account {1} if this is an advance entry.,Red {0}: Molimo vas da označite &#39;Je li unaprijed&#39; na računu {1} ako je to unos unaprijed.,
Row {0}: Please set at Tax Exemption Reason in Sales Taxes and Charges,Red {0}: postavite porez na oslobođenje od poreza u porezima na promet i naknadama,
Row {0}: Please set the Mode of Payment in Payment Schedule,Red {0}: Postavite način plaćanja na rasporedu plaćanja,
Row {0}: Please set the correct code on Mode of Payment {1},Red {0}: postavite ispravan kod na način plaćanja {1},
Row {0}: Qty is mandatory,Red {0}: Količina je obavezna,
Row {0}: Quality Inspection rejected for item {1},Red {0}: Odbijena inspekcija kvaliteta za stavku {1},
Row {0}: UOM Conversion Factor is mandatory,Red {0}: faktor konverzije UOM je obavezan,
Row {0}: select the workstation against the operation {1},Red {0}: izaberite radnu stanicu protiv operacije {1},
Row {0}: {1} Serial numbers required for Item {2}. You have provided {3}.,Red {0}: {1} Serijski brojevi potrebni za stavku {2}. Dali ste {3}.,
Row {0}: {1} is required to create the Opening {2} Invoices,Red {0}: {1} je potreban za kreiranje otvaranja {2} faktura,
Row {0}: {1} must be greater than 0,Red {0}: {1} mora biti veći od 0,
Row {0}: {1} {2} does not match with {3},Red {0}: {1} {2} se ne podudara s {3},
Row {0}:Start Date must be before End Date,Red {0}: Datum početka mora biti prije završnog datuma,
Rows with duplicate due dates in other rows were found: {0},Pronađeni su redovi s dupliciranim datumima u drugim redovima: {0},
Rules for adding shipping costs.,Pravila za dodavanje troškova dostave.,
Rules for applying pricing and discount.,Pravila za primjenu cijena i popusta.,
S.O. No.,SO No.,
SGST Amount,SGST Iznos,
SO Qty,SO Qty,
Safety Stock,Safety Stock,
Salary,Plata,
Salary Slip ID,ID plaće,
Salary Slip of employee {0} already created for this period,Isplata zarade zaposlenog {0} je već kreirana za ovaj period,
Salary Slip of employee {0} already created for time sheet {1},Isplata zarade zaposlenog {0} već kreirana za vremenski list {1},
Salary Slip submitted for period from {0} to {1},Isplata zarade poslata za period od {0} do {1},
Salary Structure Assignment for Employee already exists,Dodjela strukture zarada zaposlenom već postoji,
Salary Structure Missing,Nedostaje struktura plata,
Salary Structure must be submitted before submission of Tax Ememption Declaration,Struktura plata mora se podnijeti prije podnošenja Deklaracije o poreskoj olakšici,
Salary Structure not found for employee {0} and date {1},Struktura plata nije pronađena za zaposlene {0} i datum {1},
Salary Structure should have flexible benefit component(s) to dispense benefit amount,Struktura plata treba da ima fleksibilnu komponentu (e) beneficije za raspodjelu iznosa naknade,
"Salary already processed for period between {0} and {1}, Leave application period cannot be between this date range.","Plata koja je već obrađena za period između {0} i {1}, razdoblje napuštanja aplikacije ne može biti između ovog raspona datuma.",
Sales,Prodaja,
Sales Account,Račun prodaje,
Sales Expenses,Troškovi prodaje,
Sales Funnel,Prodajni tok,
Sales Invoice,Faktura prodaje,
Sales Invoice {0} created,Napravljena je faktura prodaje {0},
Sales Invoice {0} created as paid,Faktura prodaje {0} kreirana kao plaćena,
Sales Invoice {0} has already been submitted,Faktura prodaje {0} je već poslana,
Sales Invoice {0} must be cancelled before cancelling this Sales Order,Faktura prodaje {0} mora biti otkazana prije otkazivanja ovog prodajnog naloga,
Sales Order,Prodajni nalog,
Sales Order Item,Stavka prodajnog naloga,
Sales Order required for Item {0},Potreban prodajni nalog za stavku {0},
Sales Order to Payment,Prodajni nalog do plaćanja,
Sales Order {0} is not submitted,Prodajni nalog {0} nije dostavljen,
Sales Order {0} is not valid,Prodajni nalog {0} nije važeći,
Sales Order {0} is {1},Prodajni nalog {0} je {1},
Sales Orders,Prodajni nalozi,
Sales Partner,Prodajni partner,
Sales Pipeline,Prodaja naftovoda,
Sales Price List,Prodajni cenovnik,
Sales Return,Povratak prodaje,
Sales Summary,Sažetak prodaje,
Sales Tax Template,Šablon poreza na promet,
Sales Team,Prodajni tim,
Sales and Returns,Prodaja i povrat,
Sales campaigns.,Prodajne kampanje.,
Sales orders are not available for production,Prodajni nalozi nisu dostupni za proizvodnju,
Same Company is entered more than once,Ista kompanija se unosi više od jednom,
Same item cannot be entered multiple times.,Ista stavka se ne može unijeti više puta.,
Same supplier has been entered multiple times,Isti dobavljač je unesen više puta,
Sample Collection,Sample Collection,
Sample quantity {0} cannot be more than received quantity {1},Količina uzorka {0} ne može biti veća od primljene količine {1},
Sanctioned,Sankcionirano,
Sanctioned Amount,Sankcionisani iznos,
Sanctioned Amount cannot be greater than Claim Amount in Row {0}.,Sankcionirani iznos ne može biti veći od iznosa polaganja prava u redu {0}.,
Sand,Sand,
Saturday,Subota,
Saved,Sačuvano,
Saving {0},Spremanje {0},
Schedule,Raspored,
Schedule Admission,Schedule Admission,
Schedule Course,Raspored kursa,
Schedule Date,Datum rasporeda,
Schedule Discharge,Schedule Discharge,
Scheduled,Zakazano,
Scheduled Upto,Scheduled Upto,
"Schedules for {0} overlaps, do you want to proceed after skiping overlaped slots ?","Rasporedi za {0} preklapanja, želite li nastaviti nakon preskakanja preklopljenih slotova?",
Score cannot be greater than Maximum Score,Rezultat ne može biti veći od maksimalnog rezultata,
Score must be less than or equal to 5,Rezultat mora biti manji ili jednak 5,
Scorecards,Scorecards,
Scrapped,Otpisan,
Search,Search,
Search Item,Search Item,
Search Item (Ctrl + i),Stavka pretraživanja (Ctrl + i),
Search Results,Rezultati pretrage,
Search Sub Assemblies,Search Sub Assemblies,
"Search by item code, serial number, batch no or barcode","Pretraživanje po kodu artikla, serijskom broju, serijskom broju ili barkodu",
"Seasonality for setting budgets, targets etc.","Sezonski za postavljanje budžeta, ciljeva itd.",
Secretary,Sekretar,
Section Code,Šifra sekcije,
Secured Loans,Osigurani krediti,
Securities & Commodity Exchanges,Vrijednosni papiri i robne razmjene,
Securities and Deposits,Vrijednosni papiri i depoziti,
See All Articles,Vidi sve članke,
See all open tickets,Pogledajte sve otvorene karte,
See past orders,Pogledajte prethodne narudžbe,
See past quotations,Pogledajte prethodne citate,
Select,Izaberite,
Select Alternate Item,Odaberite Alternativni element,
Select Attribute Values,Izaberite Vrednosti atributa,
Select BOM,Izaberite BOM,
Select BOM and Qty for Production,Izaberite BOM i količinu za proizvodnju,
"Select BOM, Qty and For Warehouse","Odaberite BOM, Qty i For Warehouse",
Select Batch,Izaberite Batch,
Select Batch No,Izaberite Serijski br,
Select Batch Numbers,Izaberite Serijski brojevi,
Select Brand...,Izaberite brend ...,
Select Company,Select Company,
Select Company...,Izaberite kompaniju ...,
Select Customer,Izaberite Kupca,
Select Days,Izaberite Dani,
Select Default Supplier,Izaberite Default Supplier,
Select Department...,Odaberite odjel ...,
Select Fiscal Year...,Odaberite fiskalnu godinu ...,
Select Healthcare Practitioner...,Izaberite zdravstveni radnik ...,
Select Item (optional),Izaberi stavku (opcionalno),
Select Items based on Delivery Date,Izaberite stavke na osnovu datuma isporuke,
Select Items to Manufacture,Izaberite stavke za proizvodnju,
Select Loyalty Program,Izaberite Program lojalnosti,
Select POS Profile,Izaberite POS profil,
Select Patient,Izaberite Pacijent,
Select Possible Supplier,Odaberite Mogući dobavljač,
Select Property,Izaberite Svojstvo,
Select Quantity,Izaberite Količina,
Select Serial Numbers,Izaberite Serijski brojevi,
Select Status,Izaberite Status,
Select Target Warehouse,Izaberite Target Warehouse,
Select Type...,Odaberite Vrsta ...,
Select Warehouse...,Odaberite skladište ...,
Select an account to print in account currency,Izaberite nalog za štampanje u valuti računa,
Select an employee to get the employee advance.,Izaberite zaposlenog da biste dobili avans zaposlenika.,
Select at least one value from each of the attributes.,Odaberite najmanje jednu vrijednost iz svakog od atributa.,
Select change amount account,Odaberite račun za promjenu iznosa,
Select company first,Najprije odaberite tvrtku,
Select items to save the invoice,Izaberite stavke za čuvanje fakture,
Select or add new customer,Izaberite ili dodajte novog kupca,
Select students manually for the Activity based Group,Ručno izaberite učenike za grupu baziranu na aktivnosti,
Select the customer or supplier.,Izaberite 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.,Izaberite da biste dodali serijski broj.,
Select your Domains,Izaberite svoje domene,
Selected Price List should have buying and selling fields checked.,Izabrani cjenik treba da ima označena polja kupovine i prodaje.,
Sell,Sell,
Selling,Prodaja,
Selling Amount,Iznos prodaje,
Selling Price List,Cjenik prodaje,
Selling Rate,Stopa prodaje,
"Selling must be checked, if Applicable For is selected as {0}","Prodaja se mora provjeriti, ako je Primjenjivo za odabrano kao {0}",
Selling rate for item {0} is lower than its {1}. Selling rate should be atleast {2},Stopa prodaje za stavku {0} niža je od njene {1}. Stopa prodaje treba da bude najmanje {2},
Send Grant Review Email,Pošalji e-poruku za pregled Grant-a,
Send Now,Pošalji odmah,
Send SMS,Pošalji SMS,
Send Supplier Emails,Pošalji e-poštu dobavljača,
Send mass SMS to your contacts,Šaljite masovne SMS poruke svojim kontaktima,
Sensitivity,Osetljivost,
Serial #,Serial # \ t,
Serial No and Batch,Serijski broj i serija,
Serial No is mandatory for Item {0},Serijski broj je obavezan za stavku {0},
Serial No {0} does not belong to Batch {1},Serijski broj {0} ne pripada Batch {1},
Serial No {0} does not belong to Delivery Note {1},Serijski broj {0} ne pripada napomeni za isporuku {1},
Serial No {0} does not belong to Item {1},Serijski broj {0} ne pripada stavci {1},
Serial No {0} does not belong to Warehouse {1},Serijski broj {0} ne pripada Warehouseu {1},
Serial No {0} does not belong to any Warehouse,Serijski broj {0} ne pripada nijednom skladištu,
Serial No {0} does not exist,Serijski broj {0} ne postoji,
Serial No {0} has already been received,Serijski broj {0} je već primljen,
Serial No {0} is under maintenance contract upto {1},Serijski broj {0} je pod ugovorom o održavanju do {1},
Serial No {0} is under warranty upto {1},Serijski broj {0} je pod garancijom do {1},
Serial No {0} not found,Serijski broj {0} nije pronađen,
Serial No {0} not in stock,Serijski broj {0} nije na zalihi,
Serial No {0} quantity {1} cannot be a fraction,Serijska brojka {0} {1} ne može biti frakcija,
Serial Nos Required for Serialized Item {0},Serijski brojevi potrebni za serijsku stavku {0},
Serial Number: {0} is already referenced in Sales Invoice: {1},Serijski broj: {0} je već naveden u dostavnici: {1},
Serial Numbers,Serijski brojevi,
Serial Numbers in row {0} does not match with Delivery Note,Serijski brojevi u redu {0} se ne podudaraju s napomenom o isporuci,
Serial no item cannot be a fraction,Serijska stavka ne može biti dio,
Serial no {0} has been already returned,Serijski broj {0} je već vraćen,
Serial number {0} entered more than once,Serijski broj {0} unesen je više puta,
Serialized Inventory,Serialized Inventory,
Series Updated,Series Updated,
Series Updated Successfully,Serija je uspješno ažurirana,
Series is mandatory,Serija je obavezna,
Series {0} already used in {1},Serije {0} već korištene u {1},
Service,Service,
Service Expense,Rashodi za usluge,
"Service Item,Type,frequency and expense amount are required","Potrebna je stavka usluge, tip, učestalost i iznos troškova",
Service Level Agreement,Ugovor o nivou usluge,
Service Level Agreement.,Ugovor o nivou usluge.,
Service Level.,Nivo usluge.,
Service Stop Date cannot be after Service End Date,Datum servisnog zaustavljanja ne može biti nakon datuma završetka usluge,
Service Stop Date cannot be before Service Start Date,Datum servisnog zaustavljanja ne može biti prije datuma početka usluge,
Services,Usluge,
"Set Default Values like Company, Currency, Current Fiscal Year, etc.","Postavite standardne vrijednosti kao što su kompanija, valuta, tekuća fiskalna godina, itd.",
Set Details,Set Details,
Set New Release Date,Postavite novi datum izdavanja,
Set Open,Postavi Otvori,
Set Project and all Tasks to status {0}?,Postavite projekat i svi zadaci na status {0}?,
Set Status,Postavi status,
Set Tax Rule for shopping cart,Postavite porezno pravilo za korpe za kupovinu,
Set as Closed,Set as Closed,
Set as Completed,Postavi kao dovršeno,
Set as Default,Podesi kao podrazumevano,
Set as Lost,Postavite kao Izgubljeno,
Set as Open,Postavite kao Otvori,
Set default inventory account for perpetual inventory,Postavite standardni račun inventara za trajni inventar,
Set default mode of payment,Postavite zadani način plaćanja,
Set this if the customer is a Public Administration company.,Postavite ovo ako je klijent kompanija za javnu upravu.,
Set warehouse for Procedure {0} ,Postavi skladište za postupak {0},
Set {0} in asset category {1} or company {2},Postavite {0} u kategoriju sredstava {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đaja na {0}, budući da zaposlenik koji je priključen na niže prodajne osobe nema ID korisnika {1}",
Setting defaults,Postavljanje zadanih postavki,
Setting up Email,Podešavanje e-pošte,
Setting up Email Account,Podešavanje naloga e-pošte,
Setting up Employees,Postavljanje zaposlenih,
Setting up Taxes,Postavljanje poreza,
Setting up company,Postavljanje kompanije,
Settings,Podešavanja,
"Settings for online shopping cart such as shipping rules, price list etc.","Postavke za on-line korpe za kupovinu, kao što su pravila za dostavu, cenovnik itd.",
Settings for website homepage,Postavke za početnu stranicu web lokacije,
Settings for website product listing,Postavke za popis proizvoda na web-lokaciji,
Settled,Rešeno,
Setup Gateway accounts.,Podešavanje Gateway naloga.,
Setup SMS gateway settings,Postavite postavke SMS gateway-a,
Setup cheque dimensions for printing,Podešavanje proverite dimenzije za štampanje,
Setup default values for POS Invoices,Podesite zadane vrijednosti za POS račune,
Setup mode of POS (Online / Offline),Način postavljanja POS-a (Online / Offline),
Setup your Institute in ERPNext,Postavite svoj Institut u ERPNext,
Share Balance,Share Balance,
Share Ledger,Podijeli Ledger,
Share Management,Share Management,
Share Transfer,Deljenje transfera,
Share Type,Share Type,
Shareholder,Akcionar,
Ship To State,Ship to State,
Shipments,Pošiljke,
Shipping,Dostava,
Shipping Address,Adresa za dostavu,
"Shipping Address does not have country, which is required for this Shipping Rule","Adresa za dostavu nema zemlju, koja je potrebna za ovo Pravilo o otpremi",
Shipping rule not applicable for country {0},Pravilo dostave nije primjenjivo za zemlju {0},
Shipping rule only applicable for Buying,Pravilo dostave se primjenjuje samo za kupovinu,
Shipping rule only applicable for Selling,Pravilo o isporuci je primenljivo samo za prodaju,
Shopify Supplier,Shopify Supplier,
Shopping Cart,Kolica za kupovinu,
Shopping Cart Settings,Postavke košarice,
Shortage Qty,Količina nedostatka,
Show Completed,Show Completed,
Show Cumulative Amount,Prikaži kumulativni iznos,
Show Employee,Show Employee,
Show Open,Show Open,
Show Opening Entries,Prikaži početne unose,
Show Payment Details,Prikaži detalje plaćanja,
Show Return Entries,Prikaži povratne unose,
Show Salary Slip,Prikaži isplatu plata,
Show Variant Attributes,Prikaži atribute varijante,
Show Variants,Show Varijante,
Show closed,Prikaži zatvoreno,
Show exploded view,Prikaži eksplodirani prikaz,
Show only POS,Prikaži samo POS,
Show unclosed fiscal year's P&L balances,Prikažite bilans stanja dobiti i gubitka neotpisane fiskalne godine,
Show zero values,Prikaži nultu vrijednost,
Sick Leave,Bolovanje,
Silt,Silt,
Single Variant,Single Variant,
Single unit of an Item.,Jedinica jedinice.,
"Skipping Leave Allocation for the following employees, as Leave Allocation records already exists against them. {0}","Preskakanje izdvajanja za sljedeće zaposlenike, jer evidencija o alociranju ostavljanja već postoji protiv njih. {0}",
"Skipping Salary Structure Assignment for the following employees, as Salary Structure Assignment records already exists against them. {0}","Preskakanje rasporeda strukture plata za sljedeće zaposlenike, jer postoje zapisi o rasporedu plaća. {0}",
Slots for {0} are not added to the schedule,Sloti za {0} se ne dodaju rasporedu,
Small,Mala,
Soap & Detergent,Sapun i deterdžent,
Software,Softver,
Software Developer,Software Developer,
Softwares,Softwares,
Soil compositions do not add up to 100,Kompozicije zemljišta ne daju 100,
Sold,Sold,
Some emails are invalid,Neke poruke e-pošte su nevažeće,
Some information is missing,Neke informacije nedostaju,
Something went wrong!,Nešto je pošlo po zlu!,
"Sorry, Serial Nos cannot be merged","Žao nam je, Serijski brojevi se ne mogu spojiti",
Source,Izvor,
Source Warehouse,Izvorno skladište,
Source and Target Location cannot be same,Lokacija izvora i cilj ne može biti ista,
Source and target warehouse cannot be same for row {0},Izvorno i ciljno skladište ne može biti isto za redak {0},
Source and target warehouse must be different,Izvorno i ciljno skladište mora biti različito,
Source of Funds (Liabilities),Izvor sredstava (obaveza),
Source warehouse is mandatory for row {0},Izvorno skladište je obavezno za red {0},
Specified BOM {0} does not exist for Item {1},Navedena sastavnica {0} ne postoji za stavku {1},
Split,Podijeliti,
Split Batch,Split Batch,
Split Issue,Split Issue,
Sports,Sport,
Staffing Plan {0} already exist for designation {1},Plan osoblja {0} već postoji za oznaku {1},
Standard Buying,Standardna kupovina,
Standard Selling,Standardna prodaja,
Standard contract terms for Sales or Purchase.,Standardni uslovi ugovora za prodaju ili kupovinu.,
Start Date,Datum početka,
Start Date of Agreement can't be greater than or equal to End Date.,Datum početka sporazuma ne može biti veći od ili jednak završnom datumu.,
Start Year,Start Year,
"Start and end dates not in a valid Payroll Period, cannot calculate {0}","Početni i završni datumi koji nisu u važećem obračunskom periodu, ne mogu izračunati {0}",
"Start and end dates not in a valid Payroll Period, cannot calculate {0}.","Početni i završni datumi koji nisu u važećem obračunskom periodu, ne mogu izračunati {0}.",
Start date should be less than end date for Item {0},Datum početka treba biti manji od datuma završetka za stavku {0},
Start date should be less than end date for task {0},Početni datum treba biti manji od završnog datuma za zadatak {0},
Start day is greater than end day in task '{0}',Početni dan je veći od završnog dana u zadatku &#39;{0}&#39;,
Start on,Start on,
State,State,
State/UT Tax,Porez na državu / UT,
Statement of Account,Stanje racuna,
Status must be one of {0},Status mora biti jedan od {0},
Stock,Stock,
Stock Adjustment,Stock Adjustment,
Stock Analytics,Stock Analytics,
Stock Assets,Stock Assets,
Stock Available,Stock Available,
Stock Balance,Stock Balance,
Stock Entries already created for Work Order ,Stock Unosi već kreirani za radni nalog,
Stock Entry,Stock Entry,
Stock Entry {0} created,Stvoren je unos zaliha {0},
Stock Entry {0} is not submitted,Unos dionica {0} nije dostavljen,
Stock Expenses,Stock Expenses,
Stock In Hand,Stock In Hand,
Stock Items,Stock Items,
Stock Ledger,Stock Ledger,
Stock Ledger Entries and GL Entries are reposted for the selected Purchase Receipts,Unosi u knjigu zaliha i GL ulazi se objavljuju za odabrane potvrde o kupnji,
Stock Levels,Nivoi zaliha,
Stock Liabilities,Obaveze po dionicama,
Stock Options,Stock Options,
Stock Qty,Stock Qty,
Stock Received But Not Billed,"Zalihe primljene, ali nisu naplaćene",
Stock Reports,Stock Reports,
Stock Summary,Stock Summary,
Stock Transactions,Stock Transactions,
Stock UOM,Stock UOM,
Stock Value,Stock Value,
Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},Saldo zaliha u seriji {0} će postati negativan {1} za stavku {2} na skladištu {3},
Stock cannot be updated against Delivery Note {0},Zalihe se ne mogu ažurirati na računu isporuke {0},
Stock cannot be updated against Purchase Receipt {0},Stock nije moguće ažurirati u odnosu na potvrdu o kupnji {0},
Stock cannot exist for Item {0} since has variants,Stock ne može postojati za stavku {0} jer ima varijante,
Stock quantity to start procedure is not available in the warehouse. Do you want to record a Stock Transfer,Količina zaliha za početak postupka nije dostupna u skladištu. Želite li snimiti prijenos dionica,
Stock transactions before {0} are frozen,Stock transakcije prije {0} su zamrznute,
Stop,Stop,
Stopped,Stopped,
"Stopped Work Order cannot be cancelled, Unstop it first to cancel",Zaustavljeni radni nalog se ne može poništiti,
Stores,Trgovine,
Structures have been assigned successfully,Strukture su uspješno dodijeljene,
Student,Student,
Student Activity,Studentska aktivnost,
Student Address,Student Address,
Student Admissions,Student Admissions,
Student Attendance,Student Attendance,
"Student Batches help you track attendance, assessments and fees for students","Studentske serije pomažu vam da pratite pohađanje, procjene i naknade za studente",
Student Email Address,Adresa e-pošte studenta,
Student Email ID,ID e-pošte studenta,
Student Group,Studentska grupa,
Student Group Strength,Snaga studentske grupe,
Student Group is already updated.,Studentska grupa je već ažurirana.,
Student Group or Course Schedule is mandatory,Studentska grupa ili raspored kursa je obavezan,
Student Group: ,Grupa učenika:,
Student ID,Student ID,
Student ID: ,Student ID:,
Student LMS Activity,Student LMS Activity,
Student Mobile No.,Student Mobile No.,
Student Name,Ime studenta,
Student Name: ,Ime studenta:,
Student Report Card,Studentska iskaznica,
Student is already enrolled.,Student je već upisan.,
Student {0} - {1} appears Multiple times in row {2} & {3},Student {0} - {1} pojavljuje se više puta u redu {2} &amp; {3},
Student {0} does not belong to group {1},Student {0} ne pripada grupi {1},
Student {0} exist against student applicant {1},Student {0} postoji protiv kandidata za studente {1},
"Students are at the heart of the system, add all your students","Studenti su u srcu sistema, dodajte sve svoje učenike",
Sub Assemblies,Sub Assemblies,
Sub Type,Sub Type,
Sub-contracting,Podugovaranje,
Subcontract,Podugovor,
Subject,Predmet,
Submit,Pošalji,
Submit Proof,Submit Proof,
Submit Salary Slip,Pošaljite isplatu plate,
Submit this Work Order for further processing.,Pošaljite ovaj radni nalog za dalju obradu.,
Submit this to create the Employee record,Podnesite ovo da biste kreirali zapis zaposlenika,
Submitted orders can not be deleted,Poslani nalozi se ne mogu brisati,
Submitting Salary Slips...,Slanje slomova plata ...,
Subscription,Pretplata,
Subscription Management,Upravljanje pretplatom,
Subscriptions,Pretplate,
Subtotal,Subtotal,
Successfully Reconciled,Uspešno sravnjeno,
Successfully Set Supplier,Uspješno postavljen dobavljač,
Successfully created payment entries,Uspješno kreirani unosi plaćanja,
Successfully deleted all transactions related to this company!,Uspješno obrisane sve transakcije vezane za ovu kompaniju!,
Sum of Scores of Assessment Criteria needs to be {0}.,Zbir bodova kriterijuma procjene mora biti {0}.,
Sum of points for all goals should be 100. It is {0},Zbroj bodova za sve ciljeve treba biti 100. To je {0},
Summary for this month and pending activities,Sažetak za ovaj mjesec i aktivnosti na čekanju,
Summary for this week and pending activities,Sažetak za ovu sedmicu i aktivnosti na čekanju,
Sunday,Nedelja,
Suplier,Suplier,
Suplier Name,Suplier Name,
Supplier,Dobavljač,
Supplier Group,Group dobavljača,
Supplier Group master.,Master Group dobavljača.,
Supplier Id,Id dobavljača,
Supplier Invoice Date cannot be greater than Posting Date,Datum fakture dobavljača ne može biti veći od datuma knjiženja,
Supplier Invoice No,Faktura dobavljača br,
Supplier Invoice No exists in Purchase Invoice {0},Broj fakture dobavljača postoji u fakturi kupovine {0},
Supplier Name,Dobavljač Ime,
Supplier Part No,Broj dijela dobavljača,
Supplier Quotation,Ponuda dobavljača,
Supplier Quotation {0} created,Stvorena je Ponuda dobavljača {0},
Supplier Scorecard,Supplier Scorecard,
Supplier Warehouse mandatory for sub-contracted Purchase Receipt,Skladište dobavljača obavezno za podugovornu Potvrdu o kupovini,
Supplier database.,Baza podataka dobavljača.,
Supplier {0} not found in {1},Dobavljač {0} nije pronađen u {1},
Supplier(s),Dobavljač (i),
Supplies made to UIN holders,Potrošnja za UIN nosioce,
Supplies made to Unregistered Persons,Potrošni materijal za neregistrovana lica,
Suppliies made to Composition Taxable Persons,Dobavljači napravljeni u skladu sa poreskim obveznicima,
Supply Type,Supply Type,
Support,Podrška,
Support Analytics,Support Analytics,
Support Settings,Postavke podrške,
Support Tickets,Support Tickets,
Support queries from customers.,Podrška upitima od kupaca.,
Susceptible,Osjetljivo,
Sync Master Data,Glavni podaci o sinhronizaciji,
Sync Offline Invoices,Sync Offline Invoices,
Sync has been temporarily disabled because maximum retries have been exceeded,Sinhronizacija je privremeno onemogućena jer su prekoračeni maksimalni ponovi,
Syntax error in condition: {0},Pogreška u sintaksi: {0},
Syntax error in formula or condition: {0},Greška sintakse u formuli ili uslovu: {0},
TDS Rate %,TDS stopa%,
Taken,Taken,
Tap items to add them here,Dodirnite stavke da biste ih dodali ovdje,
Target ({}),Cilj ({}),
Target On,Target On,
Target Warehouse,Target Warehouse,
Target warehouse in row {0} must be same as Work Order,Ciljno skladište u redu {0} mora biti isto kao i radni nalog,
Target warehouse is mandatory for row {0},Ciljno skladište je obavezno za redak {0},
Task,Zadatak,
Tasks,Zadaci,
Tasks have been created for managing the {0} disease (on row {1}),Kreirani su zadaci za upravljanje {0} bolesti (u retku {1}),
Tax,Porez,
Tax Assets,Poreska imovina,
Tax Category for overriding tax rates.,Kategorija poreza za prevazilaženje poreskih stopa.,
"Tax Category has been changed to ""Total"" because all the Items are non-stock items",Poreska kategorija je promenjena u &quot;Ukupno&quot; jer su sve stavke ne-zaliha,
Tax ID,Tax ID,
Tax Id: ,Identifikacija poreza:,
Tax Rate,Stopa poreza,
Tax Rule Conflicts with {0},Porez na porezno pravilo sa {0},
Tax Rule for transactions.,Poresko pravilo za transakcije.,
Tax Template is mandatory.,Šablon poreza je obavezan.,
Tax Withholding rates to be applied on transactions.,Stopa zadržavanja poreza koja se primjenjuje na transakcije.,
Tax template for buying transactions.,Šablon poreza za transakcije kupovine.,
Tax template for item tax rates.,Šablon poreza za stope poreza na artikle.,
Tax template for selling transactions.,Šablon poreza za transakcije prodaje.,
Taxable Amount,Oporezivi iznos,
Taxes,Porezi,
Team Updates,Team Updates,
Technology,Tehnologija,
Telecommunications,Telekomunikacije,
Telephone Expenses,Telefonski troškovi,
Television,Televizija,
Template of terms or contract.,Obrazac termina ili ugovora.,
Templates of supplier scorecard criteria.,Predlošci kriterijuma ocjene dobavljača.,
Templates of supplier scorecard variables.,Predlošci varijabli pokazatelja dobavljača.,
Templates of supplier standings.,Šabloni poretka dobavljača.,
Temporarily on Hold,Privremeno na čekanju,
Temporary,Privremeno,
Temporary Accounts,Privremeni računi,
Temporary Opening,Privremeno otvaranje,
Terms and Conditions,Odredbe i uvjeti,
Terms and Conditions Template,Pravila i uslovi,
Territory,Teritorija,
Territory is Required in POS Profile,Teritorija je obavezna u POS profilu,
Test,Test,
Thank you,Hvala ti,
Thank you for your business!,Hvala vam na poslu!,
The 'From Package No.' field must neither be empty nor it's value less than 1.,&#39;Od paketa br.&#39; polje ne smije biti prazno niti je vrijednost manja od 1.,
The Brand,The Brand,
The Item {0} cannot have Batch,Stavka {0} ne može imati paket,
The Loyalty Program isn't valid for the selected company,Program vjernosti nije važeći za odabranu kompaniju,
The Patient {0} do not have customer refrence to invoice,Pacijent {0} nema preporuku kupca za fakturu,
The Payment Term at row {0} is possibly a duplicate.,Termin plaćanja u redu {0} je možda duplikat.,
The Term End Date cannot be earlier than the Term Start Date. Please correct the dates and try again.,Datum završetka termina ne može biti ranije od datuma početka termina. Ispravite datume i pokušajte ponovo.,
The Term End Date cannot be later than the Year End Date of the Academic Year to which the term is linked (Academic Year {}). Please correct the dates and try again.,Datum završetka termina ne može biti kasnije od datuma završetka godine akademske godine na koju je termin povezan (akademska godina {}). Ispravite datume i pokušajte ponovo.,
The Term Start Date cannot be earlier than the Year Start Date of the Academic Year to which the term is linked (Academic Year {}). Please correct the dates and try again.,Datum početka termina ne može biti ranije od datuma početka godine akademske godine na koju je taj termin povezan (akademska godina {}). Ispravite datume i pokušajte ponovo.,
The Year End Date cannot be earlier than the Year Start Date. Please correct the dates and try again.,Datum završetka godine ne može biti ranije od datuma početka godine. Ispravite datume i pokušajte ponovo.,
The amount of {0} set in this payment request is different from the calculated amount of all payment plans: {1}. Make sure this is correct before submitting the document.,Iznos od {0} postavljen u ovom zahtjevu za plaćanje razlikuje se od izračunatog iznosa svih planova plaćanja: {1}. Uvjerite se da je to ispravno prije slanja dokumenta.,
The day(s) on which you are applying for leave are holidays. You need not apply for leave.,Dan (a) na koji se prijavljujete za odmor su praznici. Ne trebate podnijeti zahtjev za dopust.,
The field From Shareholder cannot be blank,Polje Iz Dioničara ne može biti prazno,
The field To Shareholder cannot be blank,Polje Za dioničara 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,Brojevi folija se ne podudaraju,
The following Work Orders were created:,Kreirani su sljedeći radni nalozi:,
The holiday on {0} is not between From Date and To Date,Odmor na {0} nije između datuma i datuma,
The name of the institute for which you are setting up this system.,Naziv instituta za koji postavljate ovaj sistem.,
The name of your company for which you are setting up this system.,Ime vaše kompanije za koju postavljate ovaj sistem.,
The number of shares and the share numbers are inconsistent,Broj dionica i broj dionica su nedosljedni,
The payment gateway account in plan {0} is different from the payment gateway account in this payment request,Račun pristupnika za plaćanje u planu {0} razlikuje se od računa za pristup za plaćanje u ovom zahtjevu za plaćanje,
The request for quotation can be accessed by clicking on the following link,Zahtevu za ponudu možete pristupiti klikom na sledeći link,
The selected BOMs are not for the same item,Odabrane sastavnice nisu za istu stavku,
The selected item cannot have Batch,Odabrana stavka ne može imati paket,
The seller and the buyer cannot be the same,Prodavac i kupac ne mogu biti isti,
The shareholder does not belong to this company,Akcionar ne pripada ovom društvu,
The shares already exist,Dionice već postoje,
The shares don't exist with the {0},Dionice ne postoje sa {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 upisan kao pozadinski posao. U slučaju bilo kakvog problema u obradi u pozadini, sistem će dodati komentar o grešci na ovom usklađivanju zaliha i vratiti se na fazu nacrta",
"Then Pricing Rules are filtered out based on Customer, Customer Group, Territory, Supplier, Supplier Type, Campaign, Sales Partner etc.","Zatim se Pravila o cijenama filtriraju na temelju klijenta, grupe korisnika, teritorije, dobavljača, vrste dobavljača, kampanje, prodajnog partnera itd.",
"There are inconsistencies between the rate, no of shares and the amount calculated","Postoje nedosljednosti između stope, broja dionica i izračunatog iznosa",
There are more holidays than working days this month.,U ovom mjesecu ima više odmora nego radnih dana.,
There can be multiple tiered collection factor based on the total spent. But the conversion factor for redemption will always be same for all the tier.,Može postojati višestruki faktor sakupljanja na osnovu ukupno potrošenog. Ali faktor konverzije za otkup će uvek biti isti za sve nivoe.,
There can only be 1 Account per Company in {0} {1},U {0} {1} može biti samo jedan račun po kompaniji,
"There can only be one Shipping Rule Condition with 0 or blank value for ""To Value""",Može postojati samo jedno pravilo o pravilu otpremanja s 0 ili praznom vrijednošću za &quot;To Value&quot;,
There is no leave period in between {0} and {1},Ne postoji period odlaska između {0} i {1},
There is not enough leave balance for Leave Type {0},Nema dovoljno preostalog balansa za vrstu ostavljanja {0},
There is nothing to edit.,Nema ništa za uređivanje.,
There isn't any item variant for the selected item,Ne postoji varijanta 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.","Izgleda da postoji problem sa konfiguracijom servera GoCardless. Ne brinite, u slučaju neuspjeha, iznos će biti vraćen na vaš račun.",
There were errors creating Course Schedule,Bilo je grešaka pri kreiranju rasporeda kursa,
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 stavka je predložak i ne može se koristiti u transakcijama. Atributi stavki će se kopirati u varijante osim ako nije postavljeno &quot;No Copy&quot;,
This Item is a Variant of {0} (Template).,Ova stavka je varijanta {0} (Predložak).,
This Month's Summary,Sažetak ovog mjeseca,
This Week's Summary,Rezime ove sedmice,
This action will stop future billing. Are you sure you want to cancel this subscription?,Ova akcija će zaustaviti buduće naplate. Jeste li sigurni da želite otkazati ovu pretplatu?,
This covers all scorecards tied to this Setup,Ovo pokriva sve pokazatelje koji su vezani za ovu postavku,
This document is over limit by {0} {1} for item {4}. Are you making another {3} against the same {2}?,Ovaj dokument prekoračuje ograničenje {0} {1} za stavku {4}. Da li pravite još jednu {3} protiv iste {2}?,
This is a root account and cannot be edited.,Ovo je root nalog i ne može se uređivati.,
This is a root customer group and cannot be edited.,Ovo je glavna korisnička grupa i ne može se uređivati.,
This is a root department and cannot be edited.,Ovo je root odjel i ne može se uređivati.,
This is a root healthcare service unit and cannot be edited.,Ovo je osnovna jedinica zdravstvene službe i ne može se uređivati.,
This is a root item group and cannot be edited.,Ovo je grupa korijenskih stavki i ne može se uređivati.,
This is a root sales person and cannot be edited.,Ovo je korijenski prodavač i ne može se uređivati.,
This is a root supplier group and cannot be edited.,Ovo je osnovna grupa dobavljača i ne može se uređivati.,
This is a root territory and cannot be edited.,Ovo je korijenska teritorija i ne može se uređivati.,
This is an example website auto-generated from ERPNext,Ovo je primjer web-lokacije koja se automatski generira iz ERPNext-a,
This is based on logs against this Vehicle. See timeline below for details,Ovo se zasniva na logovima protiv ovog vozila. Za detalje pogledajte vremensku liniju ispod,
This is based on stock movement. See {0} for details,Ovo se zasniva na kretanju zaliha. Pogledajte {0} za detalje,
This is based on the Time Sheets created against this project,Ovo se zasniva na vremenskim tabelama kreiranim za ovaj projekat,
This is based on the attendance of this Employee,Ovo se zasniva na prisustvu ovog zaposlenog,
This is based on the attendance of this Student,Ovo se zasniva na prisustvu ovog studenta,
This is based on transactions against this Customer. See timeline below for details,Ovo se zasniva na transakcijama protiv ovog klijenta. Za detalje pogledajte vremensku liniju ispod,
This is based on transactions against this Healthcare Practitioner.,Ovo se zasniva na transakcijama protiv ovog zdravstvenog radnika.,
This is based on transactions against this Patient. See timeline below for details,Ovo se zasniva na transakcijama protiv ovog pacijenta. Za detalje pogledajte vremensku liniju ispod,
This is based on transactions against this Sales Person. See timeline below for details,Ovo se zasniva na transakcijama protiv ove Prodajne osobe. Za detalje pogledajte vremensku liniju ispod,
This is based on transactions against this Supplier. See timeline below for details,Ovo se zasniva na transakcijama protiv ovog dobavljača. Za detalje pogledajte vremensku liniju ispod,
This will submit Salary Slips and create accrual Journal Entry. Do you want to proceed?,Ovo će dostaviti Isplate plata i kreirati unos dnevnika obračuna. Želite li nastaviti?,
This {0} conflicts with {1} for {2} {3},Ovaj {0} je u sukobu s {1} za {2} {3},
Time Sheet for manufacturing.,Vremenski list za proizvodnju.,
Time Tracking,Praćenje vremena,
Time logs are required for job card {0},Dnevnici vremena su potrebni za karticu posla {0},
"Time slot skiped, the slot {0} to {1} overlap exisiting slot {2} to {3}","Vremenski razmak je preskočen, slot {0} do {1} preklapa postojeći slot {2} do {3}",
Time slots added,Dodani vremenski slotovi,
Time(in mins),Vrijeme (u min),
Timer,Timer,
Timer exceeded the given hours.,Tajmer je prekoračio zadate sate.,
Timesheet,Timesheet,
Timesheet for tasks.,Timesheet za zadatke.,
Timesheet {0} is already completed or cancelled,Timesheet {0} je već završen ili otkazan,
Timesheets,Timesheets,
"Timesheets help keep track of time, cost and billing for activites done by your team","Vremenski listovi pomažu u praćenju vremena, troškova i naplate za aktivnosti koje vaš tim obavlja",
Titles for print templates e.g. Proforma Invoice.,"Naslovi za predloške za ispis, npr. Proforma faktura.",
To,To,
To Address 1,Na adresu 1,
To Address 2,U adresu 2,
To Bill,Za Billa,
To Date,Izlaziti s,
To Date cannot be before From Date,Do datuma ne može biti prije datuma,
To Date cannot be less than From Date,Datum ne može biti manji od datuma,
To Date must be greater than From Date,Datum mora biti veći od datuma,
To Date should be within the Fiscal Year. Assuming To Date = {0},Datum treba da bude u okviru fiskalne godine. Pretpostavljajući da je datum = {0},
To Datetime,To Datetime,
To Deliver,Dostaviti,
To Deliver and Bill,Da isporuči i Bill,
To Fiscal Year,U fiskalnu godinu,
To GSTIN,To GSTIN,
To Party Name,Za ime stranke,
To Pin Code,Za PIN kod,
To Place,To Place,
To Receive,Primiti,
To Receive and Bill,Da primim i Bill,
To State,To State,
To Warehouse,To Warehouse,
To create a Payment Request reference document is required,Za kreiranje zahtjeva za plaćanje je potreban referentni dokument,
To date can not be equal or less than from date,Do danas ne može biti jednako ili manje od datuma,
To date can not be less than from date,Do danas ne može biti manje od datuma,
To date can not greater than employee's relieving date,Do danas ne može biti veći od datuma otpuštanja zaposlenog,
"To filter based on Party, select Party Type first","Da biste filtrirali bazu na partiji, prvo odaberite opciju Tip za partiju",
"To get the best out of ERPNext, we recommend that you take some time and watch these help videos.","Da biste dobili najbolje od ERPNexta, preporučujemo vam da odvojite malo vremena i pogledate ove video snimke pomoći.",
"To include tax in row {0} in Item rate, taxes in rows {1} must also be included","Da biste uključili porez u redu {0} u stavku Stavka, porezi u redovima {1} takođe moraju biti uključeni",
To make Customer based incentive schemes.,Izraditi šeme podsticaja zasnovane na klijentima.,
"To merge, following properties must be same for both items","Za spajanje, sljedeća svojstva moraju biti ista za obje stavke",
"To not apply Pricing Rule in a particular transaction, all applicable Pricing Rules should be disabled.","Da ne primijenimo Pravilo o cijenama u određenoj transakciji, sva primjenjiva Pravila cijena moraju biti onemogućena.",
"To set this Fiscal Year as Default, click on 'Set as Default'","Da biste postavili ovu fiskalnu godinu kao zadanu, kliknite na &quot;Postavi kao zadano&quot;",
To view logs of Loyalty Points assigned to a Customer.,Za pregled logova bodova lojalnosti dodijeljenih klijentu.,
To {0},Do {0},
To {0} | {1} {2},U {0} | {1} {2},
Toggle Filters,Toggle Filters,
Too many columns. Export the report and print it using a spreadsheet application.,Previše kolona. Izvezite izveštaj i odštampajte ga pomoću aplikacije za tabelarne proračune.,
Tools,Alati,
Total (Credit),Ukupno (kredit),
Total (Without Tax),Ukupno (bez poreza),
Total Absent,Total Absent,
Total Achieved,Ukupno postignuto,
Total Actual,Total Actual,
Total Allocated Leaves,Ukupno dodijeljenih listova,
Total Amount,Ukupan iznos,
Total Amount Credited,Ukupan iznos odobren,
Total Amount {0},Ukupan iznos {0},
Total Applicable Charges in Purchase Receipt Items table must be same as Total Taxes and Charges,Ukupne primjenjive naknade u tablici stavki računa za kupnju moraju biti iste kao i ukupni porezi i naknade,
Total Budget,Ukupni budžet,
Total Collected: {0},Ukupno prikupljenih: {0},
Total Commission,Total Commission,
Total Contribution Amount: {0},Ukupan iznos doprinosa: {0},
Total Credit/ Debit Amount should be same as linked Journal Entry,Ukupni iznos kredita / zaduženja treba biti isti kao i unos u dnevnik,
Total Debit must be equal to Total Credit. The difference is {0},Ukupan debit mora biti jednak ukupnom kreditu. Razlika je {0},
Total Deduction,Ukupno oduzimanje,
Total Invoiced Amount,Ukupni fakturisani iznos,
Total Leaves,Ukupno lišća,
Total Order Considered,Ukupan redosled razmatran,
Total Order Value,Ukupna vrijednost narudžbe,
Total Outgoing,Total Outgoing,
Total Outstanding,Total Outstanding,
Total Outstanding Amount,Ukupan preostali iznos,
Total Outstanding: {0},Total Outstanding: {0},
Total Paid Amount,Ukupan uplaćeni iznos,
Total Payment Amount in Payment Schedule must be equal to Grand / Rounded Total,Ukupni iznos uplate na rasporedu plaćanja mora biti jednak Grand / Rounded Total,
Total Payments,Ukupna plaćanja,
Total Present,Total Present,
Total Qty,Total Qty,
Total Quantity,Total Quantity,
Total Revenue,Ukupnog prihoda,
Total Student,Total Student,
Total Target,Total Target,
Total Tax,Total Tax,
Total Taxable Amount,Ukupno oporezivi iznos,
Total Taxable Value,Ukupna porezna vrijednost,
Total Unpaid: {0},Ukupno neplaćeno: {0},
Total Variance,Total Variance,
Total Weightage of all Assessment Criteria must be 100%,Ukupna težina svih kriterijuma procjene mora biti 100%,
Total advance ({0}) against Order {1} cannot be greater than the Grand Total ({2}),Ukupni napredak ({0}) protiv narudžbe {1} ne može biti veći od ukupnog iznosa ({2}),
Total advance amount cannot be greater than total claimed amount,Ukupni iznos akontacije ne može biti veći od ukupnog iznosa koji se traži,
Total advance amount cannot be greater than total sanctioned amount,Ukupni iznos akontacije ne može biti veći od ukupnog iznosa sankcije,
Total allocated leaves are more days than maximum allocation of {0} leave type for employee {1} in the period,Ukupni dodijeljeni listovi su više dana od maksimalne dodjele tipa {0} za zaposlenika {1} u periodu,
Total allocated leaves are more than days in the period,Ukupno izdvojeno lišće je više od dana u periodu,
Total allocated percentage for sales team should be 100,Ukupno dodeljeni procenat za prodajni tim treba da bude 100,
Total cannot be zero,Ukupno ne može biti nula,
Total completed qty must be greater than zero,Ukupna završena količina mora biti veća od nule,
Total contribution percentage should be equal to 100,Ukupan postotak doprinosa treba biti jednak 100,
Total flexible benefit component amount {0} should not be less than max benefits {1},Ukupna fleksibilna visina komponente kompenzacije {0} ne smije biti manja od maksimalne koristi {1},
Total hours: {0},Ukupno sati: {0},
Total leaves allocated is mandatory for Leave Type {0},Ukupno dodijeljeno lišće je obavezno za vrstu ostavljanja {0},
Total weightage assigned should be 100%. It is {0},Ukupna dodeljena težina treba da bude 100%. To je {0},
Total working hours should not be greater than max working hours {0},Ukupno radno vrijeme ne bi trebalo biti veće od maksimalnog radnog vremena {0},
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 je nula, možda bi trebalo da promijenite &quot;Distribuiranje naknada na temelju&quot;",
Total(Amt),Ukupno (Amt),
Total(Qty),Ukupno (Kol),
Traceability,Sljedivost,
Track Leads by Lead Source.,Vodeći tragovi vodećeg izvora.,
Training,Trening,
Training Event,Training Event,
Training Events,Training Events,
Training Feedback,Povratne informacije o obuci,
Training Result,Rezultat treninga,
Transaction,Transakcija,
Transaction Date,Datum transakcije,
Transaction Type,Vrsta transakcije,
Transaction currency must be same as Payment Gateway currency,Valuta transakcije mora biti ista kao i valuta Payment Gateway,
Transaction not allowed against stopped Work Order {0},Transakcija nije dozvoljena protiv zaustavljenog radnog naloga {0},
Transaction reference no {0} dated {1},Referenca transakcije broj {0} od {1},
Transactions,Transakcije,
Transactions can only be deleted by the creator of the Company,Transakcije se mogu brisati samo od strane kreatora kompanije,
Transfer,Transfer,
Transfer Material,Materijal za prijenos,
Transfer Type,Tip prenosa,
Transfer an asset from one warehouse to another,Prenesite imovinu iz jednog skladišta u drugo,
Transfered,Preneseno,
Transferred Quantity,Transferred Quantity,
Transport Receipt Date,Datum prijema prijevoza,
Transport Receipt No,Potvrda o prevozu br,
Transportation,Transport,
Transporter ID,Transporter ID,
Transporter Name,Ime transportera,
Travel,Putovanje,
Travel Expenses,Putne troškove,
Tree Type,Vrsta drveta,
Tree of Bill of Materials,Drvo materijala,
Tree of Item Groups.,Drvo grupa artikala.,
Tree of Procedures,Tree of Procedures,
Tree of Quality Procedures.,Drvo procedura kvaliteta.,
Tree of financial Cost Centers.,Stablo finansijskih troškovnih centara.,
Tree of financial accounts.,Stablo finansijskih računa.,
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 perioda Ne može biti prije početka probnog perioda,
Trialling,Trialling,
Type of Business,Tip poslovanja,
Types of activities for Time Logs,Vrste aktivnosti za logove vremena,
UOM,UOM,
UOM Conversion factor is required in row {0},UOM konverzijski faktor je potreban u redu {0},
UOM coversion factor required for UOM: {0} in Item: {1},Faktor pokrivanja UOM-a potreban za UOM: {0} u stavci: {1},
Unable to find DocType {0},Nije moguće pronaći DocType {0},
Unable to find exchange rate for {0} to {1} for key date {2}. Please create a Currency Exchange record manually,Nije moguće pronaći kurs za {0} do {1} za ključni datum {2}. Molimo vas da ručno kreirate evidenciju valutne razmene,
Unable to find score starting at {0}. You need to have standing scores covering 0 to 100,Nije moguće pronaći rezultat počevši od {0}. Potrebno je da imate stalne rezultate koji pokrivaju 0 do 100,
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 dobit / gubitak fiskalne godine (kredit),
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 unesena više od jednom u tabeli faktora konverzije,
Unknown,Nepoznato,
Unpaid,Neplaćeno,
Unsecured Loans,Unsecured Loans,
Unsubscribe from this Email Digest,Otkažite pretplatu na ovu adresu e-pošte,
Until,Do,
Unverified Webhook Data,Unverified Webhook Data,
Update Account Name / Number,Ažurirajte naziv / broj računa,
Update Account Number / Name,Ažurirajte broj računa / ime,
Update Bank Transaction Dates,Ažurirajte datume bankovnih transakcija,
Update Cost,Trošak ažuriranja,
Update Cost Center Number,Ažurirajte broj centra troškova,
Update Email Group,Ažuriraj grupu e-pošte,
Update Items,Ažuriraj stavke,
Update Print Format,Ažuriraj format ispisa,
Update Response,Ažuriraj odgovor,
Update bank payment dates with journals.,Ažurirajte datume plaćanja banaka sa časopisima.,
Update in progress. It might take a while.,Ažuriranje je u toku. Može potrajati.,
Update rate as per last purchase,Stopa ažuriranja po posljednjoj kupnji,
Update stock must be enable for the purchase invoice {0},Ažuriranje zaliha mora biti omogućeno za fakturu kupovine {0},
Updating Variants...,Ažuriranje varijanti ...,
Upload your letter head and logo. (you can edit them later).,Otpremite pismo i logo. (kasnije ih možete urediti).,
Upper Income,Upper Income,
Used Leaves,Used Leaves,
User,User,
User Forum,Forum korisnika,
User ID not set for Employee {0},ID korisnika nije postavljen za zaposlenika {0},
User Remark,Napomena za korisnika,
User has not applied rule on the invoice {0},Korisnik nije primijenio pravilo na fakturi {0},
User {0} already exists,Korisnik {0} već postoji,
User {0} created,Korisnik {0} je kreiran,
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 podrazumevani POS profil. Proverite Default at Row {1} za ovog korisnika.,
User {0} is already assigned to Employee {1},Korisnik {0} je već dodijeljen zaposleniku {1},
User {0} is already assigned to Healthcare Practitioner {1},Korisnik {0} je već dodijeljen zdravstvenom radniku {1},
Users,Korisnici,
Utility Expenses,Utrošni troškovi,
Valid From Date must be lesser than Valid Upto Date.,Važeći datum mora biti manji od važećeg datuma.,
Valid Till,Valid Till,
Valid from and valid upto fields are mandatory for the cumulative,Važeća i valjana polja upto su obavezna za kumulativ,
Valid from date must be less than valid upto date,Važeći od datuma mora biti manji od važećeg datuma,
Valid till date cannot be before transaction date,Važi do datuma ne može biti pre datuma transakcije,
Validity period of this quotation has ended.,Period valjanosti ove ponude je završen.,
Valuation Rate,Rate Rate,
Valuation Rate is mandatory if Opening Stock entered,Stopa vrednovanja je obavezna ako je otvorena ulazna zaliha,
Valuation type charges can not marked as Inclusive,Troškovi za vrednovanje ne mogu biti označeni kao inkluzivni,
Value Or Qty,Vrijednost ili broj,
Value Proposition,Vrednosni predlog,
Value for Attribute {0} must be within the range of {1} to {2} in the increments of {3} for Item {4},Vrijednost za atribut {0} mora biti u rasponu od {1} do {2} u koracima od {3} za stavku {4},
Value missing,Nedostaje vrijednost,
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","Vrednosti oslobođenih, nultog i ne-GST unutrašnjih isporuka",
Variable,Variable,
Variance,Varijanca,
Variance ({}),Varijacija ({}),
Variant,Variant,
Variant Attributes,Atributi varijanti,
Variant Based On cannot be changed,Variant Based On se ne može promijeniti,
Variant Details Report,Variant Details Report,
Variant creation has been queued.,Stvaranje varijante je stavljeno u red čekanja.,
Vehicle Expenses,Troškovi vozila,
Vehicle No,Vozilo br,
Vehicle Type,Tip vozila,
Vehicle/Bus Number,Broj vozila / autobusa,
Venture Capital,Venture Capital,
View Chart of Accounts,Pogledajte kontni plan,
View Fees Records,Pogledajte evidenciju naknada,
View Form,View Form,
View Lab Tests,Pogledajte laboratorijske testove,
View Leads,View Leads,
View Ledger,View Ledger,
View Now,Prikaži sada,
View Orders,View Orders,
View a list of all the help videos,Pogledajte listu svih videozapisa za pomoć,
View in Cart,Prikaži u košarici,
Visit report for maintenance call.,Posjetite izvješće za poziv na održavanje.,
Visit the forums,Posjetite forume,
Vital Signs,Vital Signs,
Volunteer,Volonter,
Volunteer Type information.,Informacije o tipu volontera.,
Volunteer information.,Informacije o volonterima.,
Voucher #,Voucher #,
Voucher No,Vaučer br,
Voucher Type,Tip vaučera,
WIP Warehouse,WIP skladište,
Walk In,Ući,
Warehouse can not be deleted as stock ledger entry exists for this warehouse.,Skladište se ne može izbrisati jer postoji unos dionica za ovo skladište.,
Warehouse cannot be changed for Serial No.,Skladište se ne može mijenjati za serijski broj,
Warehouse is mandatory,Skladište je obavezno,
Warehouse is mandatory for stock Item {0} in row {1},Skladište je obavezno za zalihu Stavka {0} u redu {1},
Warehouse not found in the system,Skladište nije pronađeno u sistemu,
"Warehouse required at Row No {0}, please set default warehouse for the item {1} for the company {2}","Potrebna skladišta na redu broj {0}, postavite zadano skladište za stavku {1} za tvrtku {2}",
Warehouse required for stock Item {0},Potrebna skladišta za zalihu Stavka {0},
Warehouse {0} can not be deleted as quantity exists for Item {1},Skladište {0} ne može se izbrisati jer količina postoji za stavku {1},
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, molimo navedite račun u evidenciji skladišta ili postavite zadani račun inventara u tvrtki {1}.",
Warehouses with child nodes cannot be converted to ledger,Skladišta sa podređenim čvorovima ne mogu se pretvoriti u knjigu knjiga,
Warehouses with existing transaction can not be converted to group.,Skladišta sa postojećom transakcijom ne mogu se pretvoriti u grupu.,
Warehouses with existing transaction can not be converted to ledger.,Skladišta sa postojećom transakcijom ne mogu se pretvoriti u knjigu.,
Warning,Upozorenje,
Warning: Another {0} # {1} exists against stock entry {2},Upozorenje: Još jedna {0} # {1} postoji protiv stavke zaliha {2},
Warning: Invalid SSL certificate on attachment {0},Upozorenje: Nevažeći SSL certifikat o privitku {0},
Warning: Invalid attachment {0},Upozorenje: neispravan prilog {0},
Warning: Leave application contains following block dates,Upozorenje: Napusti aplikaciju sadrži sljedeće blok datume,
Warning: Material Requested Qty is less than Minimum Order Qty,Upozorenje: Traženi materijal je manji od minimalne količine narudžbe,
Warning: Sales Order {0} already exists against Customer's Purchase Order {1},Upozorenje: prodajni nalog {0} već postoji protiv narudžbenice kupca {1},
Warning: System will not check overbilling since amount for Item {0} in {1} is zero,Upozorenje: Sistem neće proveriti overbilling jer je iznos za stavku {0} u {1} jednak nuli,
Warranty,Garancija,
Warranty Claim,Warranty Claim,
Warranty Claim against Serial No.,Zahtev za garanciju protiv serijskog broja,
Website,Website,
Website Image should be a public file or website URL,Slika web-lokacije mora biti javna datoteka ili URL web-lokacije,
Website Image {0} attached to Item {1} cannot be found,Slika web-lokacije {0} priložena stavci {1} ne može se pronaći,
Website Listing,Website Listing,
Wednesday,Sreda,
Weekly,Nedeljno,
"Weight is mentioned,\nPlease mention ""Weight UOM"" too","Navedite i težinu, Molimo vas da navedete i &quot;Težina UOM&quot;",
Welcome to ERPNext,Dobrodošli u ERPNext,
What do you need help with?,Za šta ti treba pomoć?,
What does it do?,Šta radi?,
Where manufacturing operations are carried.,Tamo gdje se obavljaju proizvodne operacije.,
"While creating account for child Company {0}, parent account {1} not found. Please create the parent account in corresponding COA","Prilikom kreiranja korisničkog računa za kompaniju {0}, nadređeni račun {1} nije pronađen. Kreirajte matični račun u odgovarajućoj COA",
White,White,
Wire Transfer,Žični prenos,
WooCommerce Products,WooCommerce Proizvodi,
Work In Progress,Posao u izradi,
Work Order,Radni nalog,
Work Order already created for all items with BOM,Radni nalog je već kreiran za sve stavke sa BOM,
Work Order cannot be raised against a Item Template,Radni nalog se ne može podići protiv šablona predmeta,
Work Order has been {0},Radni nalog je bio {0},
Work Order not created,Radni nalog nije kreiran,
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,Radni nalog {0} mora biti dostavljen,
Work Orders Created: {0},Napravljeni radni nalozi: {0},
Work Summary for {0},Sažetak posla za {0},
Work-in-Progress Warehouse is required before Submit,Prije slanja je potrebno skladište za rad u tijeku,
Workflow,Workflow,
Working,Rad,
Working Hours,Radni sati,
Workstation,Workstation,
Workstation is closed on the following dates as per Holiday List: {0},Radna stanica je zatvorena na sljedeće datume prema prazničnoj listi: {0},
Wrapping up,Umotavanje,
Wrong Password,Pogrešna lozinka,
Year start date or end date is overlapping with {0}. To avoid please set company,"Datum početka ili datum završetka se preklapa s {0}. Da biste izbegli, molim vas, postavite kompaniju",
You are in offline mode. You will not be able to reload until you have network.,Nalazite se u izvanmrežnom načinu rada. Nećete moći ponovo učitati sve dok ne dobijete mrežu.,
You are not authorized to add or update entries before {0},Nemate ovlaštenje za dodavanje ili ažuriranje unosa prije {0},
You are not authorized to approve leaves on Block Dates,Niste ovlašćeni da odobravate ostavljanje na datumu bloka,
You are not authorized to set Frozen value,Niste ovlašteni da postavljate vrijednost Frozen,
You are not present all day(s) between compensatory leave request days,Vi niste prisutni cijeli dan (a) između dana za kompenzacijsko odsustvo,
You can not change rate if BOM mentioned agianst any item,Ne možete promjeniti stopu ako BOM spominje bilo koju stavku,
You can not enter current voucher in 'Against Journal Entry' column,Ne možete uneti trenutni vaučer u kolonu „Protiv dnevnika“,
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.,Maksimalno {0} bodova možete iskoristiti samo u ovom redoslijedu.,
You can only renew if your membership expires within 30 days,Možete obnoviti samo ako vaše članstvo ističe u roku od 30 dana,
You can only select a maximum of one option from the list of check boxes.,Možete izabrati najviše jednu opciju iz liste potvrdnih okvira.,
You can only submit Leave Encashment for a valid encashment amount,Možete samo da podnesete „Ostavi inkasiranje“ za važeći iznos naplate,
You can't redeem Loyalty Points having more value than the Grand Total.,Ne možete iskoristiti bodove lojalnosti koji imaju veću vrijednost nego Grand Total.,
You cannot credit and debit same account at the same time,Ne možete istovremeno kreditirati i zadužiti 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 podrazumevana u globalnim postavkama,
You cannot delete Project Type 'External',Ne možete izbrisati tip projekta &#39;External&#39;,
You cannot edit root node.,Ne možete uređivati korijenski čvor.,
You cannot restart a Subscription that is not cancelled.,Ne možete ponovo pokrenuti pretplatu koja nije otkazana.,
You don't have enought Loyalty Points to redeem,Nemate dovoljno bodova lojalnosti da biste ih iskoristili,
You have already assessed for the assessment criteria {}.,Već ste procijenili 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 da sarađujete na projektu: {0},
You have entered duplicate items. Please rectify and try again.,Uneli ste duple stavke. Ispravite i pokušajte ponovo.,
You need to be a user other than Administrator with System Manager and Item Manager roles to register on Marketplace.,"Morate biti korisnik koji nije Administrator, sa ulogama Upravitelja sistema i Upravitelja stavki da biste se registrirali na Marketplace-u.",
You need to be a user with System Manager and Item Manager roles to add users to Marketplace.,Morate biti korisnik sa ulogama System Manager i Item Manager da biste dodali korisnike na Marketplace.,
You need to be a user with System Manager and Item Manager roles to register on Marketplace.,Morate biti korisnik sa ulogama System Manager-a i Item Manager-a za registraciju na Marketplace-u.,
You need to be logged in to access this page,Morate biti prijavljeni da biste pristupili ovoj stranici,
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 zapise prethodno generiranih faktura. Jeste li sigurni da želite ponovo pokrenuti ovu pretplatu?,
Your Organization,Your Organization,
Your cart is Empty,Vaša košarica je prazna,
Your email address...,Tvoja e-mail adresa...,
Your order is out for delivery!,Vaša narudžba je isporučena!,
Your tickets,Vaše karte,
ZIP Code,Poštanski broj,
[Error],[Greška],
[{0}](#Form/Item/{0}) is out of stock,[{0}] (# Form / Item / {0}) nema na skladištu,
`Freeze Stocks Older Than` should be smaller than %d days.,`Freeze Stocks Older Than` (Zamrznuti stokove starije od) trebao bi biti manji od% d dana.,
based_on,based_on,
cannot be greater than 100,ne može biti veća od 100,
disabled user,onemogućen korisnik,
"e.g. ""Build tools for builders""",npr. &quot;Build tools for builders&quot;,
"e.g. ""Primary School"" or ""University""",npr. &quot;Osnovna škola&quot; ili &quot;Univerzitet&quot;,
"e.g. Bank, Cash, Credit Card","npr. banka, gotovina, kreditna kartica",
hidden,skriveno,
modified,modifikovan,
on,on,
{0} '{1}' is disabled,{0} &#39;{1}&#39; je onemogućeno,
{0} '{1}' not in Fiscal Year {2},{0} &#39;{1}&#39; 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ća od planirane količine ({2}) u radnom nalogu {3},
{0} - {1} is inactive student,{0} - {1} je neaktivan student,
{0} - {1} is not enrolled in the Batch {2},{0} - {1} nije upisano u paket {2},
{0} - {1} is not enrolled in the Course {2},{0} - {1} nije upisano u kurs {2},
{0} Budget for Account {1} against {2} {3} is {4}. It will exceed by {5},{0} Budžet za račun {1} za {2} {3} je {4}. Preći će za {5},
{0} Digest,{0} Digest,
{0} Number {1} already used in account {2},{0} Broj {1} je već korišten u računu {2},
{0} Request for {1},{0} Zahtjev za {1},
{0} Result submittted,{0} Rezultat je poslan,
{0} Serial Numbers required for Item {1}. You have provided {2}.,{0} Serijski brojevi potrebni za stavku {1}. Dali ste {2}.,
{0} Student Groups created.,{0} Stvorene su studentske grupe.,
{0} Students have been enrolled,{0} Studenti su upisani,
{0} against Bill {1} dated {2},{0} protiv računa {1} sa datumom {2},
{0} against Purchase Order {1},{0} protiv Narudžbenice {1},
{0} against Sales Invoice {1},{0} protiv fakture prodaje {1},
{0} against Sales Order {1},{0} protiv prodajnog naloga {1},
{0} already allocated for Employee {1} for period {2} to {3},{0} je već dodijeljen za zaposlenika {1} za period {2} do {3},
{0} applicable after {1} working days,{0} primjenjivo nakon {1} radnih dana,
{0} asset cannot be transferred,Ne može se prenijeti {0} sredstvo,
{0} can not be negative,{0} ne može biti negativan,
{0} created,{0} kreirano,
"{0} currently has a {1} Supplier Scorecard standing, and Purchase Orders to this supplier should be issued with caution.","{0} trenutno ima status {1} dobavljača rezultata, a narudžbenice za ovog dobavljača trebaju biti izdate s oprezom.",
"{0} currently has a {1} Supplier Scorecard standing, and RFQs to this supplier should be issued with caution.","{0} trenutno ima status {1} dobavljača rezultata, a RFQ-ovi za ovog dobavljača trebaju biti izdati s oprezom.",
{0} does not belong to Company {1},{0} ne pripada kompaniji {1},
{0} does not have a Healthcare Practitioner Schedule. Add it in Healthcare Practitioner master,{0} nema raspored zdravstvenih radnika. Dodajte ga u majstora zdravstvene prakse,
{0} entered twice in Item Tax,{0} dvaput je uneseno u porez na stavku,
{0} for {1},{0} za {1},
{0} has been submitted successfully,{0} je uspješno poslana,
{0} has fee validity till {1},{0} ima valjanost naknade do {1},
{0} hours,{0} sati,
{0} in row {1},{0} u redu {1},
{0} is a company holiday,{0} je praznik kompanije,
{0} is blocked so this transaction cannot proceed,{0} je blokiran tako da se ova transakcija ne može nastaviti,
{0} is mandatory,{0} je obavezno,
{0} is mandatory for Item {1},{0} je obavezna za stavku {1},
{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2}.,{0} je obavezno. Možda zapis razmjene valuta nije kreiran za {1} do {2}.,
{0} is not a stock Item,{0} nije dionica,
{0} is not a valid Batch Number for Item {1},{0} nije važeći serijski broj za stavku {1},
{0} is not added in the table,{0} se ne dodaje u tabelu,
{0} is not in Optional Holiday List,{0} nije u opcionalnoj listi praznika,
{0} is not in a valid Payroll Period,{0} nije u važećem periodu isplate,
{0} is now the default Fiscal Year. Please refresh your browser for the change to take effect.,{0} je sada zadana fiskalna godina. Osvježite preglednik kako bi promjena stupila na snagu.,
{0} is on hold till {1},{0} je na čekanju do {1},
{0} item found.,Pronađena je {0} stavka.,
{0} items found.,Pronađeno je {0} stavki.,
{0} items in progress,{0} stavki u toku,
{0} items produced,Proizvedeno je {0} stavki,
{0} must appear only once,{0} se mora pojaviti samo jednom,
{0} must be negative in return document,{0} mora biti negativan u povratnom dokumentu,
{0} must be submitted,{0} mora biti dostavljen,
{0} not allowed to transact with {1}. Please change the Company.,{0} nije dozvoljeno obavljati transakcije sa {1}. Molimo promijenite tvrtku.,
{0} not found for item {1},{0} nije pronađen za stavku {1},
{0} on Half day Leave on {1},{0} na pola dana odlaska na {1},
{0} on Leave on {1},{0} na Ostavi na {1},
{0} parameter is invalid,Parametar {0} je nevažeći,
{0} payment entries can not be filtered by {1},{0} unosa za plaćanje ne može se filtrirati do {1},
{0} should be a value between 0 and 100,{0} treba da bude vrednost između 0 i 100,
{0} units of [{1}](#Form/Item/{1}) found in [{2}](#Form/Warehouse/{2}),{0} jedinica [{1}] (# Form / Item / {1}) pronađenih u [{2}] (# Form / Warehouse / {2}),
{0} units of {1} needed in {2} on {3} {4} for {5} to complete this transaction.,{0} jedinice {1} potrebne u {2} na {3} {4} za {5} za dovršenje ove transakcije.,
{0} units of {1} needed in {2} to complete this transaction.,{0} jedinica {1} potrebne u {2} za dovršetak ove transakcije.,
{0} valid serial nos for Item {1},{0} važeći serijski broj za stavku {1},
{0} variants created.,Stvorene su {0} varijante.,
{0} {1} created,Napravljeno je {0} {1},
{0} {1} does not exist,{0} {1} ne postoji,
{0} {1} does not exist.,{0} {1} ne postoji.,
{0} {1} has been modified. Please refresh.,{0} {1} je izmijenjeno. Please refresh.,
{0} {1} has not been submitted so the action cannot be completed,{0} {1} nije poslata tako da se akcija ne može dovršiti,
"{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} je otkazan ili zaustavljen,
{0} {1} is cancelled so the action cannot be completed,{0} {1} je otkazano tako da se radnja ne može dovršiti,
{0} {1} is closed,{0} {1} je zatvoren,
{0} {1} is disabled,{0} {1} je onemogućeno,
{0} {1} is frozen,{0} {1} je zamrznut,
{0} {1} is fully billed,{0} {1} je potpuno naplaćeno,
{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 prisutan u matičnoj kompaniji,
{0} {1} is not submitted,{0} {1} nije dostavljen,
{0} {1} is {2},{0} {1} je {2},
{0} {1} must be submitted,{0} {1} mora biti dostavljen,
{0} {1} not in any active Fiscal Year.,{0} {1} nije u nekoj aktivnoj fiskalnoj godini.,
{0} {1} status is {2},Status {0} {1} je {2},
{0} {1}: 'Profit and Loss' type account {2} not allowed in Opening Entry,{0} {1}: račun tipa &#39;Profit i gubitak&#39; {2} nije dozvoljen u uvodnom unosu,
{0} {1}: Account {2} cannot be a Group,{0} {1}: Račun {2} ne može biti grupa,
{0} {1}: Account {2} does not belong to Company {3},{0} {1}: Korisnički račun {2} ne pripada kompaniji {3},
{0} {1}: Account {2} is inactive,{0} {1}: Račun {2} je neaktivan,
{0} {1}: Accounting Entry for {2} can only be made in currency: {3},{0} {1}: Računovodstveni unos za {2} može biti samo u valuti: {3},
{0} {1}: Cost Center is mandatory for Item {2},{0} {1}: Centar troška je obavezan 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}: Centar troška je potreban za račun &#39;Profit i gubitak&#39; {2}. Postavite podrazumevani centar troškova za kompaniju.,
{0} {1}: Cost Center {2} does not belong to Company {3},{0} {1}: Centar troškova {2} ne pripada kompaniji {3},
{0} {1}: Customer is required against Receivable account {2},{0} {1}: Korisnik je obavezan protiv računa potraživanja {2},
{0} {1}: Either debit or credit amount is required for {2},{0} {1}: Potreban je iznos debitnog ili kreditnog iznosa za {2},
{0} {1}: Supplier is required against Payable account {2},{0} {1}: Dobavljač je obavezan prema računu za plaćanje {2},
{0}% Billed,{0} Naplaćeno,
{0}% Delivered,{0}% Isporučeno,
"{0}: Employee email not found, hence email not sent","{0}: E-pošta zaposlenika nije pronađena, stoga e-pošta nije poslata",
{0}: From {0} of type {1},{0}: Od {0} tipa {1},
{0}: From {1},{0}: Od {1},
{0}: {1} does not exists,{0}: {1} ne postoji,
{0}: {1} not found in Invoice Details table,{0}: {1} nije pronađena u tabeli Detalji fakture,
{} of {},{} od {},
Email Group,Email Group,
Images,Slike,
Import,Uvoz,
There is some problem with the file url: {0},Postoji neki problem sa URL-om datoteke: {0},
Values Changed,Promijenjene vrijednosti,
Ageing Range 4,Raspon starenja 4,
Allocated amount cannot be greater than unadjusted amount,Dodijeljeni iznos ne može biti veći od neusklađ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 različitosti mora biti račun vrste imovine / odgovornosti, budući da je ovaj unos dionica uvodni unos",
Error in some rows,Greška u nekim redovima,
Import Successful,Import Successful,
Please save first,Prvo sačuvajte,
Price not found for item {0} in price list {1},Cijena nije nađena za proizvod {0} u cjeniku {1},
Warehouse Type,Warehouse Type,
'Date' is required,Potreban je datum,
Benefit,Benefit,
Budgets,Budžeti,
Bundle Qty,Bundle Qty,
Company GSTIN,Kompanija GSTIN,
Company field is required,Polje kompanije je obavezno,
Creating Dimensions...,Kreiranje dimenzija ...,
Duplicate entry against the item code {0} and manufacturer {1},Dvostruki unos u odnosu na kôd stavke {0} i proizvođač {1},
Import Chart Of Accounts from CSV / Excel files,Uvezite grafikon računa iz CSV / Excel datoteka,
Invalid GSTIN! The input you've entered doesn't match the GSTIN format for UIN Holders or Non-Resident OIDAR Service Providers,Nevažeći GSTIN! Unos koji ste uneli ne odgovara GSTIN formatu za UIN nositelje ili nerezidentne OIDAR pružatelje usluga,
Invoice Grand Total,Faktura Grand Total,
Last carbon check date cannot be a future date,Zadnji datum provjere ugljika ne može biti budući datum,
Make Stock Entry,Napravite unos zaliha,
Quality Feedback,Quality Feedback,
Quality Feedback Template,Šablon kvalitete povratnih informacija,
Rules for applying different promotional schemes.,Pravila za primjenu različitih promotivnih programa.,
Shift,Shift,
Show {0},Prikaži {0},
"Special Characters except ""-"", ""#"", ""."", ""/"", ""{"" and ""}"" not allowed in naming series","Posebni znakovi osim &quot;-&quot;, &quot;#&quot;, &quot;.&quot;, &quot;/&quot;, &quot;{&quot; I &quot;}&quot; nisu dozvoljeni u imenovanju serija",
Target Details,Detalji o meti,
{0} already has a Parent Procedure {1}.,{0} već ima nadređenu proceduru {1}.,
Annual,Godišnje,
Approved,Odobreno,
Change,Promjena,
From Date,Od datuma,
Group By,Group By,
Importing {0} of {1},Uvoz {0} od {1},
No data to export,Nema podataka za izvoz,
% Of Grand Total,% Od ukupnog iznosa,
'employee_field_value' and 'timestamp' are required.,Obavezni su &#39;Employ_field_value&#39; i &#39;timetamp&#39;.,
<b>Company</b> is a mandatory filter.,<b>Kompanija</b> je obavezan filter.,
<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>Od vremena</b> ne može biti kasnije od <b>Toca</b> za {0},
<b>To Date</b> is a mandatory filter.,<b>Do danas</b> je obavezan filter.,
A new appointment has been created for you with {0},Za vas je stvoren novi sastanak sa {0},
Account Value,Vrijednost računa,
Account is mandatory to get payment entries,Račun je obavezan za unos plaćanja,
Account is not set for the dashboard chart {0},Za grafikon nadzorne ploče nije postavljen račun {0},
Account {0} does not belong to company {1},Račun {0} ne pripada kompaniji {1},
Account {0} does not exists in the dashboard chart {1},Račun {0} ne postoji u 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 Rad u tijeku i ne može ga ažurirati časopis Entry,
Account: {0} is not permitted under Payment Entry,Račun: {0} nije dozvoljen 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 „Dobit i gubitak“ {1} potrebna je računovodstvena dimenzija <b>{0</b> }.,
Accounting Masters,Majstori računovodstva,
Accounting Period overlaps with {0},Računovodstveno razdoblje se preklapa sa {0},
Activity,Aktivnost,
Add / Manage Email Accounts.,Dodavanje / upravljanje računima e-pošte.,
Add Child,Dodaj dijete,
Add Loan Security,Dodajte osiguranje kredita,
Add Multiple,Dodaj više,
Add Participants,Dodajte učesnike,
Add to Featured Item,Dodaj u istaknuti artikl,
Add your review,Dodajte svoju recenziju,
Add/Edit Coupon Conditions,Dodavanje / uređivanje uvjeta kupona,
Added to Featured Items,Dodano u istaknute predmete,
Added {0} ({1}),Dodano {0} ({1}),
Address Line 1,Adresa Line 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.,
Against Loan,Protiv zajma,
Against Loan:,Protiv zajma:,
All,Sve,
All bank transactions have been created,Sve bankarske transakcije su stvorene,
All the depreciations has been booked,Sve amortizacije su knjižene,
Allocation Expired!,Raspored je istekao!,
Allow Resetting Service Level Agreement from Support Settings.,Dopustite resetiranje sporazuma o nivou usluge iz postavki podrške.,
Amount of {0} is required for Loan closure,Za zatvaranje zajma potreban je iznos {0},
Amount paid cannot be zero,Plaćeni iznos ne može biti nula,
Applied Coupon Code,Primenjeni kod kupona,
Apply Coupon Code,Primijenite kupon kod,
Appointment Booking,Rezervacija termina,
"As there are existing transactions against item {0}, you can not change the value of {1}","Kako postoje stavke protiv stavke {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 vrednosti imovine ne može se objaviti pre datuma kupovine 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},
Assets not created for <b>{0}</b>. You will have to create asset manually.,Sredstva nisu stvorena za <b>{0}</b> . Morat ćete stvoriti imovinu ručno.,
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 jedno sredstvo.,
Attendance Marked,Posećenost je obeležena,
Attendance has been marked as per employee check-ins,Pohađanje je označeno prema prijavama zaposlenika,
Authentication Failed,Autentifikacija 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 upoređivanje 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 Home,Povratak na početnu,
Back to Messages,Nazad na poruke,
Bank Data mapper doesn't exist,Kartografski podaci bankovnih podataka ne postoje,
Bank Details,Bankovni detalji,
Bank account '{0}' has been synchronized,Bankovni račun &#39;{0}&#39; je sinhronizovan,
Bank account {0} already exists and could not be created again,Bankovni račun {0} već postoji i ne može se ponovo otvoriti,
Bank accounts added,Dodani su bankovni računi,
Batch no is required for batched item {0},Za serijski artikal nije potreban serijski broj {0},
Billing Date,Datum obračuna,
Billing Interval Count cannot be less than 1,Interni broj naplate ne može biti manji od 1,
Blue,Plava,
Book,Knjiga,
Book Appointment,Sastavljanje knjige,
Brand,Marka,
Browse,Pregledaj,
Call Connected,Poziv je povezan,
Call Disconnected,Poziv prekinuti,
Call Missed,Poziv je propušten,
Call Summary,Rezime 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 ne može da se optimizira jer nedostaje adresa vozača.,
"Cannot Unpledge, loan security value is greater than the repaid amount","Ne mogu se ukloniti, vrijednost jamstva zajma je veća od otplaćenog iznosa",
Cannot complete task {0} as its dependant task {1} are not ccompleted / cancelled.,Ne mogu dovršiti zadatak {0} jer njegov zavisni zadatak {1} nije dovršen / otkazan.,
Cannot create loan until application is approved,Nije moguće kreirati zajam dok aplikacija ne bude odobrena,
Cannot find a matching Item. Please select some other value for {0}.,Ne možete pronaći odgovarajuću stavku. Izaberite 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","Ne mogu se preplatiti za stavku {0} u redu {1} više od {2}. Da biste omogućili prekomerno naplaćivanje, molimo postavite dodatak u Postavkama računa",
Cannot unpledge more than {0} qty of {0},Ne može se ukloniti više od {0} broj od {0},
"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 koliko i vrijeme završetka",
Categories,Kategorije,
Changes in {0},Promjene u {0},
Chart,Grafikon,
Choose a corresponding payment,Odaberite odgovarajuću uplatu,
Click on the link below to verify your email and confirm the appointment,Kliknite na donju vezu kako biste potvrdili svoju e-poštu i potvrdili sastanak,
Close,Zatvori,
Communication,Komunikacija,
Compact Item Print,Štampanje kompaktnih predmeta,
Company,Kompanija,
Company of asset {0} and purchase document {1} doesn't matches.,Kompanija imovine {0} i dokument o kupovini {1} ne odgovaraju.,
Compare BOMs for changes in Raw Materials and Operations,Uporedite BOM za promjene u sirovinama i načinu rada,
Compare List function takes on list arguments,Funkcija Uporedi listu preuzima argumente liste,
Complete,Kompletna,
Completed,Završeno,
Completed Quantity,Popunjena količina,
Connect your Exotel Account to ERPNext and track call logs,Povežite svoj Exotel račun u ERPNext i pratite evidencije poziva,
Connect your bank accounts to ERPNext,Povežite svoje bankovne račune s ERPNext-om,
Contact Seller,Kontakt oglašivača,
Continue,Nastavite,
Cost Center: {0} does not exist,Centar troškova: {0} ne postoji,
Couldn't Set Service Level Agreement {0}.,Nije moguće podesiti ugovor o nivou usluge {0}.,
Country,Država,
Country Code in File does not match with country code set up in the system,Kôd države u datoteci ne podudara se sa kodom države postavljenim u sistemu,
Create New Contact,Kreirajte novi kontakt,
Create New Lead,Stvorite novi potencijal,
Create Pick List,Kreirajte listu odabira,
Create Quality Inspection for Item {0},Napravite inspekciju kvaliteta za predmet {0},
Creating Accounts...,Stvaranje računa ...,
Creating bank entries...,Stvaranje bankovnih unosa ...,
Creating {0},Stvaranje {0},
Credit limit is already defined for the Company {0},Kreditni limit je već definisan za Kompaniju {0},
Ctrl + Enter to submit,Ctrl + Enter da biste poslali,
Ctrl+Enter to submit,Ctrl + Enter da biste poslali,
Currency,Valuta,
Current Status,Trenutni status,
Customer PO,Potrošački PO,
Customize,Prilagodite,
Daily,Svakodnevno,
Date,Datum,
Date Range,Raspon datuma,
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,Podrazumevano,
Define coupon codes.,Definirajte kodove kupona.,
Delayed Days,Odloženi dani,
Delete,Izbriši,
Delivered Quantity,Isporučena količina,
Delivery Notes,Dostavnice,
Depreciated Amount,Amortizovani iznos,
Description,Opis,
Designation,Oznaka,
Difference Value,Vrijednost razlike,
Dimension Filter,Dimenzijski filter,
Disabled,Onemogućeno,
Disbursed Amount cannot be greater than loan amount,Izneseni iznos ne može biti veći od iznosa zajma,
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 nije izbrisan,
Download Template,Preuzmite predložak,
Dr,Dr,
Due Date,Datum dospeć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,Račun za e-put JSON može se generirati samo iz dostavljenog 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 detalje,
Edit Profile,Uredi profil,
Either GST Transporter ID or Vehicle No is required if Mode of Transport is Road,"Ako je način prevoza cestovni, nije potreban ili GST Transporter ID ili vozilo",
Email,Email,
Email Campaigns,Kampanja e-pošte,
Employee ID is linked with another instructor,ID zaposlenika povezan je s drugim instruktorom,
Employee Tax and Benefits,Porez na zaposlene i beneficije,
Employee is required while issuing Asset {0},Zaposlenik je potreban dok izdaje imovinu {0},
Employee {0} does not belongs to the company {1},Zaposleni {0} ne pripada kompaniji {1},
Enable Auto Re-Order,Omogući automatsku ponovnu narudžbu,
End Date of Agreement can't be less than today.,Datum završetka sporazuma ne može biti manji od današnjeg.,
End Time,Vrijeme završetka,
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,Tip entiteta,
Error,Greška,
Error in Exotel incoming call,Pogreška u dolaznom pozivu Exotela,
Error: {0} is mandatory field,Greška: {0} je obavezno polje,
Event Link,Event Link,
Exception occurred while reconciling {0},Izuzetak je nastao prilikom usklađivanja {0},
Expected and Discharge dates cannot be less than Admission Schedule date,Očekivani i datum otpuštanja ne može biti manji od datuma Plana prijema,
Expire Allocation,Isteče dodjela,
Expired,Istekao,
Expiry date is mandatory for selected item.,Datum isteka je obavezan za odabrani artikal.,
Export,Izvoz,
Export not allowed. You need {0} role to export.,Izvoz nije dozvoljen. Za izvoz vam treba {0} uloga.,
Failed to add Domain,Nije moguće dodati Domen,
Fetch Items from Warehouse,Dohvaćanje predmeta iz skladišta,
Fetching...,Dohvaćanje ...,
Field,Polje,
File Manager,File Manager,
Filters,Filteri,
Finding linked payments,Pronalaženje povezanih plaćanja,
Finished Product,Gotov proizvod,
Finished Qty,Gotovo Količina,
First add items in the Item Locations table,Prvo dodajte stavke u tablicu Lokacije predmeta,
Fleet Management,Upravljanje voznim parkom,
Following fields are mandatory to create address:,Sledeća polja su obavezna za kreiranje adrese:,
For Month,Za mesec,
"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 izabranoj 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},Besplatni artikl nije postavljen u pravilu o cijenama {0},
From Date and To Date are Mandatory,Datum i datum su obavezni,
From date can not be greater than than To date,Od datuma ne može biti veći od Do danas,
From employee is required while receiving Asset {0} to a target location,Od zaposlenika je potrebno dok prima imovinu {0} do ciljane lokacije,
Fuel Expense,Rashodi goriva,
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,Dohvati predmete,
Get Outstanding Documents,Nabavite izvanredne dokumente,
Goal,Cilj,
Greater Than Amount,Veća od iznosa,
Green,Zeleno,
Group,Grupa,
Group By Customer,Grupiranje po kupcu,
Group By Supplier,Grupiranje po dobavljaču,
Group Node,Grupni čvor,
Group Warehouses cannot be used in transactions. Please change the value of {0},Grupne skladišta se ne mogu koristiti u transakcijama. Molimo promijenite vrijednost {0},
Help,Pomoć,
Help Article,Članak pomoći,
"Helps you keep tracks of Contracts based on Supplier, Customer and Employee","Pomaže vam da pratite ugovore na osnovu dobavljača, kupca i zaposlenika",
Helps you manage appointments with your leads,Pomaže vam u upravljanju sastancima sa 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 toku,
Incoming call from {0},Dolazni poziv od {0},
Incorrect Warehouse,Pogrešno skladište,
Interest Amount is mandatory,Iznos kamate je obavezan,
Intermediate,Srednji,
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,
Invite as User,Pozovi kao korisnika,
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.","Izgleda da postoji problem sa konfiguracijom trake servera. U slučaju neuspjeha, iznos će biti vraćen na vaš račun.",
Item Reported,Stavka prijavljena,
Item listing removed,Popis predmeta je uklonjen,
Item quantity can not be zero,Količina predmeta ne može biti jednaka nuli,
Item taxes updated,Ažurirani su porezi na artikle,
Item {0}: {1} qty produced. ,Stavka {0}: {1} Količina proizvedena.,
Items are required to pull the raw materials which is associated with it.,Predmeti su potrebni za povlačenje sirovina koje su sa tim povezane.,
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,Poslednje izdanje,
Latest Age,Najnovije doba,
Leave application is linked with leave allocations {0}. Leave application cannot be set as leave without pay,Prijava za odlazak povezana je sa izdvajanjem dopusta {0}. Aplikacija za odlazak ne može se postaviti kao dopust bez plaćanja,
Leaves Taken,Ostavljeni listovi,
Less Than Amount,Manje od iznosa,
Liabilities,Obaveze,
Loading...,Učitavanje...,
Loan Amount exceeds maximum loan amount of {0} as per proposed securities,Iznos zajma premašuje maksimalni iznos zajma od {0} po predloženim hartijama od vrijednosti,
Loan Applications from customers and employees.,Prijave za zajmove od kupaca i zaposlenih.,
Loan Disbursement,Isplata zajma,
Loan Processes,Procesi zajma,
Loan Security,Zajam zajma,
Loan Security Pledge,Zalog za zajam kredita,
Loan Security Pledge Company and Loan Company must be same,Zajam za zajam zajma i zajam Društvo moraju biti isti,
Loan Security Pledge Created : {0},Stvoreno jamstvo zajma: {0},
Loan Security Pledge already pledged against loan {0},Zajam za zajam kredita već dan pozajmice {0},
Loan Security Pledge is mandatory for secured loan,Zalog osiguranja zajma je obavezan za osiguran zajam,
Loan Security Price,Cijena garancije zajma,
Loan Security Price overlapping with {0},Cijena osiguranja zajma se preklapa s {0},
Loan Security Unpledge,Bez plaćanja zajma,
Loan Security Value,Vrijednost zajma kredita,
Loan Type for interest and penalty rates,Vrsta kredita za kamate i zatezne stope,
Loan amount cannot be greater than {0},Iznos zajma ne može biti veći od {0},
Loan is mandatory,Zajam je obavezan,
Loans,Krediti,
Loans provided to customers and employees.,Krediti kupcima i zaposlenima.,
Location,Lokacija,
Log Type is required for check-ins falling in the shift: {0}.,Vrsta dnevnika potrebna je za prijave u padu: {0}.,
Looks like someone sent you to an incomplete URL. Please ask them to look into it.,Izgleda da vam je neko poslao nepotpun URL. Zamolite ih da pogledaju.,
Make Journal Entry,Unesite u časopis,
Make Purchase Invoice,Napravite fakturu za kupovinu,
Manufactured,Proizvedeno,
Mark Work From Home,Označi rad od kuće,
Master,Učiteljice,
Max strength cannot be less than zero.,Maksimalna snaga 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,Nedostaju potrebne vrijednosti,
Mobile No,Mobile No,
Mobile Number,Broj mobitela,
Month,Mesec,
Name,Ime,
Near you,U vašoj blizini,
Net Profit/Loss,Neto dobit / gubitak,
New Expense,Novi trošak,
New Invoice,Nova faktura,
New Payment,Nova uplata,
New release date should be in the future,Novi datum izlaska trebao bi biti u budućnosti,
Newsletter,Bilten,
No Account matched these filters: {},Nijedan račun ne odgovara ovim filterima: {},
No Employee found for the given employee field value. '{}': {},Za određenu vrijednost polja radnika nije pronađen nijedan zaposleni. &#39;{}&#39;: {},
No Leaves Allocated to Employee: {0} for Leave Type: {1},No Leaves dodijeljeno zaposlenom: {0} za vrstu odmora: {1},
No communication found.,Nije pronađena komunikacija.,
No correct answer is set for {0},Nije postavljen tačan odgovor za {0},
No description,Bez opisa,
No issue has been raised by the caller.,Pozivatelj nije pokrenuo nijedan problem.,
No items to publish,Nema predmeta za objavljivanje,
No outstanding invoices found,Nisu pronađeni neizmireni računi,
No outstanding invoices found for the {0} {1} which qualify the filters you have specified.,Nisu pronađene neizmirene fakture za {0} {1} koji kvalificiraju filtere 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 valid <b>Loan Security Price</b> found for {0},Nije pronađena valjana <b>cijena</b> jamstva za za {0},
No views yet,Još nema pogleda,
Non stock items,Artikli koji nisu dostupni,
Not Allowed,Nije dopusteno,
Not allowed to create accounting dimension for {0},Nije dozvoljeno kreiranje računovodstvenih dimenzija za {0},
Not permitted. Please disable the Lab Test Template,Nije dozvoljeno. Isključite predložak laboratorijskog testa,
Not permitted. Please disable the Procedure Template,Nije dozvoljeno. Molimo isključite predložak postupka,
Note,Bilješka,
Notes: ,Napomene:,
Offline,Offline,
On Converting Opportunity,O pretvaranju mogućnosti,
On Purchase Order Submission,Prilikom narudžbe,
On Sales Order Submission,Prilikom podnošenja 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,
Only expired allocation can be cancelled,Samo je istekla dodjela istekla,
Only users with the {0} role can create backdated leave applications,Samo korisnici s ulogom {0} mogu kreirati unatrag dopuštene aplikacije,
Open,Otvori,
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čna kompanija mora biti kompanija u grupi,
Passing Score value should be between 0 and 100,Vrijednost prolaska rezultata trebala bi biti između 0 i 100,
Password policy cannot contain spaces or simultaneous hyphens. The format will be restructured automatically,Politika lozinke ne može sadržavati razmake ili simultane crtice. Format će se automatski restrukturirati,
Patient History,Istorija pacijenata,
Pause,Pauza,
Pay,Platite,
Payment Document Type,Vrsta dokumenta plaćanja,
Payment Name,Naziv plaćanja,
Penalty Amount,Iznos kazne,
Pending,U toku,
Performance,Performanse,
Period based On,Period zasnovan na,
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 liste,
Plaid authentication error,Greška provjere autentičnosti,
Plaid public token error,Greška u javnom tokenu,
Plaid transactions sync error,Greška sinhronizacije transakcija u plaidu,
Please check the error log for details about the import errors,Molimo provjerite dnevnik grešaka za detalje o uvoznim greškama,
Please click on the following link to set your new password,Kliknite sljedeću vezu da biste postavili novu lozinku,
Please create <b>DATEV Settings</b> for Company <b>{}</b>.,Molimo stvorite <b>DATEV postavke</b> za kompaniju <b>{}</b> .,
Please create adjustment Journal Entry for amount {0} ,Molimo kreirajte prilagodbu unosa u časopisu za iznos {0},
Please do not create more than 500 items at a time,Molimo 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>prilagođavanje dionica</b> za kompaniju {0},
Please enter GSTIN and state for the Company Address {0},Unesite GSTIN i upišite adresu kompanije {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 enter coupon code !!,Unesite kod kupona !!,
Please enter the designation,Unesite oznaku,
Please enter valid coupon code !!,Unesite važeći kod kupona !!,
Please login as a Marketplace User to edit this item.,Prijavite se kao Korisnik Marketplace-a 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,Molimo odaberite <b>Vrsta predloška</b> za preuzimanje predloška,
Please select Applicant Type first,Prvo odaberite vrstu prijavitelja,
Please select Customer first,Prvo odaberite kupca,
Please select Item Code first,Prvo odaberite šifru predmeta,
Please select Loan Type for company {0},Molimo odaberite vrstu kredita za kompaniju {0},
Please select Patient to get prescribed procedure,Molimo odaberite pacijenta da biste dobili propisani postupak,
Please select a Delivery Note,Molimo odaberite dostavnicu,
Please select a Sales Person for item: {0},Izaberite prodajnu osobu za predmet: {0},
Please select another payment method. Stripe does not support transactions in currency '{0}',Odaberite drugi način plaćanja. Stripe ne podržava transakcije u valuti &#39;{0}&#39;,
Please select the customer.,Molimo odaberite kupca.,
Please set a Supplier against the Items to be considered in the Purchase Order.,Molimo postavite dobavljača protiv predmeta koji će se smatrati narudžbenicom.,
Please set account heads in GST Settings for Compnay {0},Postavite glave računa u GST Settings za preduzeće {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,Molimo postavite zadani UOM u Postavkama dionica,
Please set filter based on Item or Warehouse due to a large amount of entries.,Molimo postavite filtar na osnovu predmeta ili skladišta zbog velike količine unosa.,
Please set up the Campaign Schedule in the Campaign {0},Molimo postavite Raspored kampanje u kampanji {0},
Please set valid GSTIN No. in Company Address for company {0},Molimo vas da podesite važeći GSTIN br. Na adresi kompanije za kompaniju {0},
Please set {0},Molimo postavite {0},customer
Please setup a default bank account for company {0},Postavite zadani bankovni račun za kompaniju {0},
Please specify,Molimo navedite,
Please specify a {0},Navedite {0},lead
Pledge Status,Status zaloga,
Pledge Time,Vreme zaloga,
Printing,Štampanje,
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,Profitabilnost,
Project,Projekat,
Proposed Pledges are mandatory for secured Loans,Predložene zaloge su obavezne za osigurane zajmove,
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,Objavite,
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 kupovinu ne može se izvršiti protiv postojećeg sredstva {0},
Purchase Invoices,Računi za kupovinu,
Purchase Orders,Narudžbenice,
Purchase Receipt doesn't have any Item for which Retain Sample is enabled.,Potvrda o kupovini nema stavku za koju je omogućen zadržati uzorak.,
Purchase Return,Povratak kupovine,
Qty of Finished Goods Item,Količina proizvoda gotove robe,
Qty or Amount is mandatroy for loan security,Količina ili iznos je mandatroy za osiguranje kredita,
Quality Inspection required for Item {0} to submit,Inspekcija kvaliteta potrebna za podnošenje 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,Kvartalno,
Queued,U redu za red,
Quick Entry,Brzi ulazak,
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,Pomirjen,
Recruitment,Zapošljavanje,
Red,Crveno,
Refreshing,Osvežavajuće,
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 dozvoljeno,
Repayment Method is mandatory for term loans,Način otplate je obavezan za oročene kredite,
Repayment Start Date is mandatory for term loans,Datum početka otplate je obavezan za oročene kredite,
Report Item,Izvještaj,
Report this Item,Prijavi ovaj predmet,
Reserved Qty for Subcontract: Raw materials quantity to make subcontracted items.,Količina rezervisanog za podugovor: Količina sirovina za izradu predmeta koji su predmet podugovora.,
Reset,Resetovati,
Reset Service Level Agreement,Vratite ugovor o nivou usluge,
Resetting Service Level Agreement.,Poništavanje ugovora o nivou usluge.,
Response Time for {0} at index {1} can't be greater than Resolution Time.,Vrijeme odgovora za {0} u indeksu {1} ne može biti veće od vremena rezolucije.,
Return amount cannot be greater unclaimed amount,Povratni iznos ne može biti veći nenaplaćeni iznos,
Review,Pregled,
Room,Soba,
Room Type,Tip sobe,
Row # ,Red broj #,
Row #{0}: Accepted Warehouse and Supplier Warehouse cannot be same,Red # {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 broj {0}: Nije moguće izbrisati stavku {1} koja je već naplaćena.,
Row #{0}: Cannot delete item {1} which has already been delivered,Redak broj {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 broj {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čevom nalogu za kupovinu.,
Row #{0}: Cannot select Supplier Warehouse while suppling raw materials to subcontractor,Red 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škovi {1} ne pripada kompaniji {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}.,Red # {0}: Operacija {1} nije dovršena za {2} broj 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 broj {0}: Za završetak transakcije potreban je dokument o plaćanju,
Row #{0}: Serial No {1} does not belong to Batch {2},Red # {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đeni računovodstvo,
Row {0}: Invalid Item Tax Template for item {1},Red {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}),Red {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},Red {0}: korisnik nije primijenio pravilo {1} na stavku {2},
Row {0}:Sibling Date of Birth cannot be greater than today.,Red {0}: Datum rođenja braće ne može biti veći nego danas.,
Row {1}: Asset Naming Series is mandatory for the auto creation for item {0},Red {1}: Serija Imena imena je obavezna za automatsko stvaranje stavke {0},
Row({0}): {1} is already discounted in {2},Red ({0}): {1} već je diskontiran u {2},
Rows Added in {0},Redovi dodano u {0},
Rows Removed in {0},Redovi su uklonjeni za {0},
Sanctioned Amount limit crossed for {0} {1},Granica sankcionisanog iznosa pređena za {0} {1},
Sanctioned Loan Amount already exists for {0} against company {1},Već postoji sankcionirani iznos zajma za {0} protiv kompanije {1},
Save,Spremi,
Save Item,Spremi stavku,
Saved Items,Spremljene stavke,
Scheduled and Admitted dates can not be less than today,Zakazani i prihvaćeni datumi ne mogu biti manji nego danas,
Search Items ...,Stavke za pretraživanje ...,
Search for a payment,Potražite plaćanje,
Search for anything ...,Traži bilo šta ...,
Search results for,Rezultati pretrage za,
Select All,Označi sve,
Select Difference Account,Odaberite račun razlike,
Select a Default Priority.,Odaberite zadani prioritet.,
Select a Supplier from the Default Supplier List of the items below.,Izaberite dobavljača sa zadanog popisa dobavljača donjih stavki.,
Select a company,Odaberite kompaniju,
Select finance book for the item {0} at row {1},Odaberite knjigu finansiranja za stavku {0} u retku {1},
Select only one Priority as Default.,Odaberite samo jedan prioritet kao podrazumevani.,
Seller Information,Informacije o prodavaču,
Send,Pošalji,
Send a message,Pošaljite poruku,
Sending,Slanje,
Sends Mails to lead or contact based on a Campaign schedule,Šalje poruke kako bi vodio ili kontaktirao na osnovu rasporeda kampanje,
Serial Number Created,Serijski broj je kreiran,
Serial Numbers Created,Serijski brojevi stvoreni,
Serial no(s) required for serialized item {0},Serijski brojevi potrebni za serijski artikl {0},
Series,Serija,
Server Error,greska servera,
Service Level Agreement has been changed to {0}.,Ugovor o nivou usluge izmenjen je u {0}.,
Service Level Agreement tracking is not enabled.,Praćenje ugovora o nivou usluge nije omogućeno.,
Service Level Agreement was reset.,Ugovor o nivou usluge je resetiran.,
Service Level Agreement with Entity Type {0} and Entity {1} already exists.,Ugovor o nivou usluge sa tipom entiteta {0} i entitetom {1} već postoji.,
Set,Set,
Set Meta Tags,Postavljanje meta tagova,
Set Response Time and Resolution for Priority {0} at index {1}.,Podesite vrijeme odziva i rezoluciju za prioritet {0} na indeksu {1}.,
"Set item's shelf life in days, to set expiry based on manufacturing date plus shelf-life.",Podesite rok trajanja artikla u danima kako biste postavili rok upotrebe na osnovu datuma proizvodnje plus rok trajanja.,
Set {0} in company {1},Postavite {0} u kompaniju {1},
Setup,Postaviti,
Setup Wizard,Čarobnjak za podešavanje,
Shift Management,Shift Management,
Show Future Payments,Prikaži buduće isplate,
Show Linked Delivery Notes,Prikaži povezane bilješke isporuke,
Show Sales Person,Pokaži prodajnu osobu,
Show Stock Ageing Data,Prikaž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 tokom vrednovanja kviza.,
"Sorry,coupon code are exhausted","Izvinite, kod kupona je iscrpljen",
"Sorry,coupon code validity has expired","Nažalost, valjanost koda kupona je istekla",
"Sorry,coupon code validity has not started","Nažalost, valjanost koda kupona nije započela",
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 zaliha,
Stock Entry has been already created against this Pick List,Unos dionica već je stvoren protiv ove Pick liste,
Stock Ledger ID,ID knjige knjige,
Stock Value ({0}) and Account Balance ({1}) are out of sync for account {2} and it's linked warehouses.,Vrijednost zaliha ({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 sa e-mailom {0} ne postoji,
Submit Review,Pošaljite recenziju,
Submitted,Podneseno,
Supplier Addresses And Contacts,Adrese i kontakti dobavljača,
Synchronize this account,Sinhronizirajte ovaj račun,
Tag,Oznaka,
Target Location is required while receiving Asset {0} from an employee,Ciljna lokacija je potrebna dok primate imovinu {0} od zaposlenika,
Target Location is required while transferring Asset {0},Ciljana lokacija je potrebna prilikom prijenosa imovine {0},
Target Location or To Employee is required while receiving Asset {0},Ciljana lokacija ili zaposleni su potrebni za vrijeme prijema imovine {0},
Task's {0} End Date cannot be after Project's End Date.,Završni datum zadatka {0} 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,Šablon,
The Campaign '{0}' already exists for the {1} '{2}',Kampanja &#39;{0}&#39; već postoji za {1} &#39;{2}&#39;,
The difference between from time and To Time must be a multiple of Appointment,Razlika između vremena i vremena mora biti višestruka od imenovanja,
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 Vlasnički račun / račun 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,Roditeljski račun {0} ne postoji u učitanom predlošku,
The question cannot be duplicate,Pitanje ne može biti duplikat,
The selected payment entry should be linked with a creditor bank transaction,Odabrani unos za plaćanje treba biti povezan sa bankovnom transakcijom vjerovnika,
The selected payment entry should be linked with a debtor bank transaction,Odabrani unos za plaćanje treba biti povezan sa bankovnom transakcijom dužnika,
The total allocated amount ({0}) is greated than the paid amount ({1}).,Ukupni dodijeljeni iznos ({0}) je namazan od uplaćenog iznosa ({1}).,
The total completed qty({0}) must be equal to qty to manufacture({1}),Ukupni popunjeni broj ({0}) mora biti jednak količini za proizvodnju ({1}),
The value {0} is already assigned to an exisiting Item {2}.,Vrijednost {0} je već dodijeljena postojećoj stavci {2}.,
There are no vacancies under staffing plan {0},Nema slobodnih radnih mjesta u okviru kadrovskog plana {0},
This Service Level Agreement is specific to Customer {0},Ovaj Ugovor o nivou 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 sa vašim bankovnim računima. Ne može se poništiti. Jeste li sigurni?,
This bank account is already synchronized,Ovaj je bankovni račun već sinhroniziran,
This bank transaction is already fully reconciled,Ova je bankarska transakcija već u potpunosti usklađena,
This employee already has a log with the same timestamp.{0},Ovaj zaposlenik već ima dnevnik sa istim vremenskim žigom. {0},
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,
Timing,Vremenski raspored,
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 „Nadoplatu za naplatu“ 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;Over Receipt / Dozvola za isporuku&quot; u Postavke zaliha ili Artikl.",
To date needs to be before from date,Do danas treba biti prije datuma,
Total,Ukupno,
Total Early Exits,Ukupni rani izlazi,
Total Late Entries,Ukupno kasnih unosa,
Total Payment Request amount cannot be greater than {0} amount,Ukupan 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,Ukupno,
Training Event:,Trening događaj:,
Transactions already retreived from the statement,Transakcije su već povučene iz izjave,
Transfer Material to Supplier,Prenesite materijal dobavljaču,
Transport Receipt No and Date are mandatory for your chosen Mode of Transport,Ne i datum prijevoza obavezni su za odabrani način prijevoza,
Tuesday,Utorak,
Type,Tip,
Unable to find Salary Component {0},Nije moguće pronaći komponentu plaće {0},
Unable to find the time slot in the next {0} days for the operation {1}.,Nije moguće pronaći vremenski interval u narednih {0} dana za operaciju {1}.,
Unable to update remote activity,Nije moguće ažurirati daljinsku aktivnost,
Unknown Caller,Nepoznati pozivalac,
Unlink external integrations,Prekini vezu s vanjskim integracijama,
Unmarked Attendance for days,Danima bez oznake,
Unpublish Item,Ponipublishtavanje predmeta,
Unreconciled,Neusklađeno,
Unsupported GST Category for E-Way Bill JSON generation,Nepodržana GST kategorija za e-Way Bill JSON generacije,
Update,Ažuriraj,
Update Details,Ažurirajte detalje,
Update Taxes for Items,Ažurirajte porez na stavke,
"Upload a bank statement, link or reconcile a bank account","Pošaljite bankovni izvod, povežite ili usklađujete bankovni račun",
Upload a statement,Pošaljite izjavu,
Use a name that is different from previous project name,Upotrijebite ime koje se razlikuje od prethodnog naziva projekta,
User {0} is disabled,Korisnik {0} je onemogućen,
Users and Permissions,Korisnici i dozvole,
Vacancies cannot be lower than the current openings,Slobodna radna mjesta ne mogu biti niža od postojećih,
Valid From Time must be lesser than Valid Upto Time.,Vrijedi od vremena mora biti kraće od Važećeg vremena uputa.,
Valuation Rate required for Item {0} at row {1},Stopa vrednovanja potrebna za poziciju {0} u retku {1},
"Valuation rate not found for the Item {0}, which is required to do accounting entries for {1} {2}. If the item is transacting as a zero valuation rate item in the {1}, please mention that in the {1} Item table. Otherwise, please create an incoming stock transaction for the item or mention valuation rate in the Item record, and then try submiting / cancelling this entry.","Stopa vrednovanja nije pronađena za poziciju {0} koja je potrebna za unos računovodstva za {1} {2}. Ako stavka djeluje kao stavka nulte vrijednosti u {1}, navedite to u {1} tablici predmeta. U suprotnom, napravite dolaznu transakciju dionica za stavku ili navedite stopu procjene u zapisu stavke, a zatim pokušajte predati / poništiti ovaj unos.",
Values Out Of Sync,Vrijednosti van sinkronizacije,
Vehicle Type is required if Mode of Transport is Road,Vrsta vozila je obavezna ako je način prevoza cestovni,
Vendor Name,Ime dobavljača,
Verify Email,Potvrdi Email,
View,Pogled,
View all issues from {0},Pogledajte sva 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},Dobrodošli na {0},
Why do think this Item should be removed?,Zašto mislite da bi ovaj predmet trebalo ukloniti?,
Work Order {0}: Job Card not found for the operation {1},Radni nalog {0}: Job kartica nije pronađena za operaciju {1},
Workday {0} has been repeated.,Radni dan {0} se ponavlja.,
XML Files Processed,Obrađene XML datoteke,
Year,Godina,
Yearly,Godišnje,
You,Ti,
You are not allowed to enroll for this course,Nije vam dopušteno da se upišete na ovaj kurs,
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 i zalijepiti ovu vezu u svoj pretraživač,
You can publish upto 200 items.,Možete objaviti do 200 predmeta.,
You can't create accounting entries in the closed accounting period {0},Ne možete kreirati računovodstvene unose u zatvorenom obračunskom periodu {0},
You have to enable auto re-order in Stock Settings to maintain re-order levels.,Morate omogućiti automatsku ponovnu narudžbu u Postavkama dionica da biste održavali razinu ponovne narudžbe.,
You must be a registered supplier to generate e-Way Bill,Morate biti registrirani dobavljač za generiranje e-puta računa,
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,Vaše istaknute stavke,
Your Items,Vaše predmete,
Your Profile,Tvoj profil,
Your rating:,Vaša ocjena:,
Zero qty of {0} pledged against loan {0},Nulta količina {0} obećala je zajam {0},
and,i,
e-Way Bill already exists for this document,Za ovaj dokument već postoji e-Way Bill,
woocommerce - {0},woocommerce - {0},
{0} Asset{2} Created for <b>{1}</b>,{0} Imovina {2} Kreirana za <b>{1}</b>,
{0} Coupon used are {1}. Allowed quantity is exhausted,{0} Kupon se koristi {1}. Dozvoljena količina se iscrpljuje,
{0} Name,{0} Ime,
{0} Operations: {1},{0} Operacije: {1},
{0} bank transaction(s) created,{0} Napravljene su bankarske transakcije,
{0} bank transaction(s) created and {1} errors,Stvorene {0} bankovne transakcije i {1} greš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 kompanije,
{0} is not a group node. Please select a group node as parent cost center,{0} nije grupni čvor. Odaberite čvor grupe kao roditeljsko trošak,
{0} is not the default supplier for any items.,{0} nije zadani dobavljač za bilo koju robu.,
{0} is required,{0} je obavezno,
{0} units of {1} is not available.,{0} jedinice od {1} nisu dostupne.,
{0}: {1} must be less than {2},{0}: {1} mora biti manji od {2},
{} is an invalid Attendance Status.,{} je nevažeći status pohađanja.,
{} is required to generate E-Way Bill JSON,{} je potreban za generisanje računa E-Way JSON,
"Invalid lost reason {0}, please create a new lost reason","Nevažeći izgubljeni razlog {0}, napravite 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,
Clear,Jasno,
Comments,Komentari,
Download,Skinuti,
New,Novo,
Print,Ispis,
Reference Name,Referentno ime,
Refresh,Osvježiti,
Success,Uspeh,
Value,Vrijednost,
Actual,Aktuelno,
Add to Cart,Dodaj u korpu,
Days Since Last Order,Dani od poslednje narudžbe,
In Stock,Na zalihama,
Loan Amount is mandatory,Iznos zajma je obavezan,
Mode Of Payment,Način plaćanja,
No students Found,Nije pronađen nijedan student,
Not in Stock,Nije na zalihama,
Please select a Customer,Molimo odaberite kupca,
Printed On,Printed On,
Received From,Primljeno od,
Sales Person,Prodajno lice,
To date cannot be before From date,Do danas ne može biti prije Od datuma,
Write Off,Otpisati,
{0} Created,{0} Napravljeno,
Email Id,ID identiteta,
Actual ,Aktuelno,
Add to cart,Dodaj u korpu,
Budget,Budžet,
Chart Of Accounts Importer,Uvoznik računa računa,
Chart of Accounts,Računski plan,
Customer database.,Korisnička baza podataka.,
Days Since Last order,Dani od poslednje narudžbe,
Download as JSON,Preuzmi kao JSON,
End date can not be less than start date,Datum završetka ne može biti manji od datuma početka,
For Default Supplier (Optional),Za osnovnog dobavljača (neobavezno),
From date cannot be greater than To date,Od datuma ne može biti veći od Do danas,
Get items from,Dobijajte predmete od,
Group by,Grupiraj prema,
In stock,Na lageru,
Item name,Naziv predmeta,
Loan amount is mandatory,Iznos zajma je obavezan,
Minimum Qty,Minimalni broj,
More details,Više detalja,
Nature of Supplies,Priroda materijala,
No Items found.,Nije pronađen nijedan predmet.,
No employee found,Nije pronađen nijedan zaposleni,
No students found,Nije pronađen nijedan student,
Not in stock,Nema na skladištu,
Not permitted,Nije dozvoljeno,
Open Issues ,Otvorena pitanja,
Open Projects ,Otvoreni projekti,
Open To Do ,Otvoreno za napraviti,
Operation Id,Operation Id,
Partially ordered,Djelomično naređeno,
Please select company first,Prvo odaberite tvrtku,
Please select patient,Molimo odaberite pacijenta,
Printed On ,Printed On,
Projected qty,Projicirani br,
Sales person,Prodavac,
Serial No {0} Created,Serijski broj {0} Napravljeno,
Set as default,Postavi kao zadano,
Source Location is required for the Asset {0},Lokacija izvora potrebna je za imovinu {0},
Tax Id,Porezni broj,
To Time,To Time,
To date cannot be before from date,Do danas ne može biti prije datuma,
Total Taxable value,Ukupna oporeziva vrijednost,
Upcoming Calendar Events ,Nadolazeći događaji u kalendaru,
Value or Qty,Vrijednost ili Količina,
Variance ,Varijanca,
Variant of,Varijanta,
Write off,Otpisati,
Write off Amount,Otpisati iznos,
hours,sati,
received from,primljeno od,
to,do,
Customer &gt; Customer Group &gt; Territory,Kupac&gt; grupa kupaca&gt; teritorija,
Item Code &gt; Item Group &gt; Brand,Kod artikla&gt; Grupa artikala&gt; Marka,
Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Molimo postavite Naming Series za {0} putem Podešavanje&gt; Podešavanja&gt; Imenovanje serije,
Please setup Employee Naming System in Human Resource &gt; HR Settings,Postavite sistem imenovanja zaposlenika u ljudskim resursima&gt; HR postavke,
Please setup Instructor Naming System in Education &gt; Education Settings,Postavite sistem imenovanja instruktora u Obrazovanje&gt; Postavke obrazovanja,
Please setup numbering series for Attendance via Setup &gt; Numbering Series,Molimo podesite seriju numeriranja za Attendance putem Podešavanje&gt; Serija brojanja,
Supplier &gt; Supplier Type,Dobavljač&gt; vrsta dobavljača,
UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},Faktor konverzije UOM ({0} -&gt; {1}) nije pronađen za stavku: {2},
