"""Customer Provided Item"" cannot be Purchase Item also",&quot;Predmet koji pruža klijent&quot; takođe ne može biti predmet kupovine,
"""Customer Provided Item"" cannot have Valuation Rate",&quot;Predmet koji pruža klijent&quot; ne može imati stopu vrednovanja,
"""Is Fixed Asset"" cannot be unchecked, as Asset record exists against the item","&quot;Da li je osnovno sredstvo&quot; ne može biti označeno, kao rekord imovine postoji u odnosu na stavku",
'Based On' and 'Group By' can not be same,' Temelji se na' i 'Grupisanje po ' ne mogu biti isti,
'Days Since Last Order' must be greater than or equal to zero,' Dana od poslednje porudzbine ' mora biti veći ili jednak nuli,
'Entries' cannot be empty,' Prijave ' ne može biti prazno,
'From Date' is required,' Od datuma ' je potrebno,
'From Date' must be after 'To Date',"' Od datuma ' mora biti poslije ' Do datuma""",
'Has Serial No' can not be 'Yes' for non-stock item,' Ima serijski broj ' ne može biti ' Da ' za artikle bez zalihe,
'Opening',&#39;Otvaranje&#39;,
'To Case No.' cannot be less than 'From Case No.','Za slucaj br' ne može biti manji od 'Od slucaja br',
'To Date' is required,' Do datuma ' je obavezno,
'Total',&#39;Ukupno&#39;,
'Update Stock' can not be checked because items are not delivered via {0},'Azuriranje zalihe' se ne može provjeriti jer artikli nisu dostavljeni putem {0},
'Update Stock' cannot be checked for fixed asset sale,&#39;Update Stock&#39; ne može se provjeriti na prodaju osnovnih sredstava,
1 exact match.,1 tačno podudaranje.,
90-Above,Iznad 90,
A Customer Group exists with same name please change the Customer name or rename the Customer Group,Grupa kupaca sa istim nazivom već postoji. Promijenite naziv kupca ili promijenite naziv grupe kupaca.,
A Default Service Level Agreement already exists.,Ugovor o nivou usluge već postoji.,
A Lead requires either a person's name or an organization's name,Voditelj zahteva ili ime osobe ili ime organizacije,
A customer with the same name already exists,Kupac sa istim imenom već postoji,
A question must have more than one options,Pitanje mora imati više opcija,
A qustion must have at least one correct options,Qurance mora imati najmanje jednu ispravnu opciju,
A4,A4,
API Endpoint,API Endpoint,
API Key,API Key,
Abbr can not be blank or space,Skraćeno ne može biti prazan ili prostora,
Abbreviation already used for another company,Skraćenica već koristi za druge kompanije,
Abbreviation cannot have more than 5 characters,Skraćeni naziv ne može imati više od 5 znakova,
Abbreviation is mandatory,Skraćenica je obavezno,
About the Company,O kompaniji,
About your company,O vašoj kompaniji,
Above,Iznad,
Academic Term,akademski Term,
Academic Term: ,Akademski termin:,
Academic Year,Akademska godina,
Academic Year: ,Akademska godina:,
Accepted + Rejected Qty must be equal to Received quantity for Item {0},Količina prihvaćeno + odbijeno mora biti jednaka zaprimljenoj količini proizvoda {0},
Access Token,Access Token,
Accessable Value,Dostupna vrednost,
Account,Konto,
Account Number,Broj računa,
Account Number {0} already used in account {1},Broj računa {0} već se koristi na nalogu {1},
Account Pay Only,Račun plaćaju samo,
Account Type,Vrsta konta,
Account Type for {0} must be {1},Tip naloga za {0} mora biti {1},
"Account balance already in Credit, you are not allowed to set 'Balance Must Be' as 'Debit'","Stanje računa već u kredit, što se ne smije postaviti 'ravnoteža se mora' kao 'zaduženje """,
"Account balance already in Debit, you are not allowed to set 'Balance Must Be' as 'Credit'","Stanje računa već u zaduženje, ne smiju postaviti 'ravnoteža se mora' kao 'kreditne'",
Account number for account {0} is not available.<br> Please setup your Chart of Accounts correctly.,Broj računa za račun {0} nije dostupan. <br> Molimo pravilno podesite svoj račun.,
Account with child nodes cannot be converted to ledger,Konto sa pod-kontima se ne može pretvoriti u glavnoj knjizi,
Account with child nodes cannot be set as ledger,Račun s djetetom čvorovi se ne može postaviti kao glavnu knjigu,
Account with existing transaction can not be converted to group.,Konto sa postojećim transakcijama se ne može pretvoriti u grupu konta .,
Account with existing transaction can not be deleted,Konto sa postojećim transakcijama se ne može izbrisati,
Account with existing transaction cannot be converted to ledger,Konto sa postojećim transakcijama se ne može pretvoriti u glavnu knjigu,
Account {0} does not belong to company: {1},Konto {0} ne pripada preduzeću {1},
Account {0} does not belongs to company {1},Računa {0} ne pripada kompaniji {1},
Account {0} does not exist,Konto {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čuna {0} ne odgovara Company {1} u režimu računa: {2},
Account {0} has been entered multiple times,Račun {0} je ušao više puta,
Account {0} is added in the child company {1},Račun {0} se dodaje u nadređenoj kompaniji {1},
Account {0} is frozen,Konto {0} je zamrznut,
Account {0} is invalid. Account Currency must be {1},Račun {0} je nevažeća. Račun valuta mora biti {1},
Account {0}: Parent account {1} can not be a ledger,Konto {0}: Nadređeni konto {1} Ne može biti knjiga,
Account {0}: Parent account {1} does not belong to company: {2},Konto {0}: Nadređeni konto {1} ne pripada preduzeću: {2},
Account {0}: Parent account {1} does not exist,Konto {0}: Nadređeni konto {1} ne postoji,
Account {0}: You can not assign itself as parent account,Konto {0}: Ne može se označiti kao nadređeni konto samom sebi,
Account: {0} can only be updated via Stock Transactions,Račun: {0} može ažurirati samo preko Stock Transakcije,
Account: {0} with currency: {1} can not be selected,Račun: {0} s valutnom: {1} se ne mogu odabrati,
Accountant,Računovođa,
Accounting,Računovodstvo,
Accounting Entry for Asset,Računovodstveni unos za imovinu,
Accounting Entry for Stock,Računovodstvo Entry za Stock,
Accounting Entry for {0}: {1} can only be made in currency: {2},Knjiženju za {0}: {1} može se vršiti samo u valuti: {2},
Accounting Ledger,Računovodstvo Ledger,
Accounting journal entries.,Računovodstvene stavke,
Accounts,Konta,
Accounts Manager,Računi Manager,
Accounts Payable,Naplativa konta,
Accounts Payable Summary,Računi se plaćaju Sažetak,
Accounts Receivable,Konto potraživanja,
Accounts Receivable Summary,Potraživanja Pregled,
Accounts User,Računi korisnika,
Accounts table cannot be blank.,Računi stol ne može biti prazan.,
Accumulated Depreciation,Akumuliranu amortizaciju,
Accumulated Depreciation Amount,Ispravka vrijednosti iznos,
Accumulated Depreciation as on,Ispravka vrijednosti kao na,
Accumulated Monthly,akumulirani Mjesečno,
Accumulated Values,akumulirani Vrijednosti,
Accumulated Values in Group Company,Akumulirane vrijednosti u grupnoj kompaniji,
Achieved ({}),Postignuto ({}),
Action,Akcija,
Action Initialised,Akcija inicijalizirana,
Actions,Akcije,
Active,Aktivan,
Activity Cost exists for Employee {0} against Activity Type - {1},Aktivnost troškova postoji za zaposlenog {0} protiv Aktivnost Tip - {1},
Activity Cost per Employee,Aktivnost Trošak po zaposlenom,
Activity Type,Tip aktivnosti,
Actual Cost,Stvarni trošak,
Actual Delivery Date,Stvarni datum isporuke,
Actual Qty,Stvarna kol,
Actual Qty is mandatory,Stvarni Qty je obavezno,
Actual Qty {0} / Waiting Qty {1},Stvarni Količina {0} / Waiting Količina {1},
Actual Qty: Quantity available in the warehouse.,Stvarna kol: količina dostupna na skladištu.,
Actual qty in stock,Stvarne Količina na lageru,
Actual type tax cannot be included in Item rate in row {0},Stvarni tip porez ne može biti uključen u stopu stavka u nizu {0},
Add,Dodaj,
Add / Edit Prices,Dodaj / uredi cijene,
Add Comment,Dodaj komentar,
Add Customers,Dodaj Kupci,
Add Employees,Dodaj zaposlenog,
Add Item,Dodaj stavku,
Add Items,Dodaj Predmeti,
Add Leads,Add Leads,
Add Multiple Tasks,Dodajte više zadataka,
Add Sales Partners,Dodajte partnera za prodaju,
Add Serial No,Dodaj serijski broj,
Add Students,Dodaj Studenti,
Add Suppliers,Dodajte dobavljače,
Add Time Slots,Dodajte vremenske utore,
Add Timesheets,Dodaj Timesheets,
Add Timeslots,Dodaj Timeslots,
Add Users to Marketplace,Dodajte korisnike na Marketplace,
Add a new address,Dodajte novu adresu,
Add cards or custom sections on homepage,Dodajte kartice ili prilagođene odjeljke na početnu stranicu,
Add more items or open full form,Dodaj više stavki ili otvoreni punu formu,
Add notes,Dodajte beleške,
Add the rest of your organization as your users. You can also add invite Customers to your portal by adding them from Contacts,Dodajte ostatak organizacije kao korisnika. Također možete dodati pozvati kupce da vaš portal dodavanjem iz kontakata,
Add/Remove Recipients,Dodaj / ukloni primaoce,
Added,Dodano,
Added {0} users,Dodao je {0} korisnike,
Additional Salary Component Exists.,Postoje dodatne komponente plaće.,
Address,Adresa,
Address Line 2,Adresa - linija 2,
Address Name,Adresa ime,
Address Title,Naziv adrese,
Address Type,Tip adrese,
Administrative Expenses,Administrativni troškovi,
Administrative Officer,Administrativni službenik,
Administrator,Administrator,
Admission,upis,
Admission and Enrollment,Upis i upis,
Admissions for {0},Priznanja za {0},
Admit,Priznati,
Admitted,Prihvaćen,
Advance Amount,Iznos avansa,
Advance Payments,Avansna plaćanja,
Advance account currency should be same as company currency {0},Advance valuta valute mora biti ista kao valuta kompanije {0},
Advance amount cannot be greater than {0} {1},iznos Advance ne može biti veći od {0} {1},
Advertising,Oglašavanje,
Aerospace,Zračno-kosmički prostor,
Against,Protiv,
Against Account,Protiv računa,
Against Journal Entry {0} does not have any unmatched {1} entry,Protiv Journal Entry {0} nema premca {1} unos,
Against Journal Entry {0} is already adjusted against some other voucher,Protiv Journal Entry {0} je već prilagođen protiv nekih drugih vaučer,
Against Supplier Invoice {0} dated {1},Protiv Dobavljač fakture {0} od {1},
Against Voucher,Protiv Voucheru,
Against Voucher Type,Protiv voucher vrsti,
Age,Starost,
Age (Days),Starost (dani),
Ageing Based On,Starenje temelju On,
Ageing Range 1,Starenje Range 1,
Ageing Range 2,Starenje Range 2,
Ageing Range 3,Starenje Range 3,
Agriculture,Poljoprivreda,
Agriculture (beta),Poljoprivreda (beta),
Airline,Aviokompanija,
All Accounts,Svi računi,
All Addresses.,Sve adrese.,
All Assessment Groups,Sve procjene Grupe,
All BOMs,Svi sastavnica,
All Contacts.,Svi kontakti.,
All Customer Groups,Sve grupe kupaca,
All Day,Cijeli dan,
All Departments,Svi odjeli,
All Healthcare Service Units,Sve jedinice zdravstvene službe,
All Item Groups,Sve grupe artikala,
All Products,Svi proizvodi,
All Products or Services.,Svi proizvodi i usluge.,
All Student Admissions,Svi Student Prijemni,
All Supplier Groups,Sve grupe dobavljača,
All Supplier scorecards.,Sve ispostavne kartice.,
All Territories,Sve teritorije,
All Warehouses,Svi Skladišta,
All communications including and above this shall be moved into the new Issue,"Sve komunikacije, uključujući i iznad njih, biće premještene u novo izdanje",
All items have already been transferred for this Work Order.,Svi predmeti su već preneti za ovaj radni nalog.,
All other ITC,Svi ostali ITC,
All the mandatory Task for employee creation hasn't been done yet.,Sva obavezna zadatka za stvaranje zaposlenih još nije izvršena.,
Allocate Payment Amount,Izdvojiti plaćanja Iznos,
Allocated Amount,Izdvojena iznosu,
Allocating leaves...,Raspodjela listova ...,
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ć je postavljeno podrazumevano u profilu pos {0} za korisnika {1}, obično je onemogućeno podrazumevano",
Alternate Item,Alternativna jedinica,
Alternative item must not be same as item code,Alternativni predmet ne sme biti isti kao kod stavke,
Amended From,Izmijenjena Od,
Amount,Iznos,
Amount After Depreciation,Iznos nakon Amortizacija,
Amount of Integrated Tax,Iznos integriranog poreza,
Amount of TDS Deducted,Iznos TDS odbijen,
Amount should not be less than zero.,Iznos ne smije biti manji od nule.,
Amount to Bill,Iznos za naplatu,
Amount {0} {1} against {2} {3},Broj {0} {1} protiv {2} {3},
Amount {0} {1} deducted against {2},Broj {0} {1} oduzeti protiv {2},
Amount {0} {1} transferred from {2} to {3},Broj {0} {1} je prešao iz {2} u {3},
Amount {0} {1} {2} {3},Broj {0} {1} {2} {3},
Amt,Amt,
"An Item Group exists with same name, please change the item name or rename the item group","Stavka Grupa postoji s istim imenom , molimo promijenite ime stavku ili preimenovati stavku grupe",
An academic term with this 'Academic Year' {0} and 'Term Name' {1} already exists. Please modify these entries and try again.,Akademski pojam sa ovim &quot;akademska godina&quot; {0} i &#39;Term Ime&#39; {1} već postoji. Molimo vas da mijenjati ove stavke i pokušati 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} ) , molimo promijenite ime stavku grupe ili preimenovati stavku",
Analyst,Analitičar,
Annual Billing: {0},Godišnji Billing: {0},
Another Budget record '{0}' already exists against {1} '{2}' and account '{3}' for fiscal year {4},Još jedan rekord budžeta &#39;{0}&#39; već postoji {1} &#39;{2}&#39; i račun &#39;{3}&#39; za fiskalnu godinu {4},
Another Period Closing Entry {0} has been made after {1},Drugi period Zatvaranje Stupanje {0} je postignut nakon {1},
Another Sales Person {0} exists with the same Employee id,Još jedna osoba Sales {0} postoji s istim ID zaposlenih,
Antibiotic,Antibiotik,
Apparel & Accessories,Odjeća i modni dodaci,
Applicable For,primjenjivo za,
"Applicable if the company is SpA, SApA or SRL","Primjenjivo ako je tvrtka SpA, SApA ili SRL",
Applicable if the company is a limited liability company,Primjenjivo ako je društvo s ograničenom odgovornošću,
Applicable if the company is an Individual or a Proprietorship,Primjenjivo ako je kompanija fizička osoba ili vlasništvo,
Application of Funds (Assets),Primjena sredstava ( aktiva ),
Applied,Applied,
Appointment Confirmation,Potvrda o imenovanju,
Appointment Duration (mins),Trajanje imenovanja (min),
Appointment Type,Tip imenovanja,
Appointment {0} and Sales Invoice {1} cancelled,Imenovanje {0} i faktura za prodaju {1} otkazana,
Appointments and Encounters,Imenovanja i susreti,
Appointments and Patient Encounters,Imenovanja i susreti sa pacijentom,
Appraisal {0} created for Employee {1} in the given date range,Procjena {0} stvorena za zaposlenika {1} u određenom razdoblju,
Approving Role cannot be same as role the rule is Applicable To,Odobravanje ulogu ne mogu biti isti kao i ulogepravilo odnosi se na,
Approving User cannot be same as user the rule is Applicable To,Korisnik koji odobrava ne može biti isti kao i korisnik na kojeg se odnosi pravilo.,
"Apps using current key won't be able to access, are you sure?","Aplikacije koje koriste trenutni ključ neće moći da pristupe, da li ste sigurni?",
Are you sure you want to cancel this appointment?,Da li ste sigurni da želite da otkažete ovaj termin?,
Arrear,zaostatak,
As Examiner,Kao ispitivač,
As On Date,Kao i na datum,
As Supervisor,Kao supervizor,
As per rules 42 & 43 of CGST Rules,Prema pravilima 42 i 43 CGST pravila,
As per section 17(5),Prema odjeljku 17 (5),
Assessment,Procjena,
Assessment Criteria,Kriteriji procjene,
Assessment Group,procjena Group,
Assessment Group: ,Procena grupa:,
Assessment Plan,Plan procjene,
Assessment Plan Name,Naziv plana procene,
Assessment Report,Izveštaj o proceni,
Assessment Reports,Izveštaji o proceni,
Assessment Result,procjena rezultata,
Assessment Result record {0} already exists.,Evidencija Rezultat zapisa {0} već postoji.,
Asset,Asset,
Asset Category,Asset Kategorija,
Asset Category is mandatory for Fixed Asset item,Asset Kategorija je obavezno za Fixed stavku imovine,
Asset Maintenance,Održavanje imovine,
Asset Movement,Asset pokret,
Asset Movement record {0} created,rekord Asset pokret {0} stvorio,
Asset Name,Asset ime,
Asset Received But Not Billed,Imovina je primljena ali nije fakturisana,
Asset Value Adjustment,Podešavanje vrednosti imovine,
"Asset cannot be cancelled, as it is already {0}","Imovine ne može biti otkazan, jer je već {0}",
Asset scrapped via Journal Entry {0},Asset odbačen preko Journal Entry {0},
"Asset {0} cannot be scrapped, as it is already {1}","Asset {0} ne može biti ukinuta, jer je već {1}",
Asset {0} does not belong to company {1},Asset {0} ne pripada kompaniji {1},
Asset {0} must be submitted,Asset {0} mora biti dostavljena,
Assets,Imovina,
Assign To,Dodijeliti,
Associate,Pomoćnik,
At least one mode of payment is required for POS invoice.,Najmanje jedan način plaćanja je potreban za POS računa.,
Atleast one item should be entered with negative quantity in return document,Atleast jednu stavku treba upisati s negativnim količine za uzvrat dokumentu,
Atleast one of the Selling or Buying must be selected,Barem jedan od prodajete ili kupujete mora biti odabran,
Atleast one warehouse is mandatory,Atleast jednom skladištu je obavezno,
Attach Logo,Priložiti logo,
Attachment,Vezanost,
Attachments,Prilozi,
Attendance can not be marked for future dates,Gledatelji ne može biti označena za budući datum,
Attendance date can not be less than employee's joining date,Datum prisustvo ne može biti manji od datuma pristupanja zaposlenog,
Attendance for employee {0} is already marked,Gledatelja za zaposlenika {0} već označen,
Attendance has been marked successfully.,Posjećenost je uspješno označen.,
Attendance not submitted for {0} as {1} on leave.,Prisustvo nije dostavljeno {0} kao {1} na odsustvu.,
Attribute table is mandatory,Atribut sto je obavezno,
Attribute {0} selected multiple times in Attributes Table,Atribut {0} odabrani više puta u atributi tabeli,
Authorized Signatory,Ovlašteni potpisnik,
Auto Material Requests Generated,Auto materijala Zahtjevi Generirano,
Auto Repeat,Auto Repeat,
Auto repeat document updated,Automatsko ponavljanje dokumenta je ažurirano,
Automotive,Automobilska industrija,
Available,Dostupno,
Available Qty,Dostupno Količina,
Available Selling,Dostupna prodaja,
Available for use date is required,Potreban je datum upotrebe,
Available slots,Raspoložive slotove,
Available {0},Dostupno {0},
Available-for-use Date should be after purchase date,Datum dostupan za korištenje treba da bude nakon datuma kupovine,
Average Age,Prosječna starost,
Average Rate,Prosečna stopa,
Avg Daily Outgoing,Avg Daily Odlazni,
Avg. Buying Price List Rate,Avg. Kupovni cjenovnik,
Avg. Selling Price List Rate,Avg. Prodajna cijena cena,
Avg. Selling Rate,Prosj. Prodaja Rate,
BOM,BOM,
BOM Browser,BOM Browser,
BOM No,BOM br.,
BOM Rate,BOM Rate,
BOM Stock Report,BOM Stock Report,
BOM and Manufacturing Quantity are required,BOM i proizvodnja Količina su potrebne,
BOM does not contain any stock item,BOM ne sadrži nikakve zaliha stavka,
BOM {0} does not belong to Item {1},BOM {0} ne pripada Stavka {1},
BOM {0} must be active,BOM {0} mora biti aktivna,
BOM {0} must be submitted,BOM {0} mora biti dostavljena,
Balance,Ravnoteža,
Balance (Dr - Cr),Balans (Dr - Cr),
Balance ({0}),Balans ({0}),
Balance Qty,Bilans kol,
Balance Sheet,Završni račun,
Balance Value,Vrijednost bilance,
Balance for Account {0} must always be {1},Bilans konta {0} uvijek mora biti {1},
Bank,Banka,
Bank Account,Žiro račun,
Bank Accounts,Bankovni računi,
Bank Draft,Bank Nacrt,
Bank Name,Naziv banke,
Bank Overdraft Account,Bank Prekoračenje računa,
Bank Reconciliation,Banka pomirenje,
Bank Reconciliation Statement,Izjava banka pomirenja,
Bank Statement,Izjava banke,
Bank Statement Settings,Postavke banke,
Bank Statement balance as per General Ledger,Banka bilans po glavnoj knjizi,
Bank account cannot be named as {0},Žiro račun ne može biti imenovan kao {0},
Bank/Cash transactions against party or for internal transfer,transakcije protiv stranke ili za internu Transakcija / Cash,
Banking,Bankarstvo,
Banking and Payments,Bankarstvo i platni promet,
Barcode {0} already used in Item {1},Barkod {0} se već koristi u artiklu {1},
Barcode {0} is not a valid {1} code,Bar kod {0} nije važeći {1} kod,
Base URL,Baza URL,
Based On,Na osnovu,
Based On Payment Terms,Na osnovu uslova plaćanja,
Batch,Serija,
Batch Entries,Ulazne serije,
Batch ID is mandatory,Batch ID je obavezno,
Batch Inventory,Batch zaliha,
Batch Name,Batch ime,
Batch No,Broj serije,
Batch number is mandatory for Item {0},Batch broj je obavezno za Stavka {0},
Batch {0} of Item {1} has expired.,Batch {0} od {1} Stavka je istekla.,
Batch {0} of Item {1} is disabled.,Batch {0} elementa {1} je onemogućen.,
Batch: ,Serija:,
Batches,serija,
Become a Seller,Postanite prodavac,
Bill,račun,
Bill Date,Datum računa,
Bill No,Račun br,
Bill of Materials,Bill of Materials,
Bill of Materials (BOM),Sastavnice (BOM),
Billable Hours,Sati naplate,
Billed,Naplaćeno,
Billed Amount,Naplaćeni iznos,
Billing Address,Adresa za naplatu,
Billing Address is same as Shipping Address,Adresa za naplatu jednaka je adresi za dostavu,
Billing Amount,Billing Iznos,
Billing Status,Status naplate,
Billing currency must be equal to either default company's currency or party account currency,Valuta za obračun mora biti jednaka valuti valute kompanije ili valute partijskog računa,
Bills raised by Suppliers.,Mjenice podigao dobavljače.,
Bills raised to Customers.,Mjenice podignuta na kupce.,
Biotechnology,Biotehnologija,
Black,Crn,
Blanket Orders from Costumers.,Narudžbe kupaca od kupaca.,
Block Invoice,Blok faktura,
Boms,Boms,
Both Trial Period Start Date and Trial Period End Date must be set,Moraju se podesiti datum početka probnog perioda i datum završetka probnog perioda,
Both Warehouse must belong to same Company,Oba skladišta moraju pripadati istom preduzeću,
Branch,Ogranak,
Broadcasting,radiodifuzija,
Brokerage,posredništvo,
Browse BOM,Browse BOM,
Budget Against,budžet protiv,
Budget List,Budžetska lista,
Budget Variance Report,Proračun varijance Prijavi,
Budget cannot be assigned against Group Account {0},Budžet se ne može dodijeliti protiv grupe 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 prihod ili rashod račun",
Buildings,Zgrade,
Bundle items at time of sale.,Bala stavke na vrijeme prodaje.,
Business Development Manager,Business Development Manager,
Buy,kupiti,
Buying,Nabavka,
Buying Amount,Iznos nabavke,
Buying Price List,Kupovni cjenovnik,
Buying Rate,Procenat kupovine,
"Buying must be checked, if Applicable For is selected as {0}","Kupnja treba provjeriti, ako je primjenjivo za odabrano kao {0}",
By {0},Do {0},
Bypass credit check at Sales Order ,Provjerite kreditnu obavezu na nalogu za prodaju,
C-Form records,C - Form zapisi,
C-form is not applicable for Invoice: {0},C-forma nije primjenjiv za fakture: {0},
CEO,CEO,
CESS Amount,CESS iznos,
CGST Amount,CGST Iznos,
CRM,CRM,
CWIP Account,CWIP nalog,
Calculated Bank Statement balance,Izračunato Banka bilans,
Campaign,Kampanja,
Can be approved by {0},Može biti odobren od strane {0},
"Can not filter based on Account, if grouped by Account","Ne možete filtrirati na temelju računa , ako grupirani po računu",
"Can not filter based on Voucher No, if grouped by Voucher","Ne možete filtrirati na temelju vaučer No , ako grupirani po vaučer",
"Can not mark Inpatient Record Discharged, there are Unbilled Invoices {0}","Ne mogu označiti zapis hroničnih bolesti ispuštenih, postoje neobračunane fakture {0}",
Can only make payment against unbilled {0},Mogu samo napraviti uplatu protiv nenaplaćenu {0},
Can refer row only if the charge type is 'On Previous Row Amount' or 'Previous Row Total',"Može se odnositi red samo akotip zadužen je "" Na prethodni red Iznos 'ili' prethodnog retka Total '",
"Can't change valuation method, as there are transactions against some items which does not have it's own valuation method","Ne možete promijeniti način vrednovanja, jer postoje transakcije protiv nekih stvari koje nemaju svoj vlastiti način vrednovanja",
Can't create standard criteria. Please rename the criteria,Ne mogu napraviti standardne kriterijume. Molim preimenovati kriterijume,
Cancel,Otkaži,
Cancel Material Visit {0} before cancelling this Warranty Claim,Odustani Materijal {0} Posjeti prije otkazivanja ova garancija potraživanje,
Cancel Material Visits {0} before cancelling this Maintenance Visit,Odustani Posjeta materijala {0} prije otkazivanja ovog održavanja pohod,
Cancel Subscription,Otkaži pretplatu,
Cancel the journal entry {0} first,Prvo otpustite unos teksta {0},
Canceled,Otkazano,
"Cannot Submit, Employees left to mark attendance","Ne mogu da pošaljem, Zaposleni su ostavljeni da obilježavaju prisustvo",
Cannot be a fixed asset item as Stock Ledger is created.,Ne može biti osnovna stavka sredstva kao što je stvorena knjiga zaliha.,
Cannot cancel because submitted Stock Entry {0} exists,"Ne mogu otkazati , jer podnijela Stock Stupanje {0} postoji",
Cannot cancel transaction for Completed Work Order.,Ne mogu otkazati transakciju za Završeni radni nalog.,
Cannot cancel {0} {1} because Serial No {2} does not belong to the warehouse {3},Ne mogu da otkažem {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,Ne mogu promijeniti atribute nakon transakcije sa akcijama. Napravite novu stavku i prenesite zalihu na novu stavku,
Cannot change Fiscal Year Start Date and Fiscal Year End Date once the Fiscal Year is saved.,Ne možete promijeniti fiskalnu godinu datum početka i datum završetka fiskalne godine kada Fiskalna godina se sprema.,
Cannot change Service Stop Date for item in row {0},Nije moguće promeniti datum zaustavljanja usluge za stavku u redu {0},
Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,Ne mogu promijeniti svojstva varijante nakon transakcije sa akcijama. Za to ćete morati napraviti novu stavku.,
"Cannot change company's default currency, because there are existing transactions. Transactions must be cancelled to change the default currency.","Ne mogu promijeniti tvrtke zadanu valutu , jer postoje neki poslovi . Transakcije mora biti otkazana promijeniti zadanu valutu .",
Cannot change status as student {0} is linked with student application {1},Ne može promijeniti status studenta {0} je povezana s primjenom student {1},
Cannot convert Cost Center to ledger as it has child nodes,"Ne može se pretvoriti troška za knjigu , kao da ima djece čvorova",
Cannot covert to Group because Account Type is selected.,"Ne mogu da konvertovanje Group, jer je izabran Account Type.",
Cannot create Retention Bonus for left Employees,Ne mogu napraviti bonus zadržavanja za ljevičke zaposlene,
Cannot create a Delivery Trip from Draft documents.,Iz Nacrta dokumenata nije moguće kreirati dostavno putovanje.,
Cannot deactivate or cancel BOM as it is linked with other BOMs,Ne može se isključiti ili otkaže BOM kao što je povezano s drugim Boms,
"Cannot declare as lost, because Quotation has been made.","Ne može proglasiti izgubili , jer citat je napravio .",
Cannot deduct when category is for 'Valuation' or 'Valuation and Total',"Ne mogu odbiti kada kategorija je "" vrednovanje "" ili "" Vrednovanje i Total '",
Cannot deduct when category is for 'Valuation' or 'Vaulation and Total',Ne mogu odbiti kada kategorija je za &#39;Vrednovanje&#39; ili &#39;Vaulation i Total&#39;,
"Cannot delete Serial No {0}, as it is used in stock transactions","Ne možete izbrisati serijski broj {0}, koji se koristi u prodaji transakcije",
Cannot enroll more than {0} students for this student group.,Ne može upisati više od {0} studenata za ovu grupa studenata.,
Cannot produce more Item {0} than Sales Order quantity {1},Ne može proizvesti više predmeta {0} od prodajnog naloga količina {1},
Cannot promote Employee with status Left,Ne može promovirati zaposlenika sa statusom levo,
Cannot refer row number greater than or equal to current row number for this Charge type,Ne mogu se odnositi broj retka veći ili jednak trenutnom broju red za ovu vrstu Charge,
Cannot select charge type as 'On Previous Row Amount' or 'On Previous Row Total' for first row,"Ne možete odabrati vrstu naboja kao ' na prethodnim Row Iznos ""ili"" u odnosu na prethodnu Row Ukupno ""za prvi red",
Cannot set as Lost as Sales Order is made.,Ne mogu se postaviti kao izgubljen kao prodajnog naloga je napravio .,
Cannot set authorization on basis of Discount for {0},Ne mogu postaviti odobrenje na temelju popusta za {0},
Cannot set multiple Item Defaults for a company.,Ne može se podesiti više postavki postavki za preduzeće.,
Cannot set quantity less than delivered quantity,Ne može se postaviti količina manja od isporučene količine,
Cannot set quantity less than received quantity,Ne može se postaviti količina manja od primljene količine,
Cannot set the field <b>{0}</b> for copying in variants,Ne može se postaviti polje <b>{0}</b> za kopiranje u varijantama,
Cannot transfer Employee with status Left,Ne može preneti zaposlenog sa statusom Levo,
Cannot {0} {1} {2} without any negative outstanding invoice,Ne mogu {0} {1} {2} bez ikakvih negativnih izuzetan fakture,
Capital Equipments,Kapitalni oprema,
Capital Stock,Kapitala,
Capital Work in Progress,Kapitalni rad je u toku,
Cart,Kolica,
Cart is Empty,Košarica je prazna,
Case No(s) already in use. Try from Case No {0},Slučaj Ne ( i) je već u uporabi . Pokušajte s predmetu broj {0},
Cash,Gotovina,
Cash Flow Statement,Izvještaj o novčanim tokovima,
Cash Flow from Financing,Novčani tok iz Financiranje,
Cash Flow from Investing,Novčani tok iz ulagačkih,
Cash Flow from Operations,Novčani tok iz poslovanja,
Cash In Hand,Novac u blagajni,
Cash or Bank Account is mandatory for making payment entry,Novac ili bankovni račun je obvezna za izradu ulazak plaćanje,
Cashier Closing,Zatvaranje blagajnika,
Category,Kategorija,
Category Name,Naziv kategorije,
Caution,Oprez,
Central Tax,Centralni porez,
Certification,Certifikat,
Cess,Cess,
Change Amount,Promjena Iznos,
Change Item Code,Promenite stavku,
Change Release Date,Promeni datum izdanja,
Change Template Code,Promijenite šablon kod,
Changing Customer Group for the selected Customer is not allowed.,Promena klijentske grupe za izabranog klijenta nije dozvoljena.,
Chapter,Poglavlje,
Chapter information.,Informacije o poglavlju.,
Charge of type 'Actual' in row {0} cannot be included in Item Rate,Punjenje tipa ' Stvarni ' u redu {0} ne mogu biti uključeni u točki Rate,
Chargeble,Chargeble,
Charges are updated in Purchase Receipt against each item,Naknade se ažuriraju u Kupovina Prijem protiv svaku stavku,
"Charges will be distributed proportionately based on item qty or amount, as per your selection","Naknade će se distribuirati proporcionalno na osnovu stavka količina ili iznos, po svom izboru",
Chart of Cost Centers,Grafikon troškovnih centara,
Check all,Provjerite sve,
Checkout,Provjeri,
Chemical,Hemijski,
Cheque,Ček,
Cheque/Reference No,Ček / Reference Ne,
Cheques Required,Potrebni provjeri,
Cheques and Deposits incorrectly cleared,Čekovi i depoziti pogrešno spašava,
Child Task exists for this Task. You can not delete this Task.,Zadatak za djecu postoji za ovaj zadatak. Ne možete da izbrišete ovaj zadatak.,
Child nodes can be only created under 'Group' type nodes,Dijete čvorovi se mogu kreirati samo pod &#39;Grupa&#39; tipa čvorova,
Child warehouse exists for this warehouse. You can not delete this warehouse.,skladište dijete postoji za to skladište. Ne možete brisati ovo skladište.,
Circular Reference Error,Kružna Reference Error,
City,Grad,
City/Town,Grad / Mjesto,
Clay,Clay,
Clear filters,Očistite filtere,
Clear values,Jasne vrijednosti,
Clearance Date,Razmak Datum,
Clearance Date not mentioned,Razmak Datum nije spomenuo,
Clearance Date updated,Razmak Datum ažurira,
Client,Klijent,
Client ID,ID klijenta,
Client Secret,klijent Secret,
Clinical Procedure,Klinička procedura,
Clinical Procedure Template,Obrazac kliničkog postupka,
Close Balance Sheet and book Profit or Loss.,Zatvori bilanca i knjiga dobit ili gubitak .,
Close Loan,Zatvori zajam,
Close the POS,Zatvorite POS,
Closed,Zatvoreno,
Closed order cannot be cancelled. Unclose to cancel.,Zatvorena kako se ne može otkazati. Otvarati da otkaže.,
Closing (Cr),Zatvaranje (Cr),
Closing (Dr),Zatvaranje (Dr),
Closing (Opening + Total),Zatvaranje (otvaranje + ukupno),
Closing Account {0} must be of type Liability / Equity,Zatvaranje računa {0} mora biti tipa odgovornosti / Equity,
Closing Balance,Zatvaranje ravnoteže,
Code,Šifra,
Collapse All,Skupi sve,
Color,Boja,
Colour,Boja,
Combined invoice portion must equal 100%,Kombinovani deo računa mora biti 100%,
Commercial,trgovački,
Commission,Provizija,
Commission Rate %,Procenat Komisije%,
Commission on Sales,Komisija za prodaju,
Commission rate cannot be greater than 100,Proviziju ne može biti veća od 100,
Community Forum,Community Forum,
Company (not Customer or Supplier) master.,Društvo ( ne kupaca i dobavljača ) majstor .,
Company Abbreviation,Skraćeni naziv preduzeća,
Company Abbreviation cannot have more than 5 characters,Skraćenica kompanije ne može imati više od 5 znakova,
Company Name,Naziv preduzeća,
Company Name cannot be Company,Kompanija Ime ne može biti poduzeća,
Company currencies of both the companies should match for Inter Company Transactions.,Kompanijske valute obe kompanije treba da se podudaraju za transakcije Inter preduzeća.,
Company is manadatory for company account,Kompanija je umanjena za račun kompanije,
Company name not same,Ime kompanije nije isto,
Company {0} does not exist,Kompanija {0} ne postoji,
Compensatory leave request days not in valid holidays,Dane zahtjeva za kompenzacijski odmor ne važe u valjanim praznicima,
Complaint,Žalba,
Completion Date,Završetak Datum,
Computer,Računar,
Condition,Stanje,
Configure,Konfigurišite,
Configure {0},Konfigurišite {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 sa knjigama,
Connected to QuickBooks,Povezan sa QuickBooks-om,
Connecting to QuickBooks,Povezivanje na QuickBooks,
Consultation,Konsultacije,
Consultations,Konsultacije,
Consulting,savjetodavni,
Consumable,Potrošni,
Consumed,Consumed,
Consumed Amount,Consumed Iznos,
Consumed Qty,Potrošeno Kol,
Consumer Products,Consumer Products,
Contact,Kontakt,
Contact Us,Kontaktiraj nas,
Content,Sadržaj,
Content Masters,Sadržaj majstora,
Content Type,Vrsta sadržaja,
Continue Configuration,Nastavite konfiguraciju,
Contract,Ugovor,
Contract End Date must be greater than Date of Joining,Ugovor Datum završetka mora biti veći od dana ulaska u,
Contribution %,Doprinos%,
Contribution Amount,Doprinos Iznos,
Conversion factor for default Unit of Measure must be 1 in row {0},Faktor pretvorbe za zadani jedinica mjere mora biti jedan u nizu {0},
Conversion rate cannot be 0 or 1,Stopa pretvorbe ne može biti 0 ili 1,
Convert to Group,Pretvori u Grupi,
Convert to Non-Group,Pretvoriti u non-Group,
Cosmetics,Kozmetika,
Cost Center,Troška,
Cost Center Number,Broj troškovnog centra,
Cost Center and Budgeting,Troškovno središte i budžetiranje,
Cost Center is required in row {0} in Taxes table for type {1},Troška potrebno je u redu {0} poreza stolom za vrstu {1},
Cost Center with existing transactions can not be converted to group,Troška s postojećim transakcija ne može se prevesti u skupini,
Cost Center with existing transactions can not be converted to ledger,Troška s postojećim transakcija ne može pretvoriti u knjizi,
Cost Centers,Troška,
Cost Updated,Troškova Ažurirano,
Cost as on,Koštaju kao na,
Cost of Delivered Items,Troškovi isporučenih Predmeti,
Cost of Goods Sold,Troškovi prodane robe,
Cost of Issued Items,Troškovi Izdata Predmeti,
Cost of New Purchase,Troškovi New Kupovina,
Cost of Purchased Items,Troškovi Kupljene stavke,
Cost of Scrapped Asset,Troškovi Rashodovan imovine,
Cost of Sold Asset,Troškovi prodate imovine,
Cost of various activities,Troškova različitih aktivnosti,
"Could not create Credit Note automatically, please uncheck 'Issue Credit Note' and submit again","Ne mogu automatski da kreiram kreditnu poruku, molim da uklonite oznaku &#39;Izdavanje kreditne note&#39; i pošaljite ponovo",
Could not generate Secret,Nije moguće generirati tajnu,
Could not retrieve information for {0}.,Ne mogu se preuzeti podaci za {0}.,
Could not solve criteria score function for {0}. Make sure the formula is valid.,Nije moguće riješiti funkciju rezultata 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 ponderisane ocjene. Proverite da li je formula validna.,
Could not submit some Salary Slips,Ne mogu da podnesem neke plate,
"Could not update stock, invoice contains drop shipping item.","Nije mogao ažurirati zaliha, faktura sadrži drop shipping stavke.",
Country wise default Address Templates,Država mudar zadana adresa predlošci,
Course Code: ,Šifra predmeta:,
Course Enrollment {0} does not exists,Upis na tečaj {0} ne postoji,
Course Schedule,Raspored za golf,
Course: ,Kurs:,
Cr,Cr,
Create,Stvoriti,
Create BOM,Kreirajte BOM,
Create Delivery Trip,Kreirajte putovanje isporukom,
Create Employee,Kreirajte zaposlenog,
Create Employee Records,Kreiranje zaposlenih Records,
"Create Employee records to manage leaves, expense claims and payroll","Kreiranje evidencije zaposlenih za upravljanje lišće, trošak potraživanja i platnom spisku",
Create Fee Schedule,Kreirajte raspored naknada,
Create Fees,Kreiraj naknade,
Create Inter Company Journal Entry,Kreirajte unos časopisa Inter Company,
Create Invoice,Kreirajte račun,
Create Invoices,Stvorite fakture,
Create Job Card,Kreirajte Job Card,
Create Journal Entry,Kreirajte unos u časopis,
Create Lead,Stvorite olovo,
Create Leads,Napravi Leads,
Create Maintenance Visit,Kreirajte posetu za održavanje,
Create Material Request,Kreirajte materijalni zahtjev,
Create Multiple,Kreiraj više,
Create Opening Sales and Purchase Invoices,Stvorite početne fakture za prodaju i kupovinu,
Create Payment Entries,Kreirajte uplate za plaćanje,
Create Payment Entry,Kreirajte unos plaćanja,
Create Print Format,Napravi Print Format,
Create Purchase Order,Kreirajte narudžbinu,
Create Purchase Orders,Napravi Narudžbenice,
Create Quotation,stvaranje citata,
Create Sales Invoice,Kreirajte račun za prodaju,
Create Sales Order,Kreirajte porudžbinu,
Create Sales Orders to help you plan your work and deliver on-time,Stvorite prodajne naloge za lakše planiranje posla i isporuku na vreme,
Create Sample Retention Stock Entry,Napravite unos zaliha uzoraka,
Create Student,Kreirajte Student,
Create Student Batch,Napravite studentsku grupu,
Create Student Groups,Napravi studentske grupe,
Create Supplier Quotation,Kreirajte ponudu dobavljača,
Create Tax Template,Kreirajte predložak poreza,
Create Timesheet,Napravite Timesheet,
Create User,Kreiranje korisnika,
Create Users,kreiranje korisnika,
Create Variant,Kreiraj varijantu,
Create Variants,Kreirajte Varijante,
"Create and manage daily, weekly and monthly email digests.","Stvaranje i upravljanje dnevne , tjedne i mjesečne e razgradnju .",
Create customer quotes,Napravi citati kupac,
Create rules to restrict transactions based on values.,Stvaranje pravila za ograničavanje prometa na temelju vrijednosti .,
Created {0} scorecards for {1} between: ,Napravljene {0} pokazivačke karte za {1} između:,
Creating Company and Importing Chart of Accounts,Stvaranje preduzeća i uvoz računa,
Creating Fees,Kreiranje naknada,
Creating student groups,Stvaranje grupa studenata,
Creating {0} Invoice,Kreiranje {0} fakture,
Credit,Kredit,
Credit ({0}),Kredit ({0}),
Credit Account,Kreditni račun,
Credit Balance,Credit Balance,
Credit Card,Kreditna kartica,
Credit Days cannot be a negative number,Kreditni dani ne mogu biti negativni broj,
Credit Limit,Kreditni limit,
Credit Note,Kreditne Napomena,
Credit Note Amount,Kredit Napomena Iznos,
Credit Note Issued,Kreditne Napomena Zadani,
Credit Note {0} has been created automatically,Kreditna beleška {0} je kreirana automatski,
Credit limit has been crossed for customer {0} ({1}/{2}),Kreditni limit je prešao za kupca {0} ({1} / {2}),
Creditors,Kreditori,
Criteria weights must add up to 100%,Tegovi kriterijuma moraju dodati do 100%,
Crop Cycle,Crop Cycle,
Crops & Lands,Crop &amp; Lands,
Currency Exchange must be applicable for Buying or for Selling.,Menjanje mjenjača mora biti primjenjivo za kupovinu ili prodaju.,
Currency can not be changed after making entries using some other currency,Valuta ne mogu se mijenjati nakon što unose preko neke druge valute,
Currency exchange rate master.,Majstor valute .,
Currency for {0} must be {1},Valuta za {0} mora biti {1},
Currency is required for Price List {0},Valuta je potreban za Cjenovnik {0},
Currency of the Closing Account must be {0},Valuta zatvaranja računa mora biti {0},
Currency of the price list {0} must be {1} or {2},Valuta cenovnika {0} mora biti {1} ili {2},
Currency should be same as Price List Currency: {0},Valuta mora biti ista kao cenovnik Valuta: {0},
Current Assets,Dugotrajna imovina,
Current BOM and New BOM can not be same,Trenutni troškovnik i novi troškovnik ne mogu biti isti,
Current Liabilities,Kratkoročne obveze,
Current Qty,Trenutno Količina,
Current invoice {0} is missing,Nedostaje trenutna faktura {0},
Custom HTML,Custom HTML,
Custom?,Prilagođena?,
Customer,Kupci,
Customer Addresses And Contacts,Adrese i kontakti kupaca,
Customer Contact,Kontakt kupca,
Customer Database.,Šifarnik kupaca,
Customer Group,Vrsta djelatnosti Kupaca,
Customer LPO,Korisnički LPO,
Customer LPO No.,Korisnički LPO br.,
Customer Name,Naziv kupca,
Customer POS Id,Kupac POS Id,
Customer Service,Služba za korisnike,
Customer and Supplier,Kupaca i dobavljača,
Customer is required,Kupac je obavezan,
Customer isn't enrolled in any Loyalty Program,Korisnik nije upisan u bilo koji program lojalnosti,
Customer required for 'Customerwise Discount',Kupac je potrebno za ' Customerwise Popust ',
Customer {0} does not belong to project {1},Kupac {0} ne pripada projektu {1},
Customer {0} is created.,Klijent {0} je kreiran.,
Customers in Queue,Kupci u Queue,
Customize Homepage Sections,Prilagodite odjeljke početne stranice,
Customizing Forms,Prilagođavanje Obrasci,
Daily Project Summary for {0},Dnevni rezime projekta za {0},
Daily Reminders,Dnevni podsjetnik,
Data Import and Export,Podataka uvoz i izvoz,
Data Import and Settings,Uvoz podataka i postavke,
Database of potential customers.,Baza potencijalnih kupaca.,
Date Format,Format datuma,
Date Of Retirement must be greater than Date of Joining,Datum umirovljenja mora biti veći od datuma pristupa,
Date of Birth,Datum rođenja,
Date of Birth cannot be greater than today.,Datum rođenja ne može biti veći nego što je danas.,
Date of Commencement should be greater than Date of Incorporation,Datum početka trebalo bi da bude veći od Datum osnivanja,
Date of Joining,Datum pristupa,
Date of Joining must be greater than Date of Birth,Datum pristupa mora biti veći od datuma rođenja,
Date of Transaction,Datum transakcije,
Day,dan,
Debit,Zaduženje,
Debit ({0}),Debit ({0}),
Debit Account,Zaduži račun,
Debit Note,Rashodi - napomena,
Debit Note Amount,Debitne Napomena Iznos,
Debit Note Issued,Debit Napomena Zadani,
Debit To is required,To je potrebno Debit,
Debit and Credit not equal for {0} #{1}. Difference is {2}.,Debitne i kreditne nije jednaka za {0} {1} #. Razlika je u tome {2}.,
Debtors,Dužnici,
Debtors ({0}),Dužnici ({0}),
Declare Lost,Proglasite izgubljenim,
Default Activity Cost exists for Activity Type - {0},Uobičajeno aktivnosti Troškovi postoji aktivnost Tip - {0},
Default BOM ({0}) must be active for this item or its template,Uobičajeno BOM ({0}) mora biti aktivna za ovu stavku ili njegove predložak,
Default BOM for {0} not found,Uobičajeno sastavnice za {0} nije pronađen,
Default BOM not found for Item {0} and Project {1},Uobičajeno sastavnice nije pronađen za Stavka {0} i projekt {1},
Default Letter Head,Uobičajeno Letter Head,
Default Tax Template,Podrazumevani obrazac poreza,
Default Unit of Measure for Item {0} cannot be changed directly because you have already made some transaction(s) with another UOM. You will need to create a new Item to use a different Default UOM.,"Uobičajeno mjerna jedinica za artikl {0} ne može se mijenjati izravno, jer ste već napravili neke transakcije (e) sa drugim UOM. Morat ćete stvoriti nove stavke koristiti drugačiji Uobičajeno UOM.",
Default Unit of Measure for Variant '{0}' must be same as in Template '{1}',Uobičajeno mjerna jedinica za varijantu &#39;{0}&#39; mora biti isti kao u obrascu &#39;{1}&#39;,
Default settings for buying transactions.,Zadane postavke za transakciju kupnje.,
Default settings for selling transactions.,Zadane postavke za transakciju prodaje.,
Default tax templates for sales and purchase are created.,Osnovani porezni predlošci za prodaju i kupovinu su stvoreni.,
Defaults,Zadani,
Defense,Obrana,
Define Project type.,Definišite tip projekta.,
Define budget for a financial year.,Definirajte budžet za finansijsku godinu.,
Define various loan types,Definirati različite vrste kredita,
Del,Del,
Delay in payment (Days),Kašnjenje u plaćanju (Dani),
Delete all the Transactions for this Company,Izbrisati sve transakcije za ovu kompaniju,
Deletion is not permitted for country {0},Brisanje nije dozvoljeno za zemlju {0},
Delivered,Isporučeno,
Delivered Amount,Isporučena Iznos,
Delivered Qty,Isporučena količina,
Delivered: {0},Isporučuje se: {0},
Delivery,Isporuka,
Delivery Date,Datum isporuke,
Delivery Note,Otpremnica,
Delivery Note {0} is not submitted,Otpremnica {0} nije potvrđena,
Delivery Note {0} must not be submitted,Otpremnica {0} ne smije biti potvrđena,
Delivery Notes {0} must be cancelled before cancelling this Sales Order,Otpremnica {0} mora biti otkazana prije poništenja ove narudžbenice,
Delivery Notes {0} updated,Beleške o isporuci {0} ažurirane,
Delivery Status,Status isporuke,
Delivery Trip,Dostava putovanja,
Delivery warehouse required for stock item {0},Isporuka skladište potrebno za zaliha stavku {0},
Department,Odjel,
Department Stores,Robne kuće,
Depreciation,Amortizacija,
Depreciation Amount,Amortizacija Iznos,
Depreciation Amount during the period,Amortizacija Iznos u periodu,
Depreciation Date,Amortizacija Datum,
Depreciation Eliminated due to disposal of assets,Amortizacija Eliminisan zbog raspolaganje imovinom,
Depreciation Entry,Amortizacija Entry,
Depreciation Method,Način Amortizacija,
Depreciation Row {0}: Depreciation Start Date is entered as past date,Redosled amortizacije {0}: Početni datum amortizacije upisuje se kao prošli datum,
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,Redosled amortizacije {0}: Sledeći datum amortizacije ne može biti pre datuma raspoloživog za upotrebu,
Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,Redosled amortizacije {0}: Sledeći datum amortizacije ne može biti pre datuma kupovine,
Designer,Imenovatelj,
Detailed Reason,Detaljan razlog,
Details,Detalji,
Details of Outward Supplies and inward supplies liable to reverse charge,Pojedinosti o vanjskoj snabdijevanju i unutarnjim zalihama koje mogu podložiti povratnom naplatu,
Details of the operations carried out.,Detalji o poslovanju obavlja.,
Diagnosis,Dijagnoza,
Did not find any item called {0},Nije našao bilo koji predmet pod nazivom {0},
Diff Qty,Diff Količina,
Difference Account,Konto razlike,
"Difference Account must be a Asset/Liability type account, since this Stock Reconciliation is an Opening Entry","Razlika račun mora biti tip imovine / odgovornošću obzir, jer je to Stock Pomirenje je otvor za ulaz",
Difference Amount,Razlika Iznos,
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čite mjerne jedinice proizvoda će dovesti do ukupne pogrešne neto težine. Budite sigurni da je neto težina svakog proizvoda u istoj mjernoj jedinici.,
Direct Expenses,Direktni troškovi,
Direct Income,Direktni prihodi,
Disable,Ugasiti,
Disabled template must not be default template,predložak invaliditetom ne smije biti zadani predložak,
Disburse Loan,Zajam za isplatu,
Disbursed,Isplaceno,
Disc,disk,
Discharge,Pražnjenje,
Discount,Popust,
Discount Percentage can be applied either against a Price List or for all Price List.,Postotak popusta se može neovisno primijeniti prema jednom ili za više cjenika.,
Discount must be less than 100,Rabatt mora biti manji od 100,
Diseases & Fertilizers,Bolesti i đubriva,
Dispatch,Otpremanje,
Dispatch Notification,Obaveštenje o otpremi,
Dispatch State,Država otpreme,
Distance,Razdaljina,
Distribution,Distribucija,
Distributor,Distributer,
Dividends Paid,Isplaćene dividende,
Do you really want to restore this scrapped asset?,Da li zaista želite da vratite ovaj ukinut imovine?,
Do you really want to scrap this asset?,Da li zaista želite da ukine ove imovine?,
Do you want to notify all the customers by email?,Želite li obavijestiti sve kupce putem e-pošte?,
Doc Date,Doc Date,
Doc Name,Doc ime,
Doc Type,Doc tip,
Docs Search,Pretraga dokumenata,
Document Name,Dokument Ime,
Document Type,Tip dokumenta,
Domain,Domena,
Domains,Domena,
Done,Gotovo,
Donor,Donor,
Donor Type information.,Informacije o donatoru.,
Donor information.,Informacije o donatorima.,
Download JSON,Preuzmite JSON,
Draft,Draft,
Drop Ship,Drop Ship,
Drug,Lijek,
Due / Reference Date cannot be after {0},Zbog / Reference Datum ne može biti nakon {0},
Due Date cannot be before Posting / Supplier Invoice Date,Datum roka ne može biti prije datuma knjiženja / fakture dobavljača,
Due Date is mandatory,Due Date je obavezno,
Duplicate Entry. Please check Authorization Rule {0},Dupli unos. Provjerite pravila za autorizaciju {0},
Duplicate Serial No entered for Item {0},Dupli serijski broj je unešen za artikl {0},
Duplicate customer group found in the cutomer group table,Duplikat grupe potrošača naći u tabeli Cutomer grupa,
Duplicate entry,Dupli unos,
Duplicate item group found in the item group table,Duplikat stavka grupa naći u tabeli stavka grupa,
Duplicate roll number for student {0},Duplikat broj roll za studentske {0},
Duplicate row {0} with same {1},Dupli red {0} sa istim {1},
Duplicate {0} found in the table,Duplikat {0} pronađen u tabeli,
Duration in Days,Trajanje u danima,
Duties and Taxes,Carine i porezi,
E-Invoicing Information Missing,Informacije o e-računima nedostaju,
ERPNext Demo,ERPNext Demo,
ERPNext Settings,Postavke ERPNext,
Earliest,Najstarije,
Earnest Money,kapara,
Edit,Uredi,
Edit Publishing Details,Izmenite podatke o objavljivanju,
"Edit in full page for more options like assets, serial nos, batches etc.","Uredite na celoj stranici za više opcija kao što su imovina, serijski nos, serije itd.",
Education,Obrazovanje,
Either location or employee must be required,Moraju biti potrebne lokacije ili zaposleni,
Either target qty or target amount is mandatory,Ili meta Količina ili ciljani iznos je obvezna,
Either target qty or target amount is mandatory.,Ili meta Količina ili ciljani iznos je obavezna .,
Electrical,Električna,
Electronic Equipments,elektronske opreme,
Electronics,Elektronika,
Eligible ITC,Ispunjava uvjete ITC,
Email Account,Email nalog,
Email Address,E-mail adresa,
"Email Address must be unique, already exists for {0}","E-mail adresa mora biti jedinstvena, već postoji za {0}",
Email Digest: ,Email Digest:,
Email Reminders will be sent to all parties with email contacts,Email podsetnici će biti poslati svim stranama sa kontaktima e-pošte,
Email Sent,E-mail poslan,
Email Template,Email Template,
Email not found in default contact,E-pošta nije pronađena u podrazumevanom kontaktu,
Email sent to {0},E-mail poslan na {0},
Employee,Radnik,
Employee Advances,Napredak zaposlenih,
Employee ID,ID zaposlenika,
Employee Lifecycle,Životni vek zaposlenih,
Employee Name,Ime i prezime radnika,
Employee Promotion cannot be submitted before Promotion Date ,Promocija zaposlenih ne može se podneti pre datuma promocije,
Employee Transfer cannot be submitted before Transfer Date ,Transfer radnika ne može se podneti pre datuma prenosa,
Employee cannot report to himself.,Zaposleni ne može prijaviti samog sebe.,
Employee {0} has already applied for {1} between {2} and {3} : ,Zaposleni {0} već je prijavio za {1} između {2} i {3}:,
Employee {0} of grade {1} have no default leave policy,Zaposleni {0} razreda {1} nemaju nikakvu politiku za odlazni odmor,
Enable / disable currencies.,Omogućiti / onemogućiti valute .,
Enabled,Omogućeno,
"Enabling 'Use for Shopping Cart', as Shopping Cart is enabled and there should be at least one Tax Rule for Shopping Cart","Omogućavanje &#39;Koristi se za korpa &quot;, kao košarica je omogućen i treba da postoji barem jedan poreza pravilo za Košarica",
End Date,Datum završetka,
End Date can not be less than Start Date,Datum završetka ne može biti manji od početnog datuma,
End Date cannot be before Start Date.,Krajnji datum ne može biti pre početka datuma.,
End Year,do kraja godine,
End Year cannot be before Start Year,Kraja godine ne može biti prije početka godine,
End on,Završi,
Ends On date cannot be before Next Contact Date.,Završava na datum ne može biti pre Sledećeg datuma kontakta.,
Energy,Energija,
Engineer,Inženjer,
Enough Parts to Build,Dosta dijelova za izgradnju,
Enroll,upisati,
Enrolling student,upisa student,
Enrolling students,Upis studenata,
Enter depreciation details,Unesite podatke o amortizaciji,
Enter the Bank Guarantee Number before submittting.,Unesite broj garancije banke pre podnošenja.,
Enter the name of the Beneficiary before submittting.,Unesite ime Korisnika pre podnošenja.,
Enter the name of the bank or lending institution before submittting.,Pre podnošenja navedite ime banke ili kreditne institucije.,
Enter value betweeen {0} and {1},Unesite vrijednost betweeen {0} i {1},
Entertainment & Leisure,Zabava i slobodno vrijeme,
Entertainment Expenses,Zabava Troškovi,
Equity,pravičnost,
Error Log,Error Log,
Error evaluating the criteria formula,Greška u procjeni formula za kriterijume,
Error in formula or condition: {0},Greška u formuli ili stanja: {0},
Error: Not a valid id?,Greška: Ne važeći id?,
Estimated Cost,Procijenjeni troškovi,
"Even if there are multiple Pricing Rules with highest priority, then following internal priorities are applied:","Čak i ako postoji više Cijene pravila s najvišim prioritetom, onda sljedeći interni prioriteti primjenjuje se:",
Exchange Gain/Loss,Exchange dobitak / gubitak,
Exchange Rate Revaluation master.,Master revalorizacije kursa,
Exchange Rate must be same as {0} {1} ({2}),Tečajna lista moraju biti isti kao {0} {1} ({2}),
Excise Invoice,Akcizama Račun,
Execution,Izvršenje,
Executive Search,Executive Search,
Expand All,Raširi sve,
Expected Delivery Date,Očekivani rok isporuke,
Expected Delivery Date should be after Sales Order Date,Očekivani datum isporuke treba da bude nakon datuma prodaje,
Expected End Date,Očekivani Datum završetka,
Expected Hrs,Očekivana h,
Expected Start Date,Očekivani datum početka,
Expense,rashod,
Expense / Difference account ({0}) must be a 'Profit or Loss' account,Rashodi / Razlika računa ({0}) mora biti račun 'dobit ili gubitak',
Expense Account,Rashodi račun,
Expense Claim,Rashodi polaganja,
Expense Claims,Trošak potraživanja,
Expense account is mandatory for item {0},Rashodi račun je obvezna za predmet {0},
Expenses,Troškovi,
Expenses Included In Asset Valuation,Uključeni troškovi u procenu aktive,
Expenses Included In Valuation,Troškovi uključeni u vrednovanje,
Expired Batches,Istekao paketi,
Expires On,ističe,
Expiring On,Ističe se,
Expiry (In Days),Isteka (u danima),
Explore,Istražiti,
Export E-Invoices,Izvoz E-računa,
Extra Large,Ekstra veliki,
Extra Small,Extra Small,
Fail,Fail,
Failed,Nije uspio,
Failed to create website,Neuspelo je kreirati web stranicu,
Failed to install presets,Nije uspela instalirati memorije,
Failed to login,Neuspešno se prijaviti,
Failed to setup company,Nije uspela kompanija podesiti,
Failed to setup defaults,Nije uspjelo postavljanje zadanih postavki,
Failed to setup post company fixtures,Nije uspelo postaviti post kompanije,
Fax,Fax,
Fee,provizija,
Fee Created,Kreirana naknada,
Fee Creation Failed,Kreiranje Fee-a nije uspelo,
Fee Creation Pending,Čekanje stvaranja naknade,
Fee Records Created - {0},Naknada Records Kreirano - {0},
Feedback,Povratna veza,
Fees,Naknade,
Female,Ženski,
Fetch Data,Izvadite podatke,
Fetch Subscription Updates,Izvrši ažuriranje pretplate,
Fetch exploded BOM (including sub-assemblies),Fetch eksplodirala BOM (uključujući i podsklopova ),
Fetching records......,Dohvaćanje zapisa ......,
Field Name,Naziv polja,
Fieldname,"Podataka, Naziv Polja",
Fields,Polja,
"Filter Fields Row #{0}: Fieldname <b>{1}</b> must be of type ""Link"" or ""Table MultiSelect""",Red za polja filtera # {0}: Naziv polja <b>{1}</b> mora biti tipa &quot;Link&quot; ili &quot;Table MultiSelect&quot;,
Filter Total Zero Qty,Filter Total Zero Qty,
Finance Book,Finansijska knjiga,
Financial / accounting year.,Financijska / obračunska godina .,
Financial Services,financijske usluge,
Financial Statements,Finansijski izvještaji,
Financial Year,Finansijska godina,
Finish,završiti,
Finished Good,Finished Good,
Finished Good Item Code,Gotov dobar kod predmeta,
Finished Goods,Gotovih proizvoda,
Finished Item {0} must be entered for Manufacture type entry,Završio Stavka {0} mora biti unesen za tip Proizvodnja unos,
Finished product quantity <b>{0}</b> and For Quantity <b>{1}</b> cannot be different,Završena količina proizvoda <b>{0}</b> i Za količinu <b>{1}</b> ne mogu biti različite,
First Name,Ime,
"Fiscal Regime is mandatory, kindly set the fiscal regime in the company {0}","Fiskalni režim je obavezan, ljubazno postavite fiskalni režim u kompaniji {0}",
Fiscal Year,Fiskalna godina,
Fiscal Year End Date should be one year after Fiscal Year Start Date,Datum završetka fiskalne godine trebao bi biti godinu dana nakon datuma početka fiskalne godine,
Fiscal Year Start Date and Fiscal Year End Date are already set in Fiscal Year {0},Fiskalna godina Datum početka i datum završetka fiskalne godine već su postavljeni u fiskalnoj godini {0},
Fiscal Year Start Date should be one year earlier than Fiscal Year End Date,Datum početka fiskalne godine trebao bi biti godinu dana ranije od datuma završetka fiskalne godine,
Fiscal Year {0} does not exist,Fiskalna godina {0} ne postoji,
Fiscal Year {0} is required,Fiskalna godina {0} je potrebno,
Fixed Asset,Dugotrajne imovine,
Fixed Asset Item must be a non-stock item.,Osnovnih sredstava Stavka mora biti ne-stock stavku.,
Fixed Assets,Dugotrajna imovina,
Following Material Requests have been raised automatically based on Item's re-order level,Nakon materijala Zahtjevi su automatski podignuta na osnovu nivou ponovnog reda stavke,
Following accounts might be selected in GST Settings:,Sledeći nalogi mogu biti izabrani u GST Podešavanja:,
Following course schedules were created,Stvoreni su sledeći planovi kursa,
Following item {0} is not marked as {1} item. You can enable them as {1} item from its Item master,Sledeća stavka {0} nije označena kao {1} stavka. Možete ih omogućiti kao {1} stavku iz glavnog poglavlja,
Following items {0} are not marked as {1} item. You can enable them as {1} item from its Item master,Sledeće stavke {0} nisu označene kao {1} stavka. Možete ih omogućiti kao {1} stavku iz glavnog poglavlja,
"Food, Beverage & Tobacco","Hrana , piće i duhan",
For,Za,
"For 'Product Bundle' items, Warehouse, Serial No and Batch No will be considered from the 'Packing List' table. If Warehouse and Batch No are same for all packing items for any 'Product Bundle' item, those values can be entered in the main Item table, values will be copied to 'Packing List' table.","Za &#39;proizvoda Bundle&#39; stavki, Magacin, serijski broj i serijski broj smatrat će se iz &#39;Pakiranje List&#39; stol. Ako Skladište i serijski broj su isti za sve pakovanje stavke za bilo &#39;Bundle proizvoda&#39; stavku, te vrijednosti mogu se unijeti u glavnom Stavka stola, vrijednosti će se kopirati u &#39;Pakiranje List&#39; stol.",
For Quantity (Manufactured Qty) is mandatory,Za Količina (Proizvedeno Qty) je obavezno,
For Supplier,za Supplier,
For Warehouse,Za galeriju,
For Warehouse is required before Submit,Jer je potrebno Warehouse prije Podnijeti,
"For an item {0}, quantity must be negative number","Za stavku {0}, količina mora biti negativna",
"For an item {0}, quantity must be positive number","Za stavku {0}, količina mora biti pozitivni broj",
"For job card {0}, you can only make the 'Material Transfer for Manufacture' type stock entry",Za radnu karticu {0} možete izvršiti samo unos tipa „Prijenos materijala za proizvodnju“,
"For row {0} in {1}. To include {2} in Item rate, rows {3} must also be included","Za red {0} u {1}. Uključiti {2} u tačka stope, redova {3} mora biti uključena",
For row {0}: Enter Planned Qty,Za red {0}: Unesite planirani broj,
"For {0}, only credit accounts can be linked against another debit entry","Za {0}, samo kredit računa može biti povezan protiv drugog ulaska debit",
"For {0}, only debit accounts can be linked against another credit entry","Za {0}, samo debitne račune mogu povezati protiv druge kreditne unos",
Forum Activity,Aktivnost foruma,
Free item code is not selected,Besplatni kod artikla nije odabran,
Freight and Forwarding Charges,Teretni i Forwarding Optužbe,
Frequency,frekvencija,
Friday,Petak,
From,Od,
From Address 1,Od adrese 1,
From Address 2,Od adrese 2,
From Currency and To Currency cannot be same,Od valute i valuta ne mogu biti isti,
From Date and To Date lie in different Fiscal Year,Od datuma i do datuma leži u različitim fiskalnim godinama,
From Date cannot be greater than To Date,Od datuma ne može biti veća od To Date,
From Date must be before To Date,Od datuma mora biti prije do danas,
From Date should be within the Fiscal Year. Assuming From Date = {0},Od datuma trebao biti u fiskalnoj godini. Uz pretpostavku Od datuma = {0},
From Datetime,Od datuma i vremena,
From Delivery Note,Od otpremnici,
From Fiscal Year,Od fiskalne godine,
From GSTIN,Iz GSTIN-a,
From Party Name,Od imena partije,
From Pin Code,Od PIN-a,
From Place,From Place,
From Range has to be less than To Range,Od opseg mora biti manji od u rasponu,
From State,Od države,
From Time,S vremena,
From Time Should Be Less Than To Time,Od vremena bi trebalo biti manje od vremena,
From Time cannot be greater than To Time.,Od vremena ne može biti veća nego vremena.,
"From a supplier under composition scheme, Exempt and Nil rated","Od dobavljača prema shemi kompozicije, Oslobođeni i Nil",
From and To dates required,Od i Do datuma zahtijevanih,
From value must be less than to value in row {0},Od vrijednosti mora biti manje nego vrijednosti u redu {0},
From {0} | {1} {2},Od {0} | {1} {2},
Fulfillment,Ispunjenje,
Full Name,Ime i prezime,
Fully Depreciated,potpuno je oslabio,
Furnitures and Fixtures,Furnitures i raspored,
"Further accounts can be made under Groups, but entries can be made against non-Groups","Dalje računa može biti pod Grupe, ali unosa može biti protiv ne-Grupe",
Further cost centers can be made under Groups but entries can be made against non-Groups,"Dalje troška mogu biti pod Grupe, ali unosa može biti protiv ne-Grupe",
Further nodes can be only created under 'Group' type nodes,"Daljnje čvorovi mogu se samo stvorio pod ""Grupa"" tipa čvorova",
GSTIN,GSTIN,
GSTR3B-Form,GSTR3B-Obrazac,
Gain/Loss on Asset Disposal,Dobit / Gubitak imovine Odlaganje,
Gantt Chart,Gantogram,
Gantt chart of all tasks.,Gantogram svih zadataka.,
Gender,Rod,
General,Opšti,
General Ledger,Glavna knjiga,
Generate Material Requests (MRP) and Work Orders.,Generiranje zahteva za materijal (MRP) i radnih naloga.,
Generate Secret,Generiraj tajnu,
Get Invocies,Nabavite račune,
Get Invoices,Dobijajte račune,
Get Invoices based on Filters,Nabavite fakture na temelju filtera,
Get Items from BOM,Kreiraj proizvode od sastavnica (BOM),
Get Items from Healthcare Services,Uzmite predmete iz zdravstvenih usluga,
Get Items from Prescriptions,Dobijte stavke iz recepta,
Get Items from Product Bundle,Saznajte Predmeti od Bundle proizvoda,
Get Suppliers,Uzmite dobavljača,
Get Suppliers By,Uzmite dobavljača,
Get Updates,Get Updates,
Get customers from,Uzmite kupce,
Get from Patient Encounter,Izlazite iz susreta sa pacijentom,
Getting Started,Počinjemo,
GitHub Sync ID,GitHub Sync ID,
Global settings for all manufacturing processes.,Global postavke za sve proizvodne procese.,
Go to the Desktop and start using ERPNext,Idite na radnu površinu i početi koristiti ERPNext,
GoCardless SEPA Mandate,GoCardless SEPA Mandat,
GoCardless payment gateway settings,GoCardless postavke gateway plaćanja,
Goal and Procedure,Cilj i postupak,
Goals cannot be empty,Ciljevi ne može biti prazan,
Goods In Transit,Roba u tranzitu,
Goods Transferred,Prenesena roba,
Goods and Services Tax (GST India),Poreska dobara i usluga (PDV Indija),
Goods are already received against the outward entry {0},Roba je već primljena prema vanjskom ulazu {0},
Government,Vlada,
Grand Total,Ukupno za platiti,
Grant,Grant,
Grant Application,Grant aplikacija,
Grant Leaves,Grant Leaves,
Grant information.,Grant informacije.,
Grocery,Trgovina prehrambenom robom,
Gross Profit,Bruto dobit,
Gross Profit %,Bruto dobit%,
Gross Profit / Loss,Bruto dobit / gubitak,
Gross Purchase Amount,Bruto Kupovina Iznos,
Gross Purchase Amount is mandatory,Bruto Kupovina Iznos je obavezno,
Group by Account,Grupa po računu,
Group by Party,Grupno po stranci,
Group by Voucher,Grupa po jamcu,
Group by Voucher (Consolidated),Grupa po vaučerima (konsolidovani),
Group node warehouse is not allowed to select for transactions,skladište Group čvor nije dozvoljeno da izaberete za transakcije,
Group to Non-Group,Grupa Non-grupa,
Group your students in batches,Grupa svojim učenicima u serijama,
Groups,Grupe,
Guardian1 Email ID,Guardian1 Email ID,
Guardian1 Mobile No,Guardian1 Mobile Nema,
Guardian1 Name,Guardian1 ime,
Guardian2 Email ID,Guardian2 Email ID,
Guardian2 Mobile No,Guardian2 Mobile Nema,
Guardian2 Name,Guardian2 ime,
HR Manager,Šef ljudskih resursa,
HSN,HSN,
HSN/SAC,HSN / SAC,
Half Yearly,Polu godišnji,
Half-Yearly,Polugodišnje,
Hardware,Hardver,
Head of Marketing and Sales,Voditelj marketinga i prodaje,
Health Care,Zdravstvena zaštita,
Healthcare,Zdravstvena zaštita,
Healthcare (beta),Zdravstvo (beta),
Healthcare Practitioner,Zdravstveni lekar,
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,Jedinica za zdravstvenu zaštitu,
Healthcare Service Unit Tree,Jedinica za zdravstvenu zaštitu,
Healthcare Service Unit Type,Vrsta jedinice za zdravstvenu zaštitu,
Healthcare Services,Zdravstvene usluge,
Healthcare Settings,Postavke zdravstvene zaštite,
Help Results for,Pomoć rezultata za,
High,Visok,
High Sensitivity,Visoka osetljivost,
Hold,Zadrži,
Hold Invoice,Držite fakturu,
Holiday,Odmor,
Holiday List,Lista odmora,
Hotel Rooms of type {0} are unavailable on {1},Sobe Hotela tipa {0} nisu dostupne na {1},
Hotels,Hoteli,
Hourly,Po satu,
Hours,Hours,
How Pricing Rule is applied?,Kako se primjenjuje pravilo cijena?,
Hub Category,Glavna kategorija,
Hub Sync ID,Hub Sync ID,
Human Resource,Human Resource,
Human Resources,Ljudski resursi,
IGST Amount,IGST Iznos,
IP Address,IP adresa,
ITC Available (whether in full op part),Dostupan ITC (bilo u cjelini op. Dio),
ITC Reversed,ITC preokrenut,
Identifying Decision Makers,Identifikovanje donosilaca odluka,
"If Auto Opt In is checked, then the customers will be automatically linked with the concerned Loyalty Program (on save)","Ako se proveri automatsko uključivanje, klijenti će automatski biti povezani sa dotičnim programom lojalnosti (pri uštedi)",
"If multiple Pricing Rules continue to prevail, users are asked to set Priority manually to resolve conflict.","Ako više Cijene pravila i dalje prevladavaju, korisnici su zamoljeni da postavite prioritet ručno riješiti sukob.",
"If selected Pricing Rule is made for 'Rate', it will overwrite Price List. Pricing Rule rate is the final rate, so no further discount should be applied. Hence, in transactions like Sales Order, Purchase Order etc, it will be fetched in 'Rate' field, rather than 'Price List Rate' field.","Ako je izabrano odredište za cenu &quot;Rate&quot;, on će prepisati cenovnik. Pravilnost cena je konačna stopa, tako da se ne bi trebao koristiti dodatni popust. Stoga, u transakcijama kao što su Prodajni nalog, Narudžbenica i slično, to će biti preuzeto u polju &#39;Rate&#39;, a ne &#39;Polje cijena&#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 su dva ili više Pravila cijene se nalaze na osnovu gore uvjetima, Prioritet se primjenjuje. Prioritet je broj od 0 do 20, a zadana vrijednost je nula (prazno). Veći broj znači da će imati prednost, ako postoji više pravila cijenama s istim uslovima.",
"If unlimited expiry for the Loyalty Points, keep the Expiry Duration empty or 0.","Ako je neograničen rok isticanja za Loyalty Bodove, zadržite Trajanje isteka prazne ili 0.",
"If you have any questions, please get back to us.","Ako imate bilo kakvih pitanja, molimo Vas da se vratimo na nas.",
Ignore Existing Ordered Qty,Zanemarite postojeći naručeni broj,
Image,Slika,
Image View,Prikaz slike,
Import Data,Uvoz podataka,
Import Day Book Data,Uvezi podatke o knjizi dana,
Import Log,Uvoz Prijavite,
Import Master Data,Uvezi glavne podatke,
Import in Bulk,Uvoz u rinfuzi,
Import of goods,Uvoz robe,
Import of services,Uvoz usluga,
Importing Items and UOMs,Uvoz predmeta i UOM-ova,
Importing Parties and Addresses,Uvoz stranaka i adresa,
In Maintenance,U održavanju,
In Production,U proizvodnji,
In Qty,u kol,
In Stock Qty,Na skladištu Količina,
In Stock: ,Na raspolaganju:,
In Value,u vrijednost,
"In the case of multi-tier program, Customers will be auto assigned to the concerned tier as per their spent","U slučaju višeslojnog programa, Korisnici će automatski biti dodeljeni za dotičnu grupu po njihovom trošenju",
Inactive,Neaktivan,
Incentives,Poticaji,
Include Default FB Entries,Uključite zadane unose knjiga,
Include Exploded Items,Uključite eksplodirane predmete,
Include POS Transactions,Uključite POS transakcije,
Include UOM,Uključite UOM,
Included in Gross Profit,Uključeno u bruto dobit,
Income,Prihod,
Income Account,Konto prihoda,
Income Tax,Porez na dohodak,
Incoming,Dolazni,
Incoming Rate,Dolazni Stopa,
Incorrect number of General Ledger Entries found. You might have selected a wrong Account in the transaction.,Neispravan broj glavnu knjigu unose naći. Možda ste odabrali krivi račun u transakciji.,
Increment cannot be 0,Prirast ne može biti 0,
Increment for Attribute {0} cannot be 0,Prirast za Atributi {0} ne može biti 0,
Indirect Expenses,Neizravni troškovi,
Indirect Income,Neizravni dohodak,
Individual,Pojedinac,
Ineligible ITC,Neprihvatljiv ITC,
Initiated,Inicirao,
Inpatient Record,Zapisnik o stacionarnom stanju,
Installation Note,Napomena instalacije,
Installation Note {0} has already been submitted,Napomena instalacije {0} je već potvrđena,
Installation date cannot be before delivery date for Item {0},Datum Instalacija ne može biti prije datuma isporuke za točke {0},
Installing presets,Instaliranje podešavanja,
Institute Abbreviation,Institut Skraćenica,
Institute Name,Institut ime,
Instructor,Instruktor,
Insufficient Stock,nedovoljna Stock,
Insurance Start date should be less than Insurance End date,Datum osiguranje Početak bi trebao biti manji od datuma osiguranje Kraj,
Integrated Tax,Integrirani porez,
Inter-State Supplies,Međudržavne potrepštine,
Internet Publishing,Internet izdavaštvo,
Intra-State Supplies,Unutarnje države,
Introduction,Uvod,
Invalid Attribute,Invalid Atributi,
Invalid Blanket Order for the selected Customer and Item,Neveljavna porudžbina za odabrani korisnik i stavku,
Invalid Company for Inter Company Transaction.,Nevažeća kompanija za transakciju između kompanija.,
Invalid GSTIN! A GSTIN must have 15 characters.,Nevažeći GSTIN! GSTIN mora imati 15 znakova.,
Invalid GSTIN! First 2 digits of GSTIN should match with State number {0}.,Nevažeći GSTIN! Prve dvije znamenke GSTIN-a trebale bi se podudarati sa državnim brojem {0}.,
Invalid GSTIN! The input you've entered doesn't match the format of GSTIN.,Nevažeći GSTIN! Uneseni unos ne odgovara formatu GSTIN-a.,
Invalid Posting Time,Neispravno vreme slanja poruka,
Invalid attribute {0} {1},Nevažeći atributa {0} {1},
Invalid quantity specified for item {0}. Quantity should be greater than 0.,Navedena je pogrešna količina za proizvod {0}. Količina treba biti veći od 0.,
Invalid reference {0} {1},Invalid referentni {0} {1},
Invalid {0},Invalid {0},
Invalid {0} for Inter Company Transaction.,Nevažeći {0} za transakciju Inter kompanije.,
Invalid {0}: {1},{1}: Invalid {0},
Inventory,Inventar,
Investment Banking,Investicijsko bankarstvo,
Investments,Investicije,
Invoice,Faktura,
Invoice Created,Izrada fakture,
Invoice Discounting,Popust na fakture,
Invoice Patient Registration,Registracija računa pacijenta,
Invoice Posting Date,Račun Datum knjiženja,
Invoice Type,Tip fakture,
Invoice already created for all billing hours,Račun je već kreiran za sva vremena plaćanja,
Invoice can't be made for zero billing hour,Faktura ne može biti napravljena za nultu cenu fakturisanja,
Invoice {0} no longer exists,Račun {0} više ne postoji,
Invoiced,Fakturisano,
Invoiced Amount,Fakturisanog,
Invoices,Fakture,
Invoices for Costumers.,Računi za kupce.,
Inward supplies from ISD,Ulazne zalihe od ISD-a,
Inward supplies liable to reverse charge (other than 1 & 2 above),Unutarnje zalihe podložne povratnom naboju (osim 1 i 2 gore),
Is Active,Je aktivan,
Is Default,Je podrazumjevani,
Is Existing Asset,Je Postojeći imovine,
Is Frozen,Je zamrznut,
Is Group,Is Group,
Issue,Tiketi,
Issue Material,Tiketi - materijal,
Issued,Izdao,
Issues,Pitanja,
It is needed to fetch Item Details.,Potrebno je da se donese Stavka Detalji.,
Item,Artikl,
Item 1,Stavku 1,
Item 2,Stavku 2,
Item 3,Stavka 3,
Item 4,Stavka 4,
Item 5,Stavka 5,
Item Cart,stavka Košarica,
Item Code,Šifra artikla,
Item Code cannot be changed for Serial No.,Kod artikla ne može se mijenjati za serijski broj.,
Item Code required at Row No {0},Kod artikla je potreban u redu broj {0},
Item Description,Opis artikla,
Item Group,Grupa artikla,
Item Group Tree,Raspodjela grupe artikala,
Item Group not mentioned in item master for item {0},Stavka artikla se ne spominje u master artiklu za artikal {0},
Item Name,Naziv predmeta,
Item Price added for {0} in Price List {1},Stavka Cijena je dodao za {0} u {1} Cjenik,
"Item Price appears multiple times based on Price List, Supplier/Customer, Currency, Item, UOM, Qty and Dates.","Stavka Cena se pojavljuje više puta na osnovu Cenovnika, dobavljača / kupca, valute, stavke, UOM, kola i datuma.",
Item Price updated for {0} in Price List {1},Artikal Cijena ažuriranje za {0} u Cjenik {1},
Item Row {0}: {1} {2} does not exist in above '{1}' table,Stavka Red {0}: {1} {2} ne postoji iznad tabele &quot;{1}&quot;,
Item Tax Row {0} must have account of type Tax or Income or Expense or Chargeable,Stavka Porezna Row {0} mora imati račun tipa poreza ili prihoda i rashoda ili naplativ,
Item Template,Šablon predmeta,
Item Variant Settings,Postavke varijante postavki,
Item Variant {0} already exists with same attributes,Stavka Variant {0} već postoji s istim atributima,
Item Variants,Stavka Varijante,
Item Variants updated,Ažurirane su varijante predmeta,
Item has variants.,Stavka ima varijante.,
Item must be added using 'Get Items from Purchase Receipts' button,Stavka mora biti dodan pomoću 'Get stavki iz Kupovina Primici' gumb,
Item valuation rate is recalculated considering landed cost voucher amount,Stavka stopa vrednovanja izračunava se razmatra sletio troškova voucher iznosu,
Item variant {0} exists with same attributes,Stavka varijanta {0} postoji sa istim atributima,
Item {0} does not exist,Artikal {0} ne postoji,
Item {0} does not exist in the system or has expired,Artikal {0} ne postoji u sustavu ili je istekao,
Item {0} has already been returned,Artikal {0} je već vraćen,
Item {0} has been disabled,Stavka {0} je onemogućena,
Item {0} has reached its end of life on {1},Artikal {0} je dosegao svoj rok trajanja na {1},
Item {0} ignored since it is not a stock item,Artikal {0} se ignorira budući da nije skladišni artikal,
"Item {0} is a template, please select one of its variants","Stavka {0} je predložak, odaberite jednu od njegovih varijanti",
Item {0} is cancelled,Artikal {0} je otkazan,
Item {0} is disabled,Stavka {0} je onemogućeno,
Item {0} is not a serialized Item,Stavka {0} nijeserijaliziranom predmeta,
Item {0} is not a stock Item,Stavka {0} nijestock Stavka,
Item {0} is not active or end of life has been reached,Stavka {0} nije aktivan ili kraj života je postignut,
Item {0} is not setup for Serial Nos. Check Item master,"Stavka {0} nije dobro postavljen za gospodara , serijski brojevi Provjera",
Item {0} is not setup for Serial Nos. Column must be blank,Stavka {0} nije setup za serijski brojevi Stupac mora biti prazan,
Item {0} must be a Fixed Asset Item,Stavka {0} mora biti osnovna sredstva stavka,
Item {0} must be a Sub-contracted Item,Stavka {0} mora bitisklopljen ugovor artikla,
Item {0} must be a non-stock item,Stavka {0} mora biti ne-stock stavka,
Item {0} must be a stock Item,Stavka {0} mora bitistock Stavka,
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 &#39;sirovine Isporučuje&#39; sto u narudžbenice {1},
Item {0}: Ordered qty {1} cannot be less than minimum order qty {2} (defined in Item).,Stavka {0}: {1} Naručena količina ne može biti manji od minimalnog bi Količina {2} (iz točke).,
Item: {0} does not exist in the system,Detaljnije: {0} ne postoji u sustavu,
Items,Artikli,
Items Filter,Filter predmeta,
Items and Pricing,Stavke i cijene,
Items for Raw Material Request,Artikli za zahtjev za sirovine,
Job Card,Job Card,
Job card {0} created,Kartica za posao {0} kreirana,
Join,pristupiti,
Journal Entries {0} are un-linked,Journal unosi {0} su un-povezani,
Journal Entry,Časopis Stupanje,
Journal Entry {0} does not have account {1} or already matched against other voucher,Journal Entry {0} nema obzir {1} ili su već usklađene protiv drugih vaučer,
Kanban Board,Kanban odbora,
Key Reports,Ključni izvještaji,
LMS Activity,LMS aktivnost,
Lab Test,Lab Test,
Lab Test Report,Izvještaj o laboratorijskom testu,
Lab Test Sample,Primjer laboratorijskog testa,
Lab Test Template,Lab test šablon,
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 rezultata laboratorije ne može biti pre testiranja datetime,
Lab testing datetime cannot be before collection datetime,Labiranje testiranja datotime ne može biti pre snimanja datetime,
Label,Oznaka,
Laboratory,Laboratorija,
Large,Veliki,
Last Communication,Zadnje Komunikacija,
Last Communication Date,Zadnje Komunikacija Datum,
Last Name,Prezime,
Last Order Amount,Last Order Iznos,
Last Order Date,Last Order Datum,
Last Purchase Price,Poslednja cena otkupa,
Last Purchase Rate,Zadnja kupovna cijena,
Latest,Najnovije,
Latest price updated in all BOMs,Posljednja cijena ažurirana u svim BOM,
Lead,Potencijalni kupac,
Lead Count,Lead Count,
Lead Owner,Vlasnik Lead-a,
Lead Owner cannot be same as the Lead,Olovo Vlasnik ne može biti isti kao olovo,
Lead Time Days,Potencijalni kupac - ukupno dana,
Lead to Quotation,Potencijalni kupac do ponude,
"Leads help you get business, add all your contacts and more as your leads","Leads biste se lakše poslovanje, dodati sve svoje kontakte i još kao vodi",
Learn,Učiti,
Leave Management,Ostavite Management,
Leave and Attendance,Ostavite i posjećenost,
Leave application {0} already exists against the student {1},Izlaz iz aplikacije {0} već postoji protiv učenika {1},
Leaves has been granted sucessfully,Lišće je uspešno izdato,
Leaves must be allocated in multiples of 0.5,"Listovi moraju biti dodijeljeno u COMBI 0,5",
Ledger,Glavna knjiga,
Legal,Pravni,
Legal Expenses,Pravni troškovi,
Letter Head,Zaglavlje,
Letter Heads for print templates.,Zaglavlja za ispis predložaka.,
Level,Nivo,
Liability,Odgovornost,
Limit Crossed,Limit Crossed,
Link to Material Request,Link na zahtev za materijal,
List of all share transactions,Spisak svih dionica transakcija,
List of available Shareholders with folio numbers,Spisak dostupnih akcionara sa brojevima folije,
Loading Payment System,Uplata platnog sistema,
Loan,Loan,
Loan Start Date and Loan Period are mandatory to save the Invoice Discounting,Datum početka i Period zajma su obavezni da biste spremili popust na računu,
Loans (Liabilities),Zajmovi (pasiva),
Loans and Advances (Assets),Zajmovi i predujmovi (aktiva),
Local,Lokalno,
Logs for maintaining sms delivery status,Dnevnici za održavanje sms statusa isporuke,
Lost,Izgubljen,
Lost Reasons,Izgubljeni razlozi,
Low,Nizak,
Low Sensitivity,Niska osetljivost,
Lower Income,Niži Prihodi,
Loyalty Amount,Lojalnost,
Loyalty Point Entry,Ulaz lojalnosti,
Loyalty Points,Točke lojalnosti,
"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.","Točke lojalnosti će se izračunati iz potrošene (preko fakture za prodaju), na osnovu navedenog faktora sakupljanja.",
Loyalty Points: {0},Bodovi lojalnosti: {0},
Loyalty Program,Program lojalnosti,
Main,Glavni,
Maintenance,Održavanje,
Maintenance Log,Dnevnik održavanja,
Maintenance Manager,Održavanje Manager,
Maintenance Schedule,Raspored održavanja,
Maintenance Schedule is not generated for all the items. Please click on 'Generate Schedule',"Raspored održavanja ne stvara za sve stavke . Molimo kliknite na ""Generiraj raspored '",
Maintenance Schedule {0} exists against {1},Održavanje Raspored {0} postoji protiv {1},
Maintenance Schedule {0} must be cancelled before cancelling this Sales Order,Raspored održavanja {0} mora biti otkazana prije poništenja ovu prodajnog naloga,
Maintenance Status has to be Cancelled or Completed to Submit,Status održavanja mora biti poništen ili završen za slanje,
Maintenance User,Održavanje korisnika,
Maintenance Visit,Posjeta za odrzavanje,
Maintenance Visit {0} must be cancelled before cancelling this Sales Order,Posjeta za odrzavanje {0} mora biti otkazana prije otkazivanja ove ponude,
Maintenance start date can not be before delivery date for Serial No {0},Održavanje datum početka ne može biti prije datuma isporuke za rednim brojem {0},
Make,Napraviti,
Make Payment,izvrši plaćanje,
Make project from a template.,Napravite projekat iz predloška.,
Making Stock Entries,Izrada Stock unosi,
Male,Muški,
Manage Customer Group Tree.,Upravljanje vrstama djelatnosti,
Manage Sales Partners.,Upravljanje prodajnih partnera.,
Manage Sales Person Tree.,Menadzeri prodaje - Upravljanje.,
Manage Territory Tree.,Spisak teritorija - upravljanje.,
Manage your orders,Upravljanje narudžbe,
Management,upravljanje,
Manager,Menadžer,
Managing Projects,Upravljanje projektima,
Managing Subcontracting,Upravljanje Subcontracting,
Mandatory,Obavezan,
Mandatory field - Academic Year,Obavezna polja - akademska godina,
Mandatory field - Get Students From,Obavezna polja - Get Učenici iz,
Mandatory field - Program,Obavezna polja - Program,
Manufacture,Proizvodnja,
Manufacturer,Proizvođač,
Manufacturer Part Number,Proizvođač Broj dijela,
Manufacturing,Proizvodnja,
Manufacturing Quantity is mandatory,Proizvodnja Količina je obvezno,
Mapping,Mapiranje,
Mapping Type,Tip mapiranja,
Mark Absent,Mark Odsutan,
Mark Half Day,Mark Half Day,
Mark Present,Mark Present,
Marketing,Marketing,
Marketing Expenses,Troškovi marketinga,
Marketplace,Tržište,
Marketplace Error,Greška na tržištu,
Masters,Majstori,
Match Payments with Invoices,Meč plaćanja fakture,
Match non-linked Invoices and Payments.,Klađenje na ne-povezane faktura i plaćanja.,
Material,Materijal,
Material Consumption,Potrošnja materijala,
Material Consumption is not set in Manufacturing Settings.,Potrošnja materijala nije podešena u proizvodnim postavkama.,
Material Receipt,Materijal Potvrda,
Material Request,Materijal zahtjev,
Material Request Date,Materijal Upit Datum,
Material Request No,Materijal Zahtjev Ne,
"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},Materijal Zahtjev maksimalno {0} može biti za točku {1} od prodajnog naloga {2},
Material Request to Purchase Order,Materijal Zahtjev za narudžbenice,
Material Request {0} is cancelled or stopped,Materijal Zahtjev {0} je otkazan ili zaustavljen,
Material Request {0} submitted.,Podnet je materijalni zahtjev {0}.,
Material Transfer,Materijal transfera,
Material Transferred,Prenos materijala,
Material to Supplier,Materijal dobavljaču,
Max discount allowed for item: {0} is {1}%,Maksimalni popust dopušteno za predmet: {0} je {1}%,
Max: {0},Max: {0},
Maximum Samples - {0} can be retained for Batch {1} and Item {2}.,Maksimalni uzorci - {0} mogu biti zadržani za seriju {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 Item {2} u Batch {3}.,
Maximum discount for Item {0} is {1}%,Maksimalni popust za stavku {0} je {1}%,
Medical Code,Medicinski kod,
Medical Code Standard,Medical Code Standard,
Medical Department,Medicinski odjel,
Medical Record,Medicinski zapis,
Medium,Srednji,
Member Activity,Član Aktivnost,
Member ID,Član ID,
Member Name,Ime člana,
Member information.,Informacije o članovima.,
Membership,Članstvo,
Membership Details,Detalji o članstvu,
Membership ID,ID članstva,
Membership Type,Tip članstva,
Memebership Details,Memebership Details,
Memebership Type Details,Detalji o tipu Memebership,
Merge,Spoji se,
Merge Account,Merge Account,
Merge with Existing Account,Spoji se 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 sljedeće osobine su iste u oba zapisa. Grupa je, Root Tip, Društvo",
Message Examples,Primjeri poruka,
Message Sent,Poruka je poslana,
Method,Način,
Middle Income,Srednji Prihodi,
Middle Name,Srednje ime,
Middle Name (Optional),Krsno ime (opcionalno),
Min Amt can not be greater than Max Amt,Min Amt ne može biti veći od Max Amt,
Min Qty can not be greater than Max Qty,Min Kol ne može biti veći od Max Kol,
Minimum Lead Age (Days),Minimalna Olovo Starost (Dana),
Miscellaneous Expenses,Razni troškovi,
Missing Currency Exchange Rates for {0},Nedostaje Valuta Tečaj za {0},
Missing email template for dispatch. Please set one in Delivery Settings.,Nedostajući e-mail predložak za otpremu. Molimo vas da podesite jednu od postavki isporuke.,
"Missing value for Password, API Key or Shopify URL","Nedostajuća 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 prijevoza,
Model,Model,
Moderate Sensitivity,Umerena osetljivost,
Monday,Ponedjeljak,
Monthly,Mjesečno,
Monthly Distribution,Mjesečni Distribucija,
More,Više,
More Information,Više informacija,
More...,Više ...,
Motion Picture & Video,Motion Picture & Video,
Move,Potez,
Move Item,Move Stavka,
Multi Currency,Multi Valuta,
Multiple Item prices.,Više cijene stavke.,
Multiple Loyalty Program found for the Customer. Please select manually.,Višestruki program lojalnosti pronađen za klijenta. Molimo izaberite ručno.,
"Multiple Price Rules exists with same criteria, please resolve conflict by assigning priority. Price Rules: {0}","Više pravila Cijena postoji sa istim kriterijima, molimo vas da riješe sukob dodjelom prioriteta. Cijena pravila: {0}",
Multiple Variants,Višestruke varijante,
Multiple fiscal years exist for the date {0}. Please set company in Fiscal Year,Višestruki fiskalne godine postoje za datum {0}. Molimo podesite kompanije u fiskalnoj godini,
Music,Muzika,
Name error: {0},Ime greška: {0},
Name of new Account. Note: Please don't create accounts for Customers and Suppliers,Ime novog računa. Napomena: Molimo vas da ne stvaraju račune za kupcima i dobavljačima,
Name or Email is mandatory,Ime ili e-obavezno,
Nature Of Supplies,Nature of Supplies,
Navigating,Navigacija,
Needs Analysis,Analiza potreba,
Negative Quantity is not allowed,Negativna količina nije dopuštena,
Negative Valuation Rate is not allowed,Negativna stopa vrijednovanja nije dopuštena,
Negotiation/Review,Pregovaranje / pregled,
Net Asset value as on,Neto vrijednost imovine kao i na,
Net Cash from Financing,Neto gotovine iz aktivnosti finansiranja,
Net Cash from Investing,Neto novčani tok od investicione,
Net Cash from Operations,Neto novčani tok od operacije,
Net Change in Accounts Payable,Neto promjena na računima dobavljača,
Net Change in Accounts Receivable,Neto promjena u Potraživanja,
Net Change in Cash,Neto promjena u gotovini,
Net Change in Equity,Neto promjena u kapitalu,
Net Change in Fixed Asset,Neto promjena u fiksnoj Asset,
Net Change in Inventory,Neto promjena u zalihama,
Net ITC Available(A) - (B),Neto dostupan ITC (A) - (B),
Net Profit,Neto profit,
Net Total,Osnovica,
New Account Name,Naziv novog naloga,
New Address,Nova adresa,
New BOM,Novi BOM,
New Batch ID (Optional),New Batch ID (opcionalno),
New Batch Qty,New Batch Količina,
New Company,Nova firma,
New Cost Center Name,Novi troška Naziv,
New Customer Revenue,New Customer prihoda,
New Customers,Novi Kupci,
New Department,Novo odjeljenje,
New Employee,Novi zaposleni,
New Location,Nova lokacija,
New Quality Procedure,Novi postupak kvaliteta,
New Sales Invoice,Prodaja novih Račun,
New Sales Person Name,Ime prodaja novih 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 postavljen od strane burze upisu ili kupiti primitka,
New Warehouse Name,Novo skladište Ime,
New credit limit is less than current outstanding amount for the customer. Credit limit has to be atleast {0},Novi kreditni limit je manje od trenutne preostali iznos za kupca. Kreditni limit mora biti atleast {0},
New task,Novi zadatak,
New {0} pricing rules are created,Stvorena su nova {0} pravila za cene,
Newspaper Publishers,novinski izdavači,
Next,Sljedeći,
Next Contact By cannot be same as the Lead Email Address,Sljedeća kontaktirati putem ne može biti isti kao Lead-mail adresa,
Next Contact Date cannot be in the past,Sljedeća Kontakt datum ne može biti u prošlosti,
Next Steps,Sljedeći koraci,
No Action,Nema akcije,
No Customers yet!,Ne Kupci još!,
No Data,Nema podataka,
No Delivery Note selected for Customer {},Nije odabrana beleška za isporuku za kupca {},
No Item with Barcode {0},No Stavka s Barcode {0},
No Item with Serial No {0},No Stavka s rednim brojem {0},
No Items available for transfer,Nema stavki za prenos,
No Items selected for transfer,Nije izabrana stavka za prenos,
No Items to pack,Nema stavki za omot,
No Items with Bill of Materials to Manufacture,Nema artikala sa Bill materijala za proizvodnju,
No Items with Bill of Materials.,Nema predmeta s računom materijala.,
No Permission,Bez dozvole,
No Remarks,No Napomene,
No Result to submit,Nije rezultat koji se šalje,
No Student Groups created.,No studentskih grupa stvorio.,
No Students in,No Studenti u,
No Tax Withholding data found for the current Fiscal Year.,Nije pronađen nikakav porezni zadatak za tekuću fiskalnu godinu.,
No Work Orders created,Stvaranje radnih naloga,
No accounting entries for the following warehouses,Nema računovodstvene unosi za sljedeće skladišta,
No contacts with email IDs found.,Nisu pronađeni kontakti sa ID-ima e-pošte.,
No data for this period,Nema podataka za ovaj period,
No description given,Nema opisa dano,
No employees for the mentioned criteria,Nema zaposlenih po navedenim kriterijumima,
No gain or loss in the exchange rate,Nema dobiti ili gubitka kursa,
No items listed,No stavke navedene,
No items to be received are overdue,Nijedna stavka koja se primi ne kasni,
No material request created,Nije napravljen materijalni zahtev,
No of Interactions,Broj interakcija,
No of Shares,Broj akcija,
No pending Material Requests found to link for the given items.,Nema traženih materijala koji su pronađeni za povezivanje za date stavke.,
No products found,Nije pronađen nijedan proizvod,
No products found.,Nema proizvoda.,
No record found,Ne rekord naći,
No records found in the Invoice table,Nisu pronađeni u tablici fakturu,
No records found in the Payment table,Nisu pronađeni u tablici plaćanja,
No tasks,No zadataka,
No time sheets,Nema vremena listova,
No values,Nema vrijednosti,
No {0} found for Inter Company Transactions.,Nije pronađeno {0} za Inter Company Transactions.,
Non GST Inward Supplies,Non GST ulazne potrepštine,
Non Profit,Neprofitne,
Non Profit (beta),Neprofitna (beta),
Non-GST outward supplies,Vanjske zalihe bez GST-a,
Non-Group to Group,Non-grupe do grupe,
None,Ništa,
None of the items have any change in quantity or value.,Nijedan od stavki imaju bilo kakve promjene u količini ili vrijednosti.,
Nos,Nos,
Not Available,Nije dostupno,
Not Marked,neobilježen,
Not Paid and Not Delivered,Ne plaća i ne dostave,
Not Permitted,Ne Dozvoljena,
Not Started,Nije počela,
Not active,Ne aktivna,
Not allow to set alternative item for the item {0},Ne dozvolite postavljanje alternativne stavke za stavku {0},
Not allowed to update stock transactions older than {0},Nije dopušteno osvježavanje burzovnih transakcija stariji od {0},
Not authorized to edit frozen Account {0},Nije ovlašten za uređivanje smrznute račun {0},
Not authroized since {0} exceeds limits,Ne authroized od {0} prelazi granice,
Not permitted for {0},Nije dozvoljeno za {0},
"Not permitted, configure Lab Test Template as required","Nije dopušteno, konfigurirati Lab Test Template po potrebi",
Not permitted. Please disable the Service Unit Type,Nije dozvoljeno. Molim vas isključite Type Service Service Unit,
Note: Due / Reference Date exceeds allowed customer credit days by {0} day(s),Napomena: Zbog / Reference Datum premašuje dozvoljeni dana kreditnu kupca {0} dan (a),
Note: Item {0} entered multiple times,Napomena : Stavka {0} upisan je više puta,
Note: Payment Entry will not be created since 'Cash or Bank Account' was not specified,Napomena : Stupanje Plaćanje neće biti izrađen od ' Gotovina ili bankovni račun ' nije naveden,
Note: System will not check over-delivery and over-booking for Item {0} as quantity or amount is 0,Napomena : Sustav neće provjeravati pretjerano isporuke i više - booking za točku {0} kao količinu ili vrijednost je 0,
Note: There is not enough leave balance for Leave Type {0},Napomena : Nema dovoljno ravnotežu dopust za dozvolu tipa {0},
Note: This Cost Center is a Group. Cannot make accounting entries against groups.,Napomena : Ovaj troška jegrupa . Ne mogu napraviti računovodstvenih unosa protiv skupine .,
Note: {0},Napomena : {0},
Notes,Bilješke,
Nothing is included in gross,Ništa nije uključeno u bruto,
Nothing more to show.,Ništa više pokazati.,
Notify Customers via Email,Obaveštavajte kupce putem e-pošte,
Number,Broj,
Number of Depreciations Booked cannot be greater than Total Number of Depreciations,Broj Amortizacija Booked ne može biti veća od Ukupan broj Amortizacija,
Number of Interaction,Broj Interaction,
Number of Order,Broj Order,
"Number of new Account, it will be included in the account name as a prefix","Broj novog naloga, 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 novih troškovnih centara će biti uključen u naziv troškovnog centra kao prefiks,
Number of root accounts cannot be less than 4,Broj korijenskih računa ne može biti manji od 4,
Odometer,mjerač za pređeni put,
Office Equipments,uredske opreme,
Office Maintenance Expenses,Troškovi održavanja ureda,
Office Rent,najam ureda,
On Hold,Na čekanju,
On Net Total,Na Net Total,
One customer can be part of only single Loyalty Program.,Jedan korisnik može biti deo samo jednog programa lojalnosti.,
Online Auctions,Online aukcije,
"Only the Student Applicant with the status ""Approved"" will be selected in the table below.",Samo studentski kandidat sa statusom &quot;Odobreno&quot; biće izabran u donjoj tabeli.,
Only users with {0} role can register on Marketplace,Samo korisnici sa ulogom {0} mogu se registrovati na tržištu,
Open BOM {0},Otvorena BOM {0},
Open Item {0},Otvorena Stavka {0},
Open Notifications,Otvorena obavjestenja,
Open Orders,Otvori naloge,
Open a new ticket,Otvorite novu kartu,
Opening,Otvaranje,
Opening (Cr),P.S. (Pot),
Opening (Dr),P.S. (Dug),
Opening Accounting Balance,Otvaranje Računovodstvo Balance,
Opening Accumulated Depreciation,Otvaranje Ispravka vrijednosti,
Opening Accumulated Depreciation must be less than equal to {0},Otvaranje Ispravka vrijednosti mora biti manji od jednak {0},
Opening Balance,Otvaranje bilansa,
Opening Balance Equity,Početno stanje Equity,
Opening Date and Closing Date should be within same Fiscal Year,Datum otvaranja i zatvaranja datum bi trebao biti u istoj fiskalnoj godini,
Opening Date should be before Closing Date,Otvaranje Datum bi trebao biti prije zatvaranja datum,
Opening Entry Journal,Otvaranje časopisa,
Opening Invoice Creation Tool,Otvaranje alata za kreiranje fakture,
Opening Invoice Item,Otvaranje stavke fakture,
Opening Invoices,Otvaranje faktura,
Opening Invoices Summary,Otvaranje rezimea faktura,
Opening Qty,Otvaranje Kol,
Opening Stock,otvaranje Stock,
Opening Stock Balance,Otvaranje Stock Balance,
Opening Value,otvaranje vrijednost,
Opening {0} Invoice created,Otvaranje {0} Stvorena faktura,
Operation,Operacija,
Operation Time must be greater than 0 for Operation {0},Vrijeme rada mora biti veći od 0 za rad {0},
"Operation {0} longer than any available working hours in workstation {1}, break down the operation into multiple operations","Operacija {0} više od bilo koje dostupne radnog vremena u radnu stanicu {1}, razbijaju rad u više operacija",
Operations,Operacije,
Operations cannot be left blank,Operacije se ne može ostati prazno,
Opp Count,Opp Count,
Opp/Lead %,Opp / Lead%,
Opportunities,Prilike,
Opportunities by lead source,Mogućnosti izvora izvora,
Opportunity,Prilika (Opportunity),
Opportunity Amount,Mogućnost Iznos,
"Optional. Sets company's default currency, if not specified.","Opcionalno. Postavlja kompanije Zadana valuta, ako nije navedeno.",
Optional. This setting will be used to filter in various transactions.,Izborni . Ova postavka će se koristiti za filtriranje u raznim transakcijama .,
Options,Opcije,
Order Count,kako Count,
Order Entry,Unos naloga,
Order Value,Da bi vrijednost,
Order rescheduled for sync,Porudžbina je reprogramirana za sinhronizaciju,
Order/Quot %,Kako / Quot%,
Ordered,Naručeno,
Ordered Qty,Naručena kol,
"Ordered Qty: Quantity ordered for purchase, but not received.","Naručena količina: količina naručena za kupnju, ali nije došla .",
Orders,Narudžbe,
Orders released for production.,Narudžbe objavljen za proizvodnju.,
Organization,Organizacija,
Organization Name,Naziv organizacije,
Other,Drugi,
Other Reports,Ostali izveštaji,
"Other outward supplies(Nil rated,Exempted)","Ostale vanjske zalihe (Nil ocijenjeno, Izuzeti)",
Out Qty,Od kol,
Out Value,out vrijednost,
Out of Order,Ne radi,
Outgoing,Društven,
Outstanding,izvanredan,
Outstanding Amount,Izvanredna Iznos,
Outstanding Amt,Izvanredna Amt,
Outstanding Cheques and Deposits to clear,Izvanredna Čekovi i depoziti očistiti,
Outstanding for {0} cannot be less than zero ({1}),Izvanredna za {0} ne može biti manji od nule ( {1} ),
Outward taxable supplies(zero rated),Potrošačke zalihe koje su oporezovane (nulta ocjena),
Overdue,Istekao,
Overlap in scoring between {0} and {1},Preklapanje u bodovima između {0} i {1},
Overlapping conditions found between:,Preklapanje uvjeti nalaze između :,
Owner,vlasnik,
PAN,PAN,
POS,POS,
POS Profile,POS profil,
POS Profile is required to use Point-of-Sale,POS profil je potreban za korištenje Point-of-Sale,
POS Profile required to make POS Entry,POS Profil potrebno da bi POS upis,
POS Settings,POS Settings,
Packed quantity must equal quantity for Item {0} in row {1},Prepuna količina mora biti jednaka količina za točku {0} je u redu {1},
Packing Slip,Odreskom,
Packing Slip(s) cancelled,Pakiranje proklizavanja ( s) otkazan,
Paid,Plaćen,
Paid Amount,Plaćeni iznos,
Paid Amount cannot be greater than total negative outstanding amount {0},Uplaćeni iznos ne može biti veći od ukupnog broja negativnih preostali iznos {0},
Paid amount + Write Off Amount can not be greater than Grand Total,Uplaćeni iznos + otpis iznos ne može biti veći od SVEUKUPNO,
Paid and Not Delivered,Platio i nije dostavila,
Parameter,Parametar,
Parent Item {0} must not be a Stock Item,Roditelj Stavka {0} ne smije biti Stock Item,
Parents Teacher Meeting Attendance,Prisustvo sastanaka učitelja roditelja,
Partially Depreciated,Djelomično oslabio,
Partially Received,Djelomično primljeno,
Party,Stranka,
Party Name,Party ime,
Party Type,Party Tip,
Party Type and Party is mandatory for {0} account,Party Party i Party je obavezan za {0} nalog,
Party Type is mandatory,Party Tip je obavezno,
Party is mandatory,Party je obavezno,
Past Due Date,Datum prošlosti,
Patient,Pacijent,
Patient Appointment,Imenovanje pacijenta,
Patient Encounter,Patient Encounter,
Patient not found,Pacijent nije pronađen,
Pay Remaining,Plati preostalo,
Pay {0} {1},Plaćajte {0} {1},
Payable,Plativ,
Payable Account,Račun se plaća,
Payment,Plaćanje,
Payment Cancelled. Please check your GoCardless Account for more details,Plaćanje je otkazano. Molimo provjerite svoj GoCardless račun za više detalja,
Payment Confirmation,Potvrda o plaćanju,
Payment Document,plaćanje Document,
Payment Due Date,Plaćanje Due Date,
Payment Entries {0} are un-linked,Plaćanje Unosi {0} su un-povezani,
Payment Entry,plaćanje Entry,
Payment Entry already exists,Plaćanje Entry već postoji,
Payment Entry has been modified after you pulled it. Please pull it again.,Plaćanje Entry je izmijenjena nakon što ste ga izvukao. Molimo vas da se ponovo povucite.,
Payment Entry is already created,Plaćanje Ulaz je već stvorena,
Payment Failed. Please check your GoCardless Account for more details,Plaćanje nije uspelo. Molimo provjerite svoj GoCardless račun za više detalja,
Payment Gateway,Payment Gateway,
"Payment Gateway Account not created, please create one manually.","Payment Gateway računa kreiranu, molimo vas da napravite ručno.",
Payment Gateway Name,Naziv Gateway Gateway-a,
Payment Mode,Način plaćanja,
Payment Receipt Note,Plaćanje potvrda o primitku,
Payment Request,Plaćanje Upit,
Payment Request for {0},Zahtjev za plaćanje za {0},
Payment Tems,Temovi plaćanja,
Payment Term,Rok plaćanja,
Payment Terms,Uslovi plaćanja,
Payment Terms Template,Šablon izraza plaćanja,
Payment Terms based on conditions,Uslovi plaćanja na osnovu uslova,
Payment Type,Vrsta plaćanja,
"Payment Type must be one of Receive, Pay and Internal Transfer","Plaćanje Tip mora biti jedan od Primi, Pay i unutrašnje Transfer",
Payment against {0} {1} cannot be greater than Outstanding Amount {2},Plaćanje protiv {0} {1} ne može biti veći od preostalog iznosa {2},
Payment request {0} created,Zahtev za plaćanje {0} kreiran,
Payments,Plaćanja,
Payroll Payable,Payroll plaćaju,
Payslip,Payslip,
Pending Activities,Aktivnosti na čekanju,
Pending Amount,Iznos na čekanju,
Pending Leaves,Pending Leaves,
Pending Qty,U očekivanju Količina,
Pending Quantity,Količina na čekanju,
Pending Review,Na čekanju,
Pending activities for today,Aktivnostima na čekanju za danas,
Pension Funds,mirovinskim fondovima,
Percentage Allocation should be equal to 100%,Postotak izdvajanja trebala bi biti jednaka 100 %,
Perception Analysis,Analiza percepcije,
Period,Period,
Period Closing Entry,Period zatvaranja Entry,
Period Closing Voucher,Razdoblje Zatvaranje bon,
Periodicity,Periodičnost,
Personal Details,Osobni podaci,
Pharmaceutical,farmaceutski,
Pharmaceuticals,Lijekovi,
Physician,Lekar,
Place Of Supply (State/UT),Mjesto ponude (država / UT),
Place Order,Place Order,
Plan Name,Ime plana,
Plan for maintenance visits.,Plan održavanja posjeta.,
Planned Qty,Planirani Kol,
"Planned Qty: Quantity, for which, Work Order has been raised, but is pending to be manufactured.","Količina planiranih količina: Količina za koju je radni nalog povećan, ali čeka se izrada.",
Planning,Planiranje,
Plants and Machineries,Biljke i Machineries,
Please Set Supplier Group in Buying Settings.,Molim postavite grupu dobavljača u Podešavanja kupovine.,
Please add a Temporary Opening account in Chart of Accounts,Molimo da dodate račun za privremeni otvaranje na kontnom planu,
Please add the account to root level Company - ,Dodajte račun na korijensku razinu Kompanija -,
Please check Multi Currency option to allow accounts with other currency,Molimo provjerite Multi opciju valuta kako bi se omogućilo račune sa drugoj valuti,
Please click on 'Generate Schedule',"Molimo kliknite na ""Generiraj raspored '",
Please click on 'Generate Schedule' to fetch Serial No added for Item {0},"Molimo kliknite na ""Generiraj raspored ' dohvatiti Serial No dodao je za točku {0}",
Please click on 'Generate Schedule' to get schedule,"Molimo kliknite na ""Generiraj raspored ' kako bi dobili raspored",
Please create purchase receipt or purchase invoice for the item {0},Molimo vas da kreirate račun za kupovinu ili kupite fakturu za stavku {0},
Please define grade for Threshold 0%,Molimo vas da definirati razred za Threshold 0%,
Please enable Applicable on Booking Actual Expenses,Molimo omogućite stvarne troškove koji se primjenjuju na osnovu rezervisanja,
Please enable Applicable on Purchase Order and Applicable on Booking Actual Expenses,Molimo omogućite primenljivu na nalogu za kupovinu i primenljivu na trenutnim troškovima rezervacije,
Please enable pop-ups,Molimo omogućite pop-up prozora,
Please enter 'Is Subcontracted' as Yes or No,Unesite ' Je podugovoren ' kao da ili ne,
Please enter API Consumer Key,Molimo unesite API korisnički ključ,
Please enter API Consumer Secret,Molimo unesite API Potrošačku tajnu,
Please enter Account for Change Amount,Unesite račun za promjene Iznos,
Please enter Approving Role or Approving User,Unesite Odobravanje ulogu ili Odobravanje korisnike,
Please enter Cost Center,Unesite troška,
Please enter Delivery Date,Molimo unesite datum isporuke,
Please enter Employee Id of this sales person,Unesite zaposlenih Id ove prodaje osoba,
Please enter Expense Account,Unesite trošak računa,
Please enter Item Code to get Batch Number,Unesite Šifra da Batch Broj,
Please enter Item Code to get batch no,Unesite kod Predmeta da se hrpa nema,
Please enter Item first,Unesite predmeta prvi,
Please enter Maintaince Details first,Unesite prva Maintaince Detalji,
Please enter Planned Qty for Item {0} at row {1},Unesite Planirano Qty za točku {0} na redu {1},
Please enter Preferred Contact Email,Unesite Preferred Kontakt mail,
Please enter Production Item first,Unesite Proizvodnja predmeta prvi,
Please enter Purchase Receipt first,Molimo prvo unesite Kupovina prijem,
Please enter Receipt Document,Unesite dokument o prijemu,
Please enter Reference date,Unesite referentni datum,
Please enter Reqd by Date,Molimo unesite Reqd po datumu,
Please enter Woocommerce Server URL,Molimo unesite URL adresu Woocommerce Servera,
Please enter Write Off Account,Unesite otpis račun,
Please enter atleast 1 invoice in the table,Unesite atleast jedan račun u tablici,
Please enter company first,Unesite tvrtka prva,
Please enter company name first,Unesite ime tvrtke prvi,
Please enter default currency in Company Master,Unesite zadanu valutu u tvrtki Master,
Please enter message before sending,Unesite poruku prije slanja,
Please enter parent cost center,Unesite roditelj troška,
Please enter quantity for Item {0},Molimo unesite količinu za točku {0},
Please enter relieving date.,Unesite olakšavanja datum .,
Please enter valid Financial Year Start and End Dates,Molimo vas da unesete važeću finansijsku godinu datume početka i završetka,
Please enter valid email address,Molimo vas da unesete važeću e-mail adresu,
Please enter {0} first,Unesite {0} prvi,
Please fill in all the details to generate Assessment Result.,Molimo vas da popunite sve detalje da biste ostvarili rezultat procjene.,
Please identify/create Account (Group) for type - {0},Molimo identificirajte / kreirajte račun (grupu) za tip - {0},
Please identify/create Account (Ledger) for type - {0},Molimo identificirajte / kreirajte račun (knjigu) za vrstu - {0},
Please login as another user to register on Marketplace,Molimo prijavite se kao drugi korisnik da se registrujete na Marketplace,
Please make sure you really want to delete all the transactions for this company. Your master data will remain as it is. This action cannot be undone.,Molimo Vas da proverite da li ste zaista želite izbrisati sve transakcije za ovu kompaniju. Tvoj gospodar podaci će ostati kao što je to. Ova akcija se ne može poništiti.,
Please mention Basic and HRA component in Company,Molimo navedite komponentu Basic i HRA u kompaniji,
Please mention Round Off Account in Company,Navedite zaokružimo računa u Company,
Please mention Round Off Cost Center in Company,Navedite zaokružimo troškova centar u Company,
Please mention no of visits required,Molimo spomenuti nema posjeta potrebnih,
Please mention the Lead Name in Lead {0},Molim vas da navedete Lead Lead u Lead-u {0},
Please pull items from Delivery Note,Molimo povucite stavke iz Dostavnica,
Please register the SIREN number in the company information file,Molimo registrirajte broj SIREN-a u informacijskoj datoteci kompanije,
Please remove this Invoice {0} from C-Form {1},Molimo vas da uklonite ovu fakture {0} iz C-Form {1},
Please save the patient first,Molim vas prvo sačuvajte pacijenta,
Please save the report again to rebuild or update,Spremite izvještaj ponovo da biste ga ponovo izgradili ili ažurirali,
"Please select Allocated Amount, Invoice Type and Invoice Number in atleast one row","Molimo odaberite Izdvojena količina, vrsta fakture i fakture Broj u atleast jednom redu",
Please select Apply Discount On,Molimo odaberite Apply popusta na,
Please select BOM against item {0},Izaberite BOM protiv stavke {0},
Please select BOM for Item in Row {0},Molimo odaberite BOM za Stavka zaredom {0},
Please select BOM in BOM field for Item {0},Molimo odaberite BOM BOM u polje za Stavka {0},
Please select Category first,Molimo odaberite kategoriju prvi,
Please select Charge Type first,Odaberite Naknada za prvi,
Please select Company,Molimo odaberite Company,
Please select Company and Posting Date to getting entries,Molimo da odaberete Kompaniju i Datum objavljivanja da biste dobili unose,
Please select Company first,Molimo najprije odaberite Company,
Please select Completion Date for Completed Asset Maintenance Log,Molimo izaberite Datum završetka za popunjeni dnevnik održavanja sredstava,
Please select Completion Date for Completed Repair,Molimo izaberite Datum završetka za završeno popravljanje,
Please select Course,Molimo odaberite predmeta,
Please select Drug,Molimo izaberite Lijek,
Please select Existing Company for creating Chart of Accounts,Molimo odaberite postojećeg društva za stvaranje Kontni plan,
Please select Healthcare Service,Molimo odaberite Zdravstvenu službu,
"Please select Item where ""Is Stock Item"" is ""No"" and ""Is Sales Item"" is ""Yes"" and there is no other Product Bundle","Molimo odaberite Stavka u kojoj &quot;Je Stock Stavka&quot; je &quot;ne&quot; i &quot;Da li je prodaja Stavka&quot; je &quot;Da&quot;, a nema drugog Bundle proizvoda",
Please select Maintenance Status as Completed or remove Completion Date,Izaberite stanje održavanja kao završeno ili uklonite datum završetka,
Please select Party Type first,Molimo prvo odaberite Party Tip,
Please select Patient,Molimo izaberite Pacijent,
Please select Patient to get Lab Tests,Izaberite Pacijent da biste dobili laboratorijske testove,
Please select Posting Date before selecting Party,Molimo odaberite Datum knjiženja prije izbora stranke,
Please select Posting Date first,Molimo najprije odaberite Datum knjiženja,
Please select Price List,Molimo odaberite Cjenik,
Please select Program,Molimo odaberite Program,
Please select Qty against item {0},Molimo izaberite Qty protiv stavke {0},
Please select Sample Retention Warehouse in Stock Settings first,Prvo izaberite skladište za zadržavanje uzorka u postavkama zaliha,
Please select Start Date and End Date for Item {0},Molimo odaberite datum početka i datum završetka za točke {0},
Please select Student Admission which is mandatory for the paid student applicant,Molimo izaberite Studentski prijem koji je obavezan za učeniku koji je platio,
Please select a BOM,Izaberite BOM,
Please select a Batch for Item {0}. Unable to find a single batch that fulfills this requirement,Molimo odaberite serijom za Stavka {0}. Nije moguće pronaći jednu seriju koja ispunjava ovaj zahtjev,
Please select a Company,Molimo odaberite poduzeća,
Please select a batch,Molimo odaberite serije,
Please select a field to edit from numpad,Molimo izaberite polje za uređivanje iz numpad-a,
Please select a table,Izaberite tabelu,
Please select a valid Date,Izaberite važeći datum,
Please select a value for {0} quotation_to {1},Molimo odabir vrijednosti za {0} quotation_to {1},
Please select a warehouse,Molimo odaberite skladište,
Please select at least one domain.,Izaberite najmanje jedan domen.,
Please select correct account,Molimo odaberite ispravan račun,
Please select date,Molimo izaberite datum,
Please select item code,Odaberite Šifra,
Please select month and year,Molimo odaberite mjesec i godinu,
Please select the Company,Izaberite kompaniju,
Please select the Multiple Tier Program type for more than one collection rules.,Molimo da izaberete tip višestrukog programa za više pravila kolekcije.,
Please select the assessment group other than 'All Assessment Groups',"Molimo odaberite grupu procjene, osim &#39;Svi Procjena grupe&#39;",
Please select the document type first,Molimo odaberite vrstu dokumenta prvi,
Please select weekly off day,Odaberite tjednik off dan,
Please select {0},Odaberite {0},
Please select {0} first,Odaberite {0} Prvi,
Please set 'Apply Additional Discount On',Molimo podesite &#39;primijeniti dodatne popusta na&#39;,
Please set 'Asset Depreciation Cost Center' in Company {0},Molimo podesite &#39;Asset Amortizacija troškova Center&#39; u kompaniji {0},
Please set 'Gain/Loss Account on Asset Disposal' in Company {0},Molimo podesite &#39;dobitak / gubitak računa na Asset Odlaganje&#39; u kompaniji {0},
Please set Account in Warehouse {0} or Default Inventory Account in Company {1},Molimo da postavite nalog u skladištu {0} ili podrazumevani račun inventara u kompaniji {1},
Please set B2C Limit in GST Settings.,Molimo postavite B2C Limit u GST Settings.,
Please set Company,Molimo podesite Company,
Please set Company filter blank if Group By is 'Company',Molimo podesite Company filter prazno ako Skupina Od je &#39;Company&#39;,
Please set Default Payroll Payable Account in Company {0},Molimo podesite Uobičajeno plaće plaćaju račun poduzeća {0},
Please set Depreciation related Accounts in Asset Category {0} or Company {1},Molimo podesite Računi se odnose amortizacije u Asset Kategorija {0} ili kompanije {1},
Please set GST Accounts in GST Settings,Molimo postavite GST račune u GST podešavanjima,
Please set Hotel Room Rate on {},Molimo podesite Hotel Room Rate na {},
Please set Number of Depreciations Booked,Molimo podesite Broj Amortizacija Booked,
Please set Unrealized Exchange Gain/Loss Account in Company {0},Molimo da unesete Nerealizovani Exchange Gain / Loss Account u kompaniji {0},
Please set User ID field in an Employee record to set Employee Role,Molimo postavite korisniku ID polja u rekord zaposlenog da postavite uloga zaposlenih,
Please set a default Holiday List for Employee {0} or Company {1},Molimo podesite default odmor Lista za zaposlenog {0} ili kompanije {1},
Please set account in Warehouse {0},Molimo postavite nalog u skladištu {0},
Please set an active menu for Restaurant {0},Molimo aktivirajte meni za restoran {0},
Please set associated account in Tax Withholding Category {0} against Company {1},Molimo da podesite pridruženi račun u Kategorija za odbijanje poreza {0} protiv Kompanije {1},
Please set at least one row in the Taxes and Charges Table,Molimo postavite najmanje jedan red u tablici poreza i naknada,
Please set default Cash or Bank account in Mode of Payment {0},Molimo postavite zadanu gotovinom ili banka računa u načinu plaćanja {0},
Please set default account in Salary Component {0},Molimo podesite zadani račun u Plaća Komponenta {0},
Please set default customer in Restaurant Settings,Podesite podrazumevani kupac u podešavanjima restorana,
Please set default {0} in Company {1},Molimo podesite default {0} u kompaniji {1},
Please set filter based on Item or Warehouse,Molimo podesite filter na osnovu Item ili Skladište,
Please set leave policy for employee {0} in Employee / Grade record,Molimo navedite politiku odlaska za zaposlenog {0} u Zapisniku zaposlenih / razreda,
Please set recurring after saving,Molimo podesite ponavljaju nakon spremanja,
Please set the Customer Address,Molimo postavite adresu kupca,
Please set the Default Cost Center in {0} company.,Molimo da podesite Centar za podrazumevane troškove u kompaniji {0}.,
Please set the Email ID for the Student to send the Payment Request,Molimo da podesite Email ID za Student da pošaljete Zahtev za plaćanje,
Please set the Item Code first,Molimo prvo postavite kod za stavku,
Please set the Payment Schedule,Molimo postavite Raspored plaćanja,
Please set {0} for address {1},Molimo vas podesite {0} za adresu {1},
Please setup Students under Student Groups,Molimo da podesite studente pod studentskim grupama,
Please specify Company,Navedite tvrtke,
Please specify Company to proceed,Navedite Tvrtka postupiti,
Please specify a valid 'From Case No.',Navedite važeću &#39;iz Predmet br&#39;,
Please specify a valid Row ID for row {0} in table {1},Molimo navedite važeću Row ID za redom {0} {1} u tabeli,
Please specify at least one attribute in the Attributes table,Molimo navedite barem jedan atribut atribute tabeli,
Please specify currency in Company,Navedite valuta u Company,
Please specify either Quantity or Valuation Rate or both,Navedite ili količini ili vrednovanja Ocijenite ili oboje,
Please specify from/to range,Molimo navedite iz / u rasponu,
Please supply the specified items at the best possible rates,Molimo vas da dostavite navedene stavke na najbolji mogući stope,
Please wait 3 days before resending the reminder.,Molim vas sačekajte 3 dana pre ponovnog podnošenja podsetnika.,
Point of Sale,Point of Sale,
Point-of-Sale,Point-of-prodaju,
Point-of-Sale Profile,Point-of-prodaju profil,
Portal,Portal,
Possible Supplier,moguće dobavljač,
Postal Expenses,Poštanski troškovi,
Posting Date,Objavljivanje Datum,
Posting Date cannot be future date,Datum knjiženja ne može biti u budućnosti,
Posting Time,Objavljivanje Vrijeme,
Posting date and posting time is mandatory,Datum knjiženja i knjiženje vrijeme je obvezna,
Posting timestamp must be after {0},Objavljivanje timestamp mora biti poslije {0},
Potential opportunities for selling.,Potencijalne prilike za prodaju.,
Practitioner Schedule,Raspored lekara,
Pre Sales,Pre Sales,
Preference,Prednost,
Prescribed Procedures,Propisane procedure,
Prescription,Prescription,
Prescription Dosage,Dosage na recept,
Prescription Duration,Trajanje recepta,
Prescriptions,Prescriptions,
Prev,Prev,
Preview,Pregled,
Previous Financial Year is not closed,Prethodne finansijske godine nije zatvoren,
Price,Cijena,
Price List,Cjenik,
Price List Currency not selected,Cjenik valuta ne bira,
Price List Rate,Cjenik Stopa,
Price List master.,Cjenik majstor .,
Price List must be applicable for Buying or Selling,Cjenik mora biti primjenjiv za kupnju ili prodaju,
Price List {0} is disabled or does not exist,Popis Cijena {0} je isključena ili ne postoji,
Price or product discount slabs are required,Obavezne su ploče sa cijenama ili popustima na proizvode,
Pricing,Cijene,
Pricing Rule,cijene Pravilo,
"Pricing Rule is first selected based on 'Apply On' field, which can be Item, Item Group or Brand.","Cijene Pravilo prvo se bira na temelju 'Nanesite na' terenu, koji može biti točka, točka Grupa ili Brand.",
"Pricing Rule is made to overwrite Price List / define discount percentage, based on some criteria.","Cijene Pravilo je napravljen prebrisati Cjenik / definirati postotak popusta, na temelju nekih kriterija.",
Pricing Rule {0} is updated,Pravilo cijene {0} se ažurira,
Pricing Rules are further filtered based on quantity.,Pravilnik o određivanju cijena dodatno se filtrira na temelju količine.,
Primary Address Details,Primarne adrese,
Primary Contact Details,Primarni kontakt podaci,
Print Format,Format ispisa,
Print IRS 1099 Forms,Ispiši obrasce IRS 1099,
Print Report Card,Štampaj izveštaj karticu,
Print Settings,Postavke ispisa,
Print and Stationery,Print i pribora,
Print settings updated in respective print format,podešavanja print ažuriran u odgovarajućim formatu print,
Print taxes with zero amount,Odštampajte poreze sa nultim iznosom,
Printing and Branding,Tiskanje i brendiranje,
Private Equity,Private Equity,
Procedure,Procedura,
Process Day Book Data,Obradi podatke o dnevnoj knjizi,
Process Master Data,Obradu glavnih podataka,
Processing Chart of Accounts and Parties,Obrada kontnog plana i stranaka,
Processing Items and UOMs,Obrada predmeta i UOM-ova,
Processing Party Addresses,Obrada stranačkih adresa,
Processing Vouchers,Obrada vaučera,
Procurement,Nabavka,
Produced Qty,Proizveden količina,
Product,Proizvod,
Product Bundle,Bundle proizvoda,
Product Search,Traži proizvod,
Production,Proizvodnja,
Production Item,Proizvodnja Item,
Products,Proizvodi,
Profit and Loss,Račun dobiti i gubitka,
Profit for the year,Dobit za godinu,
Program,Program,
Program in the Fee Structure and Student Group {0} are different.,Program u strukturi naknada i studentskoj grupi {0} 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 više od 100.,
Project Collaboration Invitation,Projekt Collaboration Poziv,
Project Id,Id projekta,
Project Manager,Menadzer projekata,
Project Name,Naziv projekta,
Project Start Date,Datum početka projekta,
Project Status,Status projekta,
Project Summary for {0},Rezime projekta za {0},
Project Update.,Ažuriranje projekta.,
Project Value,Vrijednost projekta,
Project activity / task.,Projektna aktivnost / zadatak.,
Project master.,Direktor Projekata,
Project-wise data is not available for Quotation,Projekat - mudar podaci nisu dostupni za ponudu,
Projected,Projektovan,
Projected Qty,Projected Qty,
Projected Quantity Formula,Projektirana količina količine,
Projects,Projekti,
Proposal Writing,Pisanje prijedlog,
Proposal/Price Quote,Predlog / Cjenik cijene,
Prospecting,Istraživanje,
Provisional Profit / Loss (Credit),Privremeni dobit / gubitak (Credit),
Publications,Publikacije,
Publish Items on Website,Objavite Artikli na sajtu,
Published,Objavljen,
Publishing,objavljivanje,
Purchase,Kupiti,
Purchase Amount,Kupovina Iznos,
Purchase Date,Datum kupovine,
Purchase Invoice,Narudzbine,
Purchase Invoice {0} is already submitted,Kupnja Račun {0} već je podnijela,
Purchase Manager,Kupovina Manager,
Purchase Master Manager,Kupovina Master Manager,
Purchase Order,Narudžbenica,
Purchase Order Amount,Iznos narudžbine,
Purchase Order Amount(Company Currency),Iznos narudžbe (valuta kompanije),
Purchase Order Date,Datum naloga za kupovinu,
Purchase Order Items not received on time,Stavke porudžbine nisu blagovremeno dobijene,
Purchase Order number required for Item {0},Broj narudžbenice kupnje je potreban za artikal {0},
Purchase Order to Payment,Purchase Order na isplatu,
Purchase Order {0} is not submitted,Narudžbenicu {0} nije podnesen,
Purchase Orders are not allowed for {0} due to a scorecard standing of {1}.,Narudžbe za kupovinu nisu dozvoljene za {0} zbog stanja kartice koja se nalazi na {1}.,
Purchase Orders given to Suppliers.,Kupnja naloge koje je dao dobavljače.,
Purchase Price List,Kupoprodajna cijena List,
Purchase Receipt,Račun kupnje,
Purchase Receipt {0} is not submitted,Račun kupnje {0} nije podnesen,
Purchase Tax Template,Porez na promet Template,
Purchase User,Kupovina korisnika,
Purchase orders help you plan and follow up on your purchases,Narudžbenice vam pomoći planirati i pratiti na kupovinu,
Purchasing,Nabava,
Purpose must be one of {0},Svrha mora biti jedan od {0},
Qty,Kol,
Qty To Manufacture,Količina za proizvodnju,
Qty Total,Količina Ukupno,
Qty for {0},Količina za {0},
Qualification,Kvalifikacija,
Quality,Kvalitet,
Quality Action,Kvalitetna akcija,
Quality Goal.,Cilj kvaliteta.,
Quality Inspection,Provjera kvalitete,
Quality Inspection: {0} is not submitted for the item: {1} in row {2},Inspekcija kvaliteta: {0} se ne podnosi za stavku: {1} u redu {2},
Quality Management,upravljanja kvalitetom,
Quality Meeting,Sastanak kvaliteta,
Quality Procedure,Postupak kvaliteta,
Quality Procedure.,Postupak kvaliteta.,
Quality Review,Pregled kvaliteta,
Quantity,Količina,
Quantity for Item {0} must be less than {1},Količina za točku {0} mora biti manji od {1},
Quantity in row {0} ({1}) must be same as manufactured quantity {2},Količina u redu {0} ( {1} ) mora biti isti kao proizvedena količina {2},
Quantity must be less than or equal to {0},Količina mora biti manji ili jednak {0},
Quantity must not be more than {0},Količina ne smije biti više od {0},
Quantity required for Item {0} in row {1},Količina potrebna za točke {0} je u redu {1},
Quantity should be greater than 0,Količina bi trebao biti veći od 0,
Quantity to Make,Količina koju treba napraviti,
Quantity to Manufacture must be greater than 0.,Količina za proizvodnju mora biti veći od 0.,
Quantity to Produce,Količina za proizvodnju,
Quantity to Produce can not be less than Zero,Količina za proizvodnju ne može biti manja od nule,
Query Options,Opcije upita,
Queued for replacing the BOM. It may take a few minutes.,Očekuje se zamena BOM-a. Može potrajati nekoliko minuta.,
Queued for updating latest price in all Bill of Materials. It may take a few minutes.,Očekuje se ažuriranje najnovije cene u svim materijalima. Može potrajati nekoliko minuta.,
Quick Journal Entry,Brzi unos u dnevniku,
Quot Count,Quot Count,
Quot/Lead %,Quot / Lead%,
Quotation,Ponude,
Quotation {0} is cancelled,Ponuda {0} je otkazana,
Quotation {0} not of type {1},Ponuda {0} nije tip {1},
Quotations,Citati,
"Quotations are proposals, bids you have sent to your customers","Citati su prijedlozi, ponude koje ste poslali svojim kupcima",
Quotations received from Suppliers.,Ponude dobijene od dobavljača.,
Quotations: ,Citati:,
Quotes to Leads or Customers.,Ponude za kupce ili potencijalne kupce.,
RFQs are not allowed for {0} due to a scorecard standing of {1},RFQ-ovi nisu dozvoljeni za {0} zbog stanja karte za rezultat {1},
Range,Domet,
Rate,Cijena,
Rate:,Ocijeni:,
Rating,Ocjena,
Raw Material,sirovine,
Raw Materials,Sirovine,
Raw Materials cannot be blank.,Sirovine ne može biti prazan.,
Re-open,Ponovno otvorena,
Read blog,Pročitajte blog,
Read the ERPNext Manual,Pročitajte ERPNext Manual,
Reading Uploaded File,Čitanje preuzete datoteke,
Real Estate,Nekretnine,
Reason For Putting On Hold,Razlog za stavljanje na čekanje,
Reason for Hold,Razlog zadržavanja,
Reason for hold: ,Razlog zadržavanja:,
Receipt,priznanica,
Receipt document must be submitted,mora biti dostavljen dokument o prijemu,
Receivable,Potraživanja,
Receivable Account,Potraživanja račun,
Received,primljen,
Received On,Primljen,
Received Quantity,Primljena količina,
Received Stock Entries,Primljeni unosi na zalihe,
Receiver List is empty. Please create Receiver List,Receiver Lista je prazna . Molimo stvoriti Receiver Popis,
Recipients,Primatelji,
Reconcile,pomiriti,
"Record of all communications of type email, phone, chat, visit, etc.","Snimak svih komunikacija tipa e-mail, telefon, chat, itd",
Records,Zapisi,
Redirect URL,redirect URL,
Ref,Ref.,
Ref Date,Ref: Datum,
Reference,Upućivanje,
Reference #{0} dated {1},Reference # {0} od {1},
Reference Date,Referentni datum,
Reference Doctype must be one of {0},Referentni Doctype mora biti jedan od {0},
Reference Document,referentni dokument,
Reference Document Type,Referentni dokument Tip,
Reference No & Reference Date is required for {0},Reference Nema & Reference Datum je potrebno za {0},
Reference No and Reference Date is mandatory for Bank transaction,Poziv na broj i referentni datum je obavezan za transakcije banke,
Reference No is mandatory if you entered Reference Date,Reference Ne obvezno ako ušao referentnog datuma,
Reference No.,Referentni broj,
Reference Number,Referentni broj,
Reference Type,Referentna Tip,
"Reference: {0}, Item Code: {1} and Customer: {2}","Referenca: {0}, Šifra: {1} i kupaca: {2}",
References,Reference,
Refresh Token,Refresh Token,
Register,Registrujte se,
Rejected,Odbijen,
Related,povezan,
Relation with Guardian1,Odnos sa Guardian1,
Relation with Guardian2,Odnos sa Guardian2,
Release Date,Datum izdavanja,
Reload Linked Analysis,Ponovo učitaj analizu,
Remaining,ostali,
Remaining Balance,Preostali iznos,
Remarks,Primjedbe,
Reminder to update GSTIN Sent,Podsetnik za ažuriranje GSTIN Poslato,
Remove item if charges is not applicable to that item,Uklonite stavku ako naknada nije primjenjiv na tu stavku,
Removed items with no change in quantity or value.,Ukloniti stavke bez promjene u količini ili vrijednosti.,
Reopen,Ponovo otvoriti,
Reorder Level,Ponovno red Level,
Reorder Qty,Ponovno red Qty,
Repeat Customer Revenue,Ponovite Customer prihoda,
Repeat Customers,Ponovite Kupci,
Replace BOM and update latest price in all BOMs,Zamijenite BOM i ažurirajte najnoviju cijenu u svim BOM,
Replied,Odgovorio,
Report,Izvjestaj,
Report Type,Tip izvjestaja,
Report Type is mandatory,Vrsta izvjestaja je obavezna,
Reports,Izvještaji,
Reqd By Date,Reqd Po datumu,
Reqd Qty,Reqd Qty,
Request for Quotation,Zahtjev za ponudu,
Request for Quotations,Zahtjev za ponudu,
Request for Raw Materials,Zahtjev za sirovine,
Request for purchase.,Zahtjev za kupnju.,
Request for quotation.,Upit za ponudu.,
Requested Qty,Traženi Kol,
"Requested Qty: Quantity requested for purchase, but not ordered.","Tražena količina : Količina zatražio za kupnju , ali ne i naređeno .",
Requesting Site,Podnošenje zahtjeva,
Requesting payment against {0} {1} for amount {2},Tražeći isplatu protiv {0} {1} za iznos {2},
Requestor,Podnositelj zahteva,
Required On,Potrebna On,
Required Qty,Potrebna Kol,
Required Quantity,Tražena količina,
Reschedule,Ponovo raspored,
Research,Istraživanje,
Research & Development,istraživanje i razvoj,
Researcher,Istraživač,
Resend Payment Email,Ponovo pošaljite mail plaćanja,
Reserve Warehouse,Rezervni skladište,
Reserved Qty,Rezervirano Kol,
Reserved Qty for Production,Rezervirano Količina za proizvodnju,
Reserved Qty for Production: Raw materials quantity to make manufacturing items.,Količina rezervirane za proizvodnju: Količina sirovina za izradu proizvodnih predmeta.,
"Reserved Qty: Quantity ordered for sale, but not delivered.","Rezervirano Količina : Količina naručiti za prodaju , ali nije dostavljena .",
Reserved Warehouse is mandatory for Item {0} in Raw Materials supplied,Rezervisano 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,Otporno,
Resolve error and upload again.,Rešite grešku i ponovo je prenesite.,
Rest Of The World,Ostatak svijeta,
Restart Subscription,Restart pretplata,
Restaurant,Restoran,
Result Date,Datum rezultata,
Result already Submitted,Rezultat već podnet,
Resume,Nastavi,
Retail,Maloprodaja,
Retail & Wholesale,Trgovina na veliko i,
Retail Operations,Trgovina na malo,
Retained Earnings,Zadržana dobit,
Retention Stock Entry,Zadržavanje zaliha zaliha,
Retention Stock Entry already created or Sample Quantity not provided,Već stvoreni unos zadržavanja zaliha ili količina uzorka nisu obezbeđeni,
Return,Povratak,
Return / Credit Note,Povratak / Credit Note,
Return / Debit Note,Povratak / Debit Napomena,
Returns,povraćaj,
Reverse Journal Entry,Povratni dnevnik,
Review Invitation Sent,Poslato,
Review and Action,Pregled i radnja,
Rooms Booked,Sobe rezervirane,
Root Company,Root Company,
Root Type,korijen Tip,
Root Type is mandatory,Korijen Tip je obvezno,
Root cannot be edited.,Korijen ne može se mijenjati .,
Root cannot have a parent cost center,Korijen ne mogu imati središte troškova roditelj,
Round Off,Zaokružiti,
Rounded Total,Zaokruženi iznos,
Route,ruta,
Row # {0}: ,Row # {0}:,
Row # {0}: Batch No must be same as {1} {2},Row # {0}: serijski br mora biti isti kao {1} {2},
Row # {0}: Cannot return more than {1} for Item {2},Row # {0}: ne mogu vratiti više od {1} {2} za tačka,
Row # {0}: Rate cannot be greater than the rate used in {1} {2},Row # {0}: Rate ne može biti veća od stope koristi u {1} {2},
Row # {0}: Serial No is mandatory,Row # {0}: Serial No je obavezno,
Row # {0}: Serial No {1} does not match with {2} {3},Row # {0}: {1} Serial No ne odgovara {2} {3},
Row #{0} (Payment Table): Amount must be negative,Red # {0} (Tabela za plaćanje): Iznos mora biti negativan,
Row #{0} (Payment Table): Amount must be positive,Red # {0} (Tabela za plaćanje): Iznos mora biti pozitivan,
Row #{0}: Account {1} does not belong to company {2},Red # {0}: Račun {1} ne pripada kompaniji {2},
Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Row # {0}: dodijeljeni iznos ne može biti veći od preostalog iznosa.,
"Row #{0}: Asset {1} cannot be submitted, it is already {2}","Row # {0}: Asset {1} ne može se podnijeti, to je već {2}",
Row #{0}: Cannot set Rate if amount is greater than billed amount for Item {1}.,Red # {0}: Ne može se podesiti Rate ako je iznos veći od fakturisane količine za stavku {1}.,
Row #{0}: Clearance date {1} cannot be before Cheque Date {2},Row # {0}: datum razmak {1} ne može biti prije Ček Datum {2},
Row #{0}: Duplicate entry in References {1} {2},Row # {0}: duplikat unosa 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 pre datuma kupovine naloga,
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,Row # {0}: Journal Entry {1} nema nalog {2} ili već usklađeni protiv drugog vaučer,
Row #{0}: Not allowed to change Supplier as Purchase Order already exists,Row # {0}: Nije dozvoljeno da se promijeniti dobavljača kao narudžbenicu već postoji,
Row #{0}: Please set reorder quantity,Row # {0}: Molimo set Ponovno redj količinu,
Row #{0}: Please specify Serial No for Item {1},Row # {0}: Navedite rednim brojem predmeta za {1},
Row #{0}: Qty increased by 1,Red # {0}: Količina povećana za 1,
Row #{0}: Rate must be same as {1}: {2} ({3} / {4}) ,Row # {0}: Rate moraju biti isti kao {1}: {2} ({3} / {4}),
Row #{0}: Reference Document Type must be one of Expense Claim or Journal Entry,Red # {0}: Referentni tip dokumenta mora biti jedan od potraživanja troškova ili unosa dnevnika,
"Row #{0}: Reference Document Type must be one of Purchase Order, Purchase Invoice or Journal Entry","Row # {0}: Referenca Vrsta dokumenta mora biti jedan od Narudžbenice, fakturi ili Journal Entry",
Row #{0}: Rejected Qty can not be entered in Purchase Return,Row # {0}: Odbijena Količina ne može unijeti u Kupovina Povratak,
Row #{0}: Rejected Warehouse is mandatory against rejected Item {1},Row # {0}: Odbijena Skladište je obavezno protiv odbijen Stavka {1},
Row #{0}: Reqd by Date cannot be before Transaction Date,Red # {0}: Reqd po datumu ne može biti pre datuma transakcije,
Row #{0}: Set Supplier for item {1},Row # {0}: Set dobavljač za stavku {1},
Row #{0}: Status must be {1} for Invoice Discounting {2},Redak broj {0}: Status mora biti {1} za popust fakture {2},
"Row #{0}: The batch {1} has only {2} qty. Please select another batch which has {3} qty available or split the row into multiple rows, to deliver/issue from multiple batches","Row # {0}: Odgovor batch {1} ima samo {2} Količina. Molimo odaberite neku drugu seriju koja ima {3} Količina dostupna ili podijeliti red u više redova, za isporuku / pitanje iz više serija",
Row #{0}: Timings conflicts with row {1},Row # {0}: Timings sukobi s redom {1},
Row #{0}: {1} can not be negative for item {2},Row # {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},No red {0}: Iznos ne može biti veći od čekanju Iznos protiv rashodi potraživanje {1}. Na čekanju iznos je {2},
Row {0} : Operation is required against the raw material item {1},Red {0}: Operacija je neophodna prema elementu sirovine {1},
Row {0}# Item {1} cannot be transferred more than {2} against Purchase Order {3},Red {0} # Stavka {1} ne može se prenijeti više od {2} u odnosu na narudžbenicu {3},
Row {0}: Activity Type is mandatory.,Red {0}: Aktivnost Tip je obavezno.,
Row {0}: Advance against Customer must be credit,Red {0}: Advance protiv Klijent mora biti kredit,
Row {0}: Advance against Supplier must be debit,Red {0}: Advance protiv Dobavljač mora biti debitne,
Row {0}: Allocated amount {1} must be less than or equals to Payment Entry amount {2},Red {0}: Raspoređeni iznos {1} mora biti manji od ili jednak iznos plaćanja Entry {2},
Row {0}: Allocated amount {1} must be less than or equals to invoice outstanding amount {2},Row {0}: {1} Izdvojena iznos mora biti manji od ili jednak naplatiti preostali iznos {2},
Row {0}: An Reorder entry already exists for this warehouse {1},Row {0}: Unos Ponovno red već postoji za to skladište {1},
Row {0}: Bill of Materials not found for the Item {1},Red {0}: Bill materijala nije pronađen za stavku {1},
Row {0}: Conversion Factor is mandatory,Red {0}: pretvorbe Factor je obvezno,
Row {0}: Cost center is required for an item {1},Red {0}: Troškovni centar je potreban za stavku {1},
Row {0}: Credit entry can not be linked with a {1},Row {0}: Kredit stavka ne može se povezati sa {1},
Row {0}: Currency of the BOM #{1} should be equal to the selected currency {2},Red {0}: Valuta sastavnicu # {1} treba da bude jednaka odabrane valute {2},
Row {0}: Debit entry can not be linked with a {1},Row {0}: Debitne stavka ne može se povezati sa {1},
Row {0}: Depreciation Start Date is required,Red {0}: datum početka amortizacije je potreban,
Row {0}: Enter location for the asset item {1},Red {0}: Unesite lokaciju za stavku aktive {1},
Row {0}: Exchange Rate is mandatory,Red {0}: kursa obavezna,
Row {0}: Expected Value After Useful Life must be less than Gross Purchase Amount,Red {0}: Očekivana vrednost nakon korisnog života mora biti manja od iznosa bruto kupovine,
Row {0}: From Time and To Time is mandatory.,Red {0}: Od vremena i do vremena je obavezno.,
Row {0}: From Time and To Time of {1} is overlapping with {2},Red {0}: Od vremena i do vremena od {1} je preklapaju s {2},
Row {0}: From time must be less than to time,Red {0}: S vremena na vrijeme mora biti manje,
Row {0}: Hours value must be greater than zero.,Red {0}: Radno vrijednost mora biti veća od nule.,
Row {0}: Invalid reference {1},Red {0}: Invalid referentni {1},
Row {0}: Party / Account does not match with {1} / {2} in {3} {4},Red {0}: Party / računa ne odgovara {1} / {2} u {3} {4},
Row {0}: Party Type and Party is required for Receivable / Payable account {1},Red {0}: Party Tip i stranka je potreban za potraživanja / računa plaćaju {1},
Row {0}: Payment against Sales/Purchase Order should always be marked as advance,Row {0}: Plaćanje protiv Prodaja / narudžbenice treba uvijek biti označeni kao unaprijed,
Row {0}: Please check 'Is Advance' against Account {1} if this is an advance entry.,"Row {0}: Molimo provjerite 'Je li Advance ""protiv Account {1} ako je to unaprijed unos.",
Row {0}: Please set at Tax Exemption Reason in Sales Taxes and Charges,Red {0}: Podesite razlog oslobađanja od poreza u porezima i naknadama na promet,
Row {0}: Please set the Mode of Payment in Payment Schedule,Red {0}: Molimo postavite Način plaćanja u Rasporedu plaćanja,
Row {0}: Please set the correct code on Mode of Payment {1},Red {0}: Molimo postavite ispravan kod na Način plaćanja {1},
Row {0}: Qty is mandatory,Red {0}: Količina je obvezno,
Row {0}: Quality Inspection rejected for item {1},Red {0}: Odbačena inspekcija kvaliteta za stavku {1},
Row {0}: UOM Conversion Factor is mandatory,Red {0}: UOM Faktor konverzije je obavezno,
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}. Proveli ste {3}.,
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},Row {0}: {1} {2} ne odgovara {3},
Row {0}:Start Date must be before End Date,Red {0} : Datum početka mora biti prije datuma završetka,
Rows with duplicate due dates in other rows were found: {0},Redovi sa dupliciranim datumima u drugim redovima su pronađeni: {0},
Rules for adding shipping costs.,Pravila za dodavanjem troškove prijevoza .,
Rules for applying pricing and discount.,Pravila za primjenu cijene i popust .,
S.O. No.,S.O. Ne.,
SGST Amount,SGST Iznos,
SO Qty,SO Kol,
Safety Stock,Sigurnost Stock,
Salary,Plata,
Salary Slip submitted for period from {0} to {1},Plata za slanje poslata za period od {0} do {1},
Salary Structure must be submitted before submission of Tax Ememption Declaration,Struktura plaće mora se podnijeti prije podnošenja Izjave o porezu,
Sales,Prodaja,
Sales Account,Račun prodaje,
Sales Expenses,Prodajni troškovi,
Sales Funnel,Tok prodaje (Funnel),
Sales Invoice,Faktura prodaje,
Sales Invoice {0} has already been submitted,Prodajni računi {0} su već potvrđeni,
Sales Invoice {0} must be cancelled before cancelling this Sales Order,Prodaja Račun {0} mora biti otkazana prije poništenja ovu prodajnog naloga,
Sales Manager,Sales Manager,
Sales Master Manager,Sales Manager Master,
Sales Order,Narudžbe kupca,
Sales Order Item,Stavka narudžbe kupca,
Sales Order required for Item {0},Prodajnog naloga potrebna za točke {0},
Sales Order to Payment,Naloga prodaje na isplatu,
Sales Order {0} is not submitted,Prodajnog naloga {0} nije podnesen,
Sales Order {0} is not valid,Prodajnog naloga {0} nije ispravan,
Sales Order {0} is {1},Prodajnog naloga {0} je {1},
Sales Orders,Sales Orders,
Sales Partner,Prodajni partner,
Sales Pipeline,prodaja Pipeline,
Sales Price List,Sales Cjenovnik,
Sales Return,Povrat robe,
Sales Summary,Sažetak prodaje,
Sales Tax Template,Porez na promet Template,
Sales Team,Prodajni tim,
Sales User,Sales korisnika,
Sales and Returns,Prodaja i povratak,
Sales campaigns.,Prodajne kampanje.,
Sales orders are not available for production,Prodajni nalozi nisu dostupni za proizvodnju,
Salutation,Pozdrav,
Same Company is entered more than once,Ista firma je ušao više od jednom,
Same item cannot be entered multiple times.,Isti stavka ne može se upisati više puta.,
Same supplier has been entered multiple times,Istog dobavljača je ušao više puta,
Sample Collection,Prikupljanje uzoraka,
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,sankcionisani,
Sand,Pesak,
Saturday,Subota,
Saving {0},Čuvanje {0},
Scan Barcode,Skenirajte bar kod,
Schedule,Raspored,
Schedule Admission,Raspored prijema,
Schedule Course,Raspored predmeta,
Schedule Date,Raspored Datum,
Schedule Discharge,Raspoređivanje rasporeda,
Scheduled,Planirano,
Scheduled Upto,Planirani Upto,
"Schedules for {0} overlaps, do you want to proceed after skiping overlaped slots ?","Rasporedi za {0} se preklapaju, da li želite da nastavite nakon preskakanja preklapanih slotova?",
Score cannot be greater than Maximum Score,Rezultat ne može biti veća od maksimalne Score,
Scorecards,Scorecards,
Scrapped,odbačen,
Search,Pretraga,
Search Results,Search Results,
Search Sub Assemblies,Traži Sub skupština,
"Search by item code, serial number, batch no or barcode","Pretraga po kodu stavke, serijskom broju, broju serije ili barkodu",
"Seasonality for setting budgets, targets etc.","Sezonski za postavljanje budžeta, ciljeva itd",
Secret Key,tajni ključ,
Secretary,Sekretarica,
Section Code,Kodeks 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 prošla naređenja,
See past quotations,Pogledajte dosadašnje citate,
Select,Odaberi,
Select Alternate Item,Izaberite Alternativnu stavku,
Select Attribute Values,Odaberite vrijednosti atributa,
Select BOM,Izaberite BOM,
Select BOM and Qty for Production,Odaberite BOM i količina za proizvodnju,
"Select BOM, Qty and For Warehouse","Odaberite BOM, Količina i Za skladište",
Select Batch,Izaberite Batch,
Select Batch Numbers,Izaberite šarže,
Select Brand...,Odaberite Marka ...,
Select Company,Izaberite kompaniju,
Select Company...,Odaberite preduzeće...,
Select Customer,Izaberite Kupca,
Select Days,Izaberite Dani,
Select Default Supplier,Izaberite snabdjevač,
Select DocType,Odaberite DocType,
Select Fiscal Year...,Odaberite fiskalnu godinu ...,
Select Item (optional),Izaberite stavku (opcionalno),
Select Items based on Delivery Date,Izaberite stavke na osnovu datuma isporuke,
Select Items to Manufacture,Odaberi stavke za proizvodnju,
Select Loyalty Program,Odaberite Loyalty Program,
Select Patient,Izaberite Pacijent,
Select Possible Supplier,Odaberite Moguće dobavljač,
Select Quantity,Odaberite Količina,
Select Serial Numbers,Odaberite serijski brojevi,
Select Target Warehouse,Odaberite Target Skladište,
Select Warehouse...,Odaberite Warehouse ...,
Select an account to print in account currency,Izaberite nalog za štampanje u valuti računa,
Select at least one value from each of the attributes.,Izaberite najmanje jednu vrijednost od svakog atributa.,
Select change amount account,Izaberite promjene iznos računa,
Select company first,Prvo odaberite kompaniju,
Select students manually for the Activity based Group,Izbor studenata ručno za grupe aktivnosti na osnovu,
Select the customer or supplier.,Izaberite kupca ili dobavljača.,
Select the nature of your business.,Odaberite priroda vašeg poslovanja.,
Select the program first,Prvo izaberite program,
Select to add Serial Number.,Odaberite da dodate serijski broj.,
Select your Domains,Izaberite svoje domene,
Selected Price List should have buying and selling fields checked.,Izabrana cenovna lista treba da ima provereno kupovinu i prodaju.,
Sell,prodati,
Selling,Prodaja,
Selling Amount,Prodaja Iznos,
Selling Price List,Prodajni cjenik,
Selling Rate,Prodajna stopa,
"Selling must be checked, if Applicable For is selected as {0}","Prodaje se mora provjeriti, ako je primjenjivo za odabrano kao {0}",
Send Grant Review Email,Pošaljite e-poruku za Grant Review,
Send Now,Pošalji odmah,
Send SMS,Pošalji SMS,
Send mass SMS to your contacts,Pošalji masovne SMS poruke svojim kontaktima,
Sensitivity,Osjetljivost,
Sent,Poslano,
Serial No and Batch,Serijski broj i Batch,
Serial No is mandatory for Item {0},Serijski Nema je obvezna za točke {0},
Serial No {0} does not belong to Batch {1},Serijski broj {0} ne pripada Batch {1},
Serial No {0} does not belong to Delivery Note {1},Serijski Ne {0} ne pripada isporuke Napomena {1},
Serial No {0} does not belong to Item {1},Serijski Ne {0} ne pripada točki {1},
Serial No {0} does not belong to Warehouse {1},Serijski Ne {0} ne pripada Warehouse {1},
Serial No {0} does not belong to any Warehouse,Serijski broj {0} ne pripada nijednoj Skladište,
Serial No {0} does not exist,Serijski Ne {0} ne postoji,
Serial No {0} has already been received,Serijski Ne {0} već je primila,
Serial No {0} is under maintenance contract upto {1},Serijski Ne {0} je pod ugovorom za održavanje upto {1},
Serial No {0} is under warranty upto {1},Serijski Ne {0} je pod jamstvom upto {1},
Serial No {0} not found,Serial No {0} nije pronađena,
Serial No {0} not in stock,Serijski Ne {0} nije u dioničko,
Serial No {0} quantity {1} cannot be a fraction,Serijski Ne {0} {1} količina ne može bitidio,
Serial Nos Required for Serialized Item {0},Serijski Nos potrebna za serijaliziranom točke {0},
Serial Number: {0} is already referenced in Sales Invoice: {1},Serijski broj: {0} je već spomenut u prodaje Faktura: {1},
Serial Numbers,Serijski brojevi,
Serial Numbers in row {0} does not match with Delivery Note,Serijski brojevi u nizu {0} ne odgovara otpremnica,
Serial no {0} has been already returned,Serijski broj {0} je već vraćen,
Serial number {0} entered more than once,Serijski broj {0} ušao više puta,
Serialized Inventory,Serijalizovanoj zaliha,
Series Updated,Serija Updated,
Series Updated Successfully,Serija Updated uspješno,
Series is mandatory,Serija je obvezno,
Service,Usluga,
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,Servisni datum zaustavljanja ne može biti nakon datuma završetka usluge,
Service Stop Date cannot be before Service Start Date,Servisni datum zaustavljanja ne može biti pre početka usluge,
Services,Usluge,
"Set Default Values like Company, Currency, Current Fiscal Year, etc.","Zadane vrijednosti kao što su tvrtke , valute , tekuće fiskalne godine , itd.",
Set Details,Postavite detalje,
Set New Release Date,Podesite novi datum izdanja,
Set Project and all Tasks to status {0}?,Postavite Project i sve zadatke na status {0}?,
Set Status,Postavite status,
Set Tax Rule for shopping cart,Set poreza Pravilo za košarica,
Set as Closed,Postavi status Zatvoreno,
Set as Completed,Postavite kao dovršeno,
Set as Lost,Postavi kao Lost,
Set as Open,Postavi status Otvoreno,
Set default inventory account for perpetual inventory,Postaviti zadani račun inventar za trajnu inventar,
Set this if the customer is a Public Administration company.,Podesite to ako je kupac kompanija iz javne uprave.,
Set {0} in asset category {1} or company {2},Postavite {0} u kategoriji aktive {1} ili kompaniju {2},
"Setting Events to {0}, since the Employee attached to the below Sales Persons does not have a User ID{1}","Postavljanje Događanja u {0}, jer zaposleni u prilogu ispod prodaje osoba nema korisniku ID {1}",
Setting defaults,Podešavanje podrazumevanih vrednosti,
Setting up Email,Postavljanje e-pošte,
Setting up Email Account,Postavljanje e-pošte,
Setting up Employees,Postavljanje zaposlenih,
Setting up Taxes,Postavljanje poreza,
Setting up company,Osnivanje kompanije,
Settings,Podešavanja,
"Settings for online shopping cart such as shipping rules, price list etc.","Postavke za online kupovinu košaricu poput shipping pravila, cjenik i sl",
Settings for website homepage,Postavke za web stranice homepage,
Settings for website product listing,Podešavanja za popis proizvoda na veb lokaciji,
Settled,Riješeni,
Setup Gateway accounts.,Podešavanje Gateway račune.,
Setup SMS gateway settings,Postavke Setup SMS gateway,
Setup cheque dimensions for printing,dimenzije ček setup za štampanje,
Setup default values for POS Invoices,Podesi podrazumevane vrednosti za POS Račune,
Setup mode of POS (Online / Offline),Način podešavanja POS (Online / Offline),
Setup your Institute in ERPNext,Postavite svoj Institut u ERPNext,
Share Balance,Podeli Balans,
Share Ledger,Share Ledger,
Share Management,Share Management,
Share Transfer,Share Transfer,
Share Type,Tip deljenja,
Shareholder,Akcionar,
Ship To State,Brod u državu,
Shipments,Pošiljke,
Shipping Address,Adresa isporuke,
"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 only applicable for Buying,Pravilo o isporuci primenjivo samo za kupovinu,
Shipping rule only applicable for Selling,Pravilo o isporuci primenjuje se samo za prodaju,
Shopify Supplier,Shopify Supplier,
Shopping Cart,Korpa,
Shopping Cart Settings,Košarica Settings,
Short Name,Kratki naziv,
Shortage Qty,Nedostatak Qty,
Show Completed,Prikaži dovršeno,
Show Cumulative Amount,Prikaži kumulativni iznos,
Show Open,Pokaži otvoren,
Show Opening Entries,Prikaži unose otvaranja,
Show Payment Details,Prikaži podatke o plaćanju,
Show Return Entries,Prikaži povratne unose,
Show Variant Attributes,Prikaži varijante atributa,
Show Variants,Show Varijante,
Show closed,Show zatvoren,
Show exploded view,Pokažite eksplodiran pogled,
Show only POS,Prikaži samo POS,
Show unclosed fiscal year's P&L balances,Pokaži Neriješeni fiskalnu godinu P &amp; L salda,
Show zero values,Pokazati nulte vrijednosti,
Silt,Silt,
Single Variant,Jedinstvena varijanta,
Single unit of an Item.,Jedna jedinica stavku.,
"Skipping Leave Allocation for the following employees, as Leave Allocation records already exists against them. {0}","Preskočite raspodelu raspoređivanja za sledeće zaposlene, jer evidencije o izuzeću već postoje protiv njih. {0}",
Slideshow,Slideshow,
Slots for {0} are not added to the schedule,Slotovi za {0} se ne dodaju u raspored,
Small,Mali,
Soap & Detergent,Sapun i deterdžent,
Software,Software,
Software Developer,Software Developer,
Softwares,softvera,
Soil compositions do not add up to 100,Sastave zemljišta ne daju do 100,
Sold,prodan,
Some emails are invalid,Neki e-mailovi su nevažeći,
Some information is missing,Neke informacije nedostaju,
Something went wrong!,Nešto nije bilo u redu!,
"Sorry, Serial Nos cannot be merged","Žao nam je , Serial Nos ne mogu spojiti",
Source,Izvor,
Source Name,izvor ime,
Source Warehouse,Izvorno skladište,
Source and Target Location cannot be same,Izvor i ciljna lokacija ne mogu biti isti,
Source and target warehouse cannot be same for row {0},Izvor i ciljna skladište ne može biti isti za redom {0},
Source and target warehouse must be different,Izvor i meta skladište mora biti drugačiji,
Source of Funds (Liabilities),Izvor sredstava ( pasiva),
Source warehouse is mandatory for row {0},Izvor skladište je obvezno za redom {0},
Specified BOM {0} does not exist for Item {1},Navedene BOM {0} ne postoji za Stavka {1},
Split,Podijeliti,
Split Batch,Split Batch,
Split Issue,Split Issue,
Sports,sportovi,
Standard Buying,Standardna kupnju,
Standard Selling,Standardna prodaja,
Standard contract terms for Sales or Purchase.,Standardni uvjeti ugovora za prodaju ili kupnju.,
Start Date,Datum početka,
Start Date of Agreement can't be greater than or equal to End Date.,Datum početka ugovora ne može biti veći ili jednak Krajnjem datumu.,
Start Year,Početak godine,
Start date should be less than end date for Item {0},Početak bi trebao biti manji od krajnjeg datuma za točke {0},
Start date should be less than end date for task {0},Datum početka trebalo bi da bude manji od datuma završetka zadatka {0},
Start day is greater than end day in task '{0}',Dan početka je veći od kraja dana u zadatku &#39;{0}&#39;,
Start on,Počnite,
State,State,
State/UT Tax,Porez na države i UT,
Statement of Account,Izjava o računu,
Status must be one of {0},Status mora biti jedan od {0},
Stock,Zaliha,
Stock Adjustment,Stock Podešavanje,
Stock Analytics,Stock Analytics,
Stock Assets,dionicama u vrijednosti,
Stock Available,Stock Available,
Stock Balance,Kataloški bilanca,
Stock Entries already created for Work Order ,Upis zaliha već je kreiran za radni nalog,
Stock Entry,Kataloški Stupanje,
Stock Entry {0} created,Stock Entry {0} stvorio,
Stock Entry {0} is not submitted,Stock upis {0} nije podnesen,
Stock Expenses,Stock Troškovi,
Stock In Hand,Stock u ruci,
Stock Items,Stock Predmeti,
Stock Ledger,Stock Ledger,
Stock Ledger Entries and GL Entries are reposted for the selected Purchase Receipts,Stock Ledger unosi i GL unosi se ponovo postavila za odabrane Kupovina Primici,
Stock Levels,Stock Nivoi,
Stock Liabilities,Stock Obveze,
Stock Qty,zalihama Količina,
Stock Received But Not Billed,Stock primljeni Ali ne Naplaćeno,
Stock Reports,Stock Izvještaji,
Stock Summary,Stock Pregled,
Stock Transactions,Stock Transakcije,
Stock UOM,Kataloški UOM,
Stock Value,Stock vrijednost,
Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},Stock balans u Batch {0} će postati negativan {1} {2} za tačka na skladištu {3},
Stock cannot be updated against Delivery Note {0},Dionica ne može biti obnovljeno protiv isporuke Napomena {0},
Stock cannot be updated against Purchase Receipt {0},Stock se ne može ažurirati protiv kupovine Prijem {0},
Stock cannot exist for Item {0} since has variants,Stock ne može postojati za Stavka {0} od ima varijante,
Stock transactions before {0} are frozen,Stock transakcije prije {0} se zamrznut,
Stop,zaustaviti,
Stopped,Zaustavljen,
"Stopped Work Order cannot be cancelled, Unstop it first to cancel","Prekinuto radno porudžbanje ne može se otkazati, Unstop prvi da otkaže",
Stores,prodavaonice,
Student,Student,
Student Activity,student aktivnost,
Student Address,student adresa,
Student Admissions,student Prijemni,
Student Attendance,student Posjeta,
"Student Batches help you track attendance, assessments and fees for students","Student Paketi pomoći da pratiti prisustvo, procjene i naknade za studente",
Student Email Address,Student-mail adresa,
Student Email ID,Student-mail ID,
Student Group,student Group,
Student Group Strength,Student Group Strength,
Student Group is already updated.,Student Grupa je već ažurirana.,
Student Group: ,Student Grupa:,
Student ID,Student ID,
Student ID: ,Student ID:,
Student LMS Activity,Aktivnost učenika LMS,
Student Mobile No.,Student Mobile No.,
Student Name,Ime studenta,
Student Name: ,Ime studenta:,
Student Report Card,Studentski izveštaj kartica,
Student is already enrolled.,Student je već upisana.,
Student {0} - {1} appears Multiple times in row {2} & {3},Student {0} - {1} pojavljuje više puta u nizu {2} i {3},
Student {0} does not belong to group {1},Student {0} ne pripada grupi {1},
Student {0} exist against student applicant {1},Student {0} postoje protiv podnosioca prijave student {1},
"Students are at the heart of the system, add all your students","Studenti su u srcu sistema, dodajte sve svoje studente",
Sub Assemblies,pod skupštine,
Sub Type,Pod Tip,
Sub-contracting,Podugovaranje,
Subcontract,Podugovor,
Subject,Predmet,
Submit,Potvrdi,
Submit this Work Order for further processing.,Pošaljite ovaj nalog za dalju obradu.,
Subscription,Pretplata,
Subscription Management,Upravljanje pretplatama,
Subscriptions,Pretplate,
Subtotal,suma stavke,
Successful,Uspešno,
Successfully Reconciled,Uspješno Pomirio,
Successfully Set Supplier,Uspešno postavite dobavljača,
Successfully created payment entries,Uspješno su kreirani unosi plaćanja,
Successfully deleted all transactions related to this company!,Uspješno obrisane sve transakcije koje se odnose na ove kompanije!,
Sum of Scores of Assessment Criteria needs to be {0}.,Zbir desetine Kriteriji procjene treba da bude {0}.,
Sum of points for all goals should be 100. It is {0},Zbir bodova za sve ciljeve bi trebao biti 100. To je {0},
Summary,Sažetak,
Summary for this month and pending activities,Sažetak za ovaj mjesec i aktivnostima na čekanju,
Summary for this week and pending activities,Pregled za ovaj tjedan i aktivnostima na čekanju,
Sunday,Nedjelja,
Suplier,Suplier,
Supplier,Dobavljači,
Supplier Group,Grupa dobavljača,
Supplier Group master.,Glavni tim dobavljača.,
Supplier Id,Dobavljač Id,
Supplier Invoice Date cannot be greater than Posting Date,Dobavljač Datum računa ne može biti veći od Datum knjiženja,
Supplier Invoice No,Dobavljač Račun br,
Supplier Invoice No exists in Purchase Invoice {0},Dobavljač Račun ne postoji u fakturi {0},
Supplier Name,Dobavljač Ime,
Supplier Part No,Dobavljač dio br,
Supplier Quotation,Dobavljač Ponuda,
Supplier Scorecard,Scorecard dobavljača,
Supplier Warehouse mandatory for sub-contracted Purchase Receipt,Dobavljač skladišta obvezan je za sub - ugovoreni kupiti primitka,
Supplier database.,Šifarnik dobavljača,
Supplier {0} not found in {1},Dobavljač {0} nije pronađen u {1},
Supplier(s),Dobavljač (s),
Supplies made to UIN holders,Nabavka za držače UIN-a,
Supplies made to Unregistered Persons,Nabavka za neregistrovane osobe,
Suppliies made to Composition Taxable Persons,Isporuke za porezne obveznike na sastav,
Supply Type,Tip isporuke,
Support,Podrška,
Support Analytics,Podrska za Analitiku,
Support Settings,podrška Postavke,
Support Tickets,Podrška ulaznice,
Support queries from customers.,Podrska zahtjeva od strane korisnika,
Susceptible,Podložno,
Sync has been temporarily disabled because maximum retries have been exceeded,Sinhronizacija je privremeno onemogućena jer su prekoračeni maksimalni pokušaji,
Syntax error in condition: {0},Sintaksna greška u stanju: {0},
Syntax error in formula or condition: {0},Sintaksa greška u formuli ili stanja: {0},
System Manager,System Manager,
TDS Rate %,TDS stopa%,
Tap items to add them here,Dodirnite stavke da biste ih dodali ovdje,
Target,Meta,
Target ({}),Cilj ({}),
Target On,Target Na,
Target Warehouse,Ciljana galerija,
Target warehouse is mandatory for row {0},Target skladište je obvezno za redom {0},
Task,Zadatak,
Tasks,zadataka,
Tasks have been created for managing the {0} disease (on row {1}),Zadaci su kreirani za upravljanje {0} bolesti (na redu {1}),
Tax,Porez,
Tax Assets,porezna imovina,
Tax Category,Porezna kategorija,
Tax Category for overriding tax rates.,Porezna kategorija za previsoke porezne stope.,
"Tax Category has been changed to ""Total"" because all the Items are non-stock items","Porez Kategorija je promijenjen u &quot;Total&quot;, jer svi proizvodi bez stanju proizvodi",
Tax ID,Porez ID,
Tax Id: ,Porezni ID:,
Tax Rate,Porezna stopa,
Tax Rule Conflicts with {0},Porez pravilo sukoba sa {0},
Tax Rule for transactions.,Porez pravilo za transakcije.,
Tax Template is mandatory.,Porez Template je obavezno.,
Tax Withholding rates to be applied on transactions.,Poreske stope zadržavanja poreza na transakcije.,
Tax template for buying transactions.,Porezna Predložak za kupnju transakcije .,
Tax template for item tax rates.,Obrazac poreza za porezne stope na stavke.,
Tax template for selling transactions.,Porezna predložak za prodaju transakcije .,
Taxable Amount,Oporezivi iznos,
Taxes,Porezi,
Technology,Tehnologija,
Telecommunications,Telekomunikacije,
Telephone Expenses,Telefonski troškovi,
Television,Televizija,
Template Name,template Name,
Template of terms or contract.,Predložak termina ili ugovor.,
Templates of supplier scorecard criteria.,Šabloni za kriterijume rezultata dobavljača.,
Templates of supplier scorecard variables.,Šabloni varijabli indeksa dobavljača.,
Templates of supplier standings.,Šabloni pozicija dobavljača.,
Temporarily on Hold,Privremeno na čekanju,
Temporary,Privremen,
Temporary Accounts,Privremeni računi,
Temporary Opening,Privremeno otvaranje,
Terms and Conditions,Odredbe i uvjeti,
Terms and Conditions Template,Uvjeti predloška,
Territory,Regija,
Thank you for your business!,Hvala vam za vaše poslovanje!,
The 'From Package No.' field must neither be empty nor it's value less than 1.,&quot;Od paketa br.&quot; polje ne sme biti prazno niti je vrijednost manja od 1.,
The Brand,The Brand,
The Item {0} cannot have Batch,Stavka {0} ne može imati Batch,
The Loyalty Program isn't valid for the selected company,Program lojalnosti ne važi za izabranu kompaniju,
The Payment Term at row {0} is possibly a duplicate.,Rok plaćanja na 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.,Termin Završni datum ne može biti ranije od termina Ozljede Datum. Molimo 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.,Termin Završni datum ne može biti kasnije od kraja godine Datum akademske godine za koji je vezana pojam (akademska godina {}). Molimo 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.,Termin Ozljede Datum ne može biti ranije od godine Početak Datum akademske godine za koji je vezana pojam (akademska godina {}). Molimo 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.,The Year Završni datum ne može biti ranije od godine Ozljede Datum. Molimo 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 na ovaj zahtev za plaćanje razlikuje se od obračunatog iznosa svih planova plaćanja: {1}. Pre nego što pošaljete dokument, proverite da li je to tačno.",
The field From Shareholder cannot be blank,Polje Od 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 akcionara ne mogu biti prazna,
The folio numbers are not matching,Folio brojevi se ne podudaraju,
The holiday on {0} is not between From Date and To Date,Na odmor na {0} nije između Od datuma i Do datuma,
The name of the institute for which you are setting up this system.,U ime Instituta za koju se postavljanje ovog sistema.,
The name of your company for which you are setting up this system.,Ime vaše tvrtke za koje ste postavljanje ovog sustava .,
The number of shares and the share numbers are inconsistent,Broj akcija i brojevi učešća su nedosljedni,
The payment gateway account in plan {0} is different from the payment gateway account in this payment request,Račun plaćačkog plaćanja u planu {0} razlikuje se od naloga za plaćanje u ovom zahtjevu za plaćanje,
The selected BOMs are not for the same item,Izabrani sastavnica nisu za isti predmet,
The selected item cannot have Batch,Izabrana stavka ne može imati Batch,
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 ovoj kompaniji,
The shares already exist,Akcije već postoje,
The shares don't exist with the {0},Akcije 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 zamišljen kao pozadinski posao. U slučaju da u pozadini postoji problem s obradom, sistem će dodati komentar o grešci u ovom usklađivanju dionica i vratiti se u fazu skica",
"Then Pricing Rules are filtered out based on Customer, Customer Group, Territory, Supplier, Supplier Type, Campaign, Sales Partner etc.","Zatim Cjenovna Pravila filtriraju se temelji na Kupca, Kupac Group, Teritorij, dobavljač, proizvođač tip, Kampanja, prodajni partner i sl.",
"There are inconsistencies between the rate, no of shares and the amount calculated","Postoje nedoslednosti između stope, bez dionica i iznosa obračunatog",
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.,Na osnovu ukupne potrošnje može biti više faktora sakupljanja. Ali faktor konverzije za otkup će uvek biti isti za sve nivoe.,
There can only be 1 Account per Company in {0} {1},Tu može biti samo 1 račun po kompanije u {0} {1},
"There can only be one Shipping Rule Condition with 0 or blank value for ""To Value""","Tu može biti samo jedan Dostava Pravilo Stanje sa 0 ili prazni vrijednost za "" Da Value """,
There is not enough leave balance for Leave Type {0},Nema dovoljno ravnotežu dopust za dozvolu tipa {0},
There is nothing to edit.,Ne postoji ništa za uređivanje .,
There isn't any item variant for the selected item,Za izabranu stavku nema nijedne varijante stavki,
"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 GoCardless servera. Ne brinite, u slučaju neuspeha, iznos će vam biti vraćen na vaš račun.",
There were errors creating Course Schedule,Bilo je grešaka u 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,"Ovaj proizvod predložak i ne može se koristiti u transakcijama. Stavka atributi će se kopirati u više varijanti, osim 'Ne Copy ""je postavljena",
This Item is a Variant of {0} (Template).,Ovaj artikal je varijanta {0} (Template).,
This Month's Summary,Ovaj mjesec je sažetak,
This Week's Summary,Ovonedeljnom Pregled,
This action will stop future billing. Are you sure you want to cancel this subscription?,Ova akcija će zaustaviti buduće obračunavanje. Da li ste sigurni da želite otkazati ovu pretplatu?,
This covers all scorecards tied to this Setup,Ovo pokriva sve sisteme rezultata povezanih sa ovim postavkama,
This document is over limit by {0} {1} for item {4}. Are you making another {3} against the same {2}?,Ovaj dokument je preko granice po {0} {1} za stavku {4}. Da li što još {3} u odnosu na isti {2}?,
This is a root account and cannot be edited.,To jekorijen račun i ne može se mijenjati .,
This is a root customer group and cannot be edited.,To jekorijen skupini kupaca i ne može se mijenjati .,
This is a root department and cannot be edited.,Ovo je korijensko odjeljenje i ne može se uređivati.,
This is a root healthcare service unit and cannot be edited.,Ovo je koren zdravstvenog servisa i ne može se uređivati.,
This is a root item group and cannot be edited.,To jekorijen stavka grupa i ne može se mijenjati .,
This is a root sales person and cannot be edited.,To jekorijen prodavač i ne može se mijenjati .,
This is a root supplier group and cannot be edited.,Ovo je korenska grupa dobavljača i ne može se uređivati.,
This is a root territory and cannot be edited.,To jekorijen teritorij i ne može se mijenjati .,
This is an example website auto-generated from ERPNext,Ovo je primjer web stranica automatski generira iz ERPNext,
This is based on logs against this Vehicle. See timeline below for details,Ovo se zasniva na rezanje protiv ovog vozila. Pogledajte vremenski okvir ispod za detalje,
This is based on stock movement. See {0} for details,To se temelji na zalihama pokreta. Vidi {0} za detalje,
This is based on the Time Sheets created against this project,To se temelji na vrijeme listovi stvorio protiv ovog projekta,
This is based on the attendance of this Student,To se temelji na prisustvo ovog Student,
This is based on transactions against this Customer. See timeline below for details,Ovo se zasniva na transakcije protiv ovog kupaca. Pogledajte vremenski okvir ispod za detalje,
This is based on transactions against this Healthcare Practitioner.,Ovo se zasniva na transakcijama protiv ovog zdravstvenog lekara.,
This is based on transactions against this Patient. See timeline below for details,Ovo se zasniva na transakcijama protiv ovog pacijenta. Za detalje pogledajte vremenski okvir ispod,
This is based on transactions against this Sales Person. See timeline below for details,Ovo se zasniva na transakcijama protiv ovog Prodavca. Za detalje pogledajte vremenski okvir ispod,
This is based on transactions against this Supplier. See timeline below for details,Ovo se zasniva na transakcije protiv tog dobavljača. Pogledajte vremenski okvir ispod za detalje,
This {0} conflicts with {1} for {2} {3},Ovo {0} sukobe sa {1} za {2} {3},
Time Sheet for manufacturing.,Time Sheet za proizvodnju.,
Time Tracking,Time Tracking,
"Time slot skiped, the slot {0} to {1} overlap exisiting slot {2} to {3}","Vremenski slot preskočen, slot {0} do {1} se preklapa sa postojećim slotom {2} do {3}",
Time slots added,Dodato je vremenska utrka,
Time(in mins),Time (u min),
Timer,Tajmer,
Timer exceeded the given hours.,Tajmer je prekoračio zadate sate.,
Timesheet,kontrolna kartica,
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","Timesheets pomoći pratiti vremena, troškova i naplate za aktivnostima obavlja svoj tim",
Titles for print templates e.g. Proforma Invoice.,Naslovi za ispis predložaka pr Predračuna.,
To,To,
To Address 1,Za adresu 1,
To Address 2,Na adresu 2,
To Bill,To Bill,
To Date,Za datum,
To Date cannot be before From Date,Do danas ne može biti prije od datuma,
To Date cannot be less than From Date,Datum ne može biti manji od datuma,
To Date must be greater than From Date,Do datuma mora biti veći od Od datuma,
To Date should be within the Fiscal Year. Assuming To Date = {0},Za datum mora biti unutar fiskalne godine. Pod pretpostavkom da bi datum = {0},
To Datetime,To datuma i vremena,
To Deliver,Dostaviti,
To Deliver and Bill,Dostaviti i Bill,
To Fiscal Year,Do fiskalne godine,
To GSTIN,Za GSTIN,
To Party Name,U ime stranke,
To Pin Code,Za PIN kod,
To Place,Da postavim,
To Receive,Da Primite,
To Receive and Bill,Da primi i Bill,
To State,Držati,
To Warehouse,Za skladište,
To create a Payment Request reference document is required,Za kreiranje plaćanja Zahtjev je potrebno referentni dokument,
"To filter based on Party, select Party Type first","Da biste filtrirali na osnovu stranke, izaberite Party prvog tipa",
"To get the best out of ERPNext, we recommend that you take some time and watch these help videos.","Da biste dobili najbolje iz ERPNext, preporučujemo vam da malo vremena i gledati ove snimke pomoć.",
"To include tax in row {0} in Item rate, taxes in rows {1} must also be included","To uključuje porez u redu {0} u stopu točke , porezi u redovima {1} također moraju biti uključeni",
To make Customer based incentive schemes.,Da napravimo šeme podsticajnih zasnovanih na kupcima.,
"To merge, following properties must be same for both items","Spojiti , ova svojstva moraju biti isti za obje stavke",
"To not apply Pricing Rule in a particular transaction, all applicable Pricing Rules should be disabled.","Da se ne primjenjuje pravilo Cijene u određenoj transakciji, svim primjenjivim pravilima cijena bi trebala biti onemogućen.",
"To set this Fiscal Year as Default, click on 'Set as Default'","Za postavljanje ove fiskalne godine kao zadano , kliknite na "" Set as Default '",
To view logs of Loyalty Points assigned to a Customer.,Da biste videli evidencije o Lojalnim Tačkama dodeljenim Korisniku.,
To {0},Za {0},
To {0} | {1} {2},Za {0} | {1} {2},
Toggle Filters,Prebaci filtere,
Too many columns. Export the report and print it using a spreadsheet application.,Previše stupovi. Izvesti izvješće i ispisati pomoću aplikacije za proračunske tablice.,
Tools,Alati,
Total (Credit),Ukupno (kredit),
Total (Without Tax),Ukupno (bez poreza),
Total Achieved,Ukupno Ostvareni,
Total Actual,Ukupno Actual,
Total Amount,Ukupan iznos,
Total Amount Credited,Ukupan iznos kredita,
Total Applicable Charges in Purchase Receipt Items table must be same as Total Taxes and Charges,Ukupno Primjenjivo Optužbe na račun za prodaju Predmeti sto mora biti isti kao Ukupni porezi i naknada,
Total Budget,Ukupni budžet,
Total Collected: {0},Ukupno prikupljeno: {0},
Total Commission,Ukupno komisija,
Total Contribution Amount: {0},Ukupan iznos doprinosa: {0},
Total Credit/ Debit Amount should be same as linked Journal Entry,Ukupan iznos kredita / zaduženja treba da bude isti kao vezani dnevnik,
Total Debit must be equal to Total Credit. The difference is {0},Ukupno zaduženje mora biti jednak ukupnom kreditnom .,
Total Invoiced Amount,Ukupno Iznos dostavnice,
Total Order Considered,Ukupno Order Smatran,
Total Order Value,Ukupna vrijednost Order,
Total Outgoing,Ukupno Odlazni,
Total Outstanding,Total Outstanding,
Total Outstanding Amount,Ukupno preostali iznos,
Total Outstanding: {0},Ukupno izvanredan: {0},
Total Paid Amount,Ukupno uplaćeni iznos,
Total Payment Amount in Payment Schedule must be equal to Grand / Rounded Total,Ukupan iznos plaćanja u rasporedu plaćanja mora biti jednak Grand / zaokruženom ukupno,
Total Payments,Ukupna plaćanja,
Total Qty,Ukupno Qty,
Total Quantity,Ukupna količina,
Total Revenue,Ukupan prihod,
Total Student,Total Student,
Total Target,Ukupna ciljna,
Total Tax,Ukupno porez,
Total Taxable Amount,Ukupan iznos oporezivanja,
Total Taxable Value,Ukupna oporeziva vrednost,
Total Unpaid: {0},Ukupno Neplaćeni: {0},
Total Variance,Ukupno Varijansa,
Total Weightage of all Assessment Criteria must be 100%,Ukupno weightage svih Kriteriji ocjenjivanja mora biti 100%,
Total advance ({0}) against Order {1} cannot be greater than the Grand Total ({2}),Ukupno unaprijed ({0}) protiv Order {1} ne može biti veći od Grand Ukupno ({2}),
Total advance amount cannot be greater than total claimed amount,Ukupan iznos uplate ne može biti veći od ukupne tražene iznose,
Total allocated leaves are more days than maximum allocation of {0} leave type for employee {1} in the period,Ukupno dodijeljeno liste su više dana od maksimalne dodjele tipa {0} za zaposlenog {1} u tom periodu,
Total allocated leaves are more than days in the period,Ukupno izdvojene Listovi su više od nekoliko dana u razdoblju,
Total allocated percentage for sales team should be 100,Ukupno dodijeljeno postotak za prodajni tim bi trebao biti 100,
Total cannot be zero,Ukupna ne može biti nula,
Total contribution percentage should be equal to 100,Ukupni procenat doprinosa treba biti jednak 100,
Total hours: {0},Ukupan broj sati: {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 biste trebali promijeniti &#39;Rasporedite Optužbe na osnovu&#39;",
Total(Amt),Ukupno (Amt),
Total(Qty),Ukupno (Qty),
Traceability,Sljedivost,
Track Leads by Lead Source.,Vodite praćenje po izvorima izvora.,
Transaction,Transakcija,
Transaction Date,Transakcija Datum,
Transaction Type,Tip transakcije,
Transaction currency must be same as Payment Gateway currency,Transakcija valuta mora biti isti kao i Payment Gateway valutu,
Transaction not allowed against stopped Work Order {0},Transakcija nije dozvoljena zaustavljen Radni nalog {0},
Transaction reference no {0} dated {1},Transakcija Ref {0} od {1},
Transactions,Transakcije,
Transactions can only be deleted by the creator of the Company,Transakcije mogu se obrisati samo kreator Društva,
Transfer,Prijenos,
Transfer Material,Prijenos materijala,
Transfer Type,Tip prenosa,
Transfer an asset from one warehouse to another,Transfer imovine iz jednog skladišta u drugo,
Transfered,Prenose,
Transferred Quantity,Prenesena količina,
Transport Receipt Date,Datum prijema prevoza,
Transport Receipt No,Transportni prijem br,
Transportation,Prevoznik,
Transporter ID,ID transportera,
Transporter Name,Transporter Ime,
Travel Expenses,putni troškovi,
Tree Type,Tip stabla,
Tree of Bill of Materials,Drvo Bill of Materials,
Tree of Item Groups.,Tree stavke skupina .,
Tree of Procedures,Drvo postupaka,
Tree of Quality Procedures.,Drvo postupaka kvaliteta.,
Tree of financial Cost Centers.,Tree financijskih troškova centara.,
Tree of financial accounts.,Tree financijskih 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,Krajnji datum probnog perioda ne može biti pre početka probnog perioda,
Trialling,Trialling,
Type of Business,Tip poslovanja,
Types of activities for Time Logs,Vrste aktivnosti za vrijeme Trupci,
UOM,UOM,
UOM Conversion factor is required in row {0},Faktor UOM pretvorbe je potrebno u redu {0},
UOM coversion factor required for UOM: {0} in Item: {1},UOM faktor coversion potrebna za UOM: {0} u točki: {1},
URL,URL,
Unable to find exchange rate for {0} to {1} for key date {2}. Please create a Currency Exchange record manually,Nije moguće pronaći kurs za {0} do {1} za ključni datum {2}. Molimo vas da ručno stvoriti Mjenjačnica rekord,
Unable to find score starting at {0}. You need to have standing scores covering 0 to 100,Nije moguće pronaći rezultat od {0}. Morate imati stojeće rezultate koji pokrivaju 0 do 100,
Unable to find variable: ,Nije moguće pronaći varijablu:,
Unblock Invoice,Unblock Faktura,
Uncheck all,Poništi sve,
Unclosed Fiscal Years Profit / Loss (Credit),Neriješeni fiskalne godine dobit / gubitak (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 ušao više od jednom u konverzije Factor tablici,
Unknown,nepoznat,
Unpaid,Neplaćeno,
Unsecured Loans,unsecured krediti,
Unsubscribe from this Email Digest,Odjavili od ovog mail Digest,
Unsubscribed,Pretplatu,
Until,Do,
Unverified Webhook Data,Neprevereni podaci Webhook-a,
Update Account Name / Number,Ažurirajte ime / broj računa,
Update Account Number / Name,Ažurirajte broj računa / ime,
Update Cost,Update cost,
Update Items,Ažurirati stavke,
Update Print Format,Update Print Format,
Update bank payment dates with journals.,Update banka datum plaćanja s časopisima.,
Update in progress. It might take a while.,Ažuriranje je u toku. Možda će potrajati neko vrijeme.,
Update rate as per last purchase,Stopa ažuriranja po posljednjoj kupovini,
Update stock must be enable for the purchase invoice {0},Ažuriranje zaliha mora biti omogućeno za fakturu za kupovinu {0},
Updating Variants...,Ažuriranje varijanti ...,
Upload your letter head and logo. (you can edit them later).,Unos glavu pismo i logo. (Možete ih kasnije uređivanje).,
Upper Income,Viši Prihodi,
Use Sandbox,Koristite Sandbox,
User,User,
User ID,Korisnički ID,
User ID not set for Employee {0},Korisnik ID nije postavljen za zaposlenika {0},
User Remark,Upute Zabilješka,
User has not applied rule on the invoice {0},Korisnik nije primijenio pravilo na računu {0},
User {0} already exists,Korisnik {0} već postoji,
User {0} created,Korisnik {0} 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. Provjerite Podrazumevano na Rowu {1} za ovog Korisnika.,
User {0} is already assigned to Employee {1},Korisnik {0} već dodijeljena zaposlenika {1},
User {0} is already assigned to Healthcare Practitioner {1},Korisnik {0} je već dodeljen Zdravstvenom lekaru {1},
Users,Korisnici,
Utility Expenses,komunalna Troškovi,
Valid From Date must be lesser than Valid Upto Date.,Važi od datuma mora biti manji od važećeg datuma.,
Valid Till,Valid Till,
Valid from and valid upto fields are mandatory for the cumulative,Vrijedna i valjana upto polja obavezna su za kumulativ,
Valid from date must be less than valid upto date,Vrijedi od datuma mora biti manje od važećeg do datuma,
Valid till date cannot be before transaction date,Vrijedi do datuma ne može biti prije datuma transakcije,
Validity,Punovažnost,
Validity period of this quotation has ended.,Rok važnosti ove ponude je završen.,
Valuation Rate,Vrednovanje Stopa,
Valuation Rate is mandatory if Opening Stock entered,Vrednovanje Rate je obavezno ako ušla Otvaranje Stock,
Valuation type charges can not marked as Inclusive,Prijava tip vrednovanja ne može označiti kao Inclusive,
Value Or Qty,"Vrijednost, ili kol",
Value Proposition,Value Proposition,
Value for Attribute {0} must be within the range of {1} to {2} in the increments of {3} for Item {4},Vrijednost za Atributi {0} mora biti u rasponu od {1} na {2} u koracima od {3} za Stavka {4},
Value must be between {0} and {1},Vrijednost mora biti između {0} i {1},
"Values of exempt, nil rated and non-GST inward supplies","Vrijednosti izuzetih, nulta ocjenjivanja i ulaznih zaliha koje nisu GST",
Variance,Varijacija,
Variance ({}),Varijanca ({}),
Variant,Varijanta,
Variant Attributes,Varijanta atributi,
Variant Based On cannot be changed,Varijanta zasnovana na osnovi se ne može promijeniti,
Variant Details Report,Varijanta Detalji Izveštaj,
Variant creation has been queued.,Kreiranje varijante je stavljeno u red.,
Vehicle Expenses,Troškovi vozila,
Vehicle No,Ne vozila,
Vehicle Type,Tip vozila,
Vehicle/Bus Number,Vozila / Autobus broj,
Venture Capital,Preduzetnički kapital,
View Chart of Accounts,Pregled grafikona računa,
View Fees Records,View Fees Records,
View Form,Pogledajte obrazac,
View Lab Tests,Pregled laboratorijskih testova,
View Leads,Pogledaj potencijalne kupce,
View Ledger,Pogledaj Ledger,
View Now,Pregled Sada,
View a list of all the help videos,Pogledaj listu svih snimke Pomoć,
View in Cart,Pogledaj u košaricu,
Visit report for maintenance call.,Posjetite izvješće za održavanje razgovora.,
Visit the forums,Posjetite forum,
Vital Signs,Vitalni znaci,
Volunteer,Dobrovoljno,
Volunteer Type information.,Volonterski podaci o tipu.,
Volunteer information.,Volonterske informacije.,
Voucher #,bon #,
Voucher No,Bon Ne,
Voucher Type,Bon Tip,
WIP Warehouse,WIP skladište,
Warehouse can not be deleted as stock ledger entry exists for this warehouse.,"Skladište se ne može izbrisati , kao entry stock knjiga postoji za to skladište .",
Warehouse cannot be changed for Serial No.,Skladište se ne može promijeniti za serijskog broja,
Warehouse is mandatory,Skladište je obavezno,
Warehouse is mandatory for stock Item {0} in row {1},Skladište je obvezno za skladišne proizvode {0} u redu {1},
Warehouse not found in the system,Skladište nije pronađeno u sistemu,
"Warehouse required at Row No {0}, please set default warehouse for the item {1} for the company {2}","Skladište je potrebno na redosledu {0}, molimo postavite podrazumevano skladište za predmet {1} za kompaniju {2}",
Warehouse required for stock Item {0},Skladište je potrebno za skladišne proizvode {0},
Warehouse {0} can not be deleted as quantity exists for Item {1},Skladište {0} ne može biti izbrisano ako na njemu ima artikal {1},
Warehouse {0} does not belong to company {1},Skladište {0} ne pripada tvrtki {1},
Warehouse {0} does not exist,Skladište {0} ne postoji,
"Warehouse {0} 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 povezan na bilo koji račun, navedite račun u zapisnik skladištu ili postaviti zadani popis računa u firmi {1}.",
Warehouses with child nodes cannot be converted to ledger,Skladišta s djecom čvorovi se ne može pretvoriti u Ledger,
Warehouses with existing transaction can not be converted to group.,Skladišta sa postojećim transakcija se ne može pretvoriti u grupi.,
Warehouses with existing transaction can not be converted to ledger.,Skladišta sa postojećim transakcija se ne može pretvoriti u knjizi.,
Warning,Upozorenje,
Warning: Another {0} # {1} exists against stock entry {2},Upozorenje: Još {0} {1} # postoji protiv ulaska zaliha {2},
Warning: Invalid SSL certificate on attachment {0},Upozorenje: Invalid SSL certifikat o prilogu {0},
Warning: Invalid attachment {0},Upozorenje: Invalid Prilog {0},
Warning: Material Requested Qty is less than Minimum Order Qty,Upozorenje : Materijal tražena količina manja nego minimalna narudžba kol,
Warning: Sales Order {0} already exists against Customer's Purchase Order {1},Upozorenje: prodajnog naloga {0} već postoji protiv narudžbenice kupca {1},
Warning: System will not check overbilling since amount for Item {0} in {1} is zero,Upozorenje : Sustav neće provjeravati overbilling od iznosa za točku {0} u {1} je nula,
Warranty,Garancija,
Warranty Claim,Garantni  rok,
Warranty Claim against Serial No.,Garantni rok protiv Serial No.,
Website,Web stranica,
Website Image should be a public file or website URL,Sajt slika treba da bude javni datoteke ili web stranice URL,
Website Image {0} attached to Item {1} cannot be found,Sajt Slika {0} prilogu Stavka {1} ne može biti pronađena,
Website Manager,Web Manager,
Website Settings,Website Postavke,
Wednesday,Srijeda,
Week,sedmica,
Weekly,Tjedni,
"Weight is mentioned,\nPlease mention ""Weight UOM"" too","Težina se spominje, \n Navedite ""Težina UOM"" previše",
Welcome email sent,E-mail dobrodošlice,
Welcome to ERPNext,Dobrodošli na ERPNext,
What do you need help with?,Šta ti je potrebna pomoć?,
What does it do?,Što učiniti ?,
Where manufacturing operations are carried.,Gdje se obavljaju proizvodne operacije.,
White,Bijel,
Wire Transfer,Wire Transfer,
WooCommerce Products,WooCommerce Proizvodi,
Work In Progress,Radovi u toku,
Work Order,Radni nalog,
Work Order already created for all items with BOM,Radni nalog već je kreiran za sve predmete sa BOM,
Work Order cannot be raised against a Item Template,Nalog za rad ne može se pokrenuti protiv šablona za stavke,
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},Objavljeni radni nalogi: {0},
Work-in-Progress Warehouse is required before Submit,Rad u tijeku Warehouse je potrebno prije Podnijeti,
Working,U toku,
Working Hours,Radno vrijeme,
Workstation,Workstation,
Workstation is closed on the following dates as per Holiday List: {0},Workstation je zatvoren sljedećih datuma po Holiday List: {0},
Wrapping up,Zavijanje,
Wrong Password,Pogrešna lozinka,
Year start date or end date is overlapping with {0}. To avoid please set company,datum početka godine ili datum završetka je preklapaju sa {0}. Da bi se izbjegla molimo vas da postavite kompanija,
You are not authorized to add or update entries before {0},Niste ovlašteni za dodati ili ažurirati unose prije {0},
You are not authorized to set Frozen value,Niste ovlašteni za postavljanje Frozen vrijednost,
You can not change rate if BOM mentioned agianst any item,Ne možete promijeniti brzinu ako BOM spomenuo agianst bilo predmet,
You can not enter current voucher in 'Against Journal Entry' column,Ne možete ući trenutni voucher u 'Protiv Journal Entry' koloni,
You can only have Plans with the same billing cycle in a Subscription,Planove možete imati samo sa istim ciklusom naplate na Pretplati,
You can only redeem max {0} points in this order.,Možete uneti samo max {0} poena u ovom redosledu.,
You can only renew if your membership expires within 30 days,Možete obnoviti samo ako vaše članstvo istekne u roku od 30 dana,
You can only select a maximum of one option from the list of check boxes.,Iz liste polja za potvrdu možete izabrati najviše jedne opcije.,
You can't redeem Loyalty Points having more value than the Grand Total.,Ne možete otkupiti Loyalty Points sa više vrijednosti nego Grand Total.,
You cannot credit and debit same account at the same time,Ne možete kreditnim i debitnim isti račun u isto vrijeme,
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 postavljen kao zadani u Globalne postavke,
You cannot delete Project Type 'External',Ne možete obrisati tip projekta &#39;Spoljni&#39;,
You cannot edit root node.,Ne možete uređivati root čvor.,
You cannot restart a Subscription that is not cancelled.,Ne možete ponovo pokrenuti pretplatu koja nije otkazana.,
You don't have enough Loyalty Points to redeem,Ne iskoristite Loyalty Points za otkup,
You have already assessed for the assessment criteria {}.,Ste već ocijenili za kriterije procjene {}.,
You have already selected items from {0} {1},Vi ste već odabrane stavke iz {0} {1},
You have been invited to collaborate on the project: {0},Vi ste pozvani da surađuju na projektu: {0},
You have entered duplicate items. Please rectify and try again.,Unijeli duple stavke . Molimo ispraviti i pokušajte ponovno .,
You need to be a user other than Administrator with System Manager and Item Manager roles to register on Marketplace.,Morate biti korisnik osim administratora sa ulogama upravitelja sistema i menadžera postavki za registraciju na tržištu.,
You need to be a user with System Manager and Item Manager roles to add users to Marketplace.,Morate biti korisnik sa ulogama System Manager i Item Manager da biste dodali korisnike u Marketplace.,
You need to be a user with System Manager and Item Manager roles to register on Marketplace.,Potrebno je da budete korisnik sa ulogama System Manager i Item Manager za prijavljivanje na Marketplace.,
You need to enable Shopping Cart,Trebate omogućiti Košarica,
You will lose records of previously generated invoices. Are you sure you want to restart this subscription?,Izgubićete podatke o prethodno generisanim računima. Da li ste sigurni da želite ponovo pokrenuti ovu pretplatu?,
Your Organization,Vaša organizacija,
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}] (# obrazac / Stavka / {0}) je out of stock,
`Freeze Stocks Older Than` should be smaller than %d days.,`blokiraj zalihe starije od podrazumijevanog manje od % d dana .,
based_on,based_on,
cannot be greater than 100,ne može biti veća od 100,
disabled user,invaliditetom korisnika,
"e.g. ""Build tools for builders""","na primjer "" Izgraditi alate za graditelje """,
"e.g. ""Primary School"" or ""University""",npr &quot;Osnovna škola&quot; ili &quot;Univerzitet&quot;,
"e.g. Bank, Cash, Credit Card","npr. banka, gotovina, kreditne kartice",
hidden,skriven,
modified,modificirani,
old_parent,old_parent,
on,na,
{0} '{1}' is disabled,{0} '{1}' je onemogućeno,
{0} '{1}' not in Fiscal Year {2},{0} ' {1} ' nije u fiskalnoj godini {2},
{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0} ({1}) ne može biti već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 upisana u Batch {2},
{0} - {1} is not enrolled in the Course {2},{0} - {1} nije upisanim na predmetu {2},
{0} Budget for Account {1} against {2} {3} is {4}. It will exceed by {5},{0} budžeta za računa {1} protiv {2} {3} je {4}. To će premašiti po {5},
{0} Digest,{0} Digest,
{0} Request for {1},{0} Zahtev za {1},
{0} Result submittted,{0} Rezultat je podnet,
{0} Serial Numbers required for Item {1}. You have provided {2}.,{0} serijski brojevi potrebni za artikal {1}. koji ste trazili {2}.,
{0} Student Groups created.,{0} studentskih grupa stvorio.,
{0} Students have been enrolled,{0} Studenti su upisani,
{0} against Bill {1} dated {2},{0} protiv placanje {1}  od {2},
{0} against Purchase Order {1},{0} protiv narudzbine dobavljacu {1},
{0} against Sales Invoice {1},{0} protiv prodaje fakture {1},
{0} against Sales Order {1},{0} protiv naloga prodaje {1},
{0} asset cannot be transferred,{0} imovine ne može se prenositi,
{0} can not be negative,{0} ne može biti negativna,
{0} created,{0} kreirao,
"{0} currently has a {1} Supplier Scorecard standing, and Purchase Orders to this supplier should be issued with caution.","{0} trenutno ima {1} Scorecard stava, a narudžbine za ovaj dobavljač treba izdati oprezno.",
"{0} currently has a {1} Supplier Scorecard standing, and RFQs to this supplier should be issued with caution.",{0} trenutno ima {1} Scorecard stava i RFQs ovog dobavljača treba izdati oprezno.,
{0} does not belong to Company {1},{0} ne pripada preduzecu {1},
{0} does not have a Healthcare Practitioner Schedule. Add it in Healthcare Practitioner master,{0} nema raspored zdravstvenih radnika. Dodajte ga u Master Health Practitioner,
{0} entered twice in Item Tax,{0}pritisnite dva puta u sifri poreza,
{0} for {1},{0} {1} za,
{0} has been submitted successfully,{0} je uspešno podnet,
{0} has fee validity till {1},{0} ima važeću tarifu do {1},
{0} hours,{0} sati,
{0} in row {1},{0} u redu {1},
{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 obavezno za tu stavku {1},
{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2}.,{0} je obavezno. Možda knjigovodstveni zapis nije kreiran za {1} na {2}.,
{0} is not a stock Item,{0} ne postoji na zalihama.,
{0} is not a valid Batch Number for Item {1},{0} nije ispravan broj serije za artikal {1},
{0} is not added in the table,{0} nije dodan u tabeli,
{0} is now the default Fiscal Year. Please refresh your browser for the change to take effect.,{0} je podrazumijevana Fiskalna godina . Osvježite svoj browserda bi se izmjene primijenile.,
{0} is on hold till {1},{0} je na čekanju do {1},
{0} item found.,{0} predmet je pronađen.,
{0} items found.,{0} pronađenih predmeta.,
{0} items in progress,{0} stavke u tijeku,
{0} items produced,{0} artikala proizvedenih,
{0} must appear only once,{0} se mora pojaviti samo jednom,
{0} must be negative in return document,{0} mora biti negativan za uzvrat dokumentu,
{0} not allowed to transact with {1}. Please change the Company.,{0} nije dozvoljeno da radi sa {1}. Zamijenite Kompaniju.,
{0} not found for item {1},{0} nije pronađen za stavku {1},
{0} parameter is invalid,Parametar {0} nije važeći,
{0} payment entries can not be filtered by {1},{0} unosi isplate ne mogu biti filtrirani po {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} jedinice [{1}] (# obrazac / Stavka / {1}) naći u [{2}] (# obrazac / Skladište / {2}),
{0} units of {1} needed in {2} on {3} {4} for {5} to complete this transaction.,{0} jedinicama {1} potrebno {2} na {3} {4} za {5} da završi ovu transakciju.,
{0} units of {1} needed in {2} to complete this transaction.,{0} jedinicama {1} potrebno {2} za završetak ove transakcije.,
{0} valid serial nos for Item {1},{0} valjani serijski broj za artikal {1},
{0} variants created.,{0} kreirane varijante.,
{0} {1} created,{0} {1} stvorio,
{0} {1} does not exist,{0} {1} ne postoji,
{0} {1} has been modified. Please refresh.,{0} {1} je izmijenjen . Osvježite stranicu.,
{0} {1} has not been submitted so the action cannot be completed,{0} {1} nije dostavljen tako akciju nije moguće dovršiti,
"{0} {1} is associated with {2}, but Party Account is {3}","{0} {1} je povezan sa {2}, ali Party Party 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 otkazan tako da akcija ne može završiti,
{0} {1} is closed,{0} {1} je zatvoren,
{0} {1} is disabled,{0} {1} je onemogućena,
{0} {1} is frozen,{0} {1} je smrznuto,
{0} {1} is fully billed,{0} {1} je u potpunosti naplaćeno,
{0} {1} is not active,{0} {1} nije aktivan,
{0} {1} is not associated with {2} {3},{0} {1} nije povezan sa {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 proslijedjen,
{0} {1} is {2},{0} {1} je {2},
{0} {1} must be submitted,{0} {1} mora biti podnesen,
{0} {1} not in any active Fiscal Year.,{0} {1} ne u bilo kojem aktivnom fiskalne godine.,
{0} {1} status is {2},{0} {1} {2} status,
{0} {1}: 'Profit and Loss' type account {2} not allowed in Opening Entry,{0} {1}: &#39;dobiti i gubitka&#39; tip naloga {2} nije dozvoljeno otvaranje Entry,
{0} {1}: Account {2} does not belong to Company {3},{0} {1}: 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čunovodstvo Ulaz za {2} može se vršiti samo u valuti: {3},
{0} {1}: Cost Center is mandatory for Item {2},{0} {1}: trošak je obvezan za artikal {2},
{0} {1}: Cost Center is required for 'Profit and Loss' account {2}. Please set up a default Cost Center for the Company.,{0} {1}: Troškovi Centar je potreban za &quot;dobiti i gubitka računa {2}. Molimo vas da se uspostavi default troškova Centra za kompanije.,
{0} {1}: Cost Center {2} does not belong to Company {3},{0} {1}: Cost Center {2} ne pripada kompaniji {3},
{0} {1}: Customer is required against Receivable account {2},{0} {1}: gost je dužan protiv potraživanja nalog {2},
{0} {1}: Either debit or credit amount is required for {2},{0} {1}: Ili debitne ili kreditne iznos je potreban za {2},
{0} {1}: Supplier is required against Payable account {2},{0} {1}: dobavljača se protiv plaćaju račun {2},
{0}% Billed,{0}% Fakturisana,
{0}% Delivered,{0}% Isporučeno,
{0}: From {1},{0}: {1} Od,
{0}: {1} does not exists,{0}: {1} ne postoji,
{0}: {1} not found in Invoice Details table,{0}: {1} nije pronađen u tabeli details na fakturi,
{} of {},{} od {},
Assigned To,Dodijeljeno,
Chat,Chat,
Completed By,Završio,
Day of Week,Dan Tjedan,
"Dear System Manager,","Dragi System Manager,",
Default Value,Zadana vrijednost,
Email Group,E-mail Group,
Email Settings,Postavke e-pošte,
Email not sent to {0} (unsubscribed / disabled),E-mail ne šalju {0} (odjavljeni / invaliditetom),
Error Message,Poruka o grešci,
Fieldtype,Polja,
Help Articles,Članci pomoći,
ID,ID,
Import,Uvoz,
Language,Jezik,
Likes,Like,
Merge with existing,Merge sa postojećim,
Orientation,orijentacija,
Parent,Roditelj,
Payment Failed,plaćanje nije uspjelo,
Personal,Osobno,
Post,Pošalji,
Postal Code,poštanski broj,
Provider,Provajder,
Read Only,Read Only,
Recipient,Primalac,
Reviews,Recenzije,
Sender,Pošiljaoc,
There were errors while sending email. Please try again.,Bilo je grešaka tijekom slanja e-pošte. Molimo pokušajte ponovno .,
Values Changed,Promena vrednosti,
or,ili,
Ageing Range 4,Raspon starenja 4,
Allocated amount cannot be greater than unadjusted amount,Dodijeljeni iznos ne može biti veći od neprilagođenog iznosa,
Allocated amount cannot be negative,Dodijeljeni iznos ne može biti negativan,
"Difference Account must be a Asset/Liability type account, since this Stock Entry is an Opening Entry","Račun razlike mora biti račun vrste imovine / odgovornosti, jer je ovaj unos dionica otvaranje",
Import Successful,Uvoz je uspešan,
Please save first,Prvo sačuvajte,
Price not found for item {0} in price list {1},Cijena nije pronađena za artikl {0} u cjeniku {1},
Warehouse Type,Tip skladišta,
'Date' is required,Obavezan je datum,
Budgets,Budžeti,
Bundle Qty,Količina paketa,
Company GSTIN,Kompanija GSTIN,
Company field is required,Polje kompanije je obavezno,
Creating Dimensions...,Stvaranje dimenzija ...,
Duplicate entry against the item code {0} and manufacturer {1},Duplikat unosa sa šifrom artikla {0} i proizvođačem {1},
Invalid GSTIN! The input you've entered doesn't match the GSTIN format for UIN Holders or Non-Resident OIDAR Service Providers,Nevažeći GSTIN! Uneseni unos ne odgovara formatu GSTIN za vlasnike UIN-a ili nerezidentne dobavljače usluga OIDAR,
Invoice Grand Total,Faktura Grand Total,
Last carbon check date cannot be a future date,Posljednji datum provjere ugljika ne može biti budući datum,
Make Stock Entry,Unesite zalihe,
Quality Feedback,Kvalitetne povratne informacije,
Quality Feedback Template,Predložak kvalitetne povratne informacije,
Rules for applying different promotional schemes.,Pravila za primjenu različitih promotivnih shema.,
Show {0},Prikaži {0},
Target Details,Detalji cilja,
{0} already has a Parent Procedure {1}.,{0} već ima roditeljsku proceduru {1}.,
API,API,
Annual,godišnji,
Change,Promjena,
Contact Email,Kontakt email,
From Date,Od datuma,
Group By,Group By,
Invalid URL,Nevažeća URL adresa,
Landscape,Pejzaž,
Naming Series,Imenovanje serije,
No data to export,Nema podataka za izvoz,
Portrait,Portret,
Print Heading,Ispis Naslov,
Scheduler Inactive,Planer neaktivan,
Scheduler is inactive. Cannot import data.,Planer je neaktivan. Nije moguće uvesti podatke.,
Show Document,Prikaži dokument,
Show Traceback,Prikaži Traceback,
Video,Video,
% Of Grand Total,% Od ukupnog iznosa,
<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 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 Ne radi se i ne može se ažurirati unos u časopisu,
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.,Dodaj / Upravljanje Email Accounts.,
Add Child,Dodaj podređenu stavku,
Add Multiple,dodavanje 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 - linija 1,
Addresses,Adrese,
Admission End Date should be greater than Admission Start Date.,Datum završetka prijema trebao bi biti veći od datuma početka upisa.,
All,Sve,
All bank transactions have been created,Sve bankarske transakcije su stvorene,
All the depreciations has been booked,Sve amortizacije su knjižene,
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},
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}","Kao što je već postoje transakcije protiv stavku {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},
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.,
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 Messages,Nazad na poruke,
Bank Data mapper doesn't exist,Map Data Mapper ne postoji,
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 boja,
Book,Knjiga,
Book Appointment,Sastanak knjige,
Brand,Brend,
Browse,Izaberi,
Call Connected,Poziv je povezan,
Call Disconnected,Poziv prekinuti,
Call Missed,Poziv 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 complete task {0} as its dependant task {1} are not ccompleted / cancelled.,Ne mogu dovršiti zadatak {0} jer njegov ovisni zadatak {1} nije dovršen / otkazan.,
Cannot find a matching Item. Please select some other value for {0}.,Ne možete pronaći stavku koja se podudara. Molimo odaberite neki drugi 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",
"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,Zatvoriti,
Communication,Komunikacija,
Compact Item Print,Compact Stavka Print,
Company,Preduzeće,
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,Kompletan,
Completed,Dovršen,
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 zapise poziva,
Connect your bank accounts to ERPNext,Povežite svoje bankovne račune s ERPNext-om,
Contact Seller,Kontakt oglašivača,
Continue,Nastaviti,
Cost Center: {0} does not exist,Centar troškova: {0} ne postoji,
Couldn't Set Service Level Agreement {0}.,Nije moguće podesiti ugovor o nivou usluge {0}.,
Country,Zemlja,
Country Code in File does not match with country code set up in the system,Kôd države u datoteci ne podudara se sa kodom države postavljenim u sistemu,
Create New Contact,Kreirajte novi kontakt,
Create New Lead,Stvorite novi potencijal,
Create Pick List,Napravite 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 ...,
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 za slanje,
Currency,Valuta,
Current Status,Trenutni status,
Customer PO,Potrošački PO,
Daily,Svakodnevno,
Date,Datum,
Date of Birth cannot be greater than Joining Date.,Datum rođenja ne može biti veći od datuma pridruživanja.,
Dear,Poštovani,
Default,Podrazumjevano,
Define coupon codes.,Definirajte kodove kupona.,
Delayed Days,Odloženi dani,
Delete,Izbrisati,
Delivered Quantity,Isporučena količina,
Delivery Notes,Napomene o isporuci,
Depreciated Amount,Amortizovani iznos,
Description,Opis,
Designation,Oznaka,
Difference Value,Vrijednost razlike,
Dimension Filter,Dimenzijski filter,
Disabled,Ugašeno,
Disbursement and Repayment,Isplata i otplata,
Distance cannot be greater than 4000 kms,Udaljenost ne može biti veća od 4000 km,
Do you want to submit the material request,Želite li poslati materijalni zahtjev,
Doctype,Vrsta dokumenta,
Document {0} successfully uncleared,Dokument {0} uspješno nije izbrisan,
Download Template,Preuzmite predložak,
Dr,Doktor,
Due Date,Datum dospijeća,
Duplicate,Duplikat,
Duplicate Project with Tasks,Duplikat projekta sa zadacima,
Duplicate project has been created,Izrađen je duplikat projekta,
E-Way Bill JSON can only be generated from a submitted document,e-Way Bill JSON može se generirati samo iz poslanog dokumenta,
E-Way Bill JSON can only be generated from submitted document,e-Way Bill JSON može se generirati samo iz dostavljenog 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,Uredite detalje,
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 i beneficije zaposlenih,
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,End Time,
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,Pogreška,
Error in Exotel incoming call,Pogreška u dolaznom pozivu Exotela,
Error: {0} is mandatory field,Greška: {0} je obavezno polje,
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,
Expired,Istekla,
Export,Izvoz,
Export not allowed. You need {0} role to export.,Izvoz nisu dopušteni . Trebate {0} ulogu za izvoz .,
Failed to add Domain,Nije moguće dodati Domen,
Fetch Items from Warehouse,Dohvaćanje predmeta iz skladišta,
Fetching...,Dohvaćanje ...,
Field,polje,
Filters,Filteri,
Finding linked payments,Pronalaženje povezanih plaćanja,
Fleet Management,Fleet Management,
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 redu {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 artikal nije postavljen u pravilu o cijenama {0},
From Date and To Date are Mandatory,Datum i datum su obavezni,
From employee is required while receiving Asset {0} to a target location,Od zaposlenika je potrebno za vrijeme prijema imovine {0} do ciljane lokacije,
Future Payment Amount,Budući iznos plaćanja,
Future Payment Ref,Buduće plaćanje Ref,
Future Payments,Buduće isplate,
GST HSN Code does not exist for one or more items,GST HSN kod ne postoji za jednu ili više stavki,
Generate E-Way Bill JSON,Stvorite e-Way Bill JSON,
Get Items,Kreiraj proizvode,
Get Outstanding Documents,Nabavite izvanredne dokumente,
Goal,Cilj,
Greater Than Amount,Veća od iznosa,
Green,Zelenilo,
Group,Grupa,
Group By Customer,Grupiranje prema kupcu,
Group By Supplier,Grupiranje po dobavljaču,
Group Node,Group Node,
Group Warehouses cannot be used in transactions. Please change the value of {0},Grupne skladišta se ne mogu koristiti u transakcijama. Molimo promijenite vrijednost {0},
Help,Pomoć,
Help Article,Pomoć član,
"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 datoteka CSV / Excel.,
In Progress,U toku,
Incoming call from {0},Dolazni poziv od {0},
Incorrect Warehouse,Pogrešno skladište,
Invalid Barcode. There is no Item attached to this barcode.,Nevažeći barkod. Nijedna stavka nije priložena ovom barkodu.,
Invalid credentials,Nevažeće vjerodajnice,
Issue Priority.,Prioritet pitanja.,
Issue Type.,Vrsta izdanja,
"It seems that there is an issue with the server's stripe configuration. In case of failure, the amount will get refunded to your account.","Čini se da postoji problem sa konfiguracijom trake servera. U slučaju neuspeha, 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} proizvedeno.,
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,
Leaves Taken,Ostavljeni listovi,
Less Than Amount,Manje od iznosa,
Liabilities,Obaveze,
Loading...,Učitavanje ...,
Loan Applications from customers and employees.,Prijave za zajmove od kupaca i zaposlenih.,
Loan Processes,Procesi zajma,
Loan Type for interest and penalty rates,Vrsta kredita za kamate i zatezne stope,
Loans,Krediti,
Loans provided to customers and employees.,Krediti kupcima i zaposlenima.,
Location,Lokacija,
Looks like someone sent you to an incomplete URL. Please ask them to look into it.,Izgleda kao da je neko poslao na nepotpune URL. Zamolite ih da pogleda u nju.,
Make Journal Entry,Make Journal Entry,
Make Purchase Invoice,Napravite kupnje proizvoda,
Manufactured,Proizvedeno,
Mark Work From Home,Označi rad od kuće,
Master,Majstor,
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,Nedostaje vrijednosti potrebne,
Mobile No,Br. mobilnog telefona,
Mobile Number,Broj mobitela,
Month,Mjesec,
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,
No Account matched these filters: {},Nijedan račun ne odgovara ovim filterima: {},
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 views yet,Još uvijek nema pogleda,
Non stock items,Artikli koji nisu dostupni,
Not Allowed,Nije dozvoljen,
Not allowed to create accounting dimension for {0},Nije dozvoljeno stvaranje dimenzije računovodstva za {0},
Not permitted. Please disable the Lab Test Template,Nije dozvoljeno. Isključite predložak laboratorijskog testa,
Note,Biljeske,
Notes: ,Bilješke :,
On Converting Opportunity,O pretvaranju mogućnosti,
On Purchase Order Submission,Prilikom narudžbe,
On Sales Order Submission,O podnošenju prodajnih naloga,
On Task Completion,Po završetku zadatka,
On {0} Creation,Na {0} Stvaranje,
Only .csv and .xlsx files are supported currently,Trenutno su podržane samo .csv i .xlsx datoteke,
Open,Otvoreno,
Open Contact,Otvori kontakt,
Open Lead,Otvoreno olovo,
Opening and Closing,Otvaranje i zatvaranje,
Operating Cost as per Work Order / BOM,Operativni trošak po radnom nalogu / BOM,
Order Amount,Iznos narudžbe,
Page {0} of {1},Strana {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,
Patient History,Istorija pacijenata,
Pause,pause,
Pay,Platiti,
Payment Document Type,Vrsta dokumenta plaćanja,
Payment Name,Naziv plaćanja,
Pending,Čekanje,
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 create <b>DATEV Settings</b> for Company <b>{}</b>.,Molimo kreirajte <b>DATEV postavke</b> za kompaniju <b>{}</b> .,
Please create adjustment Journal Entry for amount {0} ,Molimo izradite podešavanje 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>prilagodbu 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 skladište i datum,
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 Customer first,Prvo odaberite kupca,
Please select Item Code first,Prvo odaberite šifru predmeta,
Please select a Delivery Note,Odaberite bilješku o dostavi,
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. Pruga 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 postavite 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 broj na adresi kompanije {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,Navedite,
Please specify a {0},Navedite {0},lead
Priority,Prioritet,
Priority has been changed to {0}.,Prioritet je promijenjen u {0}.,
Priority {0} has been repeated.,Prioritet {0} je ponovljen.,
Processing XML Files,Obrada XML datoteka,
Profitability,Profitabilnost,
Project,Projekat,
Provide the academic year and set the starting and ending date.,Navedite akademsku godinu i postavite datum početka i završetka.,
Public token is missing for this bank,Javni token nedostaje za ovu banku,
Publish 1 Item,Objavite 1 predmet,
Publish Items,Objavite stavke,
Publish More Items,Objavite još predmeta,
Publish Your First Items,Objavite svoje prve stavke,
Publish {0} Items,Objavite {0} stavke,
Published Items,Objavljeni predmeti,
Purchase Invoice cannot be made against an existing asset {0},Račun za 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.,Kupoprodajna potvrda nema stavku za koju je omogućen zadržati uzorak.,
Purchase Return,Kupnja Povratak,
Qty of Finished Goods Item,Količina proizvoda gotove robe,
Quality Inspection required for Item {0} to submit,Inspekcija 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,Na čekanju,
Quick Entry,Brzo uvođenje,
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,regrutacija,
Red,Crven,
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,preimenovati,
Rename Not Allowed,Preimenovanje nije dozvoljeno,
Report Item,Izvještaj,
Report this Item,Prijavi ovu stavku,
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,resetovanje,
Reset Service Level Agreement,Vratite ugovor o nivou usluge,
Resetting Service Level Agreement.,Poništavanje ugovora o nivou usluge.,
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 # ,Row #,
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 {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 od današnjeg.,
Row({0}): {1} is already discounted in {2},Red ({0}): {1} već je diskontiran u {2},
Rows Added in {0},Redovi dodani u {0},
Rows Removed in {0},Redovi su uklonjeni za {0},
Save,Snimi,
Save Item,Spremi stavku,
Saved Items,Spremljene stavke,
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 Difference Account,Odaberite račun razlike,
Select a Default Priority.,Odaberite zadani prioritet.,
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,Poslati,
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 br. Nisu potrebni za serijski broj {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 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 Meta Tags,Postavljanje meta tagova,
Set {0} in company {1},Set {0} u kompaniji {1},
Setup,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,Prikaži osobu prodaje,
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.,
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,Start Time,
Status,Status,
Status must be Cancelled or Completed,Status mora biti otkazan ili završ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 usklađeni 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,Submit Review,
Submitted,Potvrđeno,
Supplier Addresses And Contacts,Supplier Adrese i kontakti,
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 sredstva {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,Predložak,
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 duplicirano,
The selected payment entry should be linked with a creditor bank transaction,Odabrani unos za plaćanje treba biti povezan s 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}).,
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,Taj je bankovni račun već sinhroniziran,
This bank transaction is already fully reconciled,Ova je bankarska transakcija već u potpunosti usklađena,
This page keeps track of items you want to buy from sellers.,Ova stranica prati stvari koje želite kupiti od prodavača.,
This page keeps track of your items in which buyers have showed some interest.,Ova stranica prati vaše predmete za koje su kupci pokazali neki interes.,
Thursday,Četvrtak,
Title,Naslov,
"To allow over billing, update ""Over Billing Allowance"" in Accounts Settings or the Item.","Da biste omogućili prekomerno naplaćivanje, ažurirajte „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.",
Total,Ukupno,
Total Payment Request amount cannot be greater than {0} amount,Ukupni iznos zahtjeva za plaćanje ne može biti veći od {0},
Total payments amount can't be greater than {},Ukupni iznos plaćanja ne može biti veći od {},
Totals,Ukupan rezultat,
Transactions already retreived from the statement,Transakcije su već povučene iz izjave,
Transfer Material to Supplier,Transfera 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,Vrsta,
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,
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žurirati,
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,Koristite ime koje se razlikuje od prethodnog naziva projekta,
User {0} is disabled,Korisnik {0} je onemogućen,
Users and Permissions,Korisnici i dozvole,
Valuation Rate required for Item {0} at row {1},Stopa vrednovanja potrebna za poziciju {0} u retku {1},
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}: kartica posla 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šnji,
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 copy-paste ovaj link u vašem pregledniku,
You can publish upto 200 items.,Možete objaviti do 200 predmeta.,
You have to enable auto re-order in Stock Settings to maintain re-order levels.,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:,
and,i,
e-Way Bill already exists for this document,Za ovaj dokument već postoji e-Way Bill,
woocommerce - {0},woocommerce - {0},
{0} Coupon used are {1}. Allowed quantity is exhausted,{0} Kupon se koristi {1}. Dozvoljena količina se iscrpljuje,
{0} Operations: {1},{0} Operacije: {1},
{0} bank transaction(s) created,{0} Napravljene su bankarske transakcije,
{0} bank transaction(s) created and {1} errors,{0} napravljene bankarske transakcije i greške {1},
{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 potrebno,
{0}: {1} must be less than {2},{0}: {1} mora biti manji od {2},
{} is required to generate E-Way Bill JSON,{} je potreban za generisanje e-Way Bill 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,
Barcode,Barkod,
Clear,Jasno,
Comments,Komentari,
DocType,DocType,
Download,Skinuti,
Left,Lijevo,
Link,Veza,
New,Novo,
Print,Ispis,
Reference Name,Referentno ime,
Refresh,Osvježi,
Success,Uspeh,
Time,Vreme,
Value,Vrijednost,
Actual,Aktuelno,
Add to Cart,Dodaj u košaricu,
Days Since Last Order,Dani od poslednje narudžbe,
In Stock,U Stock,
Mode Of Payment,Način plaćanja,
No students Found,Nije pronađen nijedan student,
Not in Stock,Nije raspoloživo,
Please select a Customer,Izaberite klijenta,
Received From,Dobili 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} kreirano,
Email Id,Email ID,
No,Ne,
Reference Doctype,Referentna DOCTYPEhtml,
Yes,Da,
Actual ,Stvaran,
Add to cart,Dodaj u košaricu,
Budget,Budžet,
Chart of Accounts,Chart of Accounts,
Customer database.,Baza podataka klijenata.,
Days Since Last order,Dana od posljednje narudžbe,
Download as JSON,Preuzmi kao JSON,
End date can not be less than start date,Datum završetka ne može biti manja od početnog datuma,
For Default Supplier (Optional),Za podrazumevani dobavljač,
From date cannot be greater than To date,Od datuma ne može biti veća od To Date,
Group by,Group By,
In stock,Na zalihama,
Item name,Naziv artikla,
Minimum Qty,Minimalni količina,
More details,Više informacija,
Nature of Supplies,Nature of Supplies,
No Items found.,Ništa nije pronađeno.,
No students found,No studenti Found,
Not in stock,Nije na zalihama,
Not permitted,Nije dozvoljeno,
Open Issues ,Otvorena pitanja,
Open Projects ,Open Projekti,
Open To Do ,Open To Do,
Operation Id,Operacija ID,
Partially ordered,parcijalno uređenih,
Please select company first,Prvo izaberite preduzeće,
Please select patient,Molimo izaberite Pacijent,
Printed On ,Printed On,
Projected qty,Projektovana kolicina,
Sales person,Referent prodaje,
Serial No {0} Created,Serijski Ne {0} stvorio,
Source Location is required for the Asset {0},Izvorna lokacija je potrebna za sredstvo {0},
Tax Id,Tax ID,
To Time,Za vrijeme,
To date cannot be before from date,Do danas ne može biti prije Od datuma,
Total Taxable value,Ukupna porezna vrijednost,
Upcoming Calendar Events ,Najave Kalendar događanja,
Value or Qty,Vrijednost ili broj,
Variance ,Varijanca,
Variant of,Varijanta,
Write off,Otpisati,
hours,Hours,
received from,Dobili od,
to,To,
Cards,Karte,
Percentage,Postotak,
Failed to setup defaults for country {0}. Please contact support@erpnext.com,Nije uspjelo postavljanje zadanih postavki za zemlju {0}. Molimo kontaktirajte support@erpnext.com,
Row #{0}: Item {1} is not a Serialized/Batched Item. It cannot have a Serial No/Batch No against it.,Redak # {0}: Stavka {1} nije serijski / skupa stavka. Ne može imati serijski broj / br. Seriju protiv.,
Please set {0},Molimo postavite {0},
Please set {0},Molimo postavite {0},supplier
Draft,Skica,"docstatus,=,0"
Cancelled,Otkazano,"docstatus,=,2"
Please setup Instructor Naming System in Education > Education Settings,Postavite sistem imenovanja instruktora u Obrazovanje&gt; Postavke obrazovanja,
Please set Naming Series for {0} via Setup > Settings > Naming Series,Molimo postavite Naming Series za {0} putem Podešavanje&gt; Podešavanja&gt; Imenovanje serije,
UOM Conversion factor ({0} -> {1}) not found for item: {2},Faktor konverzije UOM ({0} -&gt; {1}) nije pronađen za stavku: {2},
Item Code > Item Group > Brand,Kod artikla&gt; Grupa artikala&gt; Marka,
Customer > Customer Group > Territory,Kupac&gt; grupa kupaca&gt; teritorija,
Supplier > Supplier Type,Dobavljač&gt; vrsta dobavljača,
The value of {0} differs between Items {1} and {2},Vrijednost {0} razlikuje se između stavki {1} i {2},
Auto Fetch,Automatsko dohvaćanje,
Fetch Serial Numbers based on FIFO,Dohvati serijske brojeve na osnovu FIFO-a,
"Outward taxable supplies(other than zero rated, nil rated and exempted)","Oporezive vanjske isporuke (osim nulte ocjene, nula i izuzete)",
"To allow different rates, disable the {0} checkbox in {1}.","Da biste omogućili različite stope, onemogućite {0} potvrdni okvir u {1}.",
Asset{} {assets_link} created for {},Sredstvo {} {assets_link} kreirano za {},
Row {}: Asset Naming Series is mandatory for the auto creation for item {},Red {}: Serija imenovanja sredstava obavezna je za automatsko kreiranje stavke {},
Assets not created for {0}. You will have to create asset manually.,Sredstva nisu kreirana za {0}. Morat ćete stvoriti materijal ručno.,
{0} {1} has accounting entries in currency {2} for company {3}. Please select a receivable or payable account with currency {2}.,{0} {1} ima knjigovodstvene stavke u valuti {2} za kompaniju {3}. Odaberite račun potraživanja ili plaćanja u valuti {2}.,
Invalid Account,Nevažeći račun,
Purchase Order Required,Narudžbenica kupnje je obavezna,
Purchase Receipt Required,Kupnja Potvrda Obvezno,
Account Missing,Račun nedostaje,
Requested,Tražena,
Partially Paid,Djelomično plaćeno,
Invalid Account Currency,Nevažeća valuta računa,
"Row {0}: The item {1}, quantity must be positive number","Red {0}: Stavka {1}, količina mora biti pozitivan broj",
"Please set {0} for Batched Item {1}, which is used to set {2} on Submit.","Postavite {0} za grupnu stavku {1}, koja se koristi za postavljanje {2} na Submit.",
Expiry Date Mandatory,Datum isteka obavezan,
Variant Item,Variant Item,
BOM 1 {0} and BOM 2 {1} should not be same,BOM 1 {0} i BOM 2 {1} ne bi trebali biti isti,
Note: Item {0} added multiple times,Napomena: Stavka {0} dodana je više puta,
YouTube,YouTube,
Vimeo,Vimeo,
Publish Date,Datum objave,
Duration,Trajanje,
Advanced Settings,Napredne postavke,
Path,Put,
Components,komponente,
Verified By,Ovjeren od strane,
Invalid naming series (. missing) for {0},Nevažeća serija imenovanja (. Nedostaje) za {0},
Filter Based On,Filter zasnovan na,
Reqd by date,Potrebno po datumu,
Manufacturer Part Number <b>{0}</b> is invalid,Broj dijela proizvođača <b>{0}</b> je nevažeći,
Invalid Part Number,Nevažeći broj dijela,
Select atleast one Social Media from Share on.,Odaberite barem jedan društveni medij iz Dijeli dalje.,
Invalid Scheduled Time,Nevažeće zakazano vrijeme,
Length Must be less than 280.,Dužina Mora biti manja od 280.,
Error while POSTING {0},Greška prilikom POSTAVLJANJA {0},
"Session not valid, Do you want to login?","Sesija nije važeća, želite li se prijaviti?",
Session Active,Sesija aktivna,
Session Not Active. Save doc to login.,Sesija nije aktivna. Sačuvajte dokument za prijavu.,
Error! Failed to get request token.,Greška! Dohvaćanje tokena zahtjeva nije uspjelo.,
Invalid {0} or {1},Nevažeće {0} ili {1},
Error! Failed to get access token.,Greška! Dohvaćanje tokena za pristup nije uspjelo.,
Invalid Consumer Key or Consumer Secret Key,Nevažeći potrošački ključ ili tajni ključ potrošača,
Your Session will be expire in ,Vaša sesija istječe za,
 days.,dana.,
Session is expired. Save doc to login.,Sjednica je istekla. Sačuvajte dokument za prijavu.,
Error While Uploading Image,Greška prilikom prijenosa slike,
You Didn't have permission to access this API,Niste imali dozvolu za pristup ovom API-ju,
Valid Upto date cannot be before Valid From date,Važeći Ažurirani datum ne može biti prije Važi od,
Valid From date not in Fiscal Year {0},Važi od datuma koji nije u fiskalnoj godini {0},
Valid Upto date not in Fiscal Year {0},Vrijedi do datuma koji nije u fiskalnoj godini {0},
Group Roll No,Grupna rola br,
Maintain Same Rate Throughout Sales Cycle,Održavati ista stopa Tijekom cijele prodajni ciklus,
"Row {1}: Quantity ({0}) cannot be a fraction. To allow this, disable '{2}' in UOM {3}.","Red {1}: Količina ({0}) ne može biti razlomak. Da biste to omogućili, onemogućite &#39;{2}&#39; u UOM-u {3}.",
Must be Whole Number,Mora biti cijeli broj,
Please setup Razorpay Plan ID,Molimo postavite Razorpay ID plana,
Contact Creation Failed,Stvaranje kontakta nije uspjelo,
Leaves Expired,Lišće je isteklo,
Row #{}: {} of {} should be {}. Please modify the account or select a different account.,Red # {}: {} od {} trebao bi biti {}. Izmijenite račun ili odaberite drugi račun.,
Row #{}: Please asign task to a member.,Red # {}: Molimo dodijelite zadatak članu.,
Process Failed,Proces nije uspio,
Tally Migration Error,Pogreška migracije Tally-a,
Please set Warehouse in Woocommerce Settings,Molimo postavite Warehouse u Woocommerce Settings,
Row {0}: Delivery Warehouse ({1}) and Customer Warehouse ({2}) can not be same,Red {0}: Skladište za dostavu ({1}) i Skladište za kupce ({2}) ne mogu biti isto,
Row {0}: Due Date in the Payment Terms table cannot be before Posting Date,Red {0}: Datum dospijeća u tablici Uslovi plaćanja ne može biti prije datuma knjiženja,
Cannot find {} for item {}. Please set the same in Item Master or Stock Settings.,Nije moguće pronaći {} za stavku {}. Molimo postavite isto u stavci Master Master ili Stock Settings.,
Row #{0}: The batch {1} has already expired.,Redak {0}: serija {1} je već istekla.,
Start Year and End Year are mandatory,Početna i završna godina su obavezne,
GL Entry,GL ulaz,
Cannot allocate more than {0} against payment term {1},Ne možete dodijeliti više od {0} prema roku plaćanja {1},
The root account {0} must be a group,Korijenski račun {0} mora biti grupa,
Shipping rule not applicable for country {0} in Shipping Address,Pravilo dostave nije primjenjivo za zemlju {0} u adresi za dostavu,
Get Payments from,Primajte uplate od,
Set Shipping Address or Billing Address,Postavite adresu za dostavu ili adresu za naplatu,
Consultation Setup,Postavljanje konsultacija,
Fee Validity,Vrijednost naknade,
Laboratory Setup,Postavljanje laboratorija,
Dosage Form,Formular za doziranje,
Records and History,Zapisi i istorija,
Patient Medical Record,Medicinski zapis pacijenta,
Rehabilitation,Rehabilitacija,
Exercise Type,Tip vježbe,
Exercise Difficulty Level,Nivo teškoće u vježbanju,
Therapy Type,Vrsta terapije,
Therapy Plan,Plan terapije,
Therapy Session,Sjednica terapije,
Motor Assessment Scale,Skala za procjenu motora,
[Important] [ERPNext] Auto Reorder Errors,[Važno] [ERPNext] Pogreške automatskog preuređivanja,
"Regards,","Pozdrav,",
The following {0} were created: {1},Stvoreni su sljedeći {0}: {1},
Work Orders,Nalozi za rad,
The {0} {1} created sucessfully,{0} {1} je uspješno kreiran,
Work Order cannot be created for following reason: <br> {0},Radni nalog se ne može kreirati iz sljedećeg razloga:<br> {0},
Add items in the Item Locations table,Dodajte stavke u tabelu Lokacije predmeta,
Update Current Stock,Ažurirajte trenutne zalihe,
"{0} Retain Sample is based on batch, please check Has Batch No to retain sample of item","{0} Zadržavanje uzorka temelji se na šarži, označite Ima šaržu br. Da biste zadržali uzorak predmeta",
Empty,Prazno,
Currently no stock available in any warehouse,Trenutno nema zaliha u bilo kojem skladištu,
BOM Qty,BOM Količina,
Time logs are required for {0} {1},Potrebni su vremenski dnevnici za {0} {1},
Total Completed Qty,Ukupno završeno Količina,
Qty to Manufacture,Količina za proizvodnju,
Social Media Campaigns,Kampanje na društvenim mrežama,
From Date can not be greater than To Date,Od datuma ne može biti veći od datuma,
Please set a Customer linked to the Patient,Postavite kupca povezanog s pacijentom,
Customer Not Found,Kupac nije pronađen,
Please Configure Clinical Procedure Consumable Item in ,Molimo konfigurirajte potrošni predmet za klinički postupak u,
Missing Configuration,Nedostaje konfiguracija,
Out Patient Consulting Charge Item,Iznad Pansionske konsultantske stavke,
Inpatient Visit Charge Item,Obavezna posjeta obaveznoj posjeti,
OP Consulting Charge,OP Konsalting Charge,
Inpatient Visit Charge,Hirurška poseta,
Appointment Status,Status imenovanja,
Test: ,Test:,
Collection Details: ,Detalji kolekcije:,
{0} out of {1},{0} od {1},
Select Therapy Type,Odaberite vrstu terapije,
{0} sessions completed,Završeno je {0} sesija,
{0} session completed,Završena je {0} sesija,
 out of {0},od {0},
Therapy Sessions,Terapijske sesije,
Add Exercise Step,Dodajte korak vježbe,
Edit Exercise Step,Uredite korak vježbe,
Patient Appointments,Imenovanja pacijenta,
Item with Item Code {0} already exists,Stavka sa kodom artikla {0} već postoji,
Registration Fee cannot be negative or zero,Naknada za registraciju ne može biti negativna ili nula,
Configure a service Item for {0},Konfigurirajte stavku usluge za {0},
Temperature: ,Temperatura:,
Pulse: ,Puls:,
Respiratory Rate: ,Stopa disanja:,
BP: ,BP:,
BMI: ,BMI:,
Note: ,Bilješka:,
Check Availability,Provjera dostupnosti,
Please select Patient first,Prvo odaberite Pacijent,
Please select a Mode of Payment first,Prvo odaberite način plaćanja,
Please set the Paid Amount first,Prvo postavite plaćeni iznos,
Not Therapies Prescribed,Nisu propisane terapije,
There are no Therapies prescribed for Patient {0},Nema propisanih terapija za pacijenta {0},
Appointment date and Healthcare Practitioner are Mandatory,Datum imenovanja i zdravstveni radnik su obavezni,
No Prescribed Procedures found for the selected Patient,Nisu pronađeni propisani postupci za odabranog pacijenta,
Please select a Patient first,Prvo odaberite pacijenta,
There are no procedure prescribed for ,Nije propisana procedura za,
Prescribed Therapies,Propisane terapije,
Appointment overlaps with ,Imenovanje se preklapa sa,
{0} has appointment scheduled with {1} at {2} having {3} minute(s) duration.,{0} ima zakazan sastanak sa {1} u {2} u trajanju od {3} minuta.,
Appointments Overlapping,Imenovanja koja se preklapaju,
Consulting Charges: {0},Naknade za savjetovanje: {0},
Appointment Cancelled. Please review and cancel the invoice {0},Imenovanje otkazano. Pregledajte i otkažite račun {0},
Appointment Cancelled.,Imenovanje otkazano.,
Fee Validity {0} updated.,Valjanost naknade {0} je ažurirana.,
Practitioner Schedule Not Found,Raspored praktičara nije pronađen,
{0} is on a Half day Leave on {1},{0} je na pola dana odlaska {1},
{0} is on Leave on {1},{0} je na dopustu {1},
{0} does not have a Healthcare Practitioner Schedule. Add it in Healthcare Practitioner,{0} nema raspored zdravstvenih radnika. Dodajte ga u Healthcare Practitioner,
Healthcare Service Units,Jedinice zdravstvene zaštite,
Complete and Consume,Dovršite i potrošite,
Complete {0} and Consume Stock?,Ispunite {0} i potrošite zalihe?,
Complete {0}?,Dovršiti {0}?,
Stock quantity to start the Procedure is not available in the Warehouse {0}. Do you want to record a Stock Entry?,Količina zaliha za pokretanje postupka nije dostupna u Skladištu {0}. Da li želite snimiti unos zaliha?,
{0} as on {1},{0} kao {1},
Clinical Procedure ({0}):,Klinički postupak ({0}):,
Please set Customer in Patient {0},Postavite kupca za pacijenta {0},
Item {0} is not active,Stavka {0} nije aktivna,
Therapy Plan {0} created successfully.,Plan terapije {0} je uspješno kreiran.,
Symptoms: ,Simptomi:,
No Symptoms,Nema simptoma,
Diagnosis: ,Dijagnoza:,
No Diagnosis,Nema dijagnoze,
Drug(s) Prescribed.,Lijek (i) propisani.,
Test(s) Prescribed.,Test (i) propisani.,
Procedure(s) Prescribed.,Procedura (i) propisana.,
Counts Completed: {0},Prebrojavanja završena: {0},
Patient Assessment,Procjena pacijenta,
Assessments,Procjene,
Heads (or groups) against which Accounting Entries are made and balances are maintained.,Heads (ili grupe) protiv kojih Računovodstvo unosi se izrađuju i sredstva se održavaju.,
Account Name,Naziv konta,
Inter Company Account,Inter Company Account,
Parent Account,Roditelj račun,
Setting Account Type helps in selecting this Account in transactions.,Postavljanje Vrsta računa pomaže u odabiru ovaj račun u prometu.,
Chargeable,Naplativ,
Rate at which this tax is applied,Stopa po kojoj je taj porez se primjenjuje,
Frozen,Zaleđeni,
"If the account is frozen, entries are allowed to restricted users.","Ako je račun zamrznut , unosi dopušteno ograničene korisnike .",
Balance must be,Bilans mora biti,
Lft,Lft,
Rgt,Rgt,
Old Parent,Stari Roditelj,
Include in gross,Uključuju se u bruto,
Auditor,Revizor,
Accounting Dimension,Računovodstvena dimenzija,
Dimension Name,Ime dimenzije,
Dimension Defaults,Zadane dimenzije,
Accounting Dimension Detail,Detalji dimenzije računovodstva,
Default Dimension,Podrazumevana dimenzija,
Mandatory For Balance Sheet,Obavezno za bilans stanja,
Mandatory For Profit and Loss Account,Obavezno za račun dobiti i gubitka,
Accounting Period,Period računovodstva,
Period Name,Ime perioda,
Closed Documents,Zatvoreni dokumenti,
Accounts Settings,Podešavanja konta,
Settings for Accounts,Postavke za račune,
Make Accounting Entry For Every Stock Movement,Provjerite knjiženje za svaki burzi pokreta,
Users with this role are allowed to set frozen accounts and create / modify accounting entries against frozen accounts,Korisnici s ovom ulogom smiju postaviti zamrznute račune i izradu / izmjenu računovodstvenih unosa protiv zamrznutih računa,
Determine Address Tax Category From,Odredite kategoriju adrese poreza od,
Over Billing Allowance (%),Dodatak za naplatu (%),
Credit Controller,Kreditne kontroler,
Check Supplier Invoice Number Uniqueness,Check Dobavljač Faktura Broj Jedinstvenost,
Make Payment via Journal Entry,Izvršiti uplatu preko Journal Entry,
Unlink Payment on Cancellation of Invoice,Odvajanje Plaćanje o otkazivanju fakture,
Book Asset Depreciation Entry Automatically,Knjiga imovine Amortizacija Entry Automatski,
Automatically Add Taxes and Charges from Item Tax Template,Automatski dodajte poreze i pristojbe sa predloška poreza na stavke,
Automatically Fetch Payment Terms,Automatski preuzmi Uvjete plaćanja,
Show Payment Schedule in Print,Prikaži raspored plaćanja u štampanju,
Currency Exchange Settings,Postavke razmjene valuta,
Allow Stale Exchange Rates,Dozvolite stare kurseve,
Stale Days,Zastareli dani,
Report Settings,Postavke izveštaja,
Use Custom Cash Flow Format,Koristite Custom Flow Flow Format,
Allowed To Transact With,Dozvoljeno za transakciju,
SWIFT number,SWIFT broj,
Branch Code,Branch Code,
Address and Contact,Adresa i kontakt,
Address HTML,Adressa u HTML-u,
Contact HTML,Kontakt HTML,
Data Import Configuration,Konfiguracija uvoza podataka,
Bank Transaction Mapping,Mapiranje bankovnih transakcija,
Plaid Access Token,Plaid Access Token,
Company Account,Račun kompanije,
Account Subtype,Podtip računa,
Is Default Account,Je zadani račun,
Is Company Account,Račun kompanije,
Party Details,Party Detalji,
Account Details,Detalji konta,
IBAN,IBAN,
Bank Account No,Bankarski račun br,
Integration Details,Detalji integracije,
Integration ID,ID integracije,
Last Integration Date,Datum posljednje integracije,
Change this date manually to setup the next synchronization start date,Ručno promenite ovaj datum da biste postavili sledeći datum početka sinhronizacije,
Mask,Maska,
Bank Account Subtype,Podvrsta bankovnog računa,
Bank Account Type,Vrsta bankovnog računa,
Bank Guarantee,Bankarska garancija,
Bank Guarantee Type,Tip garancije banke,
Receiving,Primanje,
Providing,Pružanje,
Reference Document Name,Referentni naziv dokumenta,
Validity in Days,Valjanost u Dani,
Bank Account Info,Informacije o bankovnom računu,
Clauses and Conditions,Klauzule i uslovi,
Other Details,Ostali detalji,
Bank Guarantee Number,Bankarska garancija Broj,
Name of Beneficiary,Ime korisnika,
Margin Money,Margin Money,
Charges Incurred,Napunjene naknade,
Fixed Deposit Number,Fiksni depozitni broj,
Account Currency,Valuta račun,
Select the Bank Account to reconcile.,Odaberite bankovni račun da biste ga uskladili.,
Include Reconciled Entries,Uključi pomirio objave,
Get Payment Entries,Get plaćanja unosi,
Payment Entries,plaćanje unosi,
Update Clearance Date,Ažurirajte provjeri datum,
Bank Reconciliation Detail,Banka Pomirenje Detalj,
Cheque Number,Broj čeka,
Cheque Date,Datum čeka,
Statement Header Mapping,Mapiranje zaglavlja izjave,
Statement Headers,Izjave zaglavlja,
Transaction Data Mapping,Mapiranje podataka o transakcijama,
Mapped Items,Mapped Items,
Bank Statement Settings Item,Stavka Postavke banke,
Mapped Header,Mapped Header,
Bank Header,Bank Header,
Bank Statement Transaction Entry,Prijavljivanje transakcije u banci,
Bank Transaction Entries,Bankovne transakcije,
New Transactions,Nove transakcije,
Match Transaction to Invoices,Transakcija na fakture,
Create New Payment/Journal Entry,Kreirajte novu uplatu / dnevnik,
Submit/Reconcile Payments,Pošalji / usaglasite plaćanja,
Matching Invoices,Upoređivanje faktura,
Payment Invoice Items,Stavke fakture za plaćanje,
Reconciled Transactions,Usklađene transakcije,
Bank Statement Transaction Invoice Item,Stavka fakture za transakciju iz banke,
Payment Description,Opis plaćanja,
Invoice Date,Datum fakture,
invoice,faktura,
Bank Statement Transaction Payment Item,Stavka za plaćanje transakcije u banci,
outstanding_amount,preostali iznos,
Payment Reference,Reference za plaćanje,
Bank Statement Transaction Settings Item,Stavka Postavke Transakcije Stavke Bank Banke,
Bank Data,Podaci banke,
Mapped Data Type,Mapped Data Type,
Mapped Data,Mapped Data,
Bank Transaction,Bankovna transakcija,
ACC-BTN-.YYYY.-,ACC-BTN-.YYYY.-,
Transaction ID,transakcija ID,
Unallocated Amount,neraspoređenih Iznos,
Field in Bank Transaction,Polje u bankovnoj transakciji,
Column in Bank File,Stupac u datoteci banke,
Bank Transaction Payments,Plaćanja putem bankarskih transakcija,
Control Action,Kontrolna akcija,
Applicable on Material Request,Primenljivo na zahtev za materijal,
Action if Annual Budget Exceeded on MR,Akcija ako je godišnji budžet prešao na MR,
Warn,Upozoriti,
Ignore,Ignorirati,
Action if Accumulated Monthly Budget Exceeded on MR,Akcija ako je akumulirani mesečni budžet prešao na MR,
Applicable on Purchase Order,Primenljivo na nalogu za kupovinu,
Action if Annual Budget Exceeded on PO,Akcija ako je godišnji budžet prešao na PO,
Action if Accumulated Monthly Budget Exceeded on PO,Akcija ako je zbirni mesečni budžet prešao na PO,
Applicable on booking actual expenses,Primenjuje se prilikom rezervisanja stvarnih troškova,
Action if Annual Budget Exceeded on Actual,Akcija ako se godišnji budžet premašuje na aktuelnom nivou,
Action if Accumulated Monthly Budget Exceeded on Actual,Akcija ako se akumulirani mesečni budžet premašuje na aktuelnom nivou,
Budget Accounts,računa budžeta,
Budget Account,računa budžeta,
Budget Amount,budžet Iznos,
C-Form,C-Form,
ACC-CF-.YYYY.-,ACC-CF-.YYYY.-,
C-Form No,C-Obrazac br,
Received Date,Datum pozicija,
Quarter,Četvrtina,
I,ja,
II,II,
III,III,
IV,IV,
C-Form Invoice Detail,C-Obrazac Račun Detalj,
Invoice No,Račun br,
Cash Flow Mapper,Mapper za gotovinski tok,
Section Name,Naziv odeljka,
Section Header,Header odeljka,
Section Leader,Rukovodilac odjela,
e.g Adjustments for:,npr. prilagođavanja za:,
Section Subtotal,Sekcija subota,
Section Footer,Segment Footer,
Cash Flow Mapping,Mapiranje tokova gotovine,
Select Maximum Of 1,Izaberite maksimum od 1,
Is Finance Cost,Da li je finansijski trošak,
Is Working Capital,Je radni kapital,
Is Finance Cost Adjustment,Da li je usklađivanje troškova finansiranja,
Is Income Tax Liability,Da li je porez na dohodak,
Is Income Tax Expense,Da li je porez na prihod?,
Cash Flow Mapping Accounts,Mapiranje računa gotovine,
account,Konto,
Cash Flow Mapping Template,Šablon za mapiranje toka gotovine,
Cash Flow Mapping Template Details,Detalji šablona za mapiranje gotovog toka,
POS-CLO-,POS-CLO-,
Custody,Starateljstvo,
Net Amount,Neto iznos,
Cashier Closing Payments,Plaćanje plaćanja blagajnika,
Chart of Accounts Importer,Kontni plan računa,
Import Chart of Accounts from a csv file,Uvoz računa sa CSV datoteke,
Attach custom Chart of Accounts file,Priložite datoteku prilagođenog računa računa,
Chart Preview,Pregled grafikona,
Chart Tree,Chart Tree,
Cheque Print Template,Ček Ispis Template,
Has Print Format,Ima Print Format,
Primary Settings,primarni Postavke,
Cheque Size,Ček Veličina,
Regular,redovan,
Starting position from top edge,Početne pozicije od gornje ivice,
Cheque Width,Ček Širina,
Cheque Height,Ček Visina,
Scanned Cheque,skeniranim Ček,
Is Account Payable,Je nalog plaćaju,
Distance from top edge,Udaljenost od gornje ivice,
Distance from left edge,Udaljenost od lijevog ruba,
Message to show,Poruke za prikaz,
Date Settings,Datum Postavke,
Starting location from left edge,Početna lokacija od lijevog ruba,
Payer Settings,Payer Postavke,
Width of amount in word,Širina iznos u riječi,
Line spacing for amount in words,Prored za iznos u riječima,
Amount In Figure,Iznos Na slici,
Signatory Position,potpisnik Pozicija,
Closed Document,Zatvoreni dokument,
Track separate Income and Expense for product verticals or divisions.,Pratite odvojene prihoda i rashoda za vertikala proizvod ili podjele.,
Cost Center Name,Troška Name,
Parent Cost Center,Roditelj troška,
lft,LFT,
rgt,RGT,
Coupon Code,Kupon kod,
Coupon Name,Naziv kupona,
"e.g. ""Summer Holiday 2019 Offer 20""",npr. &quot;Ljetni odmor 201 ponuda 20&quot;,
Coupon Type,Vrsta kupona,
Promotional,Promotivni,
Gift Card,Poklon kartica,
unique e.g. SAVE20  To be used to get discount,jedinstveni npr. SAVE20 Da biste koristili popust,
Validity and Usage,Rok valjanosti i upotreba,
Valid From,Vrijedi od,
Valid Upto,Vrijedi do,
Maximum Use,Maksimalna upotreba,
Used,Rabljeni,
Coupon Description,Opis kupona,
Discounted Invoice,Račun s popustom,
Debit to,Na teret,
Exchange Rate Revaluation,Revalorizacija deviznog kursa,
Get Entries,Get Entries,
Exchange Rate Revaluation Account,Račun revalorizacije kursa,
Total Gain/Loss,Ukupni dobitak / gubitak,
Balance In Account Currency,Balans u valuti računa,
Current Exchange Rate,Tekući kurs,
Balance In Base Currency,Bilans u osnovnoj valuti,
New Exchange Rate,Novi kurs,
New Balance In Base Currency,Novo stanje u osnovnoj valuti,
Gain/Loss,Dobit / gubitak,
**Fiscal Year** represents a Financial Year. All accounting entries and other major transactions are tracked against **Fiscal Year**.,** Fiskalna godina ** predstavlja finansijske godine. Svi računovodstvene stavke i drugih većih transakcija se prate protiv ** Fiskalna godina **.,
Year Name,Naziv godine,
"For e.g. 2012, 2012-13","Za npr. 2012, 2012-13",
Year Start Date,Početni datum u godini,
Year End Date,Završni datum godine,
Companies,Companies,
Auto Created,Automatski kreiran,
Stock User,Stock korisnika,
Fiscal Year Company,Fiskalna godina Company,
Debit Amount,Debit Iznos,
Credit Amount,Iznos kredita,
Debit Amount in Account Currency,Debit Iznos u računu valuta,
Credit Amount in Account Currency,Iznos kredita u računu valuta,
Voucher Detail No,Bon Detalj Ne,
Is Opening,Je Otvaranje,
Is Advance,Je avans,
To Rename,Preimenovati,
GST Account,GST račun,
CGST Account,CGST nalog,
SGST Account,SGST nalog,
IGST Account,IGST nalog,
CESS Account,CESS nalog,
Loan Start Date,Datum početka zajma,
Loan Period (Days),Period zajma (Dani),
Loan End Date,Datum završetka zajma,
Bank Charges,Naknade za banke,
Short Term Loan Account,Kratkoročni račun zajma,
Bank Charges Account,Račun bankovnih naknada,
Accounts Receivable Credit Account,Račun za naplatu potraživanja,
Accounts Receivable Discounted Account,Račun s diskontovanim potraživanjima,
Accounts Receivable Unpaid Account,Neplaćeni račun za potraživanja,
Item Tax Template,Predložak poreza na stavku,
Tax Rates,Porezne stope,
Item Tax Template Detail,Detalj predloška predloška poreza,
Entry Type,Entry Tip,
Inter Company Journal Entry,Inter Company Journal Entry,
Bank Entry,Bank Entry,
Cash Entry,Cash Entry,
Credit Card Entry,Credit Card Entry,
Contra Entry,Contra Entry,
Excise Entry,Akcizama Entry,
Write Off Entry,Napišite Off Entry,
Opening Entry,Otvaranje unos,
ACC-JV-.YYYY.-,ACC-JV-YYYY.-,
Accounting Entries,Računovodstvo unosi,
Total Debit,Ukupno zaduženje,
Total Credit,Ukupna kreditna,
Difference (Dr - Cr),Razlika ( dr. - Cr ),
Make Difference Entry,Čine razliku Entry,
Total Amount Currency,Ukupan iznos valute,
Total Amount in Words,Ukupan iznos riječima,
Remark,Primjedba,
Paid Loan,Paid Loan,
Inter Company Journal Entry Reference,Referenca za unos dnevnika Inter Company,
Write Off Based On,Otpis na temelju,
Get Outstanding Invoices,Kreiraj neplaćene račune,
Write Off Amount,Otpis iznosa,
Printing Settings,Printing Settings,
Pay To / Recd From,Platiti Da / RecD Od,
Payment Order,Nalog za plaćanje,
Subscription Section,Subscription Section,
Journal Entry Account,Journal Entry račun,
Account Balance,Bilans konta,
Party Balance,Party Balance,
Accounting Dimensions,Računovodstvene dimenzije,
If Income or Expense,Ako prihoda i rashoda,
Exchange Rate,Tečaj,
Debit in Company Currency,Debit u Company valuta,
Credit in Company Currency,Credit Company valuta,
Payroll Entry,Unos plata,
Employee Advance,Advance Employee,
Reference Due Date,Referentni rok za dostavljanje,
Loyalty Program Tier,Nivo programa lojalnosti,
Redeem Against,Iskoristi protiv,
Expiry Date,Datum isteka,
Loyalty Point Entry Redemption,Povlačenje ulazne točke na lojalnost,
Redemption Date,Datum otkupljenja,
Redeemed Points,Iskorišćene tačke,
Loyalty Program Name,Ime programa lojalnosti,
Loyalty Program Type,Vrsta programa lojalnosti,
Single Tier Program,Jednostavni program,
Multiple Tier Program,Multiple Tier Program,
Customer Territory,Teritorija kupaca,
Auto Opt In (For all customers),Automatsko uključivanje (za sve potrošače),
Collection Tier,Kolekcija Tier,
Collection Rules,Pravila sakupljanja,
Redemption,Otkupljenje,
Conversion Factor,Konverzijski faktor,
1 Loyalty Points = How much base currency?,1 Loyalty Bodovi = Kolika osnovna valuta?,
Expiry Duration (in days),Trajanje isteka (u danima),
Help Section,Help Section,
Loyalty Program Help,Pomoć programa za lojalnost,
Loyalty Program Collection,Zbirka programa lojalnosti,
Tier Name,Tier Name,
Minimum Total Spent,Minimalno ukupno potrošeno,
Collection Factor (=1 LP),Faktor sakupljanja (= 1 LP),
For how much spent = 1 Loyalty Point,Za koliko je potrošeno = 1 lojalnost,
Mode of Payment Account,Način plaćanja računa,
Default Account,Podrazumjevani konto,
Default account will be automatically updated in POS Invoice when this mode is selected.,Podrazumevani nalog će se automatski ažurirati u POS računu kada je izabran ovaj režim.,
**Monthly Distribution** helps you distribute the Budget/Target across months if you have seasonality in your business.,** Mjesečna distribucija ** će Vam pomoći distribuirati budžeta / Target preko mjeseca ako imate sezonalnost u vaše poslovanje.,
Distribution Name,Naziv distribucije,
Name of the Monthly Distribution,Naziv Mjesečni distribucije,
Monthly Distribution Percentages,Mjesečni Distribucija Procenat,
Monthly Distribution Percentage,Mjesečni Distribucija Postotak,
Percentage Allocation,Postotak Raspodjela,
Create Missing Party,Napravite Missing Party,
Create missing customer or supplier.,Kreirajte nestalog klijenta ili dobavljača.,
Opening Invoice Creation Tool Item,Stavka o otvaranju fakture kreiranja stavke,
Temporary Opening Account,Privremeni račun za otvaranje,
Party Account,Party račun,
Type of Payment,Vrsta plaćanja,
ACC-PAY-.YYYY.-,ACC-PAY-.YYYY.-,
Receive,Primiti,
Internal Transfer,Interna Transfer,
Payment Order Status,Status naloga za plaćanje,
Payment Ordered,Raspored plaćanja,
Payment From / To,Plaćanje Od / Do,
Company Bank Account,Bankovni račun kompanije,
Party Bank Account,Bankovni račun stranke,
Account Paid From,Računa isplaćuju iz,
Account Paid To,Račun Paid To,
Paid Amount (Company Currency),Uplaćeni iznos (poduzeća Valuta),
Received Amount,Primljeni Iznos,
Received Amount (Company Currency),Primljeni Iznos (Company Valuta),
Get Outstanding Invoice,Nabavite izvanredni račun,
Payment References,plaćanje Reference,
Writeoff,Otpisati,
Total Allocated Amount,Ukupan dodijeljeni iznos,
Total Allocated Amount (Company Currency),Ukupan dodijeljeni iznos (Company Valuta),
Set Exchange Gain / Loss,Set Exchange dobitak / gubitak,
Difference Amount (Company Currency),Razlika Iznos (Company Valuta),
Write Off Difference Amount,Otpis Razlika Iznos,
Deductions or Loss,Smanjenja ili gubitak,
Payment Deductions or Loss,Plaćanje Smanjenja ili gubitak,
Cheque/Reference Date,Ček / Referentni datum,
Payment Entry Deduction,Plaćanje Entry Odbitak,
Payment Entry Reference,Plaćanje Entry Reference,
Allocated,Izdvojena,
Payment Gateway Account,Payment Gateway računa,
Payment Account,Plaćanje računa,
Default Payment Request Message,Uobičajeno plaćanje poruka zahtjeva,
PMO-,PMO-,
Payment Order Type,Vrsta naloga za plaćanje,
Payment Order Reference,Referentni nalog za plaćanje,
Bank Account Details,Detalji o bankovnom računu,
Payment Reconciliation,Pomirenje plaćanja,
Receivable / Payable Account,Potraživanja / Account plaćaju,
Bank / Cash Account,Banka / Cash račun,
From Invoice Date,Iz Datum računa,
To Invoice Date,Da biste Datum računa,
Minimum Invoice Amount,Minimalni iznos fakture,
Maximum Invoice Amount,Maksimalni iznos fakture,
System will fetch all the entries if limit value is zero.,Sustav će preuzeti sve unose ako je granična vrijednost jednaka nuli.,
Get Unreconciled Entries,Kreiraj neusklađene ulaze,
Unreconciled Payment Details,Nesaglašen Detalji plaćanja,
Invoice/Journal Entry Details,Račun / Journal Entry Detalji,
Payment Reconciliation Invoice,Pomirenje Plaćanje fakture,
Invoice Number,Račun broj,
Payment Reconciliation Payment,Pomirenje Plaćanje Plaćanje,
Reference Row,referentni Row,
Allocated amount,Izdvojena iznosu,
Payment Request Type,Tip zahtjeva za plaćanje,
Outward,Napolju,
Inward,Unutra,
ACC-PRQ-.YYYY.-,ACC-PRQ-YYYY.-,
Transaction Details,Detalji transakcije,
Amount in customer's currency,Iznos u valuti kupca,
Is a Subscription,Je Pretplata,
Transaction Currency,transakcija valuta,
Subscription Plans,Planovi pretplate,
SWIFT Number,SWIFT broj,
Recipient Message And Payment Details,Primalac poruka i plaćanju,
Make Sales Invoice,Ostvariti prodaju fakturu,
Mute Email,Mute-mail,
payment_url,payment_url,
Payment Gateway Details,Payment Gateway Detalji,
Payment Schedule,Raspored plaćanja,
Invoice Portion,Portfelj fakture,
Payment Amount,Plaćanje Iznos,
Payment Term Name,Naziv termina plaćanja,
Due Date Based On,Due Date Based On,
Day(s) after invoice date,Dan (a) nakon datuma fakture,
Day(s) after the end of the invoice month,Dan (i) nakon završetka meseca fakture,
Month(s) after the end of the invoice month,Mesec (i) nakon kraja mjeseca fakture,
Credit Days,Kreditne Dani,
Credit Months,Kreditni meseci,
Allocate Payment Based On Payment Terms,Dodijelite plaćanje na osnovu uslova plaćanja,
"If this checkbox is checked, paid amount will be splitted and allocated as per the amounts in payment schedule against each payment term","Ako je ovo polje potvrđeno, uplaćeni iznos podijelit će se i rasporediti prema iznosima u rasporedu plaćanja prema svakom roku plaćanja",
Payment Terms Template Detail,Detail Template Template,
Closing Fiscal Year,Zatvaranje Fiskalna godina,
Closing Account Head,Zatvaranje računa šefa,
"The account head under Liability or Equity, in which Profit/Loss will be booked","Glava račun pod odgovornošću ili Equity, u kojoj će se rezervirati Dobit / Gubitak",
POS Customer Group,POS kupaca Grupa,
POS Field,POS polje,
POS Item Group,POS Stavka Group,
Company Address,Company Adresa,
Update Stock,Ažurirajte Stock,
Ignore Pricing Rule,Ignorirajte Cijene pravilo,
Applicable for Users,Primenljivo za korisnike,
Sales Invoice Payment,Prodaja fakture za plaćanje,
Item Groups,stavka grupe,
Only show Items from these Item Groups,Prikažite samo stavke iz ovih grupa predmeta,
Customer Groups,Customer grupe,
Only show Customer of these Customer Groups,Pokaži samo kupca ovih grupa kupaca,
Write Off Account,Napišite Off račun,
Write Off Cost Center,Otpis troška,
Account for Change Amount,Nalog za promjene Iznos,
Taxes and Charges,Porezi i naknade,
Apply Discount On,Nanesite popusta na,
POS Profile User,POS korisnik profila,
Apply On,Primjeni na,
Price or Product Discount,Cijena ili popust na proizvod,
Apply Rule On Item Code,Primijenite pravilo na kod predmeta,
Apply Rule On Item Group,Primijenite pravilo na grupu predmeta,
Apply Rule On Brand,Primjeni pravilo na marku,
Mixed Conditions,Mešani uslovi,
Conditions will be applied on all the selected items combined. ,Uvjeti će se primjenjivati na sve odabrane stavke zajedno.,
Is Cumulative,Je kumulativno,
Coupon Code Based,Na osnovu koda kupona,
Discount on Other Item,Popust na drugi artikl,
Apply Rule On Other,Primijenite Pravilo na ostalo,
Party Information,Informacije o zabavi,
Quantity and Amount,Količina i količina,
Min Qty,Min kol,
Max Qty,Max kol,
Min Amt,Min Amt,
Max Amt,Max Amt,
Period Settings,Podešavanja razdoblja,
Margin,Marža,
Margin Type,Margina Tip,
Margin Rate or Amount,Margina Rate ili iznos,
Price Discount Scheme,Shema popusta na cijene,
Rate or Discount,Stopa ili popust,
Discount Percentage,Postotak rabata,
Discount Amount,Iznos rabata,
For Price List,Za Cjeniku,
Product Discount Scheme,Shema popusta na proizvode,
Same Item,Ista stavka,
Free Item,Free Item,
Threshold for Suggestion,Prag za sugestiju,
System will notify to increase or decrease quantity or amount ,Sistem će obavijestiti da poveća ili smanji količinu ili količinu,
"Higher the number, higher the priority","Veći broj, veći prioritet",
Apply Multiple Pricing Rules,Primenite višestruka pravila cena,
Apply Discount on Rate,Primenite popust na rate,
Validate Applied Rule,Potvrdite primijenjeno pravilo,
Rule Description,Opis pravila,
Pricing Rule Help,Cijene Pravilo Pomoć,
Promotional Scheme Id,Id promotivne šeme,
Promotional Scheme,Promotivna šema,
Pricing Rule Brand,Marka pravila o cijenama,
Pricing Rule Detail,Detalj pravila o cijenama,
Child Docname,Ime deteta,
Rule Applied,Pravilo se primjenjuje,
Pricing Rule Item Code,Pravilo cijene Šifra predmeta,
Pricing Rule Item Group,Skupina pravila pravila o cijenama,
Price Discount Slabs,Ploče s popustom cijena,
Promotional Scheme Price Discount,Popust na promotivne šeme,
Product Discount Slabs,Ploče s popustom na proizvode,
Promotional Scheme Product Discount,Popust na promotivne šeme proizvoda,
Min Amount,Min. Iznos,
Max Amount,Maksimalni iznos,
Discount Type,Tip popusta,
ACC-PINV-.YYYY.-,ACC-PINV-.YYYY.-,
Tax Withholding Category,Kategorija za oduzimanje poreza,
Edit Posting Date and Time,Edit knjiženja datuma i vremena,
Is Paid,plaća,
Is Return (Debit Note),Je povratak (obaveštenje o zaduživanju),
Apply Tax Withholding Amount,Primijeniti iznos poreznog štednje,
Accounting Dimensions ,Računovodstvene dimenzije,
Supplier Invoice Details,Dobavljač Račun Detalji,
Supplier Invoice Date,Dobavljač Datum fakture,
Return Against Purchase Invoice,Vratiti protiv fakturi,
Select Supplier Address,Izaberite dobavljač adresa,
Contact Person,Kontakt osoba,
Select Shipping Address,Izaberite Dostava Adresa,
Currency and Price List,Valuta i cjenik,
Price List Currency,Cjenik valuta,
Price List Exchange Rate,Cjenik tečajna,
Set Accepted Warehouse,Postavite Prihvaćeno skladište,
Rejected Warehouse,Odbijen galerija,
Warehouse where you are maintaining stock of rejected items,Skladište gdje ste održavanju zaliha odbijenih stavki,
Raw Materials Supplied,Sirovine nabavlja,
Supplier Warehouse,Dobavljač galerija,
Pricing Rules,Pravila cijena,
Supplied Items,Isporučenog pribora,
Total (Company Currency),Ukupno (Company valuta),
Net Total (Company Currency),Neto Ukupno (Društvo valuta),
Total Net Weight,Ukupna neto težina,
Shipping Rule,Pravilo transporta,
Purchase Taxes and Charges Template,Kupiti poreza i naknada Template,
Purchase Taxes and Charges,Kupnja Porezi i naknade,
Tax Breakup,porez Raspad,
Taxes and Charges Calculation,Porezi i naknade Proračun,
Taxes and Charges Added (Company Currency),Porezi i naknade uvrštenja (Društvo valuta),
Taxes and Charges Deducted (Company Currency),Porezi i naknade Umanjenja (Društvo valuta),
Total Taxes and Charges (Company Currency),Ukupno Porezi i naknade (Društvo valuta),
Taxes and Charges Added,Porezi i naknade Dodano,
Taxes and Charges Deducted,Porezi i naknade oduzeti,
Total Taxes and Charges,Ukupno Porezi i naknade,
Additional Discount,Dodatni popust,
Apply Additional Discount On,Nanesite dodatni popust na,
Additional Discount Amount (Company Currency),Dodatni popust Iznos (Company valuta),
Additional Discount Percentage,Dodatni postotak popusta,
Additional Discount Amount,Dodatni iznos popusta,
Grand Total (Company Currency),Sveukupno (valuta tvrtke),
Rounding Adjustment (Company Currency),Prilagođavanje zaokruživanja (valuta kompanije),
Rounded Total (Company Currency),Zaobljeni Ukupno (Društvo valuta),
In Words (Company Currency),Riječima (valuta tvrtke),
Rounding Adjustment,Prilagođavanje zaokruživanja,
In Words,Riječima,
Total Advance,Ukupno predujma,
Disable Rounded Total,Ugasiti zaokruženi iznos,
Cash/Bank Account,Novac / bankovni račun,
Write Off Amount (Company Currency),Otpis Iznos (poduzeća Valuta),
Set Advances and Allocate (FIFO),Postavite napredak i dodelite (FIFO),
Get Advances Paid,Kreiraj avansno plaćanje,
Advances,Avansi,
Terms,Uvjeti,
Terms and Conditions1,Odredbe i Conditions1,
Group same items,Grupa iste stavke,
Print Language,print Jezik,
"Once set, this invoice will be on hold till the set date","Jednom podešen, ovaj račun će biti na čekanju do određenog datuma",
Credit To,Kreditne Da,
Party Account Currency,Party računa valuta,
Against Expense Account,Protiv Rashodi račun,
Inter Company Invoice Reference,Referenca interne kompanije,
Is Internal Supplier,Je interni snabdevač,
Start date of current invoice's period,Početak datum tekućeg razdoblja dostavnice,
End date of current invoice's period,Kraj datum tekućeg razdoblja dostavnice,
Update Auto Repeat Reference,Ažurirajte Auto Repeat Reference,
Purchase Invoice Advance,Narudzbine avans,
Purchase Invoice Item,Narudzbine stavki,
Quantity and Rate,Količina i stopa,
Received Qty,Pozicija Kol,
Accepted Qty,Prihvaćeno Količina,
Rejected Qty,odbijena Količina,
UOM Conversion Factor,UOM konverzijski faktor,
Discount on Price List Rate (%),Popust na cijenu List stopa (%),
Price List Rate (Company Currency),Cjenik stopa (Društvo valuta),
Rate ,Cijena,
Rate (Company Currency),Cijena (Valuta kompanije),
Amount (Company Currency),Iznos (valuta preduzeća),
Is Free Item,Je besplatna stavka,
Net Rate,Neto stopa,
Net Rate (Company Currency),Neto stopa (Company valuta),
Net Amount (Company Currency),Neto iznos (Company valuta),
Item Tax Amount Included in Value,Iznos poreza uključen u vrijednost,
Landed Cost Voucher Amount,Sleteo Cost vaučera Iznos,
Raw Materials Supplied Cost,Sirovine Isporuka Troškovi,
Accepted Warehouse,Prihvaćeno skladište,
Serial No,Serijski br,
Rejected Serial No,Odbijen Serijski br,
Expense Head,Rashodi voditelj,
Is Fixed Asset,Fiksni Asset,
Asset Location,Lokacija imovine,
Deferred Expense,Odloženi troškovi,
Deferred Expense Account,Odloženi račun za troškove,
Service Stop Date,Datum zaustavljanja usluge,
Enable Deferred Expense,Omogućite odloženi trošak,
Service Start Date,Datum početka usluge,
Service End Date,Datum završetka usluge,
Allow Zero Valuation Rate,Dozvolite Zero Vrednovanje Rate,
Item Tax Rate,Poreska stopa artikla,
Tax detail table fetched from item master as a string and stored in this field.\nUsed for Taxes and Charges,Porez detalj stol učitani iz stavka master kao string i pohranjeni u ovoj oblasti.\n Koristi se za poreza i naknada,
Purchase Order Item,Narudžbenica predmet,
Purchase Receipt Detail,Detalji potvrde o kupnji,
Item Weight Details,Detaljna težina stavke,
Weight Per Unit,Težina po jedinici,
Total Weight,Ukupna tezina,
Weight UOM,Težina UOM,
Page Break,Prijelom stranice,
Consider Tax or Charge for,Razmislite poreza ili pristojbi za,
Valuation and Total,Vrednovanje i Total,
Valuation,Procjena,
Add or Deduct,Zbrajanje ili oduzimanje,
Deduct,Odbiti,
On Previous Row Amount,Na prethodnu Row visini,
On Previous Row Total,Na prethodni redak Ukupno,
On Item Quantity,Na Količina predmeta,
Reference Row #,Reference Row #,
Is this Tax included in Basic Rate?,Je li ovo pristojba uključena u osnovne stope?,
"If checked, the tax amount will be considered as already included in the Print Rate / Print Amount","Ako je označeno, iznos poreza će se smatrati već uključena u Print Rate / Ispis Iznos",
Account Head,Zaglavlje konta,
Tax Amount After Discount Amount,Iznos poreza Nakon iznosa popusta,
Item Wise Tax Detail ,Detalj poreza na mudar predmet,
"Standard tax template that can be applied to all Purchase Transactions. This template can contain list of tax heads and also other expense heads like ""Shipping"", ""Insurance"", ""Handling"" etc.\n\n#### Note\n\nThe tax rate you define here will be the standard tax rate for all **Items**. If there are **Items** that have different rates, they must be added in the **Item Tax** table in the **Item** master.\n\n#### Description of Columns\n\n1. Calculation Type: \n    - This can be on **Net Total** (that is the sum of basic amount).\n    - **On Previous Row Total / Amount** (for cumulative taxes or charges). If you select this option, the tax will be applied as a percentage of the previous row (in the tax table) amount or total.\n    - **Actual** (as mentioned).\n2. Account Head: The Account ledger under which this tax will be booked\n3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.\n4. Description: Description of the tax (that will be printed in invoices / quotes).\n5. Rate: Tax rate.\n6. Amount: Tax amount.\n7. Total: Cumulative total to this point.\n8. Enter Row: If based on ""Previous Row Total"" you can select the row number which will be taken as a base for this calculation (default is the previous row).\n9. Consider Tax or Charge for: In this section you can specify if the tax / charge is only for valuation (not a part of total) or only for total (does not add value to the item) or for both.\n10. Add or Deduct: Whether you want to add or deduct the tax.","Standard poreza predložak koji se može primijeniti na sve kupovnih transakcija. Ovaj predložak može sadržavati popis poreskih glava i drugih rashoda glave kao što su ""Shipping"", ""osiguranje"", ""Rukovanje"" itd \n\n #### Napomena \n\n Stopa poreza te definirati ovdje će biti standardna stopa poreza za sve ** Predmeti **. Ako postoje ** ** Predmeti koji imaju različite stope, oni moraju biti dodan u ** Stavka poreza na stolu ** u ** ** Stavka master.\n\n #### Opis Kolumne \n\n 1. Obračun Tip: \n - To može biti na ** Neto Ukupno ** (to je zbroj osnovnog iznosa).\n - ** Na Prethodna Row Ukupan / Iznos ** (za kumulativni poreza ili naknada). Ako odaberete ovu opciju, porez će se primjenjivati kao postotak prethodnog reda (u tabeli poreza) iznos ili ukupno.\n - ** Stvarna ** (kao što je spomenuto).\n 2. Račun Head: The račun knjigu pod kojima porez će biti kažnjen \n 3. Trošak Center: Ako porez / zadužen je prihod (kao što je shipping) ili rashod treba da se rezervirati protiv troška.\n 4. Opis: Opis poreza (koje će se štampati u fakturama / navodnika).\n 5. Rate: Stopa poreza.\n 6. Iznos: Iznos PDV-a.\n 7. Ukupno: Kumulativni ukupno do ove tačke.\n 8. Unesite Row: Ako na osnovu ""Prethodna Row Ukupno"" možete odabrati broj reda koji se mogu uzeti kao osnova za ovaj proračun (default je prethodnog reda).\n 9. Razmislite poreza ili naknada za: U ovom dijelu možete odrediti ako poreski / zadužen je samo za vrednovanje (nije dio od ukupnog broja), ili samo za ukupno (ne dodaje vrijednost u stavku) ili oboje.\n 10. Dodavanje ili Oduzeti: Bilo da želite dodati ili oduzeti porez.",
ACC-SINV-.YYYY.-,ACC-SINV-.YYYY.-,
Include Payment (POS),Uključuju plaćanje (POS),
Offline POS Name,Offline POS Ime,
Is Return (Credit Note),Je povratak (kreditna beleška),
Return Against Sales Invoice,Vratiti Protiv Sales fakture,
Update Billed Amount in Sales Order,Ažurirajte naplaćeni iznos u prodajnom nalogu,
Customer PO Details,Kupac PO Detalji,
Customer's Purchase Order,Narudžbenica kupca,
Customer's Purchase Order Date,Kupca narudžbenice Datum,
Customer Address,Kupac Adresa,
Shipping Address Name,Dostava adresa Ime,
Company Address Name,Kompanija adresa Ime,
Rate at which Customer Currency is converted to customer's base currency,Stopa po kojoj Kupac valuta se pretvaraju u kupca osnovne valute,
Rate at which Price list currency is converted to customer's base currency,Stopa po kojoj Cjenik valute se pretvaraju u kupca osnovne valute,
Set Source Warehouse,Podesite Source Warehouse,
Packing List,Popis pakiranja,
Packed Items,Pakirano Predmeti,
Product Bundle Help,Proizvod Bundle Pomoć,
Time Sheet List,Time Sheet List,
Time Sheets,Time listovi,
Total Billing Amount,Ukupan iznos naplate,
Sales Taxes and Charges Template,Prodaja poreza i naknada Template,
Sales Taxes and Charges,Prodaja Porezi i naknade,
Loyalty Points Redemption,Povlačenje lojalnosti,
Redeem Loyalty Points,Iskoristite lojalnostne tačke,
Redemption Account,Račun za otkup,
Redemption Cost Center,Centar za isplatu troškova,
In Words will be visible once you save the Sales Invoice.,U riječi će biti vidljiv nakon što spremite prodaje fakture.,
Allocate Advances Automatically (FIFO),Dodjeljivanje unaprijed automatski (FIFO),
Get Advances Received,Kreiraj avansno primanje,
Base Change Amount (Company Currency),Base Promijeni Iznos (Company Valuta),
Write Off Outstanding Amount,Otpisati preostali iznos,
Terms and Conditions Details,Uvjeti Detalji,
Is Internal Customer,Je interni korisnik,
Is Discounted,Se snižava,
Unpaid and Discounted,Neplaćeno i sniženo,
Overdue and Discounted,Zakašnjeli i sniženi,
Accounting Details,Računovodstvo Detalji,
Debit To,Rashodi za,
Is Opening Entry,Je Otvaranje unos,
C-Form Applicable,C-obrascu,
Commission Rate (%),Komisija stopa (%),
Sales Team1,Prodaja Team1,
Against Income Account,Protiv računu dohotka,
Sales Invoice Advance,Predujam prodajnog računa,
Advance amount,Iznos avansa,
Sales Invoice Item,Stavka fakture prodaje,
Customer's Item Code,Kupca Stavka Šifra,
Brand Name,Naziv brenda,
Qty as per Stock UOM,Količina po burzi UOM,
Discount and Margin,Popust i Margin,
Rate With Margin,Stopu sa margina,
Discount (%) on Price List Rate with Margin,Popust (%) na Cjenovnik objekta sa margina,
Rate With Margin (Company Currency),Rate With Margin (Valuta kompanije),
Delivered By Supplier,Isporučuje dobavljač,
Deferred Revenue,Odloženi prihodi,
Deferred Revenue Account,Odgođeni račun za prihode,
Enable Deferred Revenue,Omogućite odloženi prihod,
Stock Details,Stock Detalji,
Customer Warehouse (Optional),Customer Warehouse (Opcionalno),
Available Batch Qty at Warehouse,Dostupno Batch Količina na Skladište,
Available Qty at Warehouse,Dostupna količina na skladištu,
Delivery Note Item,Stavka otpremnice,
Base Amount (Company Currency),Base Iznos (Company Valuta),
Sales Invoice Timesheet,Prodaja Račun Timesheet,
Time Sheet,Time Sheet,
Billing Hours,Billing Hours,
Timesheet Detail,Timesheet Detail,
Tax Amount After Discount Amount (Company Currency),Iznos PDV-a Nakon Popust Iznos (Company valuta),
Item Wise Tax Detail,Stavka Wise Porezna Detalj,
Parenttype,Parenttype,
"Standard tax template that can be applied to all Sales Transactions. This template can contain list of tax heads and also other expense / income heads like ""Shipping"", ""Insurance"", ""Handling"" etc.\n\n#### Note\n\nThe tax rate you define here will be the standard tax rate for all **Items**. If there are **Items** that have different rates, they must be added in the **Item Tax** table in the **Item** master.\n\n#### Description of Columns\n\n1. Calculation Type: \n    - This can be on **Net Total** (that is the sum of basic amount).\n    - **On Previous Row Total / Amount** (for cumulative taxes or charges). If you select this option, the tax will be applied as a percentage of the previous row (in the tax table) amount or total.\n    - **Actual** (as mentioned).\n2. Account Head: The Account ledger under which this tax will be booked\n3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.\n4. Description: Description of the tax (that will be printed in invoices / quotes).\n5. Rate: Tax rate.\n6. Amount: Tax amount.\n7. Total: Cumulative total to this point.\n8. Enter Row: If based on ""Previous Row Total"" you can select the row number which will be taken as a base for this calculation (default is the previous row).\n9. Is this Tax included in Basic Rate?: If you check this, it means that this tax will not be shown below the item table, but will be included in the Basic Rate in your main item table. This is useful where you want give a flat price (inclusive of all taxes) price to customers.","Standard poreza predložak koji se može primijeniti na sve poslove prodaje. Ovaj predložak može sadržavati popis poreskih glava i ostali rashodi / prihodi glave kao što su ""Shipping"", ""osiguranje"", ""Rukovanje"" itd \n\n #### Napomena \n\n Stopa poreza te definirati ovdje će biti standardna stopa poreza za sve ** Predmeti **. Ako postoje ** ** Predmeti koji imaju različite stope, oni moraju biti dodan u ** Stavka poreza na stolu ** u ** ** Stavka master.\n\n #### Opis Kolumne \n\n 1. Obračun Tip: \n - To može biti na ** Neto Ukupno ** (to je zbroj osnovnog iznosa).\n - ** Na Prethodna Row Ukupan / Iznos ** (za kumulativni poreza ili naknada). Ako odaberete ovu opciju, porez će se primjenjivati kao postotak prethodnog reda (u tabeli poreza) iznos ili ukupno.\n - ** Stvarna ** (kao što je spomenuto).\n 2. Račun Head: The račun knjigu pod kojima porez će biti kažnjen \n 3. Trošak Center: Ako porez / zadužen je prihod (kao što je shipping) ili rashod treba da se rezervirati protiv troška.\n 4. Opis: Opis poreza (koje će se štampati u fakturama / navodnika).\n 5. Rate: Stopa poreza.\n 6. Iznos: Iznos PDV-a.\n 7. Ukupno: Kumulativni ukupno do ove tačke.\n 8. Unesite Row: Ako na osnovu ""Prethodna Row Ukupno"" možete odabrati broj reda koji se mogu uzeti kao osnova za ovaj proračun (default je prethodnog reda).\n 9. Je li ovo pristojba uključena u Basic Rate ?: Ako označite ovu, to znači da ovaj porez neće biti prikazan ispod stola stavku, ali će biti uključeni u Basic Rate na glavnom stavku stola. To je korisno u kojoj želite dati cijena stana (uključujući sve poreze) cijene kupcima.",
* Will be calculated in the transaction.,* Hoće li biti izračunata u transakciji.,
From No,Od br,
To No,Da ne,
Is Company,Je kompanija,
Current State,Trenutna drzava,
Purchased,Kupljeno,
From Shareholder,Od dioničara,
From Folio No,Od Folio No,
To Shareholder,Za dioničara,
To Folio No,Za Folio No,
Equity/Liability Account,Račun kapitala / obaveza,
Asset Account,Račun imovine,
(including),(uključujući),
ACC-SH-.YYYY.-,ACC-SH-YYYY.-,
Folio no.,Folio br.,
Address and Contacts,Adresa i kontakti,
Contact List,Lista kontakata,
Hidden list maintaining the list of contacts linked to Shareholder,Skrivena lista održavajući listu kontakata povezanih sa akcionarima,
Specify conditions to calculate shipping amount,Odredite uvjete za izračunavanje iznosa shipping,
Shipping Rule Label,Naziv pravila transporta,
example: Next Day Shipping,Primjer: Sljedeći dan Dostava,
Shipping Rule Type,Tip pravila isporuke,
Shipping Account,Konto transporta,
Calculate Based On,Izračun zasnovan na,
Fixed,Fiksna,
Net Weight,Neto težina,
Shipping Amount,Iznos transporta,
Shipping Rule Conditions,Uslovi pravila transporta,
Restrict to Countries,Ograničiti zemlje,
Valid for Countries,Vrijedi za zemlje,
Shipping Rule Condition,Uslov pravila transporta,
A condition for a Shipping Rule,A uvjet za Shipping Pravilo,
From Value,Od Vrijednost,
To Value,Za vrijednost,
Shipping Rule Country,Dostava Pravilo Country,
Subscription Period,Period pretplate,
Subscription Start Date,Datum početka pretplate,
Cancelation Date,Datum otkazivanja,
Trial Period Start Date,Datum početka probnog perioda,
Trial Period End Date,Datum završetka probnog perioda,
Current Invoice Start Date,Trenutni datum početka fakture,
Current Invoice End Date,Trenutni datum završetka računa,
Days Until Due,Dani do dospijeća,
Number of days that the subscriber has to pay invoices generated by this subscription,Broj dana kada pretplatnik mora platiti fakture koje generiše ova pretplata,
Cancel At End Of Period,Otkaži na kraju perioda,
Generate Invoice At Beginning Of Period,Generirajte fakturu na početku perioda,
Plans,Planovi,
Discounts,Popusti,
Additional DIscount Percentage,Dodatni popust Procenat,
Additional DIscount Amount,Dodatni popust Iznos,
Subscription Invoice,Pretplata faktura,
Subscription Plan,Plan pretplate,
Cost,Troškovi,
Billing Interval,Interval zaračunavanja,
Billing Interval Count,Interval broja obračuna,
"Number of intervals for the interval field e.g if Interval is 'Days' and Billing Interval Count is 3, invoices will be generated every 3 days","Broj intervala za intervalno polje npr. Ako je Interval &quot;Dani&quot; i broj intervala obračuna je 3, fakture će biti generirane svakih 3 dana",
Payment Plan,Plan placanja,
Subscription Plan Detail,Detalji pretplate,
Plan,Plan,
Subscription Settings,Podešavanja pretplate,
Grace Period,Grace Period,
Number of days after invoice date has elapsed before canceling subscription or marking subscription as unpaid,Broj dana od dana kada je faktura protekla prije otkazivanja pretplate ili obilježavanja pretplate kao neplaćenog,
Prorate,Prorate,
Tax Rule,Porez pravilo,
Tax Type,Vrste poreza,
Use for Shopping Cart,Koristiti za Košarica,
Billing City,Billing Grad,
Billing County,Billing županije,
Billing State,State billing,
Billing Zipcode,Zipcode za naplatu,
Billing Country,Billing Country,
Shipping City,Dostava City,
Shipping County,Dostava županije,
Shipping State,State dostava,
Shipping Zipcode,Isporuka Zipcode,
Shipping Country,Dostava Country,
Tax Withholding Account,Porez na odbitak,
Tax Withholding Rates,Poreske stope odbijanja,
Rates,Cijene,
Tax Withholding Rate,Stopa zadržavanja poreza,
Single Transaction Threshold,Pojedinačni transakcioni prag,
Cumulative Transaction Threshold,Kumulativni prag transakcije,
Agriculture Analysis Criteria,Kriterijumi za analizu poljoprivrede,
Linked Doctype,Linked Doctype,
Water Analysis,Analiza vode,
Soil Analysis,Analiza tla,
Plant Analysis,Analiza biljaka,
Fertilizer,Đubrivo,
Soil Texture,Tekstura tla,
Weather,Vrijeme,
Agriculture Manager,Poljoprivredni menadžer,
Agriculture User,Korisnik poljoprivrede,
Agriculture Task,Poljoprivreda zadatak,
Task Name,Task Name,
Start Day,Početak dana,
End Day,Krajnji dan,
Holiday Management,Holiday Management,
Ignore holidays,Ignoriši praznike,
Previous Business Day,Prethodni radni dan,
Next Business Day,Sledeći radni dan,
Urgent,Hitan,
Crop Name,Naziv žetve,
Scientific Name,Naučno ime,
"You can define all the tasks which need to carried out for this crop here. The day field is used to mention the day on which the task needs to be carried out, 1 being the 1st day, etc.. ","Možete definisati sve zadatke koje je potrebno izvršiti za ovu žetvu ovdje. Dnevno polje se koristi da se pomene dan na koji se zadatak treba izvršiti, 1 je 1. dan itd.",
Crop Spacing,Rastojanje usjeva,
Crop Spacing UOM,Crop Spacing UOM,
Row Spacing,Razmak redova,
Row Spacing UOM,Razmak redova UOM,
Perennial,Višegodišnje,
Biennial,Bijenale,
Planting UOM,Sadnja UOM,
Planting Area,Sala za sadnju,
Yield UOM,Primarni UOM,
Materials Required,Potrebni materijali,
Produced Items,Proizvedene stavke,
Produce,Proizvesti,
Byproducts,Podbrojevi,
Linked Location,Povezana lokacija,
A link to all the Locations in which the Crop is growing,Veza sa svim lokacijama u kojima se Crop raste,
This will be day 1 of the crop cycle,Ovo će biti dan 1 ciklusa usjeva,
ISO 8601 standard,ISO 8601 standard,
Cycle Type,Tip ciklusa,
Less than a year,Manje od godinu dana,
The minimum length between each plant in the field for optimum growth,Minimalna dužina između svake biljke u polju za optimalan rast,
The minimum distance between rows of plants for optimum growth,Minimalno rastojanje između redova biljaka za optimalan rast,
Detected Diseases,Otkrivene bolesti,
List of diseases detected on the field. When selected it'll automatically add a list of tasks to deal with the disease ,"Spisak otkrivenih bolesti na terenu. Kada je izabran, automatski će dodati listu zadataka koji će se baviti bolesti",
Detected Disease,Detektovana bolest,
LInked Analysis,LInked Analysis,
Disease,Bolest,
Tasks Created,Kreirani zadaci,
Common Name,Zajedničko ime,
Treatment Task,Tretman zadataka,
Treatment Period,Period lečenja,
Fertilizer Name,Ime đubriva,
Density (if liquid),Gustina (ako je tečnost),
Fertilizer Contents,Sadržaj đubriva,
Fertilizer Content,Sadržaj đubriva,
Linked Plant Analysis,Analiza povezanih biljaka,
Linked Soil Analysis,Linked soil analysis,
Linked Soil Texture,Linked Soil Texture,
Collection Datetime,Kolekcija Datetime,
Laboratory Testing Datetime,Laboratorijsko ispitivanje Datetime,
Result Datetime,Result Datetime,
Plant Analysis Criterias,Kriterijumi za analizu biljaka,
Plant Analysis Criteria,Kriterijumi za analizu biljaka,
Minimum Permissible Value,Minimalna dozvoljena vrijednost,
Maximum Permissible Value,Maksimalna dozvoljena vrijednost,
Ca/K,Ca / K,
Ca/Mg,Ca / Mg,
Mg/K,Mg / K,
(Ca+Mg)/K,(Ca + Mg) / K,
Ca/(K+Ca+Mg),Ca / (K + Ca + Mg),
Soil Analysis Criterias,Kriterijumi za analizu zemljišta,
Soil Analysis Criteria,Kriterijumi za analizu zemljišta,
Soil Type,Vrsta zemljišta,
Loamy Sand,Loamy Sand,
Sandy Loam,Sandy Loam,
Loam,Loam,
Silt Loam,Silt Loam,
Sandy Clay Loam,Sandy Clay Loam,
Clay Loam,Clay Loam,
Silty Clay Loam,Silty Clay Loam,
Sandy Clay,Sandy Clay,
Silty Clay,Silty Clay,
Clay Composition (%),Glina sastav (%),
Sand Composition (%),Kompozicija peska (%),
Silt Composition (%),Silt sastav (%),
Ternary Plot,Ternary plot,
Soil Texture Criteria,Kriterijumi za teksturu tla,
Type of Sample,Tip uzorka,
Container,Kontejner,
Origin,Poreklo,
Collection Temperature ,Temperatura kolekcije,
Storage Temperature,Temperatura skladištenja,
Appearance,Izgled,
Person Responsible,Odgovorna osoba,
Water Analysis Criteria,Kriterijumi za analizu vode,
Weather Parameter,Vremenski parametar,
ACC-ASS-.YYYY.-,ACC-ASS-YYYY.-,
Asset Owner,Vlasnik imovine,
Asset Owner Company,Vlasnička kompanija,
Custodian,Skrbnik,
Disposal Date,odlaganje Datum,
Journal Entry for Scrap,Journal Entry za otpad,
Available-for-use Date,Datum dostupan za upotrebu,
Calculate Depreciation,Izračunajte amortizaciju,
Allow Monthly Depreciation,Dopustite mjesečnu amortizaciju,
Number of Depreciations Booked,Broj Amortizacija Booked,
Finance Books,Finansijske knjige,
Straight Line,Duž,
Double Declining Balance,Double degresivne,
Manual,priručnik,
Value After Depreciation,Vrijednost Nakon Amortizacija,
Total Number of Depreciations,Ukupan broj Amortizacija,
Frequency of Depreciation (Months),Učestalost amortizacije (mjeseci),
Next Depreciation Date,Sljedeća Amortizacija Datum,
Depreciation Schedule,Amortizacija Raspored,
Depreciation Schedules,Amortizacija rasporedi,
Insurance details,Detalji osiguranja,
Policy number,Broj police,
Insurer,Osiguravač,
Insured value,Osigurana vrijednost,
Insurance Start Date,Datum početka osiguranja,
Insurance End Date,Krajnji datum osiguranja,
Comprehensive Insurance,Sveobuhvatno osiguranje,
Maintenance Required,Potrebno održavanje,
Check if Asset requires Preventive Maintenance or Calibration,Proverite da li imovina zahteva preventivno održavanje ili kalibraciju,
Booked Fixed Asset,Rezervisana osnovna sredstva,
Purchase Receipt Amount,Iznos kupoprodajnog iznosa,
Default Finance Book,Osnovna finansijska knjiga,
Quality Manager,Quality Manager,
Asset Category Name,Asset Ime kategorije,
Depreciation Options,Opcije amortizacije,
Enable Capital Work in Progress Accounting,Omogućite kapitalni rad u računovodstvu u toku,
Finance Book Detail,Knjiga finansija Detail,
Asset Category Account,Asset Kategorija računa,
Fixed Asset Account,Osnovnih sredstava računa,
Accumulated Depreciation Account,Ispravka vrijednosti računa,
Depreciation Expense Account,Troškovi amortizacije računa,
Capital Work In Progress Account,Kapitalni rad je u toku,
Asset Finance Book,Asset Finance Book,
Written Down Value,Pisanje vrednosti,
Expected Value After Useful Life,Očekivana vrijednost Nakon Korisni Life,
Rate of Depreciation,Stopa amortizacije,
In Percentage,U procentima,
Maintenance Team,Tim za održavanje,
Maintenance Manager Name,Ime menadžera održavanja,
Maintenance Tasks,Zadaci održavanja,
Manufacturing User,Proizvodnja korisnika,
Asset Maintenance Log,Dnevnik o održavanju imovine,
ACC-AML-.YYYY.-,ACC-AML-.YYYY.-,
Maintenance Type,Održavanje Tip,
Maintenance Status,Održavanje statusa,
Planned,Planirano,
Has Certificate ,Ima certifikat,
Certificate,Certifikat,
Actions performed,Izvršene akcije,
Asset Maintenance Task,Zadatak održavanja sredstava,
Maintenance Task,Zadatak održavanja,
Preventive Maintenance,Preventivno održavanje,
Calibration,Kalibracija,
2 Yearly,2 Yearly,
Certificate Required,Sertifikat je potreban,
Assign to Name,Dodijeli imenu,
Next Due Date,Sljedeći datum roka,
Last Completion Date,Zadnji datum završetka,
Asset Maintenance Team,Tim za održavanje imovine,
Maintenance Team Name,Naziv tima za održavanje,
Maintenance Team Members,Članovi tima za održavanje,
Purpose,Svrha,
Stock Manager,Stock Manager,
Asset Movement Item,Stavka kretanja imovine,
Source Location,Izvor Lokacija,
From Employee,Od zaposlenika,
Target Location,Ciljna lokacija,
To Employee,Za zaposlene,
Asset Repair,Popravka imovine,
ACC-ASR-.YYYY.-,ACC-ASR-.YYYY.-,
Failure Date,Datum otkaza,
Assign To Name,Dodeli ime,
Repair Status,Status popravke,
Error Description,Opis greške,
Downtime,Zaustavljanje,
Repair Cost,Troškovi popravki,
Manufacturing Manager,Proizvodnja Manager,
Current Asset Value,Trenutna vrednost aktive,
New Asset Value,Nova vrijednost imovine,
Make Depreciation Entry,Make Amortizacija Entry,
Finance Book Id,Id Book of Finance,
Location Name,Ime lokacije,
Parent Location,Lokacija roditelja,
Is Container,Je kontejner,
Check if it is a hydroponic unit,Proverite da li je to hidroponska jedinica,
Location Details,Detalji o lokaciji,
Latitude,Latitude,
Longitude,Dužina,
Area,Područje,
Area UOM,Područje UOM,
Tree Details,Tree Detalji,
Maintenance Team Member,Član tima za održavanje,
Team Member,Član tima,
Maintenance Role,Uloga održavanja,
Buying Settings,Podešavanja nabavke,
Settings for Buying Module,Postavke za kupovinu modul,
Supplier Naming By,Dobavljač nazivanje,
Default Supplier Group,Podrazumevana grupa dobavljača,
Default Buying Price List,Zadani cjenik kupnje,
Backflush Raw Materials of Subcontract Based On,Backflush sirovine od podizvođača na bazi,
Material Transferred for Subcontract,Preneseni materijal za podugovaranje,
Over Transfer Allowance (%),Dodatak za prebacivanje (%),
Percentage you are allowed to transfer more against the quantity ordered. For example: If you have ordered 100 units. and your Allowance is 10% then you are allowed to transfer 110 units.,"Postotak koji vam je dozvoljen da prenesete više u odnosu na naručenu količinu. Na primjer: Ako ste naručili 100 jedinica. a vaš dodatak iznosi 10%, tada vam je dozvoljeno prenijeti 110 jedinica.",
PUR-ORD-.YYYY.-,PUR-ORD-YYYY.-,
Get Items from Open Material Requests,Saznajte Predmeti od Open materijala Zahtjevi,
Fetch items based on Default Supplier.,Dohvatite stavke na osnovu zadanog dobavljača.,
Required By,Potrebna Do,
Order Confirmation No,Potvrda o porudžbini br,
Order Confirmation Date,Datum potvrđivanja porudžbine,
Customer Mobile No,Mobilni broj kupca,
Customer Contact Email,Email kontakta kupca,
Set Target Warehouse,Postavite Target Warehouse,
Sets 'Warehouse' in each row of the Items table.,Postavlja &#39;Skladište&#39; u svaki red tabele Predmeti.,
Supply Raw Materials,Supply sirovine,
Purchase Order Pricing Rule,Pravilo o cenama narudžbe,
Set Reserve Warehouse,Postavite rezervnu magacinu,
In Words will be visible once you save the Purchase Order.,U riječi će biti vidljiv nakon što spremite narudžbenice.,
Advance Paid,Advance Paid,
Tracking,Praćenje,
% Billed,Naplaćeno%,
% Received,% Primljeno,
Ref SQ,Ref. SQ,
Inter Company Order Reference,Referentna narudžba kompanije,
Supplier Part Number,Dobavljač Broj dijela,
Billed Amt,Naplaćeni izn,
Warehouse and Reference,Skladište i upute,
To be delivered to customer,Dostaviti kupcu,
Material Request Item,Materijal Zahtjev artikla,
Supplier Quotation Item,Dobavljač ponudu artikla,
Against Blanket Order,Protiv pokrivača,
Blanket Order,Narudžbina odeće,
Blanket Order Rate,Stopa porudžbine odeće,
Returned Qty,Vraćeni Količina,
Purchase Order Item Supplied,Narudžbenica artikla Isporuka,
BOM Detail No,BOM detalji - broj,
Stock Uom,Kataloški UOM,
Raw Material Item Code,Sirovine Stavka Šifra,
Supplied Qty,Isporučeni Količina,
Purchase Receipt Item Supplied,Kupnja Prijem artikla Isporuka,
Current Stock,Trenutni Stock,
PUR-RFQ-.YYYY.-,PUR-RFQ-.YYYY.-,
For individual supplier,Za pojedinačne dobavljač,
Link to Material Requests,Link do zahtjeva za materijalom,
Message for Supplier,Poruka za dobavljača,
Request for Quotation Item,Zahtjev za ponudu artikla,
Required Date,Potrebna Datum,
Request for Quotation Supplier,Zahtjev za ponudu dobavljač,
Send Email,Pošaljite e-mail,
Quote Status,Quote Status,
Download PDF,Preuzmi PDF,
Supplier of Goods or Services.,Dobavljač robe ili usluga.,
Name and Type,Naziv i tip,
SUP-.YYYY.-,SUP-.YYYY.-,
Default Bank Account,Zadani bankovni račun,
Is Transporter,Je transporter,
Represents Company,Predstavlja kompaniju,
Supplier Type,Dobavljač Tip,
Allow Purchase Invoice Creation Without Purchase Order,Dozvoli stvaranje računa za kupovinu bez naloga za kupovinu,
Allow Purchase Invoice Creation Without Purchase Receipt,Dozvoli stvaranje računa za kupovinu bez potvrde o kupovini,
Warn RFQs,Upozorite RFQs,
Warn POs,Upozorite PO,
Prevent RFQs,Sprečite RFQs,
Prevent POs,Sprečite PO,
Billing Currency,Valuta plaćanja,
Default Payment Terms Template,Podrazumevani obrazac za plaćanje,
Block Supplier,Blok isporučilac,
Hold Type,Tip držanja,
Leave blank if the Supplier is blocked indefinitely,Ostavite prazno ako je Dobavljač blokiran na neodređeno vreme,
Default Payable Accounts,Uobičajeno Računi dobavljača,
Mention if non-standard payable account,Navesti ukoliko nestandardnog plaća račun,
Default Tax Withholding Config,Podrazumevana poreska obaveza zadržavanja poreza,
Supplier Details,Dobavljač Detalji,
Statutory info and other general information about your Supplier,Zakonska info i druge opće informacije o vašem Dobavljaču,
PUR-SQTN-.YYYY.-,PUR-SQTN-YYYY.-,
Supplier Address,Dobavljač Adresa,
Link to material requests,Link za materijal zahtjeva,
Rounding Adjustment (Company Currency,Prilagođavanje zaokruživanja (valuta kompanije,
Auto Repeat Section,Auto Repeat Odjeljak,
Is Subcontracted,Je podugovarati,
Lead Time in days,Potencijalni kupac u danima,
Supplier Score,Ocjena dobavljača,
Indicator Color,Boja boje,
Evaluation Period,Period evaluacije,
Per Week,Po tjednu,
Per Month,Mjesečno,
Per Year,Godišnje,
Scoring Setup,Podešavanje bodova,
Weighting Function,Funkcija ponderiranja,
"Scorecard variables can be used, as well as:\n{total_score} (the total score from that period),\n{period_number} (the number of periods to present day)\n","Može se koristiti varijable Scorecard, kao i: {total_score} (ukupna ocjena iz tog perioda), {period_number} (broj perioda za današnji dan)",
Scoring Standings,Tabelarni stavovi,
Criteria Setup,Postavljanje kriterijuma,
Load All Criteria,Učitaj sve kriterije,
Scoring Criteria,Kriteriji bodovanja,
Scorecard Actions,Action Scorecard,
Warn for new Request for Quotations,Upozorite na novi zahtev za citate,
Warn for new Purchase Orders,Upozoriti na nova narudžbina,
Notify Supplier,Obavijestiti dobavljača,
Notify Employee,Obavesti zaposlenika,
Supplier Scorecard Criteria,Kriterijumi za ocenjivanje dobavljača,
Criteria Name,Ime kriterijuma,
Max Score,Max Score,
Criteria Formula,Kriterijum Formula,
Criteria Weight,Kriterij Težina,
Supplier Scorecard Period,Period perioda ocenjivanja dobavljača,
PU-SSP-.YYYY.-,PU-SSP-YYYY.-,
Period Score,Ocena perioda,
Calculations,Izračunavanje,
Criteria,Kriterijumi,
Variables,Varijable,
Supplier Scorecard Setup,Podešavanje Scorecard-a,
Supplier Scorecard Scoring Criteria,Kriterijumi bodovanja rezultata ocenjivanja dobavljača,
Score,skor,
Supplier Scorecard Scoring Standing,Postupak Scorecard Scoreing Standing,
Standing Name,Stalno ime,
Purple,Ljubičasta,
Yellow,Žuta,
Orange,Narandžasta,
Min Grade,Min razred,
Max Grade,Max Grade,
Warn Purchase Orders,Upozoravajte narudžbenice,
Prevent Purchase Orders,Sprečite kupovne naloge,
Employee ,Radnik,
Supplier Scorecard Scoring Variable,Dobavljač Scorecard Scoring Variable,
Variable Name,Ime promenljive,
Parameter Name,Ime parametra,
Supplier Scorecard Standing,Standing Scorecard Standing,
Notify Other,Obavesti drugu,
Supplier Scorecard Variable,Varijabilni pokazatelj dobavljača,
Call Log,Spisak poziva,
Received By,Primio,
Caller Information,Informacije o pozivaocu,
Contact Name,Kontakt ime,
Lead ,Olovo,
Lead Name,Ime Lead-a,
Ringing,Zvuči,
Missed,Propušteno,
Call Duration in seconds,Trajanje poziva u sekundi,
Recording URL,URL za snimanje,
Communication Medium,Srednja komunikacija,
Communication Medium Type,Srednja komunikacija,
Voice,Glas,
Catch All,Catch All,
"If there is no assigned timeslot, then communication will be handled by this group","Ako nema dodeljenog vremenskog intervala, komunikacija će upravljati ovom grupom",
Timeslots,Timeslots,
Communication Medium Timeslot,Srednja komunikacija za vreme komunikacije,
Employee Group,Employee Group,
Appointment,Imenovanje,
Scheduled Time,Zakazano vreme,
Unverified,Neprovereno,
Customer Details,Korisnički podaci,
Phone Number,Telefonski broj,
Skype ID,Skype ID,
Linked Documents,Povezani dokumenti,
Appointment With,Sastanak sa,
Calendar Event,Kalendar događaja,
Appointment Booking Settings,Podešavanja rezervacije termina,
Enable Appointment Scheduling,Omogući zakazivanje termina,
Agent Details,Detalji o agentu,
Availability Of Slots,Dostupnost Slotova,
Number of Concurrent Appointments,Broj istodobnih imenovanja,
Agents,Agenti,
Appointment Details,Detalji sastanka,
Appointment Duration (In Minutes),Trajanje sastanka (u nekoliko minuta),
Notify Via Email,Obavijesti putem e-pošte,
Notify customer and agent via email on the day of the appointment.,Obavijestite kupca i agenta putem e-maila na dan sastanka.,
Number of days appointments can be booked in advance,Broj dana termina može se unaprijed rezervirati,
Success Settings,Postavke uspjeha,
Success Redirect URL,URL za preusmeravanje uspeha,
"Leave blank for home.\nThis is relative to site URL, for example ""about"" will redirect to ""https://yoursitename.com/about""","Ostavite prazno kod kuće. Ovo se odnosi na URL stranice, na primjer, &quot;about&quot; će se preusmjeriti na &quot;https://yoursitename.com/about&quot;",
Appointment Booking Slots,Slotovi za rezervaciju termina,
Day Of Week,Dan u nedelji,
From Time ,S vremena,
Campaign Email Schedule,Raspored e-pošte kampanje,
Send After (days),Pošaljite nakon (dana),
Signed,Potpisano,
Party User,Party User,
Unsigned,Unsigned,
Fulfilment Status,Status ispune,
N/A,N / A,
Unfulfilled,Neispunjeno,
Partially Fulfilled,Delimično ispunjeno,
Fulfilled,Ispunjeno,
Lapsed,Propušteno,
Contract Period,Period ugovora,
Signee Details,Signee Detalji,
Signee,Signee,
Signed On,Signed On,
Contract Details,Detalji ugovora,
Contract Template,Template Template,
Contract Terms,Uslovi ugovora,
Fulfilment Details,Ispunjavanje Detalji,
Requires Fulfilment,Zahteva ispunjenje,
Fulfilment Deadline,Rok ispunjenja,
Fulfilment Terms,Uslovi ispunjenja,
Contract Fulfilment Checklist,Kontrolna lista Ispunjavanja ugovora,
Requirement,Zahtev,
Contract Terms and Conditions,Uslovi i uslovi ugovora,
Fulfilment Terms and Conditions,Uslovi ispunjavanja uslova,
Contract Template Fulfilment Terms,Uslovi ispunjavanja obrasca ugovora,
Email Campaign,Kampanja e-pošte,
Email Campaign For ,Kampanja e-pošte za,
Lead is an Organization,Olovo je organizacija,
CRM-LEAD-.YYYY.-,CRM-LEAD-.YYYY.-,
Person Name,Ime osobe,
Lost Quotation,Lost Ponuda,
Interested,Zainteresovan,
Converted,Pretvoreno,
Do Not Contact,Ne kontaktirati,
From Customer,Od kupca,
Campaign Name,Naziv kampanje,
Follow Up,Pratite gore,
Next Contact By,Sledeci put kontaktirace ga,
Next Contact Date,Datum sledeceg kontaktiranja,
Ends On,Završava se,
Address & Contact,Adresa i kontakt,
Mobile No.,Mobitel broj,
Lead Type,Tip potencijalnog kupca,
Channel Partner,Partner iz prodajnog kanala,
Consultant,Konsultant,
Market Segment,Tržišni segment,
Industry,Industrija,
Request Type,Zahtjev Tip,
Product Enquiry,Na upit,
Request for Information,Zahtjev za informacije,
Suggestions,Prijedlozi,
Blog Subscriber,Blog pretplatnik,
LinkedIn Settings,Postavke LinkedIn-a,
Company ID,ID kompanije,
OAuth Credentials,OAuth akreditivi,
Consumer Key,Potrošački ključ,
Consumer Secret,Potrošačka tajna,
User Details,Detalji o korisniku,
Person URN,Osoba URN,
Session Status,Status sesije,
Lost Reason Detail,Detalj izgubljenog razloga,
Opportunity Lost Reason,Prilika izgubljen razlog,
Potential Sales Deal,Potencijalni Sales Deal,
CRM-OPP-.YYYY.-,CRM-OPP-YYYY.-,
Opportunity From,Prilika od,
Customer / Lead Name,Kupac / Ime osobe koja je Lead,
Opportunity Type,Vrsta prilike,
Converted By,Pretvorio,
Sales Stage,Prodajna scena,
Lost Reason,Razlog gubitka,
Expected Closing Date,Očekivani datum zatvaranja,
To Discuss,Za diskusiju,
With Items,Sa stavkama,
Probability (%),Verovatnoća (%),
Contact Info,Kontakt Informacije,
Customer / Lead Address,Kupac / Adresa Lead-a,
Contact Mobile No,Kontak GSM,
Enter name of campaign if source of enquiry is campaign,"Unesite naziv kampanje, ako je izvor upit je kampanja",
Opportunity Date,Datum prilike,
Opportunity Item,Poslovna prilika artikla,
Basic Rate,Osnovna stopa,
Stage Name,Ime faze,
Social Media Post,Post na društvenim mrežama,
Post Status,Post post,
Posted,Objavljeno,
Share On,Podijelite dalje,
Twitter,Twitter,
LinkedIn,LinkedIn,
Twitter Post Id,Twitter Post Id,
LinkedIn Post Id,LinkedIn Post Id,
Tweet,Tweet,
Twitter Settings,Twitter postavke,
API Secret Key,Tajni ključ API-ja,
Term Name,term ime,
Term Start Date,Term Ozljede Datum,
Term End Date,Term Završni datum,
Academics User,akademici korisnika,
Academic Year Name,Akademska godina Ime,
Article,Član,
LMS User,Korisnik LMS-a,
Assessment Criteria Group,Kriteriji procjene Group,
Assessment Group Name,Procjena Ime grupe,
Parent Assessment Group,Parent Procjena Group,
Assessment Name,procjena ime,
Grading Scale,Pravilo Scale,
Examiner,ispitivač,
Examiner Name,Examiner Naziv,
Supervisor,nadzornik,
Supervisor Name,Supervizor ime,
Evaluate,Procijenite,
Maximum Assessment Score,Maksimalan rezultat procjene,
Assessment Plan Criteria,Kriteriji Plan Procjena,
Maximum Score,Maksimalna Score,
Grade,razred,
Assessment Result Detail,Procjena Rezultat Detail,
Assessment Result Tool,Procjena Alat Rezultat,
Result HTML,rezultat HTML,
Content Activity,Sadržajna aktivnost,
Last Activity ,Poslednja aktivnost,
Content Question,Sadržajno pitanje,
Question Link,Link pitanja,
Course Name,Naziv predmeta,
Topics,Teme,
Hero Image,Image Hero,
Default Grading Scale,Uobičajeno Pravilo Scale,
Education Manager,Menadžer obrazovanja,
Course Activity,Aktivnost kursa,
Course Enrollment,Upis na tečaj,
Activity Date,Datum aktivnosti,
Course Assessment Criteria,Kriteriji procjene naravno,
Weightage,Weightage,
Course Content,Sadržaj kursa,
Quiz,Kviz,
Program Enrollment,Upis program,
Enrollment Date,upis Datum,
Instructor Name,instruktor ime,
EDU-CSH-.YYYY.-,EDU-CSH-YYYY.-,
Course Scheduling Tool,Naravno rasporedu Tool,
Course Start Date,Naravno Ozljede Datum,
To TIme,Za vrijeme,
Course End Date,Naravno Završni datum,
Course Topic,Tema kursa,
Topic Name,Topic Name,
Education Settings,Obrazovne postavke,
Current Academic Year,Trenutni akademske godine,
Current Academic Term,Trenutni Academic Term,
Attendance Freeze Date,Posjećenost Freeze Datum,
Validate Batch for Students in Student Group,Potvrditi Batch za studente u Studentskom Group,
"For Batch based Student Group, the Student Batch will be validated for every Student from the Program Enrollment.",Za studentske grupe Batch bazi Studentskog Batch će biti potvrđeni za svakog studenta iz Upis Programa.,
Validate Enrolled Course for Students in Student Group,Potvrditi upisala kurs za studente u Studentskom Group,
"For Course based Student Group, the Course will be validated for every Student from the enrolled Courses in Program Enrollment.","Za studentske grupe na osnovu Naravno, kurs će biti potvrđeni za svakog studenta iz upisao jezika u upisu Programa.",
Make Academic Term Mandatory,Obavezni akademski termin,
"If enabled, field Academic Term will be Mandatory in Program Enrollment Tool.","Ako je omogućeno, polje Akademski termin će biti obavezno u alatu za upisivanje programa.",
Skip User creation for new Student,Preskoči stvaranje korisnika za novog učenika,
"By default, a new User is created for every new Student. If enabled, no new User will be created when a new Student is created.","Po defaultu se za svakog novog učenika kreira novi korisnik. Ako je omogućeno, neće se kreirati novi korisnik kada se kreira novi student.",
Instructor Records to be created by,Instruktorske zapise koje kreira,
Employee Number,Broj radnika,
Fee Category,naknada Kategorija,
Fee Component,naknada Komponenta,
Fees Category,naknade Kategorija,
Fee Schedule,naknada Raspored,
Fee Structure,naknada Struktura,
EDU-FSH-.YYYY.-,EDU-FSH-YYYY.-,
Fee Creation Status,Status stvaranja naknade,
In Process,U procesu,
Send Payment Request Email,Pošaljite zahtev za plaćanje,
Student Category,student Kategorija,
Fee Breakup for each student,Naknada za svaki student,
Total Amount per Student,Ukupan iznos po učeniku,
Institution,institucija,
Fee Schedule Program,Program raspoređivanja naknada,
Student Batch,student Batch,
Total Students,Ukupno Studenti,
Fee Schedule Student Group,Raspored studijske grupe,
EDU-FST-.YYYY.-,EDU-FST-.YYYY.-,
EDU-FEE-.YYYY.-,EDU-FEE-.YYYY.-,
Include Payment,Uključi plaćanje,
Send Payment Request,Pošaljite zahtev za plaćanje,
Student Details,Student Detalji,
Student Email,Student Email,
Grading Scale Name,Pravilo Scale Ime,
Grading Scale Intervals,Pravilo Scale Intervali,
Intervals,intervali,
Grading Scale Interval,Pravilo Scale Interval,
Grade Code,Grade Kod,
Threshold,prag,
Grade Description,Grade Opis,
Guardian,staratelj,
Guardian Name,Guardian ime,
Alternate Number,Alternativna Broj,
Occupation,okupacija,
Work Address,rad Adresa,
Guardian Of ,Guardian Of,
Students,studenti,
Guardian Interests,Guardian Interesi,
Guardian Interest,Guardian interesa,
Interest,interes,
Guardian Student,Guardian Student,
EDU-INS-.YYYY.-,EDU-INS-.YYYY.-,
Instructor Log,Logor instruktora,
Other details,Ostali detalji,
Option,Opcija,
Is Correct,Tacno je,
Program Name,Naziv programa,
Program Abbreviation,program Skraćenica,
Courses,kursevi,
Is Published,Objavljeno je,
Allow Self Enroll,Dozvoli samoostvarivanje,
Is Featured,Je istaknuto,
Intro Video,Intro Video,
Program Course,program kursa,
School House,School House,
Boarding Student,Boarding Student,
Check this if the Student is residing at the Institute's Hostel.,Označite ovu ako student boravi na Instituta Hostel.,
Walking,hodanje,
Institute's Bus,Institutski autobus,
Self-Driving Vehicle,Self-vožnje vozila,
Pick/Drop by Guardian,Pick / Drop Guardian,
Enrolled courses,upisani kurseve,
Program Enrollment Course,Program Upis predmeta,
Program Enrollment Fee,Program Upis Naknada,
Program Enrollment Tool,Program Upis Tool,
Get Students From,Get Studenti iz,
Student Applicant,student zahtjeva,
Get Students,Get Studenti,
Enrollment Details,Detalji upisa,
New Program,novi program,
New Student Batch,Nova studentska serija,
Enroll Students,upisati studenti,
New Academic Year,Nova akademska godina,
New Academic Term,Novi akademski termin,
Program Enrollment Tool Student,Program Upis Tool Student,
Student Batch Name,Student Batch Ime,
Program Fee,naknada za program,
Question,Pitanje,
Single Correct Answer,Jedan tačan odgovor,
Multiple Correct Answer,Višestruki ispravan odgovor,
Quiz Configuration,Konfiguracija kviza,
Passing Score,Prolazni rezultat,
Score out of 100,Rezultat od 100,
Max Attempts,Maks pokušaji,
Enter 0 to waive limit,Unesite 0 da biste odbili granicu,
Grading Basis,Osnove ocjenjivanja,
Latest Highest Score,Najnoviji najviši rezultat,
Latest Attempt,Najnoviji pokušaj,
Quiz Activity,Aktivnost kviza,
Enrollment,Upis,
Pass,Pass,
Quiz Question,Pitanje za kviz,
Quiz Result,Rezultat kviza,
Selected Option,Izabrana opcija,
Correct,Tacno,
Wrong,Pogrešno,
Room Name,Soba Naziv,
Room Number,Broj sobe,
Seating Capacity,Broj sjedećih mjesta,
House Name,nazivu,
EDU-STU-.YYYY.-,EDU-STU-YYYY.-,
Student Mobile Number,Student Broj mobilnog,
Blood Group,Krvna grupa,
A+,A +,
A-,A-,
B+,B +,
B-,B-,
O+,O +,
O-,O-,
AB+,AB +,
AB-,AB-,
Nationality,državljanstvo,
Home Address,Kućna adresa,
Guardian Details,Guardian Detalji,
Guardians,čuvari,
Sibling Details,Polubrat Detalji,
Siblings,braća i sestre,
Exit,Izlaz,
Date of Leaving,Datum odlaska,
Leaving Certificate Number,Maturom Broj,
Reason For Leaving,Razlog za napuštanje,
Student Admission,student Ulaz,
Admission Start Date,Prijem Ozljede Datum,
Admission End Date,Prijem Završni datum,
Eligibility and Details,Prihvatljivost i Detalji,
Student Admission Program,Studentski program za prijem studenata,
Minimum Age,Minimalna dob,
Maximum Age,Maksimalno doba,
Application Fee,naknada aplikacija,
Naming Series (for Student Applicant),Imenovanje serija (za studentske Podnositelj zahtjeva),
LMS Only,Samo LMS,
EDU-APP-.YYYY.-,EDU-APP-YYYY.-,
Application Date,patenta,
Student Attendance Tool,Student Posjeta Tool,
Group Based On,Na osnovu grupe,
Students HTML,studenti HTML,
Group Based on,Grupa na osnovu,
Student Group Name,Student Ime grupe,
Max Strength,Max Snaga,
Set 0 for no limit,Set 0 za no limit,
Instructors,instruktori,
Student Group Creation Tool,Student Group Creation Tool,
Leave blank if you make students groups per year,Ostavite prazno ako napravite grupa studenata godišnje,
Get Courses,Get kursevi,
Separate course based Group for every Batch,Poseban grupe na osnovu naravno za svaku seriju,
Leave unchecked if you don't want to consider batch while making course based groups. ,Ostavite nekontrolisano ako ne želite uzeti u obzir batch prilikom donošenja grupe naravno na bazi.,
Student Group Creation Tool Course,Student Group Creation Tool Course,
Course Code,Šifra predmeta,
Student Group Instructor,Student Group Instruktor,
Student Group Student,Student Group Studentski,
Group Roll Number,Grupa Roll Broj,
Student Guardian,student Guardian,
Relation,Odnos,
Mother,majka,
Father,otac,
Student Language,student Jezik,
Student Leave Application,Student Leave aplikacije,
Mark as Present,Mark kao Present,
Student Log,student Prijavite,
Academic,akademski,
Achievement,Postignuće,
Student Report Generation Tool,Alat za generisanje studenata,
Include All Assessment Group,Uključite svu grupu procene,
Show Marks,Pokaži oznake,
Add letterhead,Dodaj slovo,
Print Section,Odsek za štampu,
Total Parents Teacher Meeting,Ukupno sastanak učitelja roditelja,
Attended by Parents,Prisustvuju roditelji,
Assessment Terms,Uslovi za procjenu,
Student Sibling,student Polubrat,
Studying in Same Institute,Studiranje u istom institutu,
NO,Ne,
YES,DA,
Student Siblings,student Siblings,
Topic Content,Sadržaj teme,
Amazon MWS Settings,Amazon MWS Settings,
ERPNext Integrations,ERPNext Integrations,
Enable Amazon,Omogućite Amazon,
MWS Credentials,MVS akreditivi,
Seller ID,ID prodavca,
AWS Access Key ID,AWS Access Key ID,
MWS Auth Token,MWS Auth Token,
Market Place ID,ID tržišta,
AE,AE,
AU,AU,
BR,BR,
CA,CA,
CN,CN,
DE,DE,
ES,ES,
FR,FR,
JP,JP,
IT,IT,
MX,mx,
UK,UK,
US,SAD,
Customer Type,Tip kupca,
Market Place Account Group,Tržišna grupa računa,
After Date,Posle Datuma,
Amazon will synch data updated after this date,Amazon će sinhronizovati podatke ažurirane nakon ovog datuma,
Sync Taxes and Charges,Sinhronizacija poreza i naknada,
Get financial breakup of Taxes and charges data by Amazon ,Dobije finansijski raspad podataka o porezima i naplaćuje Amazon,
Sync Products,Sync Products,
Always sync your products from Amazon MWS before synching the Orders details,Uvijek sinhronizirajte svoje proizvode s Amazona MWS prije sinkronizacije detalja narudžbi,
Sync Orders,Nalozi za sinhronizaciju,
Click this button to pull your Sales Order data from Amazon MWS.,Kliknite ovo dugme da biste izveli podatke o prodaji iz Amazon MWS-a.,
Enable Scheduled Sync,Omogućite planiranu sinhronizaciju,
Check this to enable a scheduled Daily synchronization routine via scheduler,Proverite ovo da biste omogućili planiranu dnevnu sinhronizaciju rutine preko rasporeda,
Max Retry Limit,Maks retry limit,
Exotel Settings,Exotel Settings,
Account SID,SID računa,
API Token,API Token,
GoCardless Mandate,GoCardless Mandate,
Mandate,Mandat,
GoCardless Customer,GoCardless kupac,
GoCardless Settings,GoCardless Settings,
Webhooks Secret,Webhooks Secret,
Plaid Settings,Plaid Settings,
Synchronize all accounts every hour,Sinkronizirajte sve račune na svakih sat vremena,
Plaid Client ID,Plaid ID klijenta,
Plaid Secret,Plaid Secret,
Plaid Environment,Plaid Environment,
sandbox,peskovnik,
development,razvoj,
production,proizvodnja,
QuickBooks Migrator,QuickBooks Migrator,
Application Settings,Postavke aplikacije,
Token Endpoint,Krajnji tačak žetona,
Scope,Obim,
Authorization Settings,Podešavanja autorizacije,
Authorization Endpoint,Autorizacija Endpoint,
Authorization URL,URL autorizacije,
Quickbooks Company ID,Identifikacijski broj kompanije Quickbooks,
Company Settings,Tvrtka Postavke,
Default Shipping Account,Uobičajeni nalog za isporuku,
Default Warehouse,Glavno skladište,
Default Cost Center,Standard Cost Center,
Undeposited Funds Account,Račun Undeposited Funds,
Shopify Log,Shopify Log,
Shopify Settings,Shopify Settings,
status html,status html,
Enable Shopify,Omogući Shopify,
App Type,Tip aplikacije,
Last Sync Datetime,Last Sync Datetime,
Shop URL,URL prodavnice,
eg: frappe.myshopify.com,npr: frappe.myshopify.com,
Shared secret,Zajednička tajna,
Webhooks Details,Webhooks Details,
Webhooks,Webhooks,
Customer Settings,Postavke klijenta,
Default Customer,Podrazumevani korisnik,
Customer Group will set to selected group while syncing customers from Shopify,Grupa potrošača će postaviti odabranu grupu dok sinhronizuje kupce iz Shopify-a,
For Company,Za tvrtke,
Cash Account will used for Sales Invoice creation,Gotovinski račun će se koristiti za kreiranje prodajne fakture,
Update Price from Shopify To ERPNext Price List,Ažurirajte cijenu od Shopify do ERPNext Cjenik,
Default Warehouse to to create Sales Order and Delivery Note,Podrazumevano skladište za kreiranje naloga za prodaju i dostave,
Sales Order Series,Narudžbe serije prodaje,
Import Delivery Notes from Shopify on Shipment,Napomene o uvoznoj isporuci od Shopify na pošiljci,
Delivery Note Series,Serija Napomena o isporuci,
Import Sales Invoice from Shopify if Payment is marked,Uvezite fakturu prodaje iz Shopify-a ako je oznaka uplaćena,
Sales Invoice Series,Serija faktura prodaje,
Shopify Tax Account,Kupujte poreski račun,
Shopify Tax/Shipping Title,Kupujte naslov poreza / dopuštenja,
ERPNext Account,ERPNext nalog,
Shopify Webhook Detail,Shopify Webhook Detail,
Webhook ID,Webhook ID,
Tally Migration,Tally Migration,
Master Data,Glavni podaci,
"Data exported from Tally that consists of the Chart of Accounts, Customers, Suppliers, Addresses, Items and UOMs","Podaci izvezeni iz Tally-a koji se sastoje od kontnog plana, kupaca, dobavljača, adresa, predmeta i UOM-ova",
Is Master Data Processed,Obrađuju li se glavni podaci,
Is Master Data Imported,Uvezu se glavni podaci,
Tally Creditors Account,Račun poverioca Tally,
Creditors Account set in Tally,Račun povjerilaca postavljen u Tally,
Tally Debtors Account,Račun dužnika Tally,
Debtors Account set in Tally,Račun dužnika postavljen u Tally-u,
Tally Company,Tally Company,
Company Name as per Imported Tally Data,Naziv kompanije prema uvoznim Tally podacima,
Default UOM,Zadani UOM,
UOM in case unspecified in imported data,UOM u slučaju da nije specificiran u uvezenim podacima,
ERPNext Company,Kompanija ERPNext,
Your Company set in ERPNext,Vaša kompanija smještena je u ERPNext,
Processed Files,Obrađene datoteke,
Parties,Stranke,
UOMs,UOMs,
Vouchers,Vaučeri,
Round Off Account,Zaokružiti račun,
Day Book Data,Podaci o dnevnoj knjizi,
Day Book Data exported from Tally that consists of all historic transactions,Podaci iz dnevne knjige izvezeni iz Tally-a koji se sastoje od svih povijesnih transakcija,
Is Day Book Data Processed,Obrađuju se podaci dnevnih knjiga,
Is Day Book Data Imported,Uvoze li se podaci dnevnih knjiga,
Woocommerce Settings,Woocommerce postavke,
Enable Sync,Omogući sinhronizaciju,
Woocommerce Server URL,Woocommerce Server URL,
Secret,Tajna,
API consumer key,API korisnički ključ,
API consumer secret,API potrošačke tajne,
Tax Account,Poreski račun,
Freight and Forwarding Account,Teretni i špediterski račun,
Creation User,Stvaranje korisnika,
"The user that will be used to create Customers, Items and Sales Orders. This user should have the relevant permissions.","Korisnik koji će se koristiti za kreiranje kupaca, predmeta i naloga za prodaju. Ovaj korisnik trebao bi imati odgovarajuća dopuštenja.",
"This warehouse will be used to create Sales Orders. The fallback warehouse is ""Stores"".",Ovo skladište će se koristiti za kreiranje prodajnih naloga. Rezervno skladište su &quot;Trgovine&quot;.,
"The fallback series is ""SO-WOO-"".",Rezervna serija je „SO-WOO-“.,
This company will be used to create Sales Orders.,Ova kompanija će se koristiti za kreiranje prodajnih naloga.,
Delivery After (Days),Dostava nakon (dana),
This is the default offset (days) for the Delivery Date in Sales Orders. The fallback offset is 7 days from the order placement date.,Ovo je zadani offset (dani) za datum isporuke u prodajnim nalozima. Ponovno nadoknađivanje je 7 dana od datuma slanja narudžbe.,
"This is the default UOM used for items and Sales orders. The fallback UOM is ""Nos"".",Ovo je zadani UOM koji se koristi za artikle i prodajne naloge. Povratna UOM je &quot;Nos&quot;.,
Endpoints,Krajnje tačke,
Endpoint,Krajnja tačka,
Antibiotic Name,Antibiotički naziv,
Healthcare Administrator,Administrator zdravstvene zaštite,
Laboratory User,Laboratorijski korisnik,
Is Inpatient,Je stacionarno,
Default Duration (In Minutes),Zadano trajanje (u minutama),
Body Part,Dio tijela,
Body Part Link,Link dijela tijela,
HLC-CPR-.YYYY.-,HLC-CPR-YYYY.-,
Procedure Template,Šablon procedure,
Procedure Prescription,Procedura Prescription,
Service Unit,Servisna jedinica,
Consumables,Potrošni materijal,
Consume Stock,Consume Stock,
Invoice Consumables Separately,Fakturirajte potrošni materijal odvojeno,
Consumption Invoiced,Potrošnja fakturirana,
Consumable Total Amount,Potrošni ukupni iznos,
Consumption Details,Detalji potrošnje,
Nursing User,Korisnik medicinske sestre,
Clinical Procedure Item,Klinička procedura,
Invoice Separately as Consumables,Faktura posebno kao Potrošni materijal,
Transfer Qty,Transfer Količina,
Actual Qty (at source/target),Stvarna kol (na izvoru/cilju),
Is Billable,Da li se može naplatiti,
Allow Stock Consumption,Dozvolite potrošnju zaliha,
Sample UOM,Uzorak UOM,
Collection Details,Detalji o kolekciji,
Change In Item,Promjena stavke,
Codification Table,Tabela kodifikacije,
Complaints,Žalbe,
Dosage Strength,Snaga doziranja,
Strength,Snaga,
Drug Prescription,Prescription drugs,
Drug Name / Description,Naziv / opis lijeka,
Dosage,Doziranje,
Dosage by Time Interval,Doziranje po vremenskom intervalu,
Interval,Interval,
Interval UOM,Interval UOM,
Hour,Sat,
Update Schedule,Raspored ažuriranja,
Exercise,Vježbaj,
Difficulty Level,Nivo poteškoće,
Counts Target,Broji meta,
Counts Completed,Brojanja završena,
Assistance Level,Nivo pomoći,
Active Assist,Active Assist,
Exercise Name,Naziv vježbe,
Body Parts,Dijelovi tijela,
Exercise Instructions,Upute za vježbu,
Exercise Video,Video za vježbu,
Exercise Steps,Koraci vježbanja,
Steps Table,Tabela koraka,
Exercise Type Step,Tip vježbe korak,
Max number of visit,Maksimalan broj poseta,
Visited yet,Posjećeno još,
Reference Appointments,Referentna imenovanja,
Valid till,Vrijedi do,
Fee Validity Reference,Referenca valjanosti naknade,
Basic Details,Osnovni detalji,
HLC-PRAC-.YYYY.-,FHP-PRAC-.GGGG.-,
Mobile,Mobilni,
Phone (R),Telefon (R),
Phone (Office),Telefon (Office),
Employee and User Details,Podaci o zaposleniku i korisniku,
Hospital,Bolnica,
Appointments,Imenovanja,
Practitioner Schedules,Raspored lekara,
Charges,Naknade,
Out Patient Consulting Charge,Naknada za konsultacije sa pacijentima,
Default Currency,Zadana valuta,
Healthcare Schedule Time Slot,Vremenska raspored zdravstvene zaštite,
Parent Service Unit,Jedinica za roditeljsku službu,
Service Unit Type,Tip jedinice servisne jedinice,
Allow Appointments,Dozvoli zakazivanja,
Allow Overlap,Dopusti preklapanje,
Inpatient Occupancy,Bolničko stanovanje,
Occupancy Status,Status zauzetosti,
Vacant,Slobodno,
Occupied,Zauzeti,
Item Details,Detalji artikla,
UOM Conversion in Hours,UOM konverzija u satima,
Rate / UOM,Rate / UOM,
Change in Item,Promenite stavku,
Out Patient Settings,Out Pacijent Settings,
Patient Name By,Ime pacijenta,
Patient Name,Ime pacijenta,
Link Customer to Patient,Povežite kupca sa pacijentom,
"If checked, a customer will be created, mapped to Patient.\nPatient Invoices will be created against this Customer. You can also select existing Customer while creating Patient.","Ako se proveri, biće kreiran korisnik, mapiran na Pacijent. Pacijentove fakture će biti stvorene protiv ovog Korisnika. Takođe možete izabrati postojećeg kupca prilikom stvaranja Pacijenta.",
Default Medical Code Standard,Standardni medicinski kodni standard,
Collect Fee for Patient Registration,Prikupiti naknadu za registraciju pacijenta,
Checking this will create new Patients with a Disabled status by default and will only be enabled after invoicing the Registration Fee.,"Ako provjerite ovo, stvorit će se novi pacijenti sa statusom onemogućenog prema zadanim postavkama i bit će omogućeni tek nakon fakturiranja naknade za registraciju.",
Registration Fee,Kotizaciju,
Automate Appointment Invoicing,Automatizirajte fakturiranje imenovanja,
Manage Appointment Invoice submit and cancel automatically for Patient Encounter,Upravljanje imenovanjima Faktura podnosi i otkazati automatski za susret pacijenta,
Enable Free Follow-ups,Omogućite besplatna praćenja,
Number of Patient Encounters in Valid Days,Broj susreta pacijenata u važećim danima,
The number of free follow ups (Patient Encounters in valid days) allowed,Dozvoljen broj besplatnih praćenja (Susreti pacijenata u važećim danima),
Valid Number of Days,Veliki broj dana,
Time period (Valid number of days) for free consultations,Vremenski period (važeći broj dana) za besplatne konsultacije,
Default Healthcare Service Items,Zadane stavke zdravstvenih usluga,
"You can configure default Items for billing consultation charges, procedure consumption items and inpatient visits","Možete konfigurirati zadane stavke za troškove savjetovanja za naplatu, stavke potrošnje postupka i stacionarne posjete",
Clinical Procedure Consumable Item,Klinička procedura Potrošna stavka,
Default Accounts,Zadani računi,
Default income accounts to be used if not set in Healthcare Practitioner to book Appointment charges.,Uobičajeni računi prihoda koji će se koristiti ako nisu postavljeni u Zdravstvenom lekaru da rezervišu troškove naplate.,
Default receivable accounts to be used to book Appointment charges.,Zadani računi potraživanja koji će se koristiti za knjiženje troškova imenovanja.,
Out Patient SMS Alerts,Out Patient SMS upozorenja,
Patient Registration,Registracija pacijenata,
Registration Message,Poruka za upis,
Confirmation Message,Potvrda poruka,
Avoid Confirmation,Izbjegavajte potvrdu,
Do not confirm if appointment is created for the same day,Ne potvrdite da li je zakazan termin za isti dan,
Appointment Reminder,Pamćenje imenovanja,
Reminder Message,Poruka podsetnika,
Laboratory Settings,Laboratorijske postavke,
Create Lab Test(s) on Sales Invoice Submission,Kreirajte laboratorijske testove na podnošenju fakture za prodaju,
Checking this will create Lab Test(s) specified in the Sales Invoice on submission.,"Ako potvrdite ovo, stvoriće se laboratorijski testovi navedeni u Računu prodaje prilikom slanja.",
Create Sample Collection document for Lab Test,Stvorite dokument za prikupljanje uzoraka za laboratorijski test,
Checking this will create a Sample Collection document  every time you create a Lab Test,"Ako potvrdite ovo, stvoriće se dokument sa uzorcima svaki put kada kreirate laboratorijski test",
Employee name and designation in print,Ime i oznaka zaposlenika u štampi,
Check this if you want the Name and Designation of the Employee associated with the User who submits the document to be printed in the Lab Test Report.,Označite ovo ako želite da se ime i ime zaposlenika povezanog s korisnikom koji preda dokument ispišu u izvještaju o laboratorijskom ispitivanju.,
Do not print or email Lab Tests without Approval,Nemojte štampati ili slati laboratorijske testove bez odobrenja,
Checking this will restrict printing and emailing of Lab Test documents unless they have the status as Approved.,"Ako ovo provjerite, ograničit će se ispis i slanje dokumenata laboratorijskog testa po e-pošti, osim ako nemaju status Odobreno.",
Custom Signature in Print,Prilagođeni potpis u štampi,
Laboratory SMS Alerts,Laboratorijski SMS upozorenja,
Result Printed Message,Rezultat ispisana poruka,
Result Emailed Message,Poruka rezultata e-poštom,
Check In,Provjeri,
Check Out,Provjeri,
HLC-INP-.YYYY.-,HLC-INP-YYYY.-,
A Positive,Pozitivan,
A Negative,Negativan,
AB Positive,AB Pozitivan,
AB Negative,AB Negativ,
B Positive,B Pozitivan,
B Negative,B Negativno,
O Positive,O Pozitivno,
O Negative,O Negativ,
Date of birth,Datum rođenja,
Admission Scheduled,Prijem zakazan,
Discharge Scheduled,Pražnjenje je zakazano,
Discharged,Ispušteni,
Admission Schedule Date,Datum prijema prijave,
Admitted Datetime,Prihvaćeno Datetime,
Expected Discharge,Očekivano pražnjenje,
Discharge Date,Datum otpustanja,
Lab Prescription,Lab recept,
Lab Test Name,Naziv laboratorijskog testa,
Test Created,Test Created,
Submitted Date,Datum podnošenja,
Approved Date,Odobreni datum,
Sample ID,Primer uzorka,
Lab Technician,Laboratorijski tehničar,
Report Preference,Prednost prijave,
Test Name,Ime testa,
Test Template,Test Template,
Test Group,Test grupa,
Custom Result,Prilagođeni rezultat,
LabTest Approver,LabTest Approver,
Add Test,Dodajte test,
Normal Range,Normalni opseg,
Result Format,Format rezultata,
Single,Singl,
Compound,Jedinjenje,
Descriptive,Deskriptivno,
Grouped,Grupisano,
No Result,Bez rezultata,
This value is updated in the Default Sales Price List.,Ova vrijednost se ažurira na listi podrazumevanih prodajnih cijena.,
Lab Routine,Lab Routine,
Result Value,Vrednost rezultata,
Require Result Value,Zahtevaj vrednost rezultata,
Normal Test Template,Normalni testni šablon,
Patient Demographics,Demografija pacijenta,
HLC-PAT-.YYYY.-,HLC-PAT-YYYY.-,
Middle Name (optional),Srednje ime (nije obavezno),
Inpatient Status,Status bolesnika,
"If ""Link Customer to Patient"" is checked in Healthcare Settings and an existing Customer is not selected then, a Customer will be created for this Patient for recording transactions in Accounts module.","Ako je u postavkama zdravstvene zaštite označeno &quot;Poveži kupca sa pacijentom&quot; i ne odabere se postojeći kupac, za ovog pacijenta će se stvoriti kupac za evidentiranje transakcija u modulu Računi.",
Personal and Social History,Lična i društvena istorija,
Marital Status,Bračni status,
Married,Oženjen,
Divorced,Rastavljen,
Widow,Udovica,
Patient Relation,Relacija pacijenta,
"Allergies, Medical and Surgical History","Alergije, medicinska i hirurška istorija",
Allergies,Alergije,
Medication,Lijekovi,
Medical History,Medicinska istorija,
Surgical History,Hirurška istorija,
Risk Factors,Faktori rizika,
Occupational Hazards and Environmental Factors,Opasnosti po životnu sredinu i faktore zaštite životne sredine,
Other Risk Factors,Ostali faktori rizika,
Patient Details,Detalji pacijenta,
Additional information regarding the patient,Dodatne informacije o pacijentu,
HLC-APP-.YYYY.-,FHP-APP-.GGGG.-,
Patient Age,Pacijentsko doba,
Get Prescribed Clinical Procedures,Zatražite propisane kliničke postupke,
Therapy,Terapija,
Get Prescribed Therapies,Nabavite propisane terapije,
Appointment Datetime,Imenovanje Datum i vrijeme,
Duration (In Minutes),Trajanje (u minutama),
Reference Sales Invoice,Referentna faktura prodaje,
More Info,Više informacija,
Referring Practitioner,Poznavanje lekara,
HLC-PA-.YYYY.-,FHP-PA-.GGGG.-,
Assessment Template,Predložak procjene,
Assessment Datetime,Procjena datum i vrijeme,
Assessment Description,Opis procjene,
Assessment Sheet,Procjena lista,
Total Score Obtained,Ukupni postignuti rezultat,
Scale Min,Vaga Min,
Scale Max,Skala Max,
Patient Assessment Detail,Detalji o procjeni pacijenta,
Assessment Parameter,Parametar procjene,
Patient Assessment Parameter,Parametar procjene pacijenta,
Patient Assessment Sheet,List za procjenu pacijenta,
Patient Assessment Template,Predložak procjene pacijenta,
Assessment Parameters,Parametri procjene,
Parameters,Parametri,
Assessment Scale,Skala procjene,
Scale Minimum,Skala minimalna,
Scale Maximum,Skala maksimum,
HLC-ENC-.YYYY.-,HLC-ENC-YYYY.-,
Encounter Date,Datum susreta,
Encounter Time,Vrijeme susreta,
Encounter Impression,Encounter Impression,
Symptoms,Simptomi,
In print,U štampi,
Medical Coding,Medicinsko kodiranje,
Procedures,Procedure,
Therapies,Terapije,
Review Details,Detalji pregleda,
Patient Encounter Diagnosis,Dijagnoza susreta pacijenta,
Patient Encounter Symptom,Simptom susreta s pacijentom,
HLC-PMR-.YYYY.-,HLC-PMR-YYYY.-,
Attach Medical Record,Priložite medicinsku evidenciju,
Spouse,Supružnik,
Family,Porodica,
Schedule Details,Detalji rasporeda,
Schedule Name,Ime rasporeda,
Time Slots,Time Slots,
Practitioner Service Unit Schedule,Raspored jedinica službe lekara,
Procedure Name,Ime postupka,
Appointment Booked,Imenovanje rezervirano,
Procedure Created,Kreiran postupak,
HLC-SC-.YYYY.-,HLC-SC-YYYY.-,
Collected By,Prikupljeno od strane,
Particulars,Posebnosti,
Result Component,Komponenta rezultata,
HLC-THP-.YYYY.-,FHP-THP-.GGGG.-,
Therapy Plan Details,Detalji plana terapije,
Total Sessions,Ukupno sesija,
Total Sessions Completed,Ukupno završenih sesija,
Therapy Plan Detail,Detalji plana terapije,
No of Sessions,Broj sesija,
Sessions Completed,Sesije završene,
Tele,Tele,
Exercises,Vježbe,
Therapy For,Terapija za,
Add Exercises,Dodajte vježbe,
Body Temperature,Temperatura tela,
Presence of a fever (temp &gt; 38.5 °C/101.3 °F or sustained temp &gt; 38 °C/100.4 °F),"Prisustvo groznice (temperatura&gt; 38,5 ° C / 101,3 ° F ili trajna temperatura&gt; 38 ° C / 100,4 ° F)",
Heart Rate / Pulse,Srčana brzina / impuls,
Adults' pulse rate is anywhere between 50 and 80 beats per minute.,Stopa pulsa odraslih je između 50 i 80 otkucaja u minuti.,
Respiratory rate,Stopa respiratornih organa,
Normal reference range for an adult is 16–20 breaths/minute (RCP 2012),Normalni referentni opseg za odraslu osobu je 16-20 diha / minut (RCP 2012),
Tongue,Jezik,
Coated,Premazan,
Very Coated,Veoma prevučeni,
Normal,Normalno,
Furry,Furry,
Cuts,Rezanja,
Abdomen,Stomak,
Bloated,Vatreno,
Fluid,Fluid,
Constipated,Zapremljen,
Reflexes,Refleksi,
Hyper,Hyper,
Very Hyper,Veoma Hyper,
One Sided,Jednostrani,
Blood Pressure (systolic),Krvni pritisak (sistolni),
Blood Pressure (diastolic),Krvni pritisak (dijastolni),
Blood Pressure,Krvni pritisak,
"Normal resting blood pressure in an adult is approximately 120 mmHg systolic, and 80 mmHg diastolic, abbreviated ""120/80 mmHg""","Normalni krvni pritisak pri odraslima je oko 120 mmHg sistolnog, a dijastolni 80 mmHg, skraćeni &quot;120/80 mmHg&quot;",
Nutrition Values,Vrednosti ishrane,
Height (In Meter),Visina (u metrima),
Weight (In Kilogram),Težina (u kilogramu),
BMI,BMI,
Hotel Room,Hotelska soba,
Hotel Room Type,Tip sobe hotela,
Capacity,Kapacitet,
Extra Bed Capacity,Kapacitet dodatnog ležaja,
Hotel Manager,Menadžer hotela,
Hotel Room Amenity,Hotelska soba Amenity,
Billable,Naplativo,
Hotel Room Package,Paket za hotelsku sobu,
Amenities,Pogodnosti,
Hotel Room Pricing,Hotelska soba Pricing,
Hotel Room Pricing Item,Stavka hotela u sobi,
Hotel Room Pricing Package,Paket za hotelsku sobu,
Hotel Room Reservation,Hotelska rezervacija,
Guest Name,Ime gosta,
Late Checkin,Late Checkin,
Booked,Rezervirano,
Hotel Reservation User,Rezervacija korisnika hotela,
Hotel Room Reservation Item,Hotelska rezervacija Stavka,
Hotel Settings,Hotel Settings,
Default Taxes and Charges,Uobičajeno Porezi i naknadama,
Default Invoice Naming Series,Podrazumevana faktura imenovanja serije,
HR,HR,
Date on which this component is applied,Datum primjene ove komponente,
Salary Slip,Plaća proklizavanja,
HR User,HR korisnika,
Job Applicant,Posao podnositelj,
Body,Telo,
Appraisal Template,Procjena Predložak,
Parent Department,Odeljenje roditelja,
Leave Block List,Ostavite Block List,
Days for which Holidays are blocked for this department.,Dani za koje su praznici blokirani za ovaj odjel.,
Leave Approver,Ostavite odobravatelju,
Expense Approver,Rashodi Approver,
Required Skills,Potrebne veštine,
Skills,Vještine,
Driver,Vozač,
HR-DRI-.YYYY.-,HR-DRI-.YYYY.-,
Suspended,Suspendirano,
Transporter,Transporter,
Applicable for external driver,Važeće za spoljni upravljački program,
Cellphone Number,Broj mobitela,
License Details,Detalji o licenci,
License Number,Broj licence,
Issuing Date,Datum izdavanja,
Driving License Categories,Vozačke dozvole Kategorije,
Driving License Category,Kategorija vozačke dozvole,
Fleet Manager,Fleet Manager,
Driver licence class,Klasa vozačke dozvole,
HR-EMP-,HR-EMP-,
Employment Type,Zapošljavanje Tip,
Emergency Contact,Hitni kontakt,
Emergency Contact Name,Ime kontakta za hitne slučajeve,
Emergency Phone,Hitna Telefon,
ERPNext User,ERPNext User,
"System User (login) ID. If set, it will become default for all HR forms.","ID korisnika sustava. Ako je postavljen, postat će zadani za sve HR oblike.",
Create User Permission,Kreirajte dozvolu korisnika,
This will restrict user access to other employee records,Ovo će ograničiti pristup korisnika drugim zapisima zaposlenih,
Joining Details,Sastavljanje Detalji,
Offer Date,ponuda Datum,
Confirmation Date,potvrda Datum,
Contract End Date,Ugovor Datum završetka,
Notice (days),Obavijest (dani ),
Date Of Retirement,Datum odlaska u mirovinu,
Department and Grade,Odeljenje i razred,
Reports to,Izvještaji za,
Attendance and Leave Details,Detalji posjeta i odlaska,
Attendance Device ID (Biometric/RF tag ID),ID uređaja prisutnosti (ID biometrijske / RF oznake),
Applicable Holiday List,Primjenjivo odmor Popis,
Default Shift,Podrazumevano Shift,
Salary Mode,Plaća način,
Bank A/C No.,Bankovni  A/C br.,
Health Insurance,Zdravstveno osiguranje,
Health Insurance Provider,Zdravstveno osiguranje,
Health Insurance No,Zdravstveno osiguranje br,
Prefered Email,Prefered mail,
Personal Email,Osobni e,
Permanent Address Is,Stalna adresa je,
Rented,Iznajmljuje,
Owned,U vlasništvu,
Permanent Address,Stalna adresa,
Prefered Contact Email,Prefered Kontakt mail,
Company Email,Zvanični e-mail,
Provide Email Address registered in company,Osigurati mail registrovan u kompaniji Adresa,
Current Address Is,Trenutni Adresa je,
Current Address,Trenutna adresa,
Personal Bio,Lični Bio,
Bio / Cover Letter,Bio / Cover Letter,
Short biography for website and other publications.,Kratka biografija za web stranice i druge publikacije.,
Passport Number,Putovnica Broj,
Date of Issue,Datum izdavanja,
Place of Issue,Mjesto izdavanja,
Widowed,Udovički,
Family Background,Obitelj Pozadina,
"Here you can maintain family details like name and occupation of parent, spouse and children","Ovdje možete održavati obiteljske pojedinosti kao što su ime i okupacije roditelja, supružnika i djecu",
Health Details,Zdravlje Detalji,
"Here you can maintain height, weight, allergies, medical concerns etc","Ovdje možete održavati visina, težina, alergije, medicinske brige itd.",
Educational Qualification,Obrazovne kvalifikacije,
Previous Work Experience,Radnog iskustva,
External Work History,Vanjski History Work,
History In Company,Povijest tvrtke,
Internal Work History,Interni History Work,
Resignation Letter Date,Ostavka Pismo Datum,
Relieving Date,Rasterećenje Datum,
Reason for Leaving,Razlog za odlazak,
Leave Encashed?,Ostavite Encashed?,
Encashment Date,Encashment Datum,
New Workplace,Novi radnom mjestu,
Returned Amount,Iznos vraćenog iznosa,
Advance Account,Advance Account,
Benefits Applied,Prednosti koje se primjenjuju,
Benefit Type and Amount,Tip i iznos povlastice,
Task Weight,zadatak Težina,
Employee Education,Obrazovanje zaposlenog,
School/University,Škola / Univerzitet,
Graduate,Diplomski,
Post Graduate,Post diplomski,
Under Graduate,Pod diplomski,
Year of Passing,Tekuća godina,
Class / Percentage,Klasa / Postotak,
Major/Optional Subjects,Glavni / Izborni predmeti,
Employee External Work History,Istorija rada zaposlenog izvan preduzeća,
Total Experience,Ukupno Iskustvo,
Default Leave Policy,Default Leave Policy,
Employee Group Table,Tabela grupe zaposlenih,
ERPNext User ID,ERPNext User ID,
Employee Internal Work History,Istorija rada zaposlenog u preduzeću,
Activities,Aktivnosti,
Employee Onboarding Activity,Aktivnost aktivnosti na radnom mjestu,
Employee Promotion Detail,Detalji o napredovanju zaposlenih,
Employee Transfer Property,Imovina Transfera zaposlenika,
Unclaimed amount,Neobjavljeni iznos,
Holiday List Name,Naziv liste odmora,
Total Holidays,Total Holidays,
Add Weekly Holidays,Dodajte Weekly Holidays,
Weekly Off,Tjedni Off,
Add to Holidays,Dodaj u praznike,
Holidays,Praznici,
Clear Table,Poništi tabelu,
Retirement Age,Retirement Godine,
Enter retirement age in years,Unesite dob za odlazak u penziju u godinama,
Stop Birthday Reminders,Zaustavi Rođendan Podsjetnici,
Leave Settings,Ostavite podešavanja,
Accepted,Prihvaćeno,
Printing Details,Printing Detalji,
Job Title,Titula,
Allocation,Alokacija,
Select Employees,Odaberite Zaposleni,
Allocate,Dodijeli,
Max Leaves Allowed,Maksimalno dozvoljeno odstupanje,
Maximum Continuous Days Applicable,Primenjivi su maksimalni trajni dani,
Select Payroll Period,Odaberite perioda isplate,
Abbr,Skraćeni naziv,
Condition and Formula,Stanje i formula,
Total Working Hours,Ukupno Radno vrijeme,
Hour Rate,Cijena sata,
Bank Account No.,Žiro račun broj,
Earning & Deduction,Zarada &amp; Odbitak,
Loan repayment,Otplata kredita,
Employee Loan,zaposlenik kredita,
Total Principal Amount,Ukupni glavni iznos,
Total Interest Amount,Ukupan iznos kamate,
Total Loan Repayment,Ukupno otplate kredita,
net pay info,neto plata info,
Gross Pay - Total Deduction - Loan Repayment,Bruto Pay - Ukupno odbitak - Otplata kredita,
Net Pay (in words) will be visible once you save the Salary Slip.,Neto plaća (riječima) će biti vidljiva nakon što spremite klizne plaće.,
Staffing Plan Details,Detalji o kadrovskom planu,
Optional,Neobavezno,
Costing,Koštanje,
Vehicle,vozilo,
License Plate,registarska tablica,
Odometer Value (Last),Odometar vrijednost (Zadnje),
Acquisition Date,akvizicija Datum,
Chassis No,šasija Ne,
Vehicle Value,Vrijednost vozila,
Insurance Details,osiguranje Detalji,
Insurance Company,Insurance Company,
Policy No,Politika Nema,
Additional Details,Dodatni Detalji,
Fuel Type,Vrsta goriva,
Petrol,benzin,
Diesel,dizel,
Natural Gas,prirodni gas,
Electric,Electric,
Fuel UOM,gorivo UOM,
Last Carbon Check,Zadnji Carbon Check,
Wheels,Wheels,
Doors,vrata,
last Odometer Value ,zadnja vrijednost odometra,
Service Detail,Servis Detail,
Hub Tracked Item,Hub Gusjen stavka,
Hub Node,Hub Node,
Image List,Lista slika,
Item Manager,Stavka Manager,
Hub User,Hub User,
Hub Password,Hub Password,
Hub Users,Korisnici Hub-a,
Marketplace Settings,Postavke tržišta,
Disable Marketplace,Onemogući tržište,
Marketplace URL (to hide and update label),URL prodavnice (za skrivanje i ažuriranje oznake),
Registered,Registrovano,
Sync in Progress,Sinhronizacija u toku,
Hub Seller Name,Hub Ime prodavca,
Custom Data,Korisnički podaci,
Repay From Salary,Otplatiti iz Plata,
Regular Payment,Redovna uplata,
Loan Closure,Zatvaranje zajma,
Rate of Interest (%) Yearly,Kamatnu stopu (%) Godišnji,
MAT-MSH-.YYYY.-,MAT-MSH-YYYY.-,
Generate Schedule,Generiranje Raspored,
Schedules,Rasporedi,
Maintenance Schedule Detail,Raspored održavanja detaljno,
Scheduled Date,Planski datum,
Actual Date,Stvarni datum,
Maintenance Schedule Item,Raspored održavanja stavki,
Random,Slučajno,
No of Visits,Bez pregleda,
MAT-MVS-.YYYY.-,MAT-MVS-YYYY.-,
Maintenance Date,Održavanje Datum,
Maintenance Time,Održavanje Vrijeme,
Completion Status,Završetak Status,
Partially Completed,Djelomično Završeni,
Fully Completed,Potpuno Završeni,
Unscheduled,Neplanski,
Breakdown,Slom,
Purposes,Namjene,
Customer Feedback,Ocjena Kupca,
Maintenance Visit Purpose,Svrha posjete za odrzavanje,
Work Done,Rad Done,
Against Document No,Protiv dokumentu nema,
Against Document Detail No,Protiv dokumenta Detalj No,
MFG-BLR-.YYYY.-,MFG-BLR-YYYY.-,
Order Type,Vrsta narudžbe,
Blanket Order Item,Stavka narudžbe odeće,
Ordered Quantity,Naručena količina,
Item to be manufactured or repacked,Artikal će biti proizveden ili prepakiran,
Quantity of item obtained after manufacturing / repacking from given quantities of raw materials,Količina predmeta dobije nakon proizvodnju / pakiranje od navedenih količina sirovina,
Set rate of sub-assembly item based on BOM,Postavite brzinu stavke podkomponenta na osnovu BOM-a,
Allow Alternative Item,Dozvoli alternativu,
Item UOM,Mjerna jedinica artikla,
Conversion Rate,Stopa konverzije,
Rate Of Materials Based On,Stopa materijali na temelju,
With Operations,Uz operacije,
Manage cost of operations,Upravljanje troškove poslovanja,
Transfer Material Against,Prenos materijala protiv,
Routing,Routing,
Materials,Materijali,
Quality Inspection Required,Potrebna inspekcija kvaliteta,
Quality Inspection Template,Šablon za proveru kvaliteta,
Scrap,komadić,
Scrap Items,Scrap Predmeti,
Operating Cost,Operativni troškovi,
Raw Material Cost,Troškovi sirovina,
Scrap Material Cost,Otpadnog materijala troškova,
Operating Cost (Company Currency),Operativni trošak (Company Valuta),
Raw Material Cost (Company Currency),Trošak sirovina (Kompanija valuta),
Scrap Material Cost(Company Currency),Otpadnog materijala troškova (poduzeća Valuta),
Total Cost,Ukupan trošak,
Total Cost (Company Currency),Ukupni trošak (valuta kompanije),
Materials Required (Exploded),Materijali Obavezno (eksplodirala),
Exploded Items,Eksplodirani predmeti,
Show in Website,Prikaži na web lokaciji,
Item Image (if not slideshow),Slika proizvoda (ako nije slide prikaz),
Thumbnail,Thumbnail,
Website Specifications,Web Specifikacije,
Show Items,Pokaži Predmeti,
Show Operations,Pokaži operacije,
Website Description,Web stranica Opis,
BOM Explosion Item,BOM eksplozije artikla,
Qty Consumed Per Unit,Kol Potrošeno po jedinici,
Include Item In Manufacturing,Uključi stavku u proizvodnju,
BOM Item,BOM proizvod,
Item operation,Rad operacija,
Rate & Amount,Cijena i količina,
Basic Rate (Company Currency),Osnovna stopa (valuta preduzeća),
Scrap %,Otpad%,
Original Item,Original Item,
BOM Operation,BOM operacija,
Operation Time ,Vrijeme rada,
In minutes,Za nekoliko minuta,
Batch Size,Veličina serije,
Base Hour Rate(Company Currency),Base Hour Rate (Company Valuta),
Operating Cost(Company Currency),Operativni trošak (Company Valuta),
BOM Scrap Item,BOM otpad Stavka,
Basic Amount (Company Currency),Osnovni Iznos (Company Valuta),
BOM Update Tool,Alat za ažuriranje BOM,
"Replace a particular BOM in all other BOMs where it is used. It will replace the old BOM link, update cost and regenerate ""BOM Explosion Item"" table as per new BOM.\nIt also updates latest price in all the BOMs.","Zamenite određenu tehničku tehničku pomoć u svim ostalim BOM-u gde se koristi. On će zamijeniti stari BOM link, ažurirati troškove i regenerirati tabelu &quot;BOM Explosion Item&quot; po novom BOM-u. Takođe ažurira najnoviju cenu u svim BOM.",
Replace BOM,Zamijenite BOM,
Current BOM,Trenutni BOM,
The BOM which will be replaced,BOM koji će biti zamijenjen,
The new BOM after replacement,Novi BOM nakon zamjene,
Replace,Zamijeniti,
Update latest price in all BOMs,Ažurirajte najnoviju cenu u svim BOM,
BOM Website Item,BOM Web Stavka,
BOM Website Operation,BOM Web Operacija,
Operation Time,Operacija Time,
PO-JOB.#####,POZIV. #####,
Timing Detail,Detalji vremena,
Time Logs,Time Dnevnici,
Total Time in Mins,Ukupno vrijeme u minima,
Operation ID,ID operacije,
Transferred Qty,prebačen Kol,
Job Started,Započeo posao,
Started Time,Started Time,
Current Time,Trenutno vrijeme,
Job Card Item,Stavka za karticu posla,
Job Card Time Log,Vremenski dnevnik radne kartice,
Time In Mins,Vrijeme u minutima,
Completed Qty,Završen Kol,
Manufacturing Settings,Proizvodnja Settings,
Raw Materials Consumption,Potrošnja sirovina,
Allow Multiple Material Consumption,Dozvolite višestruku potrošnju materijala,
Backflush Raw Materials Based On,Backflush sirovine na osnovu,
Material Transferred for Manufacture,Materijal za Preneseni Proizvodnja,
Capacity Planning,Planiranje kapaciteta,
Disable Capacity Planning,Onemogući planiranje kapaciteta,
Allow Overtime,Omogućiti Prekovremeni rad,
Allow Production on Holidays,Dopustite Production o praznicima,
Capacity Planning For (Days),Kapacitet planiranje (Dana),
Default Warehouses for Production,Zadane Skladišta za proizvodnju,
Default Work In Progress Warehouse,Uobičajeno Work in Progress Skladište,
Default Finished Goods Warehouse,Uobičajeno Gotovi proizvodi skladište,
Default Scrap Warehouse,Uobičajeno Scrap Warehouse,
Overproduction Percentage For Sales Order,Procenat prekomerne proizvodnje za porudžbinu prodaje,
Overproduction Percentage For Work Order,Procent prekomerne proizvodnje za radni nalog,
Other Settings,Ostale postavke,
Update BOM Cost Automatically,Ažurirajte BOM trošak automatski,
Material Request Plan Item,Zahtev za materijalni zahtev za materijal,
Material Request Type,Materijal Zahtjev Tip,
Material Issue,Materijal Issue,
Customer Provided,Kupac,
Minimum Order Quantity,Minimalna količina narudžbine,
Default Workstation,Uobičajeno Workstation,
Production Plan,Plan proizvodnje,
MFG-PP-.YYYY.-,MFG-PP-YYYY.-,
Get Items From,Get stavke iz,
Get Sales Orders,Kreiraj narudžbe,
Material Request Detail,Zahtev za materijal za materijal,
Get Material Request,Get materijala Upit,
Material Requests,materijal Zahtjevi,
Get Items For Work Order,Dobijte stavke za radni nalog,
Material Request Planning,Planiranje zahtjeva za materijal,
Include Non Stock Items,Uključite stavke bez zaliha,
Include Subcontracted Items,Uključite predmete sa podugovaračima,
Ignore Existing Projected Quantity,Zanemarite postojeću projiciranu količinu,
"To know more about projected quantity, <a href=""https://erpnext.com/docs/user/manual/en/stock/projected-quantity"" style=""text-decoration: underline;"" target=""_blank"">click here</a>.","Da biste saznali više o projektovanoj količini, <a href=""https://erpnext.com/docs/user/manual/en/stock/projected-quantity"" style=""text-decoration: underline;"" target=""_blank"">kliknite ovdje</a> .",
Download Required Materials,Preuzmite potrebne materijale,
Get Raw Materials For Production,Uzmite sirovine za proizvodnju,
Total Planned Qty,Ukupna planirana količina,
Total Produced Qty,Ukupno proizvedeni količina,
Material Requested,Zahtevani materijal,
Production Plan Item,Proizvodnja plan artikla,
Make Work Order for Sub Assembly Items,Napravite radni nalog za predmete podmontaže,
"If enabled, system will create the work order for the exploded items against which BOM is available.","Ako je omogućeno, sistem će kreirati radni nalog za eksplodirane predmete protiv kojih je BOM dostupan.",
Planned Start Date,Planirani Ozljede Datum,
Quantity and Description,Količina i opis,
material_request_item,material_request_item,
Product Bundle Item,Proizvod Bundle Stavka,
Production Plan Material Request,Proizvodni plan materijala Upit,
Production Plan Sales Order,Proizvodnja plan prodajnog naloga,
Sales Order Date,Datum narudžbe kupca,
Routing Name,Ime rutiranja,
MFG-WO-.YYYY.-,MFG-WO-.YYYY.-,
Item To Manufacture,Artikal za proizvodnju,
Material Transferred for Manufacturing,Materijal Prebačen za izradu,
Manufactured Qty,Proizvedeno Kol,
Use Multi-Level BOM,Koristite multi-level BOM,
Plan material for sub-assemblies,Plan materijal za podsklopove,
Skip Material Transfer to WIP Warehouse,Preskočite transfer materijala u WIP skladište,
Check if material transfer entry is not required,Provjerite da li se ne traži upis prenosa materijala,
Backflush Raw Materials From Work-in-Progress Warehouse,Backflush sirovine iz radnog materijala u skladištu,
Update Consumed Material Cost In Project,Ažurirajte potrošene troškove materijala u projektu,
Warehouses,Skladišta,
This is a location where raw materials are available.,To je mjesto gdje su dostupne sirovine.,
Work-in-Progress Warehouse,Rad u tijeku Warehouse,
This is a location where operations are executed.,Ovo je lokacija na kojoj se izvode operacije.,
This is a location where final product stored.,Ovo je mjesto na kojem se sprema krajnji proizvod.,
Scrap Warehouse,Scrap Skladište,
This is a location where scraped materials are stored.,Ovo je mjesto gdje se čuvaju strugani materijali.,
Required Items,potrebna Predmeti,
Actual Start Date,Stvarni datum početka,
Planned End Date,Planirani Završni datum,
Actual End Date,Stvarni datum završetka,
Operation Cost,Operacija Cost,
Planned Operating Cost,Planirani operativnih troškova,
Actual Operating Cost,Stvarni operativnih troškova,
Additional Operating Cost,Dodatni operativnih troškova,
Total Operating Cost,Ukupni trošak,
Manufacture against Material Request,Proizvodnja protiv Materijal Upit,
Work Order Item,Work Order Item,
Available Qty at Source Warehouse,Dostupno Količina na izvoru Skladište,
Available Qty at WIP Warehouse,Dostupno Količina u WIP Skladište,
Work Order Operation,Operacija rada,
Operation Description,Operacija Opis,
Operation completed for how many finished goods?,Operacija završena za koliko gotovih proizvoda?,
Work in Progress,Radovi u toku,
Estimated Time and Cost,Procijenjena vremena i troškova,
Planned Start Time,Planirani Start Time,
Planned End Time,Planirani End Time,
in Minutes,U minuta,
Actual Time and Cost,Stvarno vrijeme i troškovi,
Actual Start Time,Stvarni Start Time,
Actual End Time,Stvarni End Time,
Updated via 'Time Log',Ažurirano putem 'Time Log',
Actual Operation Time,Stvarni Operation Time,
in Minutes\nUpdated via 'Time Log',u minutama \n ažurirano preko 'Time Log',
(Hour Rate / 60) * Actual Operation Time,(Satnica / 60) * Puna radno vrijeme,
Workstation Name,Ime Workstation,
Production Capacity,Kapacitet proizvodnje,
Operating Costs,Operativni troškovi,
Electricity Cost,Troškovi struje,
per hour,na sat,
Consumable Cost,potrošni cost,
Rent Cost,Rent cost,
Wages,Plata,
Wages per hour,Plaće po satu,
Net Hour Rate,Neto Hour Rate,
Workstation Working Hour,Workstation Radno vrijeme,
Certification Application,Aplikacija za sertifikaciju,
Name of Applicant,Ime podnosioca zahteva,
Certification Status,Status certifikacije,
Yet to appear,Još uvek se pojavljuje,
Certified,Certified,
Not Certified,Nije sertifikovan,
USD,Američki dolar,
INR,INR,
Certified Consultant,Certified Consultant,
Name of Consultant,Ime konsultanta,
Certification Validity,Validnost sertifikacije,
Discuss ID,Diskutujte ID,
GitHub ID,GitHub ID,
Non Profit Manager,Neprofitni menadžer,
Chapter Head,Glava poglavlja,
Meetup Embed HTML,Upoznajte Embed HTML,
chapters/chapter_name\nleave blank automatically set after saving chapter.,poglavlja / chapter_name ostavite prazno automatski nakon podešavanja poglavlja.,
Chapter Members,Članovi poglavlja,
Members,Članovi,
Chapter Member,Član poglavlja,
Website URL,Website URL,
Leave Reason,Ostavite razlog,
Donor Name,Ime donatora,
Donor Type,Tip donatora,
Withdrawn,povučen,
Grant Application Details ,Grant Application Details,
Grant Description,Grant Opis,
Requested Amount,Traženi iznos,
Has any past Grant Record,Ima bilo kakav prošli Grant Record,
Show on Website,Show on Website,
Assessment  Mark (Out of 10),Oznaka ocene (od 10),
Assessment  Manager,Menadžer procjene,
Email Notification Sent,Poslato obaveštenje o pošti,
NPO-MEM-.YYYY.-,NPO-MEM-.YYYY.-,
Membership Expiry Date,Datum isteka članstva,
Razorpay Details,Razorpay Detalji,
Subscription ID,ID pretplate,
Customer ID,ID kupca,
Subscription Activated,Pretplata aktivirana,
Subscription Start ,Početak pretplate,
Subscription End,Kraj pretplate,
Non Profit Member,Član neprofitne organizacije,
Membership Status,Status članstva,
Member Since,Član od,
Payment ID,ID plaćanja,
Membership Settings,Postavke članstva,
Enable RazorPay For Memberships,Omogućite RazorPay za članstva,
RazorPay Settings,Postavke RazorPay-a,
Billing Cycle,Ciklus naplate,
Billing Frequency,Učestalost naplate,
"The number of billing cycles for which the customer should be charged. For example, if a customer is buying a 1-year membership that should be billed on a monthly basis, this value should be 12.","Broj obračunskih ciklusa za koji se kupcu treba naplatiti. Na primjer, ako kupac kupuje jednogodišnje članstvo koje bi trebalo naplaćivati mjesečno, ova vrijednost trebala bi biti 12.",
Razorpay Plan ID,ID plana za Razorpay,
Volunteer Name,Ime volontera,
Volunteer Type,Volonterski tip,
Availability and Skills,Dostupnost i vještine,
Availability,Dostupnost,
Weekends,Vikendi,
Availability Timeslot,Availability Timeslot,
Morning,Jutro,
Afternoon,Popodne,
Evening,Veče,
Anytime,Uvek,
Volunteer Skills,Volonterske veštine,
Volunteer Skill,Volonterska vještina,
Homepage,homepage,
Hero Section Based On,Odjeljak za heroje zasnovan na,
Homepage Section,Odjeljak početne stranice,
Hero Section,Sekcija heroja,
Tag Line,Tag Line,
Company Tagline for website homepage,Kompanija Tagline za web stranice homepage,
Company Description for website homepage,Kompanija Opis za web stranice homepage,
Homepage Slideshow,Prezentacija početne stranice,
"URL for ""All Products""",URL za &quot;Svi proizvodi&quot;,
Products to be shown on website homepage,Proizvodi koji će biti prikazan na sajtu homepage,
Homepage Featured Product,Homepage Istaknuti proizvoda,
route,ruta,
Section Based On,Odeljak na osnovu,
Section Cards,Karte odsjeka,
Number of Columns,Broj stupaca,
Number of columns for this section. 3 cards will be shown per row if you select 3 columns.,Broj stupaca za ovaj odjeljak. Po 3 kartice prikazat će se u svakom retku ako odaberete 3 stupca.,
Section HTML,Odjeljak HTML,
Use this field to render any custom HTML in the section.,Upotrijebite ovo polje za prikaz bilo kojeg prilagođenog HTML-a u odjeljku.,
Section Order,Odredba odjeljka,
"Order in which sections should appear. 0 is first, 1 is second and so on.","Redoslijed u kojim će se odjeljcima pojaviti. 0 je prvo, 1 je drugo itd.",
Homepage Section Card,Kartica odsjeka za početnu stranicu,
Subtitle,Podnaslov,
Products Settings,Proizvodi Postavke,
Home Page is Products,Početna stranica su proizvodi,
"If checked, the Home page will be the default Item Group for the website","Ako je označeno, na početnu stranicu će biti default Stavka grupe za web stranicu",
Show Availability Status,Prikaži status dostupnosti,
Product Page,Stranica proizvoda,
Products per Page,Proizvodi po stranici,
Enable Field Filters,Omogući filtre polja,
Item Fields,Polja predmeta,
Enable Attribute Filters,Omogući filtre atributa,
Attributes,Atributi,
Hide Variants,Sakrij varijante,
Website Attribute,Atributi web lokacije,
Attribute,Atribut,
Website Filter Field,Polje filtera za web stranicu,
Activity Cost,Aktivnost troškova,
Billing Rate,Billing Rate,
Costing Rate,Costing Rate,
title,naslov,
Projects User,Projektni korisnik,
Default Costing Rate,Uobičajeno Costing Rate,
Default Billing Rate,Uobičajeno Billing Rate,
Dependent Task,Zavisna Task,
Project Type,Vrsta projekta,
% Complete Method,% Complete Način,
Task Completion,zadatak Završetak,
Task Progress,zadatak Napredak,
% Completed,Završen%,
From Template,Iz šablona,
Project will be accessible on the website to these users,Projekt će biti dostupna na web stranici ovih korisnika,
Copied From,kopira iz,
Start and End Dates,Datume početka i završetka,
Actual Time in Hours (via Timesheet),Stvarno vrijeme (u satima),
Costing and Billing,Cijena i naplata,
Total Costing Amount (via Timesheet),Ukupni iznos troškova (preko Timesheeta),
Total Expense Claim (via Expense Claim),Ukupni rashodi potraživanja (preko rashodi potraživanja),
Total Purchase Cost (via Purchase Invoice),Ukupno TROŠKA (preko fakturi),
Total Sales Amount (via Sales Order),Ukupan iznos prodaje (preko prodajnog naloga),
Total Billable Amount (via Timesheet),Ukupan iznos iznosa (preko Timesheeta),
Total Billed Amount (via Sales Invoice),Ukupan fakturisani iznos (preko faktura prodaje),
Total Consumed Material Cost (via Stock Entry),Ukupni troškovi potrošnje materijala (preko zaliha zaliha),
Gross Margin,Bruto marža,
Gross Margin %,Bruto marža %,
Monitor Progress,Napredak monitora,
Collect Progress,Prikupi napredak,
Frequency To Collect Progress,Frekvencija za sakupljanje napretka,
Twice Daily,Twice Daily,
First Email,Prva e-pošta,
Second Email,Druga e-pošta,
Time to send,Vreme za slanje,
Day to Send,Dan za slanje,
Message will be sent to the users to get their status on the Project,Korisnicima će se poslati poruka da dobiju svoj status na Projektu,
Projects Manager,Projektni menadzer,
Project Template,Predložak projekta,
Project Template Task,Zadatak predloška projekta,
Begin On (Days),Početak (dani),
Duration (Days),Trajanje (dani),
Project Update,Ažuriranje projekta,
Project User,Korisnik projekta,
View attachments,Pregledajte priloge,
Projects Settings,Postavke projekata,
Ignore Workstation Time Overlap,Prezreti vremensko preklapanje radne stanice,
Ignore User Time Overlap,Isključiti preklapanje korisničkog vremena,
Ignore Employee Time Overlap,Prezreti vremensko preklapanje radnika,
Weight,težina,
Parent Task,Zadatak roditelja,
Timeline,Vremenska linija,
Expected Time (in hours),Očekivano trajanje (u satima),
% Progress,% Napredak,
Is Milestone,je Milestone,
Task Description,Opis zadatka,
Dependencies,Zavisnosti,
Dependent Tasks,Zavisni zadaci,
Depends on Tasks,Ovisi o Zadaci,
Actual Start Date (via Timesheet),Stvarni Ozljede Datum (preko Time Sheet),
Actual Time in Hours (via Timesheet),Stvarno vrijeme (u satima),
Actual End Date (via Timesheet),Stvarni Završni datum (preko Time Sheet),
Total Expense Claim (via Expense Claim),Ukupni rashodi potraživanja (preko rashodi potraživanje),
Review Date,Datum pregleda,
Closing Date,Datum zatvaranja,
Task Depends On,Zadatak ovisi o,
Task Type,Tip zadatka,
TS-.YYYY.-,TS-.YYYY.-,
Employee Detail,Detalji o radniku,
Billing Details,Billing Detalji,
Total Billable Hours,Ukupno naplative Hours,
Total Billed Hours,Ukupno Fakturisana Hours,
Total Costing Amount,Ukupno Costing iznos,
Total Billable Amount,Ukupno naplative iznos,
Total Billed Amount,Ukupno Fakturisana iznos,
% Amount Billed,% Naplaćenog iznosa,
Hrs,Hrs,
Costing Amount,Costing Iznos,
Corrective/Preventive,Korektivni / preventivni,
Corrective,Korektiv,
Preventive,Preventivno,
Resolution,Rezolucija,
Resolutions,Rezolucije,
Quality Action Resolution,Kvalitetna rezolucija akcije,
Quality Feedback Parameter,Parametar povratne informacije o kvalitetu,
Quality Feedback Template Parameter,Parametar predloška za povratne informacije o kvalitetu,
Quality Goal,Cilj kvaliteta,
Monitoring Frequency,Frekvencija praćenja,
Weekday,Radnim danom,
Objectives,Ciljevi,
Quality Goal Objective,Cilj kvaliteta kvaliteta,
Objective,Cilj,
Agenda,Dnevni red,
Minutes,Minute,
Quality Meeting Agenda,Agenda za kvalitetni sastanak,
Quality Meeting Minutes,Zapisnici sa kvalitetom sastanka,
Minute,Minuta,
Parent Procedure,Postupak roditelja,
Processes,Procesi,
Quality Procedure Process,Proces postupka kvaliteta,
Process Description,Opis procesa,
Link existing Quality Procedure.,Povežite postojeći postupak kvaliteta.,
Additional Information,Dodatne informacije,
Quality Review Objective,Cilj pregleda kvaliteta,
DATEV Settings,Postavke DATEV-a,
Regional,regionalni,
Consultant ID,ID konsultanta,
GST HSN Code,PDV HSN Kod,
HSN Code,HSN Kod,
GST Settings,PDV Postavke,
GST Summary,PDV Pregled,
GSTIN Email Sent On,GSTIN mail poslan,
GST Accounts,GST računi,
B2C Limit,B2C Limit,
Set Invoice Value for B2C. B2CL and B2CS calculated based on this invoice value.,Postavite vrednost fakture za B2C. B2CL i B2CS izračunati na osnovu ove fakture vrednosti.,
GSTR 3B Report,GSTR 3B Izvještaj,
January,Januar,
February,februar,
March,Marta,
April,Aprila,
August,Avgusta,
September,Septembra,
October,Oktobar,
November,Novembra,
December,Prosinca,
JSON Output,Izlaz JSON,
Invoices with no Place Of Supply,Računi bez mjesta opskrbe,
Import Supplier Invoice,Uvoz fakture dobavljača,
Invoice Series,Serija fakture,
Upload XML Invoices,Pošaljite XML fakture,
Zip File,Zip File,
Import Invoices,Uvoz računa,
Click on Import Invoices button once the zip file has been attached to the document. Any errors related to processing will be shown in the Error Log.,Kliknite gumb Uvezi račune nakon što se dokument pridruži. Sve pogreške povezane s obradom bit će prikazane u dnevniku grešaka.,
Lower Deduction Certificate,Potvrda o nižem odbitku,
Certificate Details,Detalji certifikata,
194A,194A,
194C,194C,
194D,194D,
194H,194H,
194I,194I,
194J,194J,
194LA,194LA,
194LBB,194LBB,
194LBC,194LBC,
Certificate No,Potvrda br,
Deductee Details,Detalji o odbitku,
PAN No,PAN br,
Validity Details,Detalji valjanosti,
Rate Of TDS As Per Certificate,Stopa TDS-a prema certifikatu,
Certificate Limit,Ograničenje certifikata,
Invoice Series Prefix,Prefix serije računa,
Active Menu,Aktivni meni,
Restaurant Menu,Restoran meni,
Price List (Auto created),Cenovnik (Automatski kreiran),
Restaurant Manager,Restoran menadžer,
Restaurant Menu Item,Restoran Menu Item,
Restaurant Order Entry,Restoran za unos naloga,
Restaurant Table,Restoran Stol,
Click Enter To Add,Kliknite Enter za dodavanje,
Last Sales Invoice,Poslednja prodaja faktura,
Current Order,Trenutna porudžbina,
Restaurant Order Entry Item,Restoran za unos stavke,
Served,Servirano,
Restaurant Reservation,Rezervacija restorana,
Waitlisted,Waitlisted,
No Show,Ne Show,
No of People,Broj ljudi,
Reservation Time,Vrijeme rezervacije,
Reservation End Time,Vreme završetka rezervacije,
No of Seats,Broj sedišta,
Minimum Seating,Minimalno sedenje,
"Keep Track of Sales Campaigns. Keep track of Leads, Quotations, Sales Order etc from Campaigns to gauge Return on Investment. ","Pratite prodajne kampanje. Pratite Lead-ove, Ponude, Porudžbenice itd iz Kampanje i procijeniti povrat investicije.",
SAL-CAM-.YYYY.-,SAL-CAM-YYYY.-,
Campaign Schedules,Rasporedi kampanje,
Buyer of Goods and Services.,Kupac robe i usluga.,
CUST-.YYYY.-,CUST-YYYY.-,
Default Company Bank Account,Bankovni račun kompanije,
From Lead,Od Lead-a,
Account Manager,Menadžer računa,
Allow Sales Invoice Creation Without Sales Order,Omogućite stvaranje fakture za prodaju bez naloga za prodaju,
Allow Sales Invoice Creation Without Delivery Note,Dozvoli stvaranje fakture za prodaju bez napomene o isporuci,
Default Price List,Zadani cjenik,
Primary Address and Contact Detail,Primarna adresa i kontakt detalji,
"Select, to make the customer searchable with these fields",Izaberite da biste potrošaču omogućili pretragu sa ovim poljima,
Customer Primary Contact,Primarni kontakt klijenta,
"Reselect, if the chosen contact is edited after save","Ponovo izaberi, ako je odabrani kontakt uređen nakon čuvanja",
Customer Primary Address,Primarna adresa klijenta,
"Reselect, if the chosen address is edited after save","Ponovo odaberite, ako je izabrana adresa uređena nakon čuvanja",
Primary Address,Primarna adresa,
Mention if non-standard receivable account,Spomenuti ako nestandardni potraživanja račun,
Credit Limit and Payment Terms,Kreditni limit i uslovi plaćanja,
Additional information regarding the customer.,Dodatne informacije o kupcu.,
Sales Partner and Commission,Prodajnog partnera i Komisije,
Commission Rate,Komisija Stopa,
Sales Team Details,Prodaja Team Detalji,
Customer POS id,Korisnički POS id,
Customer Credit Limit,Limit za klijenta,
Bypass Credit Limit Check at Sales Order,Provjerite kreditni limit za obilaznicu na nalogu za prodaju,
Industry Type,Industrija Tip,
MAT-INS-.YYYY.-,MAT-INS-.YYYY.-,
Installation Date,Instalacija Datum,
Installation Time,Vrijeme instalacije,
Installation Note Item,Napomena instalacije proizvoda,
Installed Qty,Instalirana kol,
Lead Source,Izvor potencijalnog kupca,
Period Start Date,Datum početka perioda,
Period End Date,Datum završetka perioda,
Cashier,Blagajna,
Difference,Razlika,
Modes of Payment,Načini plaćanja,
Linked Invoices,Povezane fakture,
POS Closing Voucher Details,POS Closing Voucher Detalji,
Collected Amount,Prikupljeni iznos,
Expected Amount,Očekivani iznos,
POS Closing Voucher Invoices,POS zaključavanje vaučera,
Quantity of Items,Količina predmeta,
"Aggregate group of **Items** into another **Item**. This is useful if you are bundling a certain **Items** into a package and you maintain stock of the packed **Items** and not the aggregate **Item**. \n\nThe package **Item** will have ""Is Stock Item"" as ""No"" and ""Is Sales Item"" as ""Yes"".\n\nFor Example: If you are selling Laptops and Backpacks separately and have a special price if the customer buys both, then the Laptop + Backpack will be a new Product Bundle Item.\n\nNote: BOM = Bill of Materials","Agregat grupa ** Predmeti ** u drugu ** Stavka **. Ovo je korisno ako se vezanje određenog ** Predmeti ** u paketu i održavanje zaliha na upakovane ** Predmeti ** a ne agregata ** Stavka **. Paket ** ** Stavka će imati &quot;Je Stock Stavka&quot; kao &quot;ne&quot; i &quot;Da li je prodaja Stavka&quot; kao &quot;Da&quot;. Na primjer: Ako se prodaje laptopa i Ruksaci odvojeno i imaju posebnu cijenu ako kupac kupuje obje, onda Laptop + Ruksak će biti novi Bundle proizvoda stavku. Napomena: BOM = Bill of Materials",
Parent Item,Roditelj artikla,
List items that form the package.,Popis stavki koje čine paket.,
SAL-QTN-.YYYY.-,SAL-QTN-YYYY-,
Quotation To,Ponuda za,
Rate at which customer's currency is converted to company's base currency,Stopa po kojoj se valuta klijenta se pretvaraju u tvrtke bazne valute,
Rate at which Price list currency is converted to company's base currency,Stopa po kojoj Cjenik valute se pretvaraju u tvrtke bazne valute,
Additional Discount and Coupon Code,Dodatni popust i kod kupona,
Referral Sales Partner,Preporuka prodajni partner,
In Words will be visible once you save the Quotation.,U riječi će biti vidljiv nakon što spremite ponudu.,
Term Details,Oročeni Detalji,
Quotation Item,Artikl iz ponude,
Against Doctype,Protiv DOCTYPE,
Against Docname,Protiv Docname,
Additional Notes,Dodatne napomene,
SAL-ORD-.YYYY.-,SAL-ORD-YYYY.-,
Skip Delivery Note,Preskočite dostavnicu,
In Words will be visible once you save the Sales Order.,U riječi će biti vidljiv nakon što spremite prodajnog naloga.,
Track this Sales Order against any Project,Prati ovu porudzbinu na svim Projektima,
Billing and Delivery Status,Obračun i Status isporuke,
Not Delivered,Ne Isporučeno,
Fully Delivered,Potpuno Isporučeno,
Partly Delivered,Djelomično Isporučeno,
Not Applicable,Nije primjenjivo,
%  Delivered,Isporučeno%,
% of materials delivered against this Sales Order,% Materijala dostavljenih od ovog prodajnog naloga,
% of materials billed against this Sales Order,% Materijala naplaćeno protiv ovog prodajnog naloga,
Not Billed,Ne Naplaćeno,
Fully Billed,Potpuno Naplaćeno,
Partly Billed,Djelomično Naplaćeno,
Ensure Delivery Based on Produced Serial No,Osigurati isporuku zasnovanu na serijskom br,
Supplier delivers to Customer,Dobavljač dostavlja kupaca,
Delivery Warehouse,Isporuka Skladište,
Planned Quantity,Planirana količina,
For Production,Za proizvodnju,
Work Order Qty,Work Order Količina,
Produced Quantity,Proizvedena količina,
Used for Production Plan,Koristi se za plan proizvodnje,
Sales Partner Type,Vrsta prodajnog partnera,
Contact No.,Kontakt broj,
Contribution (%),Doprinos (%),
Contribution to Net Total,Doprinos neto Ukupno,
Selling Settings,Podešavanja prodaje,
Settings for Selling Module,Postavke za prodaju modul,
Customer Naming By,Kupac Imenovanje By,
Campaign Naming By,Imenovanje kampanja po,
Default Customer Group,Zadana grupa korisnika,
Default Territory,Zadani teritorij,
Close Opportunity After Days,Zatvori Opportunity Nakon nekoliko dana,
Default Quotation Validity Days,Uobičajeni dani valute kvotiranja,
Sales Update Frequency,Frekvencija ažuriranja prodaje,
Each Transaction,Svaka transakcija,
SMS Center,SMS centar,
Send To,Pošalji na adresu,
All Contact,Svi kontakti,
All Customer Contact,Svi kontakti kupaca,
All Supplier Contact,Svi kontakti dobavljača,
All Sales Partner Contact,Svi kontakti distributera,
All Lead (Open),Svi potencijalni kupci (aktualni),
All Employee (Active),Svi zaposleni (aktivni),
All Sales Person,Svi prodavači,
Create Receiver List,Kreiraj listu primalaca,
Receiver List,Lista primalaca,
Messages greater than 160 characters will be split into multiple messages,Poruka veća od 160 karaktera će biti odvojena u više poruka,
Total Characters,Ukupno Likovi,
Total Message(s),Ukupno poruka ( i),
Authorization Control,Odobrenje kontrole,
Authorization Rule,Autorizacija Pravilo,
Average Discount,Prosječni popust,
Customerwise Discount,Customerwise Popust,
Itemwise Discount,Itemwise Popust,
Customer or Item,Kupac ili stavka,
Customer / Item Name,Kupac / Stavka Ime,
Authorized Value,Ovlašteni Vrijednost,
Applicable To (Role),Odnosi se na (uloga),
Applicable To (Employee),Odnosi se na (Radnik),
Applicable To (User),Odnosi se na (Upute),
Applicable To (Designation),Odnosi se na (Oznaka),
Approving Role (above authorized value),Odobravanje ulogu (iznad ovlašteni vrijednost),
Approving User  (above authorized value),Odobravanje korisnika (iznad ovlašteni vrijednost),
Brand Defaults,Podrazumevane robne marke,
Legal Entity / Subsidiary with a separate Chart of Accounts belonging to the Organization.,Pravna osoba / Podružnica sa zasebnim kontnom pripadaju Organizacije.,
Change Abbreviation,Promijeni Skraćenica,
Parent Company,Matična kompanija,
Default Values,Default vrijednosti,
Default Holiday List,Uobičajeno Holiday List,
Default Selling Terms,Uobičajeni prodajni uslovi,
Default Buying Terms,Uvjeti kupnje,
Create Chart Of Accounts Based On,Napravite Kontni plan na osnovu,
Standard Template,standard Template,
Existing Company,Postojeća kompanija,
Chart Of Accounts Template,Kontni plan Template,
Existing Company ,postojeći Company,
Date of Establishment,Datum uspostavljanja,
Sales Settings,Postavke prodaje,
Monthly Sales Target,Mesečni cilj prodaje,
Sales Monthly History,Prodaja mesečne istorije,
Transactions Annual History,Godišnja istorija transakcija,
Total Monthly Sales,Ukupna mesečna prodaja,
Default Cash Account,Zadani novčani račun,
Default Receivable Account,Uobičajeno Potraživanja račun,
Round Off Cost Center,Zaokružimo troškova Center,
Discount Allowed Account,Dopušten popust,
Discount Received Account,Račun primljen na popust,
Exchange Gain / Loss Account,Exchange dobitak / gubitak računa,
Unrealized Exchange Gain/Loss Account,Nerealizirani račun za dobitak / gubitak,
Allow Account Creation Against Child Company,Dozvolite otvaranje računa protiv kompanije Child,
Default Payable Account,Uobičajeno računa se plaća,
Default Employee Advance Account,Uobičajeni uposni račun zaposlenog,
Default Cost of Goods Sold Account,Uobičajeno Nabavna vrednost prodate robe računa,
Default Income Account,Zadani račun prihoda,
Default Deferred Revenue Account,Podrazumevani odloženi porezni račun,
Default Deferred Expense Account,Podrazumevani odloženi račun za troškove,
Default Payroll Payable Account,Uobičajeno zarade plaćaju nalog,
Default Expense Claim Payable Account,Podrazumevani troškovi potraživanja,
Stock Settings,Stock Postavke,
Enable Perpetual Inventory,Omogućiti vječni zaliha,
Default Inventory Account,Uobičajeno zaliha računa,
Stock Adjustment Account,Stock Adjustment račun,
Fixed Asset Depreciation Settings,Osnovnih sredstava Amortizacija Postavke,
Series for Asset Depreciation Entry (Journal Entry),Serija za unos sredstava za amortizaciju (dnevnik),
Gain/Loss Account on Asset Disposal,Dobitak / gubitak računa na Asset Odlaganje,
Asset Depreciation Cost Center,Asset Amortizacija troškova Center,
Budget Detail,Proračun Detalj,
Exception Budget Approver Role,Izuzetna budžetska uloga odobravanja,
Company Info,Podaci o preduzeću,
For reference only.,Za referencu samo.,
Company Logo,Logo kompanije,
Date of Incorporation,Datum osnivanja,
Date of Commencement,Datum početka,
Phone No,Telefonski broj,
Company Description,Opis preduzeća,
Registration Details,Registracija Brodu,
Company registration numbers for your reference. Tax numbers etc.,Tvrtka registracijski brojevi za svoju referencu. Porezni brojevi itd.,
Delete Company Transactions,Izbrišite Company Transakcije,
Currency Exchange,Mjenjačnica,
Specify Exchange Rate to convert one currency into another,Odredite Exchange Rate pretvoriti jedne valute u drugu,
From Currency,Od novca,
To Currency,Valutno,
For Buying,Za kupovinu,
For Selling,Za prodaju,
Customer Group Name,Naziv vrste djelatnosti Kupca,
Parent Customer Group,Roditelj Kupac Grupa,
Only leaf nodes are allowed in transaction,Samo leaf čvorovi su dozvoljeni u transakciji,
Mention if non-standard receivable account applicable,Spomenite ako nestandardnih potraživanja računa važećim,
Credit Limits,Kreditni limiti,
Email Digest,E-pošta,
Send regular summary reports via Email.,Pošalji redovne zbirne izvještaje putem e-maila.,
Email Digest Settings,E-pošta Postavke,
How frequently?,Koliko često?,
Next email will be sent on:,Sljedeća e-mail će biti poslan na:,
Note: Email will not be sent to disabled users,Napomena: E-mail neće biti poslan invalide,
Profit & Loss,Dobiti i gubitka,
New Income,novi prihod,
New Expenses,novi Troškovi,
Annual Income,Godišnji prihod,
Annual Expenses,Godišnji troškovi,
Bank Balance,Banka Balance,
Bank Credit Balance,Kreditni saldo banke,
Receivables,Potraživanja,
Payables,Obveze,
Sales Orders to Bill,Prodajni nalogi za Bill,
Purchase Orders to Bill,Narudžbe za kupovinu,
New Sales Orders,Nove narudžbenice,
New Purchase Orders,Novi narudžbenice kupnje,
Sales Orders to Deliver,Prodajna narudžbina za isporuku,
Purchase Orders to Receive,Narudžbe za kupovinu,
New Purchase Invoice,Nova faktura za kupovinu,
New Quotations,Nove ponude,
Open Quotations,Open Quotations,
Open Issues,Otvorena izdanja,
Open Projects,Otvoreni projekti,
Purchase Orders Items Overdue,Nalozi za kupovinu narudžbine,
Upcoming Calendar Events,Nadolazeći kalendarski događaji,
Open To Do,Otvoreno za obaviti,
Add Quote,Dodaj Citat,
Global Defaults,Globalne zadane postavke,
Default Company,Zadana tvrtka,
Current Fiscal Year,Tekuće fiskalne godine,
Default Distance Unit,Podrazumevana jedinica udaljenosti,
Hide Currency Symbol,Sakrij simbol valute,
Do not show any symbol like $ etc next to currencies.,Ne pokazati nikakav simbol poput $ iza valute.,
"If disable, 'Rounded Total' field will not be visible in any transaction","Ako onemogućite, &#39;Ukupno&#39; Zaobljeni polje neće biti vidljiv u bilo kojoj transakciji",
Disable In Words,Onemogućena u Words,
"If disable, 'In Words' field will not be visible in any transaction","Ako onemogućite, &#39;riječima&#39; polju neće biti vidljivi u bilo koju transakciju",
Item Classification,Stavka Klasifikacija,
General Settings,General Settings,
Item Group Name,Naziv grupe artikla,
Parent Item Group,Roditelj artikla Grupa,
Item Group Defaults,Podrazumevana postavka grupe,
Item Tax,Porez artikla,
Check this if you want to show in website,Označite ovo ako želite pokazati u web,
Show this slideshow at the top of the page,Prikaži ovaj slideshow na vrhu stranice,
HTML / Banner that will show on the top of product list.,HTML / baner koji će se prikazivati na vrhu liste proizvoda.,
Set prefix for numbering series on your transactions,Postavite prefiks za numeriranje niza na svoje transakcije,
Setup Series,Postavljanje Serija,
Update Series,Update serija,
Change the starting / current sequence number of an existing series.,Promjena polaznu / tekući redni broj postojeće serije.,
Quotation Lost Reason,Razlog nerealizirane ponude,
A third party distributor / dealer / commission agent / affiliate / reseller who sells the companies products for a commission.,A treće strane distributera / trgovca / komisije agent / affiliate / prodavače koji prodaje kompanije proizvoda za proviziju.,
Sales Partner Name,Prodaja Ime partnera,
Partner Type,Partner Tip,
Address & Contacts,Adresa i kontakti,
Address Desc,Adresa silazno,
Contact Desc,Kontakt ukratko,
Sales Partner Target,Prodaja partner Target,
Targets,Mete,
Show In Website,Pokaži Na web stranice,
Referral Code,Kod preporuke,
To Track inbound purchase,Da biste pratili ulaznu kupovinu,
Logo,Logo,
Partner website,website partner,
All Sales Transactions can be tagged against multiple **Sales Persons** so that you can set and monitor targets.,"Sve Sales Transakcije mogu biti označena protiv više osoba ** ** Sales, tako da možete postaviti i pratiti ciljeve.",
Name and Employee ID,Ime i ID zaposlenika,
Sales Person Name,Ime referenta prodaje,
Parent Sales Person,Roditelj Prodaja Osoba,
Select company name first.,Prvo odaberite naziv preduzeća.,
Sales Person Targets,Prodaje osobi Mete,
Set targets Item Group-wise for this Sales Person.,Set cilja predmet Grupa-mudar za ovaj prodavač.,
Supplier Group Name,Ime grupe dobavljača,
Parent Supplier Group,Matična grupa dobavljača,
Target Detail,Ciljana Detalj,
Target Qty,Ciljana Kol,
Target  Amount,Ciljani iznos,
Target Distribution,Ciljana Distribucija,
"Standard Terms and Conditions that can be added to Sales and Purchases.\n\nExamples:\n\n1. Validity of the offer.\n1. Payment Terms (In Advance, On Credit, part advance etc).\n1. What is extra (or payable by the Customer).\n1. Safety / usage warning.\n1. Warranty if any.\n1. Returns Policy.\n1. Terms of shipping, if applicable.\n1. Ways of addressing disputes, indemnity, liability, etc.\n1. Address and Contact of your Company.","Standardnim uvjetima koji se mogu dodati da prodaje i kupovine.\n\n Primjeri: \n\n 1. Valjanost ponude.\n 1. Uslovi plaćanja (unaprijed, na kredit, dio unaprijed itd).\n 1. Što je extra (ili na teret kupca).\n 1. Sigurnost / Upozorenje korištenje.\n 1. Jamstvo ako ih ima.\n 1. Vraća politike.\n 1. Uvjeti shipping, ako je primjenjivo.\n 1. Načini adresiranja sporova, naknadu štete, odgovornosti, itd \n 1. Adresu i kontakt vaše kompanije.",
Applicable Modules,Primjenjivi moduli,
Terms and Conditions Help,Uslovi Pomoć,
Classification of Customers by region,Klasifikacija Kupci po regiji,
Territory Name,Regija Ime,
Parent Territory,Roditelj Regija,
Territory Manager,Manager teritorije,
For reference,Za referencu,
Territory Targets,Teritorij Mete,
Set Item Group-wise budgets on this Territory. You can also include seasonality by setting the Distribution.,Postavite Stavka Grupa-mudre proračune na ovom području. Također možete uključiti sezonalnost postavljanjem Distribution.,
UOM Name,UOM Ime,
Check this to disallow fractions. (for Nos),Provjerite to da ne dopušta frakcija. (Za br),
Website Item Group,Web stranica artikla Grupa,
Cross Listing of Item in multiple groups,Cross Oglas tačke u više grupa,
Default settings for Shopping Cart,Početne postavke za Košarica,
Enable Shopping Cart,Enable Košarica,
Display Settings,Podešavanja izgleda,
Show Public Attachments,Pokaži Javna Prilozi,
Show Price,Prikaži cijene,
Show Stock Availability,Show Stock Availability,
Show Contact Us Button,Prikaži gumb Kontaktirajte nas,
Show Stock Quantity,Show Stock Quantity,
Show Apply Coupon Code,Prikaži Primjeni kod kupona,
Allow items not in stock to be added to cart,Dopustite da se dodaju u košaricu artikli koji nisu na zalihama,
Prices will not be shown if Price List is not set,Cijene neće biti prikazan ako nije postavljena Cjenik,
Quotation Series,Citat serije,
Checkout Settings,Plaćanje Postavke,
Enable Checkout,Enable Checkout,
Payment Success Url,Plaćanje Uspjeh URL,
After payment completion redirect user to selected page.,Nakon završetka uplate preusmjeriti korisnika na odabrani stranicu.,
Batch Details,Detalji serije,
Batch ID,ID serije,
image,slika,
Parent Batch,roditelja Batch,
Manufacturing Date,Datum proizvodnje,
Batch Quantity,Serijska količina,
Batch UOM,Batch UOM,
Source Document Type,Izvor Document Type,
Source Document Name,Izvor Document Name,
Batch Description,Batch Opis,
Bin,Kanta,
Reserved Quantity,Rezervirano Količina,
Actual Quantity,Stvarna količina,
Requested Quantity,Tražena količina,
Reserved Qty for sub contract,Rezervisana količina za pod ugovorom,
Moving Average Rate,Premještanje prosječna stopa,
FCFS Rate,FCFS Stopa,
Customs Tariff Number,Carinski tarifni broj,
Tariff Number,tarifni broj,
Delivery To,Dostava za,
MAT-DN-.YYYY.-,MAT-DN-YYYY.-,
Is Return,Je li povratak,
Issue Credit Note,Izdajte kreditnu poruku,
Return Against Delivery Note,Vratiti protiv Isporuka Napomena,
Customer's Purchase Order No,Kupca Narudžbenica br,
Billing Address Name,Naziv adrese za naplatu,
Required only for sample item.,Potrebna je samo za primjer stavke.,
"If you have created a standard template in Sales Taxes and Charges Template, select one and click on the button below.","Ako ste kreirali standardni obrazac u prodaji poreza i naknada Template, odaberite jednu i kliknite na dugme ispod.",
In Words will be visible once you save the Delivery Note.,Riječima će biti vidljivo nakon što spremite otpremnicu.,
In Words (Export) will be visible once you save the Delivery Note.,Riječima (izvoz) će biti vidljivo nakon što spremite otpremnicu.,
Transporter Info,Transporter Info,
Driver Name,Ime vozača,
Track this Delivery Note against any Project,Prati ovu napomenu o isporuci na svim Projektima,
Inter Company Reference,Inter Company Reference,
Print Without Amount,Ispis Bez visini,
% Installed,Instalirano%,
% of materials delivered against this Delivery Note,% Materijala dostavljenih protiv ove otpremnici,
Installation Status,Status instalacije,
Excise Page Number,Trošarina Broj stranice,
Instructions,Instrukcije,
From Warehouse,Od Skladište,
Against Sales Order,Protiv prodajnog naloga,
Against Sales Order Item,Protiv naloga prodaje Item,
Against Sales Invoice,Protiv prodaje fakture,
Against Sales Invoice Item,Protiv prodaje fakture Item,
Available Batch Qty at From Warehouse,Dostupno Batch Količina na Od Skladište,
Available Qty at From Warehouse,Dostupno Količina na Od Skladište,
Delivery Settings,Postavke isporuke,
Dispatch Settings,Dispečerske postavke,
Dispatch Notification Template,Šablon za obavještenje o otpremi,
Dispatch Notification Attachment,Prilog za obavještenje o otpremi,
Leave blank to use the standard Delivery Note format,Ostavite prazno da biste koristili standardni format isporuke,
Send with Attachment,Pošaljite sa Prilogom,
Delay between Delivery Stops,Kašnjenje između prekida isporuke,
Delivery Stop,Dostava Stop,
Lock,Zaključati,
Visited,Posjetio,
Order Information,Informacije o porudžbini,
Contact Information,Kontakt informacije,
Email sent to,E-mail poslat,
Dispatch Information,Informacije o otpremi,
Estimated Arrival,Procijenjeni dolazak,
MAT-DT-.YYYY.-,MAT-DT-YYYY.-,
Initial Email Notification Sent,Poslato je prvo obaveštenje o e-mailu,
Delivery Details,Detalji isporuke,
Driver Email,E-adresa vozača,
Driver Address,Adresa vozača,
Total Estimated Distance,Ukupna procenjena rastojanja,
Distance UOM,Udaljenost UOM,
Departure Time,Vrijeme odlaska,
Delivery Stops,Dostava je prestala,
Calculate Estimated Arrival Times,Izračunajte procenjene vremenske prilike,
Use Google Maps Direction API to calculate estimated arrival times,Koristite API za Google Maps Direction za izračunavanje predviđenih vremena dolaska,
Optimize Route,Optimizirajte rutu,
Use Google Maps Direction API to optimize route,Koristite API za usmjeravanje Google Maps za optimizaciju rute,
In Transit,U prolazu,
Fulfillment User,Fulfillment User,
"A Product or a Service that is bought, sold or kept in stock.","Proizvoda ili usluge koja je kupio, prodati ili držati u čoporu.",
STO-ITEM-.YYYY.-,STO-ITEM-.YYYY.-,
Variant Of,Variant Of,
"If item is a variant of another item then description, image, pricing, taxes etc will be set from the template unless explicitly specified","Ako proizvod varijanta druge stavke onda opis, slike, cijene, poreze itd će biti postavljena iz predloška, osim ako izričito navedeno",
Is Item from Hub,Je stavka iz Hub-a,
Default Unit of Measure,Zadana mjerna jedinica,
Maintain Stock,Održavati Stock,
Standard Selling Rate,Standard prodajni kurs,
Auto Create Assets on Purchase,Automatski kreirajte sredstva prilikom kupovine,
Asset Naming Series,Serija imenovanja imovine,
Over Delivery/Receipt Allowance (%),Nadoknada za isporuku / primanje (%),
Barcodes,Barkodovi,
Shelf Life In Days,Rok trajanja u danima,
End of Life,Kraj života,
Default Material Request Type,Uobičajeno materijala Upit Tip,
Valuation Method,Vrednovanje metoda,
FIFO,FIFO,
Moving Average,Moving Average,
Warranty Period (in days),Jamstveni period (u danima),
Auto re-order,Autorefiniš reda,
Reorder level based on Warehouse,Nivo Ponovno red zasnovan na Skladište,
Will also apply for variants unless overridden,Primjenjivat će se i za varijante osim overridden,
Units of Measure,Jedinice mjere,
Will also apply for variants,Primjenjivat će se i za varijante,
Serial Nos and Batches,Serijski brojevi i Paketi,
Has Batch No,Je Hrpa Ne,
Automatically Create New Batch,Automatski Create New Batch,
Batch Number Series,Serija brojeva serija,
"Example: ABCD.#####. If series is set and Batch No is not mentioned in transactions, then automatic batch number will be created based on this series. If you always want to explicitly mention Batch No for this item, leave this blank. Note: this setting will take priority over the Naming Series Prefix in Stock Settings.","Primer: ABCD. #####. Ako je serija postavljena i Batch No se ne pominje u transakcijama, na osnovu ove serije će se kreirati automatski broj serije. Ako uvek želite da eksplicitno navedete Batch No za ovu stavku, ostavite ovo praznim. Napomena: ovo podešavanje će imati prioritet nad Prefiksom naziva serije u postavkama zaliha.",
Has Expiry Date,Ima datum isteka,
Retain Sample,Zadrži uzorak,
Max Sample Quantity,Maksimalna količina uzorka,
Maximum sample quantity that can be retained,Maksimalna količina uzorka koja se može zadržati,
Has Serial No,Ima serijski br,
Serial Number Series,Serijski broj serije,
"Example: ABCD.#####\nIf series is set and Serial No is not mentioned in transactions, then automatic serial number will be created based on this series. If you always want to explicitly mention Serial Nos for this item. leave this blank.","Primjer:. ABCD ##### \n Ako serije je postavljen i serijski broj se ne spominje u transakcijama, a zatim automatski serijski broj će biti kreiran na osnovu ove serije. Ako želite uvijek izričito spomenuti Serial Nos za ovu stavku. ovo ostavite prazno.",
Variants,Varijante,
Has Variants,Ima Varijante,
"If this item has variants, then it cannot be selected in sales orders etc.","Ako ova stavka ima varijante, onda ne može biti izabran u prodaji naloge itd",
Variant Based On,Varijanta na osnovu,
Item Attribute,Stavka Atributi,
"Sales, Purchase, Accounting Defaults","Prodaja, kupovina, podrazumevane vrednosti računovodstva",
Item Defaults,Item Defaults,
"Purchase, Replenishment Details","Detalji kupovine, dopunjavanja",
Is Purchase Item,Je dobavljivi proizvod,
Default Purchase Unit of Measure,Podrazumevana jedinica kupovine mjere,
Minimum Order Qty,Minimalna količina za naručiti,
Minimum quantity should be as per Stock UOM,Minimalna količina treba biti prema zalihama UOM-a,
Average time taken by the supplier to deliver,Prosječno vrijeme koje je dobavljač isporuči,
Is Customer Provided Item,Da li je predmet koji pruža klijent,
Delivered by Supplier (Drop Ship),Isporučuje Dobavljač (Drop Ship),
Supplier Items,Dobavljač Predmeti,
Foreign Trade Details,Vanjske trgovine Detalji,
Country of Origin,Zemlja porijekla,
Sales Details,Prodajni detalji,
Default Sales Unit of Measure,Podrazumevana jedinica prodaje mjere,
Is Sales Item,Je artikl namijenjen prodaji,
Max Discount (%),Max rabat (%),
No of Months,Broj meseci,
Customer Items,Customer Predmeti,
Inspection Criteria,Inspekcijski Kriteriji,
Inspection Required before Purchase,Inspekcija Obavezno prije kupnje,
Inspection Required before Delivery,Inspekcija Potrebna prije isporuke,
Default BOM,Zadani BOM,
Supply Raw Materials for Purchase,Supply sirovine za kupovinu,
If subcontracted to a vendor,Ako podizvođača na dobavljača,
Customer Code,Kupac Šifra,
Default Item Manufacturer,Zadani proizvođač predmeta,
Default Manufacturer Part No,Zadani broj dijela proizvođača,
Show in Website (Variant),Pokaži u Web (Variant),
Items with higher weightage will be shown higher,Predmeti sa višim weightage će biti prikazan veći,
Show a slideshow at the top of the page,Prikaži slideshow na vrhu stranice,
Website Image,Slika web stranice,
Website Warehouse,Web stranica galerije,
"Show ""In Stock"" or ""Not in Stock"" based on stock available in this warehouse.",Show &quot;na lageru&quot; ili &quot;Nije u skladištu&quot; temelji se na skladištu dostupna u tom skladištu.,
Website Item Groups,Website Stavka Grupe,
List this Item in multiple groups on the website.,Popis ovaj predmet u više grupa na web stranici.,
Copy From Item Group,Primjerak iz točke Group,
Website Content,Sadržaj web stranice,
You can use any valid Bootstrap 4 markup in this field. It will be shown on your Item Page.,U ovom polju možete koristiti bilo koji važeći oznaku Bootstrap 4. To će biti prikazano na vašoj stranici predmeta.,
Total Projected Qty,Ukupni planirani Količina,
Hub Publishing Details,Detalji izdavanja stanice,
Publish in Hub,Objavite u Hub,
Publish Item to hub.erpnext.com,Objavite stavku da hub.erpnext.com,
Hub Category to Publish,Glavna kategorija za objavljivanje,
Hub Warehouse,Hub skladište,
"Publish ""In Stock"" or ""Not in Stock"" on Hub based on stock available in this warehouse.",Objavite &quot;Na lageru&quot; ili &quot;Nema na lageru&quot; na Hub-u na osnovu raspoloživih zaliha u ovom skladištu.,
Synced With Hub,Pohranjen Hub,
Item Alternative,Artikal Alternative,
Alternative Item Code,Alternativni kod artikla,
Two-way,Dvosmerno,
Alternative Item Name,Alternativni naziv predmeta,
Attribute Name,Atributi Ime,
Numeric Values,Brojčane vrijednosti,
From Range,Od Range,
Increment,Prirast,
To Range,U rasponu,
Item Attribute Values,Stavka Atributi vrijednosti,
Item Attribute Value,Stavka vrijednost atributa,
Attribute Value,Vrijednost atributa,
Abbreviation,Skraćenica,
"This will be appended to the Item Code of the variant. For example, if your abbreviation is ""SM"", and the item code is ""T-SHIRT"", the item code of the variant will be ""T-SHIRT-SM""","Ovo će biti dodan na Šifra za varijantu. Na primjer, ako je vaš skraćenica ""SM"", a stavka kod je ""T-SHIRT"", stavka kod varijante će biti ""T-SHIRT-SM""",
Item Barcode,Barkod artikla,
Barcode Type,Tip barkoda,
EAN,EAN,
UPC-A,UPC-A,
Item Customer Detail,Artikal - detalji kupca,
"For the convenience of customers, these codes can be used in print formats like Invoices and Delivery Notes","Za praktičnost kupaca, te kodovi mogu se koristiti u tiskanim formata kao što su fakture i otpremnice",
Ref Code,Ref. Šifra,
Item Default,Stavka Default,
Purchase Defaults,Kupovina Defaults,
Default Buying Cost Center,Zadani trošak kupnje,
Default Supplier,Glavni dobavljač,
Default Expense Account,Zadani račun rashoda,
Sales Defaults,Sales Defaults,
Default Selling Cost Center,Zadani trošak prodaje,
Item Manufacturer,artikal Proizvođač,
Item Price,Cijena artikla,
Packing Unit,Jedinica za pakovanje,
Quantity  that must be bought or sold per UOM,Količina koja se mora kupiti ili prodati po UOM,
Item Quality Inspection Parameter,Parametar provjere kvalitete artikala,
Acceptance Criteria,Kriterij prihvaćanja,
Item Reorder,Ponovna narudžba artikla,
Check in (group),Check in (grupa),
Request for,Zahtjev za,
Re-order Level,Re-order Level,
Re-order Qty,Re-order Količina,
Item Supplier,Dobavljač artikla,
Item Variant,Stavka Variant,
Item Variant Attribute,Stavka Variant Atributi,
Do not update variants on save,Ne ažurirajte varijante prilikom štednje,
Fields will be copied over only at time of creation.,Polja će se kopirati samo u trenutku kreiranja.,
Allow Rename Attribute Value,Dozvoli preimenovati vrednost atributa,
Rename Attribute Value in Item Attribute.,Preimenuj vrijednost atributa u atributu predmeta.,
Copy Fields to Variant,Kopiraj polja na varijantu,
Item Website Specification,Specifikacija web stranice artikla,
Table for Item that will be shown in Web Site,Sto za stavku koja će se prikazati u Web Site,
Landed Cost Item,Sletio Troškovi artikla,
Receipt Document Type,Prijem Document Type,
Receipt Document,dokument o prijemu,
Applicable Charges,Mjerodavno Optužbe,
Purchase Receipt Item,Kupnja Potvrda predmet,
Landed Cost Purchase Receipt,Sletio Trošak Kupnja Potvrda,
Landed Cost Taxes and Charges,Sleteo Troškovi poreza i naknada,
Landed Cost Voucher,Sleteo Cost vaučera,
MAT-LCV-.YYYY.-,MAT-LCV-YYYY.-,
Purchase Receipts,Kupovina Primici,
Purchase Receipt Items,Primka proizvoda,
Get Items From Purchase Receipts,Get Predmeti iz otkupa Primici,
Distribute Charges Based On,Podijelite Optužbe na osnovu,
Landed Cost Help,Sleteo Cost Pomoć,
Manufacturers used in Items,Proizvođači se koriste u Predmeti,
Limited to 12 characters,Ograničena na 12 znakova,
MAT-MR-.YYYY.-,MAT-MR-.YYYY.-,
Partially Ordered,Djelomično naređeno,
Transferred,prebačen,
% Ordered,% Poruceno,
Terms and Conditions Content,Uvjeti sadržaj,
Quantity and Warehouse,Količina i skladišta,
Lead Time Date,Datum i vrijeme Lead-a,
Min Order Qty,Min Red Kol,
Packed Item,Dostava Napomena Pakiranje artikla,
To Warehouse (Optional),Da Warehouse (Opcionalno),
Actual Batch Quantity,Stvarna količina serije,
Prevdoc DocType,Prevdoc DOCTYPE,
Parent Detail docname,Roditelj Detalj docname,
"Generate packing slips for packages to be delivered. Used to notify package number, package contents and its weight.","Generirajte pakovanje Slips za pakete dostaviti. Koristi se za obavijesti paket broja, sadržaj paket i njegove težine.",
Indicates that the package is a part of this delivery (Only Draft),Ukazuje da je paket je dio ove isporuke (samo nacrti),
MAT-PAC-.YYYY.-,MAT-PAC-YYYY.-,
From Package No.,Iz paketa broj,
Identification of the package for the delivery (for print),Identifikacija paketa za dostavu (za tisak),
To Package No.,Za Paket br,
If more than one package of the same type (for print),Ako je više od jedan paket od iste vrste (za tisak),
Package Weight Details,Težina paketa - detalji,
The net weight of this package. (calculated automatically as sum of net weight of items),Neto težina tog paketa. (Automatski izračunava kao zbroj neto težini predmeta),
Net Weight UOM,Težina mjerna jedinica,
Gross Weight,Bruto težina,
The gross weight of the package. Usually net weight + packaging material weight. (for print),Bruto težina paketa. Obično neto težina + ambalaža težina. (Za tisak),
Gross Weight UOM,Bruto težina UOM,
Packing Slip Item,Odreskom predmet,
DN Detail,DN detalj,
STO-PICK-.YYYY.-,STO-PICK-.YYYY.-,
Material Transfer for Manufacture,Prijenos materijala za izradu,
Qty of raw materials will be decided based on the qty of the Finished Goods Item,Količina sirovina odlučivat će se na osnovu količine proizvoda Gotove robe,
Parent Warehouse,Parent Skladište,
Items under this warehouse will be suggested,Predlozi ispod ovog skladišta bit će predloženi,
Get Item Locations,Dohvati lokacije predmeta,
Item Locations,Lokacije predmeta,
Pick List Item,Izaberite stavku popisa,
Picked Qty,Izabrani broj,
Price List Master,Cjenik Master,
Price List Name,Cjenik Ime,
Price Not UOM Dependent,Cijena nije UOM zavisna,
Applicable for Countries,Za zemlje u,
Price List Country,Cijena Lista država,
MAT-PRE-.YYYY.-,MAT-PRE-YYYY.-,
Supplier Delivery Note,Napomena o isporuci dobavljača,
Time at which materials were received,Vrijeme u kojem su materijali primili,
Return Against Purchase Receipt,Vratiti protiv Kupovina prijem,
Rate at which supplier's currency is converted to company's base currency,Stopa po kojoj supplier valuta se pretvaraju u tvrtke bazne valute,
Sets 'Accepted Warehouse' in each row of the items table.,Postavlja &#39;Prihvaćeno skladište&#39; u svaki red tablice stavki.,
Sets 'Rejected Warehouse' in each row of the items table.,Postavlja &#39;Odbijeno skladište&#39; u svaki red tablice stavki.,
Raw Materials Consumed,Potrošena sirovina,
Get Current Stock,Kreiraj trenutne zalihe,
Consumed Items,Potrošeni predmeti,
Add / Edit Taxes and Charges,Dodaj / uredi poreze i troškove,
Auto Repeat Detail,Auto Repeat Detail,
Transporter Details,Transporter Detalji,
Vehicle Number,Broj vozila,
Vehicle Date,Vozilo Datum,
Received and Accepted,Primljeni i prihvaćeni,
Accepted Quantity,Prihvaćena količina,
Rejected Quantity,Odbijen Količina,
Accepted Qty as per Stock UOM,Prihvaćena količina prema zalihama UOM,
Sample Quantity,Količina uzorka,
Rate and Amount,Kamatna stopa i iznos,
MAT-QA-.YYYY.-,MAT-QA-YYYY.-,
Report Date,Prijavi Datum,
Inspection Type,Inspekcija Tip,
Item Serial No,Serijski broj artikla,
Sample Size,Veličina uzorka,
Inspected By,Provjereno od strane,
Readings,Očitavanja,
Quality Inspection Reading,Kvaliteta Inspekcija čitanje,
Reading 1,Čitanje 1,
Reading 2,Čitanje 2,
Reading 3,Čitanje 3,
Reading 4,Čitanje 4,
Reading 5,Čitanje 5,
Reading 6,Čitanje 6,
Reading 7,Čitanje 7,
Reading 8,Čitanje 8,
Reading 9,Čitanje 9,
Reading 10,Čitanje 10,
Quality Inspection Template Name,Kvalitetno ime za proveru kvaliteta,
Quick Stock Balance,Brzi bilans stanja,
Available Quantity,Dostupna količina,
Distinct unit of an Item,Različite jedinice strane jedinice,
Warehouse can only be changed via Stock Entry / Delivery Note / Purchase Receipt,Skladište se može mijenjati samo preko Stock Stupanje / Dostavnica / kupiti primitka,
Purchase / Manufacture Details,Kupnja / Proizvodnja Detalji,
Creation Document Type,Tip stvaranje dokumenata,
Creation Document No,Stvaranje dokumenata nema,
Creation Date,Datum stvaranja,
Creation Time,vrijeme kreiranja,
Asset Details,Detalji o aktivi,
Asset Status,Status imovine,
Delivery Document Type,Dokument isporuke - tip,
Delivery Document No,Dokument isporuke br,
Delivery Time,Vrijeme isporuke,
Invoice Details,Račun Detalji,
Warranty / AMC Details,Jamstveni / AMC Brodu,
Warranty Expiry Date,Datum isteka jamstva,
AMC Expiry Date,AMC Datum isteka,
Under Warranty,Pod jamstvo,
Out of Warranty,Od jamstvo,
Under AMC,Pod AMC,
Out of AMC,Od AMC,
Warranty Period (Days),Jamstveni period (dani),
Serial No Details,Serijski nema podataka,
MAT-STE-.YYYY.-,MAT-STE-YYYY.-,
Stock Entry Type,Vrsta unosa zaliha,
Stock Entry (Outward GIT),Unos dionica (vanjski GIT),
Material Consumption for Manufacture,Potrošnja materijala za proizvodnju,
Repack,Prepakovati,
Send to Subcontractor,Pošaljite podizvođaču,
Delivery Note No,Otpremnica br,
Sales Invoice No,Faktura prodaje br,
Purchase Receipt No,Primka br.,
Inspection Required,Inspekcija Obvezno,
From BOM,Iz BOM,
For Quantity,Za količina,
As per Stock UOM,Kao po burzi UOM,
Including items for sub assemblies,Uključujući i stavke za pod sklopova,
Default Source Warehouse,Zadano izvorno skladište,
Source Warehouse Address,Adresa skladišta izvora,
Default Target Warehouse,Centralno skladište,
Target Warehouse Address,Adresa ciljne magacine,
Update Rate and Availability,Ažuriranje Rate i raspoloživost,
Total Incoming Value,Ukupna vrijednost Incoming,
Total Outgoing Value,Ukupna vrijednost Odlazni,
Total Value Difference (Out - In),Ukupna vrijednost Razlika (Out - In),
Additional Costs,Dodatni troškovi,
Total Additional Costs,Ukupno dodatnih troškova,
Customer or Supplier Details,Detalji o Kupcu ili Dobavljacu,
Per Transferred,Per Transferred,
Stock Entry Detail,Kataloški Stupanje Detalj,
Basic Rate (as per Stock UOM),Basic Rate (kao po akciji UOM),
Basic Amount,Osnovni iznos,
Additional Cost,Dodatni trošak,
Serial No / Batch,Serijski Ne / Batch,
BOM No. for a Finished Good Item,BOM broj za Gotovi Dobar točki,
Material Request used to make this Stock Entry,Materijal Zahtjev se koristi da bi se ova Stock unos,
Subcontracted Item,Predmet podizvođača,
Against Stock Entry,Protiv ulaska u dionice,
Stock Entry Child,Dijete ulaska na zalihe,
PO Supplied Item,PO isporučeni artikal,
Reference Purchase Receipt,Referentna kupovina,
Stock Ledger Entry,Stock Ledger Stupanje,
Outgoing Rate,Odlazni Rate,
Actual Qty After Transaction,Stvarna količina nakon transakcije,
Stock Value Difference,Stock Vrijednost razlika,
Stock Queue (FIFO),Kataloški red (FIFO),
Is Cancelled,Je otkazan,
Stock Reconciliation,Kataloški pomirenje,
This tool helps you to update or fix the quantity and valuation of stock in the system. It is typically used to synchronise the system values and what actually exists in your warehouses.,Ovaj alat pomaže vam da ažurirate ili popraviti količinu i vrednovanje zaliha u sistemu. To se obično koristi za usklađivanje vrijednosti sistema i ono što zaista postoji u skladištima.,
MAT-RECO-.YYYY.-,MAT-RECO-YYYY.-,
Reconciliation JSON,Pomirenje JSON,
Stock Reconciliation Item,Stock Pomirenje Item,
Before reconciliation,Prije nego pomirenje,
Current Serial No,Trenutni serijski br,
Current Valuation Rate,Trenutno Vrednovanje Rate,
Current Amount,Trenutni iznos,
Quantity Difference,Količina Razlika,
Amount Difference,iznos Razlika,
Item Naming By,Artikal imenovan po,
Default Item Group,Zadana grupa proizvoda,
Default Stock UOM,Zadana kataloška mjerna jedinica,
Sample Retention Warehouse,Skladište za zadržavanje uzorka,
Default Valuation Method,Zadana metoda vrednovanja,
Show Barcode Field,Pokaži Barcode Field,
Convert Item Description to Clean HTML,Pretvoriti stavku Opis za čišćenje HTML-a,
Allow Negative Stock,Dopustite negativnu zalihu,
Automatically Set Serial Nos based on FIFO,Automatski se postavlja rednim brojevima na osnovu FIFO,
Auto Material Request,Auto Materijal Zahtjev,
Inter Warehouse Transfer Settings,Postavke prijenosa Inter Warehouse,
Freeze Stock Entries,Zamrzavanje Stock Unosi,
Stock Frozen Upto,Kataloški Frozen Upto,
Batch Identification,Identifikacija serije,
Use Naming Series,Koristite nazive serije,
Naming Series Prefix,Prefiks naziva serije,
UOM Category,Kategorija UOM,
UOM Conversion Detail,UOM pretvorbe Detalj,
Variant Field,Varijantsko polje,
A logical Warehouse against which stock entries are made.,A logično Skladište protiv kojih su napravljeni unosa zaliha.,
Warehouse Detail,Detalji o skladištu,
Warehouse Name,Naziv skladišta,
Warehouse Contact Info,Kontakt informacije skladišta,
PIN,PIN,
ISS-.YYYY.-,ISS-.GGGG.-,
Raised By (Email),Pokrenuo (E-mail),
Issue Type,Vrsta izdanja,
Issue Split From,Izdanje Split From,
Service Level,Nivo usluge,
Response By,Odgovor By,
Response By Variance,Odgovor prema varijanci,
Ongoing,U toku,
Resolution By,Rezolucija,
Resolution By Variance,Rezolucija po varijanti,
Service Level Agreement Creation,Izrada sporazuma o nivou usluge,
First Responded On,Prvi put odgovorio dana,
Resolution Details,Detalji o rjesenju problema,
Opening Date,Otvaranje Datum,
Opening Time,Radno vrijeme,
Resolution Date,Rezolucija Datum,
Via Customer Portal,Preko portala za kupce,
Support Team,Tim za podršku,
Issue Priority,Prioritet pitanja,
Service Day,Dan usluge,
Workday,Radni dan,
Default Priority,Default Priority,
Priorities,Prioriteti,
Support Hours,sati podrške,
Support and Resolution,Podrška i rezolucija,
Default Service Level Agreement,Standardni ugovor o nivou usluge,
Entity,Entitet,
Agreement Details,Detalji sporazuma,
Response and Resolution Time,Vreme odziva i rešavanja,
Service Level Priority,Prioritet na nivou usluge,
Resolution Time,Vreme rezolucije,
Support Search Source,Podrška za pretragu,
Source Type,Tip izvora,
Query Route String,String string upita,
Search Term Param Name,Termin za pretragu Param Ime,
Response Options,Opcije odgovora,
Response Result Key Path,Response Result Key Path,
Post Route String,Post String niz,
Post Route Key List,Lista spiska ključeva,
Post Title Key,Ključ posta za naslov,
Post Description Key,Post Opis Ključ,
Link Options,Link Options,
Source DocType,Source DocType,
Result Title Field,Polje rezultata rezultata,
Result Preview Field,Polje za pregled rezultata,
Result Route Field,Polje trase rezultata,
Service Level Agreements,Ugovori o nivou usluge,
Track Service Level Agreement,Sporazum o nivou usluge za praćenje,
Allow Resetting Service Level Agreement,Dozvoli resetiranje sporazuma o nivou usluge,
Close Issue After Days,Zatvori Issue Nakon nekoliko dana,
Auto close Issue after 7 days,Auto blizu izdanje nakon 7 dana,
Support Portal,Portal za podršku,
Get Started Sections,Započnite sekcije,
Show Latest Forum Posts,Prikaži najnovije poruke foruma,
Forum Posts,Forum Posts,
Forum URL,Forum URL,
Get Latest Query,Najnoviji upit,
Response Key List,Lista ključnih reagovanja,
Post Route Key,Post Route Key,
Search APIs,API pretraživanja,
SER-WRN-.YYYY.-,SER-WRN-.YYYY.-,
Issue Date,Datum izdavanja,
Item and Warranty Details,Stavka i garancija Detalji,
Warranty / AMC Status,Jamstveni / AMC Status,
Resolved By,Riješen Do,
Service Address,Usluga Adresa,
If different than customer address,Ako se razlikuje od kupaca adresu,
Raised By,Povišena Do,
From Company,Iz Društva,
Rename Tool,Preimenovanje alat,
Utilities,Komunalne usluge,
Type of document to rename.,Vrsta dokumenta za promjenu naziva.,
File to Rename,File da biste preimenovali,
"Attach .csv file with two columns, one for the old name and one for the new name","Priložiti .csv datoteku s dvije kolone, jedan za stari naziv i jedna za novo ime",
Rename Log,Preimenovanje Prijavite,
SMS Log,SMS log,
Sender Name,Ime / Naziv pošiljaoca,
Sent On,Poslano na adresu,
No of Requested SMS,Nema traženih SMS,
Requested Numbers,Traženi brojevi,
No of Sent SMS,Ne poslanih SMS,
Sent To,Poslati,
Absent Student Report,Odsutan Student Report,
Assessment Plan Status,Status plana procjene,
Asset Depreciation Ledger,Asset Amortizacija Ledger,
Asset Depreciations and Balances,Imovine Amortizacija i vage,
Available Stock for Packing Items,Raspoloživo stanje za pakirane proizvode,
Bank Clearance Summary,Razmak banka Sažetak,
Batch Item Expiry Status,Batch Stavka Status isteka,
Batch-Wise Balance History,Batch-Wise bilanca Povijest,
BOM Explorer,BOM Explorer,
BOM Search,BOM pretraga,
BOM Stock Calculated,Obračun BOM-a,
BOM Variance Report,Izveštaj BOM varijacije,
Campaign Efficiency,kampanja efikasnost,
Cash Flow,Priliv novca,
Completed Work Orders,Završene radne naloge,
To Produce,proizvoditi,
Produced,Proizvedeno,
Consolidated Financial Statement,Konsolidovana finansijska izjava,
Course wise Assessment Report,Naravno mudar Izvještaj o procjeni,
Customer Acquisition and Loyalty,Stjecanje kupaca i lojalnost,
Customer Credit Balance,Customer Credit Balance,
Customer Ledger Summary,Sažetak knjige klijenta,
Customer-wise Item Price,Kupcima prilagođena cijena,
Customers Without Any Sales Transactions,Kupci bez prodajnih transakcija,
Daily Timesheet Summary,Dnevni Timesheet Pregled,
DATEV,DATEV,
Delayed Item Report,Izvještaj o odloženom predmetu,
Delayed Order Report,Izveštaj o odloženom nalogu,
Delivered Items To Be Billed,Isporučeni proizvodi za naplatiti,
Delivery Note Trends,Trendovi otpremnica,
Electronic Invoice Register,Registar elektroničkih računa,
Employee Billing Summary,Sažetak naplate zaposlenika,
Employee Birthday,Rođendani zaposlenih,
Employee Information,Informacija o zaposlenom,
Employee Leave Balance,Zaposlenik napuste balans,
Employee Leave Balance Summary,Sažetak ravnoteže zaposlenika,
Eway Bill,Eway Bill,
Expiring Memberships,Istekao članstva,
Fichier des Ecritures Comptables [FEC],Fichier des Ecritures Comptables [FEC],
Final Assessment Grades,Završne ocene,
Fixed Asset Register,Registar fiksne imovine,
Gross and Net Profit Report,Izvještaj o bruto i neto dobiti,
GST Itemised Purchase Register,PDV Specificirane Kupovina Registracija,
GST Itemised Sales Register,PDV Specificirane prodaje Registracija,
GST Purchase Register,PDV Kupovina Registracija,
GST Sales Register,PDV prodaje Registracija,
GSTR-1,GSTR-1,
GSTR-2,GSTR-2,
Hotel Room Occupancy,Hotelska soba u posjedu,
HSN-wise-summary of outward supplies,HSN-mudar-rezime izvora isporuke,
Inactive Customers,neaktivnih kupaca,
Inactive Sales Items,Neaktivni artikli prodaje,
IRS 1099,IRS 1099,
Issued Items Against Work Order,Izdate stavke protiv radnog naloga,
Projected Quantity as Source,Projektovanih količina kao izvor,
Item Balance (Simple),Balans predmeta (Jednostavno),
Item Price Stock,Stavka cijena Stock,
Item Prices,Cijene artikala,
Item Shortage Report,Nedostatak izvješća za artikal,
Item Variant Details,Detalji varijante proizvoda,
Item-wise Price List Rate,Stavka - mudar Cjenovnik Ocijenite,
Item-wise Purchase History,Stavka-mudar Kupnja Povijest,
Item-wise Purchase Register,Stavka-mudar Kupnja Registracija,
Item-wise Sales History,Stavka-mudar Prodaja Povijest,
Item-wise Sales Register,Stavka-mudri prodaja registar,
Items To Be Requested,Potraživani artikli,
Reserved,Rezervirano,
Itemwise Recommended Reorder Level,Itemwise Preporučio redoslijeda Level,
Lead Details,Detalji potenciajalnog kupca,
Lead Owner Efficiency,Lead Vlasnik efikasnost,
Lost Opportunity,Izgubljena prilika,
Maintenance Schedules,Rasporedi održavanja,
Material Requests for which Supplier Quotations are not created,Materijalni Zahtjevi za koje Supplier Citati nisu stvorene,
Open Work Orders,Otvorite radne naloge,
Qty to Deliver,Količina za dovođenje,
Patient Appointment Analytics,Analitika imenovanja pacijenta,
Payment Period Based On Invoice Date,Razdoblje za naplatu po Datum fakture,
Pending SO Items For Purchase Request,Otvorena SO Proizvodi za zahtjev za kupnju,
Procurement Tracker,Praćenje nabavke,
Product Bundle Balance,Bilans proizvoda,
Production Analytics,proizvodnja Analytics,
Profit and Loss Statement,Račun dobiti i gubitka,
Profitability Analysis,Analiza profitabilnosti,
Project Billing Summary,Sažetak naplate projekta,
Project wise Stock Tracking,Projektno mudro praćenje zaliha,
Project wise Stock Tracking ,Supervizor pracenje zaliha,
Prospects Engaged But Not Converted,Izgledi Engaged Ali ne pretvaraju,
Purchase Analytics,Kupnja Analytics,
Purchase Invoice Trends,Trendovi kupnje proizvoda,
Qty to Receive,Količina za primanje,
Received Qty Amount,Količina primljene količine,
Billed Qty,Količina računa,
Purchase Order Trends,Trendovi narudžbenica kupnje,
Purchase Receipt Trends,Račun kupnje trendovi,
Purchase Register,Kupnja Registracija,
Quotation Trends,Trendovi ponude,
Received Items To Be Billed,Primljeni Proizvodi se naplaćuje,
Qty to Order,Količina za narudžbu,
Requested Items To Be Transferred,Traženi stavki za prijenos,
Qty to Transfer,Količina za prijenos,
Sales Analytics,Prodajna analitika,
Sales Invoice Trends,Trendovi prodajnih računa,
Sales Order Trends,Prodajnog naloga trendovi,
Sales Partner Commission Summary,Rezime Komisije za prodajne partnere,
Sales Partner Target Variance based on Item Group,Ciljna varijanta prodajnog partnera na temelju grupe proizvoda,
Sales Partner Transaction Summary,Sažetak transakcije prodajnog partnera,
Sales Partners Commission,Prodaja Partneri komisija,
Invoiced Amount (Exclusive Tax),Iznos na fakturi (ekskluzivni porez),
Average Commission Rate,Prosječna stopa komisija,
Sales Payment Summary,Sažetak prodaje plata,
Sales Person Commission Summary,Povjerenik Komisije za prodaju,
Sales Person Target Variance Based On Item Group,Ciljna varijacija prodajnog lica na osnovu grupe predmeta,
Sales Person-wise Transaction Summary,Prodaja Osobne mudar Transakcija Sažetak,
Sales Register,Prodaja Registracija,
Serial No Service Contract Expiry,Serijski Bez isteka Ugovor o pružanju usluga,
Serial No Status,Serijski Bez Status,
Serial No Warranty Expiry,Serijski Nema jamstva isteka,
Stock Ageing,Kataloški Starenje,
Stock and Account Value Comparison,Poređenje vrednosti akcija i računa,
Stock Projected Qty,Projektovana kolicina na zalihama,
Student and Guardian Contact Details,Student i Guardian Kontakt detalji,
Student Batch-Wise Attendance,Student Batch-Wise Posjećenost,
Student Fee Collection,Student Naknada Collection,
Student Monthly Attendance Sheet,Student Mjesečni Posjeta list,
Subcontracted Item To Be Received,Podugovarački predmet koji treba primiti,
Subcontracted Raw Materials To Be Transferred,Podugovarane sirovine koje treba prenijeti,
Supplier Ledger Summary,Sažetak knjige dobavljača,
Supplier-Wise Sales Analytics,Supplier -mudar prodaje Analytics,
Support Hour Distribution,Podrška Distribucija sata,
TDS Computation Summary,Pregled TDS računa,
TDS Payable Monthly,TDS se plaća mesečno,
Territory Target Variance Based On Item Group,Varijacija ciljne teritorije na osnovu grupe predmeta,
Territory-wise Sales,Prodaja na teritoriji,
Total Stock Summary,Ukupno Stock Pregled,
Trial Balance,Pretresno bilanca,
Trial Balance (Simple),Probni balans (jednostavan),
Trial Balance for Party,Suđenje Balance za stranke,
Warehouse wise Item Balance Age and Value,Skladno mudro Stavka Balansno doba i vrijednost,
Work Order Stock Report,Izveštaj o radnom nalogu,
Work Orders in Progress,Radni nalogi u toku,
Automatically Process Deferred Accounting Entry,Automatski obradi odgođeni knjigovodstveni unos,
Bank Clearance,Potvrda banke,
Bank Clearance Detail,Detalji o odobrenju banke,
Update Cost Center Name / Number,Ažuriranje naziva / broja mjesta troška,
Journal Entry Template,Predložak unosa u časopis,
Template Title,Naslov predloška,
Journal Entry Type,Vrsta unosa u časopis,
Journal Entry Template Account,Račun predloška unosa u dnevnik,
Process Deferred Accounting,Obraditi odgođeno računovodstvo,
Manual entry cannot be created! Disable automatic entry for deferred accounting in accounts settings and try again,Nije moguće kreirati ručni unos! Onemogućite automatski unos za odgođeno računovodstvo u postavkama računa i pokušajte ponovo,
End date cannot be before start date,Datum završetka ne može biti prije datuma početka,
Total Counts Targeted,Ukupno ciljano brojanje,
Total Counts Completed,Ukupno prebrojavanje završeno,
Counts Targeted: {0},Broj ciljanih brojeva: {0},
Material Request Warehouse,Skladište zahtjeva za materijalom,
Select warehouse for material requests,Odaberite skladište za zahtjeve za materijalom,
Transfer Materials For Warehouse {0},Transfer materijala za skladište {0},
Production Plan Material Request Warehouse,Skladište zahtjeva za planom proizvodnje,
Sets 'Source Warehouse' in each row of the items table.,Postavlja &#39;Izvorno skladište&#39; u svaki red tablice stavki.,
Sets 'Target Warehouse' in each row of the items table.,Postavlja &#39;Target Warehouse&#39; u svaki red tablice stavki.,
Show Cancelled Entries,Prikaži otkazane unose,
Backdated Stock Entry,Unos dionica sa zadnjim datumom,
Row #{}: Currency of {} - {} doesn't matches company currency.,Redak {{}: Valuta od {} - {} se ne podudara s valutom kompanije.,
{} Assets created for {},{} Sredstva kreirana za {},
{0} Number {1} is already used in {2} {3},{0} Broj {1} već se koristi u dokumentu {2} {3},
Update Bank Clearance Dates,Ažurirajte datume odobrenja za banke,
Healthcare Practitioner: ,Zdravstveni radnik:,
Lab Test Conducted: ,Izvršen laboratorijski test:,
Lab Test Event: ,Laboratorijski test:,
Lab Test Result: ,Rezultat laboratorijskog testa:,
Clinical Procedure conducted: ,Provedeni klinički postupak:,
Therapy Session Charges: {0},Troškovi sesije terapije: {0},
Therapy: ,Terapija:,
Therapy Plan: ,Plan terapije:,
Total Counts Targeted: ,Ukupno ciljano brojanje:,
Total Counts Completed: ,Ukupno završeno brojanje:,
Is Mandatory,Je obavezna,
Service Received But Not Billed,"Usluga primljena, ali ne naplaćena",
Deferred Accounting Settings,Postavke odgođenog računovodstva,
Book Deferred Entries Based On,Rezervirajte odložene unose na osnovu,
Days,Dani,
Months,Mjeseci,
Book Deferred Entries Via Journal Entry,Rezervirajte unose putem dnevnika,
Submit Journal Entries,Pošaljite članke u časopisu,
If this is unchecked Journal Entries will be saved in a Draft state and will have to be submitted manually,"Ako ovo nije označeno, unosi u dnevnik bit će spremljeni u stanje nacrta i morat će se slati ručno",
Enable Distributed Cost Center,Omogući distribuirano mjesto troškova,
Distributed Cost Center,Distribuirano mjesto troškova,
Dunning,Dunning,
DUNN-.MM.-.YY.-,DUNN-.MM .-. YY.-,
Overdue Days,Zakašnjeli dani,
Dunning Type,Dunning Type,
Dunning Fee,Naknada za Dunning,
Dunning Amount,Iznos za izlazak,
Resolved,Riješeno,
Unresolved,Neriješeno,
Printing Setting,Podešavanje ispisa,
Body Text,Body Text,
Closing Text,Završni tekst,
Resolve,Riješi,
Dunning Letter Text,Dunning Letter Text,
Is Default Language,To je zadani jezik,
Letter or Email Body Text,Tekst pisma ili e-pošte,
Letter or Email Closing Text,Završni tekst pisma ili e-pošte,
Body and Closing Text Help,Pomoć za tekst i završni tekst,
Overdue Interval,Preostali interval,
Dunning Letter,Dunning Letter,
"This section allows the user to set the Body and Closing text of the Dunning Letter for the Dunning Type based on language, which can be used in Print.","Ovaj odjeljak omogućava korisniku da postavi tekst tijela i završni tekst Pisma za upozoravanje za vrstu odbojke na osnovu jezika, koji se može koristiti u Ispisu.",
Reference Detail No,Referentni detalj br,
Custom Remarks,Prilagođene napomene,
Please select a Company first.,Prvo odaberite kompaniju.,
"Row #{0}: Reference Document Type must be one of Sales Order, Sales Invoice, Journal Entry or Dunning","Redak {0}: vrsta referentnog dokumenta mora biti jedan od prodajnih naloga, faktura prodaje, unosa u dnevnik ili isteka",
POS Closing Entry,Zatvaranje ulaza u POS,
POS Opening Entry,POS otvaranje,
POS Transactions,POS transakcije,
POS Closing Entry Detail,Detalji o zatvaranju POS-a,
Opening Amount,Iznos otvaranja,
Closing Amount,Završni iznos,
POS Closing Entry Taxes,POS porez na zatvaranje,
POS Invoice,POS faktura,
ACC-PSINV-.YYYY.-,ACC-PSINV-.GGGG.-,
Consolidated Sales Invoice,Konsolidovana faktura prodaje,
Return Against POS Invoice,Povraćaj protiv POS fakture,
Consolidated,Konsolidovano,
POS Invoice Item,POS faktura,
POS Invoice Merge Log,Dnevnik spajanja POS faktura,
POS Invoices,POS fakture,
Consolidated Credit Note,Konsolidovana kreditna napomena,
POS Invoice Reference,Referenca POS računa,
Set Posting Date,Postavite datum knjiženja,
Opening Balance Details,Detalji o početnom stanju,
POS Opening Entry Detail,Detalji o otvaranju POS-a,
POS Payment Method,POS način plaćanja,
Payment Methods,metode plaćanja,
Process Statement Of Accounts,Obraditi izvod računa,
General Ledger Filters,Filteri glavne knjige,
Customers,Kupci,
Select Customers By,Odaberite Kupce prema,
Fetch Customers,Dohvatite kupce,
Send To Primary Contact,Pošalji primarnom kontaktu,
Print Preferences,Postavke ispisa,
Include Ageing Summary,Uključite sažetak starenja,
Enable Auto Email,Omogućite automatsku e-poštu,
Filter Duration (Months),Trajanje filtra (mjeseci),
CC To,CC To,
Help Text,Tekst pomoći,
Emails Queued,E-adrese u redu,
Process Statement Of Accounts Customer,Obradite izvod računa,
Billing Email,E-adresa za naplatu,
Primary Contact Email,Primarna kontakt adresa e-pošte,
PSOA Cost Center,PSOA centar troškova,
PSOA Project,PSOA projekat,
ACC-PINV-RET-.YYYY.-,ACC-PINV-RET-.GGGG.-,
Supplier GSTIN,Dobavljač GSTIN,
Place of Supply,Mjesto isporuke,
Select Billing Address,Odaberite Adresa za naplatu,
GST Details,GST detalji,
GST Category,GST kategorija,
Registered Regular,Registered Regular,
Registered Composition,Registrovana kompozicija,
Unregistered,Neregistrirano,
SEZ,SEZ,
Overseas,Prekomorski,
UIN Holders,UIN držači,
With Payment of Tax,Uz plaćanje poreza,
Without Payment of Tax,Bez plaćanja poreza,
Invoice Copy,Kopija fakture,
Original for Recipient,Original za primatelja,
Duplicate for Transporter,Duplikat za Transporter,
Duplicate for Supplier,Duplikat za dobavljača,
Triplicate for Supplier,Trostruki primjerak za dobavljača,
Reverse Charge,Obrnuto punjenje,
Y,Y.,
N,N,
E-commerce GSTIN,E-trgovina GSTIN,
Reason For Issuing document,Razlog za izdavanje dokumenta,
01-Sales Return,01-Povratak prodaje,
02-Post Sale Discount,Popust za prodaju nakon 02,
03-Deficiency in services,03-Nedostatak usluga,
04-Correction in Invoice,04-Ispravak na fakturi,
05-Change in POS,05-Promjena u POS-u,
06-Finalization of Provisional assessment,06-Finalizacija privremene procjene,
07-Others,07-Ostalo,
Eligibility For ITC,Ispunjavanje uslova za ITC,
Input Service Distributor,Distributer ulaznih usluga,
Import Of Service,Uvoz usluge,
Import Of Capital Goods,Uvoz kapitalnih dobara,
Ineligible,Neprihvatljivo,
All Other ITC,Svi ostali ITC,
Availed ITC Integrated Tax,Integrisani ITC integrisani porez,
Availed ITC Central Tax,Dostupni centralni porez ITC-a,
Availed ITC State/UT Tax,Availed ITC State / UT porez,
Availed ITC Cess,Availed ITC Cess,
Is Nil Rated or Exempted,Da li je Nil ocijenjen ili izuzet,
Is Non GST,Nije GST,
ACC-SINV-RET-.YYYY.-,ACC-SINV-RET-.GGGG.-,
E-Way Bill No.,E-Way Bill No.,
Is Consolidated,Konsolidovan je,
Billing Address GSTIN,Adresa za naplatu GSTIN,
Customer GSTIN,Kupac GSTIN,
GST Transporter ID,GST Transporter ID,
Distance (in km),Udaljenost (u km),
Road,Cesta,
Air,Zrak,
Rail,Rail,
Ship,Brod,
GST Vehicle Type,GST tip vozila,
Over Dimensional Cargo (ODC),Prekomerni teret (ODC),
Consumer,Potrošač,
Deemed Export,Predviđeni izvoz,
Port Code,Port port,
 Shipping Bill Number,Broj računa za dostavu,
Shipping Bill Date,Datum dostave računa,
Subscription End Date,Datum završetka pretplate,
Follow Calendar Months,Pratite mjesece kalendara,
If this is checked subsequent new invoices will be created on calendar  month and quarter start dates irrespective of current invoice start date,"Ako je ovo potvrđeno, kreirat će se nove fakture na datum početka kalendarskog mjeseca i kvartala, bez obzira na datum početka tekuće fakture",
Generate New Invoices Past Due Date,Generirajte nove fakture s rokom dospijeća,
New invoices will be generated as per schedule even if current invoices are unpaid or past due date,"Nove fakture generirat će se prema rasporedu, čak i ako su tekuće fakture neplaćene ili su istekle",
Document Type ,Tip dokumenta,
Subscription Price Based On,Cijena pretplate na osnovu,
Fixed Rate,Fiksna stopa,
Based On Price List,Na osnovu cjenika,
Monthly Rate,Mjesečna stopa,
Cancel Subscription After Grace Period,Otkažite pretplatu nakon počeka,
Source State,Izvorna država,
Is Inter State,Je Inter State,
Purchase Details,Detalji kupovine,
Depreciation Posting Date,Datum knjiženja amortizacije,
"By default, the Supplier Name is set as per the Supplier Name entered. If you want Suppliers to be named by a  ","Prema zadanim postavkama, ime dobavljača je postavljeno prema unesenom imenu dobavljača. Ako želite da dobavljače imenuje",
 choose the 'Naming Series' option.,odaberite opciju &#39;Naming Series&#39;.,
Configure the default Price List when creating a new Purchase transaction. Item prices will be fetched from this Price List.,Konfigurišite zadani cjenik prilikom kreiranja nove transakcije kupovine. Cijene stavki će se preuzeti iz ovog cjenika.,
"If this option is configured 'Yes', ERPNext will prevent you from creating a Purchase Invoice or Receipt without creating a Purchase Order first. This configuration can be overridden for a particular supplier by enabling the 'Allow Purchase Invoice Creation Without Purchase Order' checkbox in the Supplier master.","Ako je ova opcija konfigurirana kao &quot;Da&quot;, ERPNext će vas spriječiti u stvaranju računa ili potvrde o kupovini bez prethodnog kreiranja narudžbenice. Ovu konfiguraciju možete nadjačati za određenog dobavljača tako što ćete omogućiti potvrdni okvir &#39;Dopusti stvaranje računa za kupovinu bez narudžbenice&#39; u glavnom meniju dobavljača.",
"If this option is configured 'Yes', ERPNext will prevent you from creating a Purchase Invoice without creating a Purchase Receipt first. This configuration can be overridden for a particular supplier by enabling the 'Allow Purchase Invoice Creation Without Purchase Receipt' checkbox in the Supplier master.","Ako je ova opcija konfigurirana kao &quot;Da&quot;, ERPNext će vas spriječiti u stvaranju fakture za kupovinu bez prethodnog kreiranja potvrde o kupovini. Ovu konfiguraciju možete nadjačati za određenog dobavljača tako što ćete omogućiti potvrdni okvir &#39;Omogući stvaranje računa za kupovinu bez potvrde o kupovini&#39; na glavnom mjestu dobavljača.",
Quantity & Stock,Količina i zalihe,
Call Details,Detalji poziva,
Authorised By,Ovlašteno od,
Signee (Company),Potpisnik (kompanija),
Signed By (Company),Potpisao (kompanija),
First Response Time,Vrijeme prvog odgovora,
Request For Quotation,Zahtjev za ponudu,
Opportunity Lost Reason Detail,Detalji izgubljenog razloga za priliku,
Access Token Secret,Pristup tajnoj žetonu,
Add to Topics,Dodaj u teme,
...Adding Article to Topics,... Dodavanje članka u teme,
Add Article to Topics,Dodajte članak u teme,
This article is already added to the existing topics,Ovaj je članak već dodan postojećim temama,
Add to Programs,Dodaj u programe,
Programs,Programi,
...Adding Course to Programs,... Dodavanje kursa programima,
Add Course to Programs,Dodajte kurs u programe,
This course is already added to the existing programs,Ovaj kurs je već dodan postojećim programima,
Learning Management System Settings,Postavke sistema za upravljanje učenjem,
Enable Learning Management System,Omogućite sistem upravljanja učenjem,
Learning Management System Title,Naslov sistema upravljanja učenjem,
...Adding Quiz to Topics,... Dodavanje kviza u teme,
Add Quiz to Topics,Dodajte kviz u teme,
This quiz is already added to the existing topics,Ovaj kviz je već dodan postojećim temama,
Enable Admission Application,Omogućite prijavu za prijem,
EDU-ATT-.YYYY.-,EDU-ATT-.GGGG.-,
Marking attendance,Označavanje prisustva,
Add Guardians to Email Group,Dodajte skrbnike u grupu e-pošte,
Attendance Based On,Prisustvo na osnovu,
Check this to mark the student as present in case the student is not attending the institute to participate or represent the institute in any event.\n\n,Označite ovo da biste studenta označili kao prisutnog u slučaju da student ne pohađa institut da bi u bilo kojem slučaju učestvovao ili predstavljao institut.,
Add to Courses,Dodaj u kurseve,
...Adding Topic to Courses,... Dodavanje teme kursevima,
Add Topic to Courses,Dodajte temu kursevima,
This topic is already added to the existing courses,Ova je tema već dodana postojećim tečajevima,
"If Shopify does not have a customer in the order, then while syncing the orders, the system will consider the default customer for the order","Ako Shopify nema kupca u narudžbi, tada će tijekom sinkronizacije narudžbi sistem uzeti u obzir zadanog kupca za narudžbu.",
The accounts are set by the system automatically but do confirm these defaults,"Račune sustav postavlja automatski, ali potvrđuje ove zadane postavke",
Default Round Off Account,Zadani zaokruženi račun,
Failed Import Log,Dnevnik uvoza nije uspio,
Fixed Error Log,Fiksni dnevnik grešaka,
Company {0} already exists. Continuing will overwrite the Company and Chart of Accounts,Kompanija {0} već postoji. Nastavak će prebrisati kompaniju i kontni plan,
Meta Data,Meta podaci,
Unresolve,Nerazriješi,
Create Document,Kreirajte dokument,
Mark as unresolved,Označi kao neriješeno,
TaxJar Settings,Postavke TaxJar-a,
Sandbox Mode,Peščanik režim,
Enable Tax Calculation,Omogućite obračun poreza,
Create TaxJar Transaction,Kreirajte TaxJar transakciju,
Credentials,Akreditivi,
Live API Key,API API ključ,
Sandbox API Key,API ključ Sandbox-a,
Configuration,Konfiguracija,
Tax Account Head,Voditelj poreznog računa,
Shipping Account Head,Šef računa za isporuku,
Practitioner Name,Ime liječnika,
Enter a name for the Clinical Procedure Template,Unesite naziv za obrazac kliničke procedure,
Set the Item Code which will be used for billing the Clinical Procedure.,Postavite kod predmeta koji će se koristiti za naplatu kliničkog postupka.,
Select an Item Group for the Clinical Procedure Item.,Odaberite grupu predmeta za stavku kliničkog postupka.,
Clinical Procedure Rate,Stopa kliničke procedure,
Check this if the Clinical Procedure is billable and also set the rate.,Provjerite ovo ako se klinički postupak naplati i također postavite stopu.,
Check this if the Clinical Procedure utilises consumables. Click ,Provjerite ovo ako klinički postupak koristi potrošni materijal. Kliknite,
 to know more,da znam više,
"You can also set the Medical Department for the template. After saving the document, an Item will automatically be created for billing this Clinical Procedure. You can then use this template while creating Clinical Procedures for Patients. Templates save you from filling up redundant data every single time. You can also create templates for other operations like Lab Tests, Therapy Sessions, etc.","Za obrazac možete postaviti i Medicinsko odjeljenje. Nakon spremanja dokumenta, automatski će se stvoriti stavka za naplatu ovog kliničkog postupka. Tada možete koristiti ovaj obrazac dok kreirate kliničke postupke za pacijente. Predlošci vas štede od popunjavanja suvišnih podataka svaki put. Također možete stvoriti predloške za druge operacije poput laboratorijskih testova, terapijskih sesija itd.",
Descriptive Test Result,Opisni rezultat testa,
Allow Blank,Dopusti prazno,
Descriptive Test Template,Opisni testni obrazac,
"If you want to track Payroll and other HRMS operations for a Practitoner, create an Employee and link it here.","Ako želite pratiti obračun plaća i druge HRMS operacije za praktičara, stvorite zaposlenika i povežite ga ovdje.",
Set the Practitioner Schedule you just created. This will be used while booking appointments.,Postavite raspored praktičara koji ste upravo kreirali. Ovo će se koristiti prilikom rezervacije termina.,
Create a service item for Out Patient Consulting.,Stvorite stavku usluge za savjetovanje izvan pacijenata.,
"If this Healthcare Practitioner works for the In-Patient Department, create a service item for Inpatient Visits.","Ako ovaj zdravstveni radnik radi za stacionar, stvorite uslugu za stacionarne posjete.",
Set the Out Patient Consulting Charge for this Practitioner.,Postavite naknadu za konsultacije s pacijentom za ovog praktičara.,
"If this Healthcare Practitioner also works for the In-Patient Department, set the inpatient visit charge for this Practitioner.","Ako ovaj zdravstveni radnik radi i na stacionaru, postavite mu troškove stacionarnog posjeta.",
"If checked, a customer will be created for every Patient. Patient Invoices will be created against this Customer. You can also select existing Customer while creating a Patient. This field is checked by default.","Ako se označi, stvorit će se kupac za svakog pacijenta. Računi za pacijenta stvorit će se protiv ovog kupca. Također možete odabrati postojećeg kupca tijekom stvaranja pacijenta. Ovo polje je standardno označeno.",
Collect Registration Fee,Naplati naknadu za registraciju,
"If your Healthcare facility bills registrations of Patients, you can check this and set the Registration Fee in the field below. Checking this will create new Patients with a Disabled status by default and will only be enabled after invoicing the Registration Fee.","Ako vaša zdravstvena ustanova obračunava registraciju pacijenata, možete to provjeriti i postaviti polje za registraciju u donjem polju. Ako provjerite ovo, stvorit će se novi pacijenti sa statusom onemogućenog prema zadanim postavkama i bit će omogućeni tek nakon fakturiranja naknade za registraciju.",
Checking this will automatically create a Sales Invoice whenever an appointment is booked for a Patient.,"Ako potvrdite ovo, automatski će se stvoriti faktura prodaje kad god se za pacijenta rezervira sastanak.",
Healthcare Service Items,Predmeti zdravstvene zaštite,
"You can create a service item for Inpatient Visit Charge and set it here. Similarly, you can set up other Healthcare Service Items for billing in this section. Click ","Možete stvoriti stavku usluge za naplatu stacionarnih posjeta i postaviti je ovdje. Slično tome, u ovom odjeljku možete postaviti druge stavke zdravstvenih usluga za naplatu. Kliknite",
Set up default Accounts for the Healthcare Facility,Postavite zadane račune za zdravstvenu ustanovu,
"If you wish to override default accounts settings and configure the Income and Receivable accounts for Healthcare, you can do so here.","Ako želite zamijeniti zadane postavke računa i konfigurirati račune prihoda i potraživanja za zdravstvenu zaštitu, to možete učiniti ovdje.",
Out Patient SMS alerts,Upozorenja za SMS pacijenta,
"If you want to send SMS alert on Patient Registration, you can enable this option. Similary, you can set up Out Patient SMS alerts for other functionalities in this section. Click ","Ako želite poslati SMS upozorenje o registraciji pacijenta, možete omogućiti ovu opciju. Slično tome, u ovom odjeljku možete postaviti upozorenja za SMS pacijenta za druge funkcije. Kliknite",
Admission Order Details,Detalji naloga za prijem,
Admission Ordered For,Ulaz naređen za,
Expected Length of Stay,Očekivana dužina boravka,
Admission Service Unit Type,Vrsta jedinice usluge prijema,
Healthcare Practitioner (Primary),Zdravstveni radnik (primarni),
Healthcare Practitioner (Secondary),Zdravstveni radnik (sekundarni),
Admission Instruction,Uputstvo za prijem,
Chief Complaint,Žalba šefa,
Medications,Lijekovi,
Investigations,Istrage,
Discharge Detials,Ispuštanja,
Discharge Ordered Date,Datum otpuštanja,
Discharge Instructions,Upute za pražnjenje,
Follow Up Date,Datum praćenja,
Discharge Notes,Otpusne napomene,
Processing Inpatient Discharge,Obrada otpusta iz bolnice,
Processing Patient Admission,Obrada prijema pacijenta,
Check-in time cannot be greater than the current time,Vrijeme prijave ne može biti duže od trenutnog vremena,
Process Transfer,Prenos procesa,
HLC-LAB-.YYYY.-,FHP-LAB-.GGGG.-,
Expected Result Date,Očekivani datum rezultata,
Expected Result Time,Očekivano vrijeme rezultata,
Printed on,Odštampano,
Requesting Practitioner,Zahtjev za praktičarom,
Requesting Department,Odjel za podnošenje zahtjeva,
Employee (Lab Technician),Zaposlenik (laboratorijski tehničar),
Lab Technician Name,Ime laboratorijskog tehničara,
Lab Technician Designation,Oznaka laboratorijskog tehničara,
Compound Test Result,Rezultat složenog testa,
Organism Test Result,Rezultat testa organizma,
Sensitivity Test Result,Rezultat testa osjetljivosti,
Worksheet Print,Ispis radnog lista,
Worksheet Instructions,Upute za radni list,
Result Legend Print,Rezultat Legend Print,
Print Position,Položaj ispisa,
Both,Oboje,
Result Legend,Legenda rezultata,
Lab Tests,Laboratorijski testovi,
No Lab Tests found for the Patient {0},Nisu pronađeni laboratorijski testovi za pacijenta {0},
"Did not send SMS, missing patient mobile number or message content.","Nisam poslao SMS, broj mobilnog telefona pacijenta ili sadržaj poruke.",
No Lab Tests created,Nije kreiran nijedan laboratorijski test,
Creating Lab Tests...,Izrada laboratorijskih testova ...,
Lab Test Group Template,Predložak grupe za laboratorijske testove,
Add New Line,Dodaj novu liniju,
Secondary UOM,Sekundarni UOM,
"<b>Single</b>: Results which require only a single input.\n<br>\n<b>Compound</b>: Results which require multiple event inputs.\n<br>\n<b>Descriptive</b>: Tests which have multiple result components with manual result entry.\n<br>\n<b>Grouped</b>: Test templates which are a group of other test templates.\n<br>\n<b>No Result</b>: Tests with no results, can be ordered and billed but no Lab Test will be created. e.g.. Sub Tests for Grouped results","<b>Pojedinačno</b> : Rezultati koji zahtijevaju samo jedan unos.<br> <b>Složeni</b> : Rezultati koji zahtijevaju višestruke unose događaja.<br> <b>Opisno</b> : Ispitivanja koja imaju više komponenata rezultata sa ručnim unosom rezultata.<br> <b>Grupirano</b> : Predlošci za testiranje koji su grupa ostalih predložaka za ispitivanje.<br> <b>Nema rezultata</b> : testovi bez rezultata mogu se naručiti i naplatiti, ali neće biti kreiran laboratorijski test. npr. Podtestovi za grupisane rezultate",
"If unchecked, the item will not be available in Sales Invoices for billing but can be used in group test creation. ","Ako se ne označi, stavka neće biti dostupna u fakturama prodaje za naplatu, ali se može koristiti u kreiranju grupnog testa.",
Description ,Opis,
Descriptive Test,Opisni test,
Group Tests,Grupni testovi,
Instructions to be printed on the worksheet,Upute za ispis na radnom listu,
"Information to help easily interpret the test report, will be printed as part of the Lab Test result.",Informacije koje će vam olakšati tumačenje izvještaja o ispitivanju bit će tiskane kao dio rezultata laboratorijskog testa.,
Normal Test Result,Uobičajeni rezultat testa,
Secondary UOM Result,Sekundarni rezultat UOM-a,
Italic,Kurziv,
Underline,Podvući,
Organism,Organizam,
Organism Test Item,Predmet ispitivanja organizma,
Colony Population,Stanovništvo kolonija,
Colony UOM,Colony UOM,
Tobacco Consumption (Past),Potrošnja duhana (prošlost),
Tobacco Consumption (Present),Potrošnja duhana (danas),
Alcohol Consumption (Past),Konzumacija alkohola (prošlost),
Alcohol Consumption (Present),Konzumacija alkohola (danas),
Billing Item,Predmet naplate,
Medical Codes,Medicinski kodovi,
Clinical Procedures,Klinički postupci,
Order Admission,Naručite prijem,
Scheduling Patient Admission,Zakazivanje prijema pacijenta,
Order Discharge,Naručite pražnjenje,
Sample Details,Detalji uzorka,
Collected On,Prikupljeno dana,
No. of prints,Broj otisaka,
Number of prints required for labelling the samples,Broj otisaka potrebnih za označavanje uzoraka,
HLC-VTS-.YYYY.-,FHP-VTS-.GGGG.-,
Payroll Cost Center,Centar troškova troškova zarada,
Approvers,Odobrivači,
The first Approver in the list will be set as the default Approver.,Prvi odobravatelj na listi postavit će se kao zadani odobravatelj.,
Shift Request Approver,Odobrivač zahtjeva za smjenom,
Provident Fund Account,Račun osiguravajućeg fonda,
MICR Code,MICR kod,
Repay unclaimed amount from salary,Otplatite neiskorišteni iznos iz plate,
Deduction from salary,Odbitak od plate,
If this is not checked the loan by default will be considered as a Demand Loan,"Ako ovo nije potvrđeno, zajam će se prema zadanim postavkama smatrati zajmom na zahtjev",
This account is used for booking loan repayments from the borrower and also disbursing loans to the borrower,Ovaj račun koristi se za rezerviranje otplate zajma od zajmoprimca i za isplatu zajmova zajmoprimcu,
This account is capital account which is used to allocate capital for loan disbursal account ,Ovaj račun je račun kapitala koji se koristi za alokaciju kapitala za račun izdvajanja kredita,
This account will be used for booking loan interest accruals,Ovaj račun će se koristiti za rezerviranje obračunatih kamata,
This account will be used for booking penalties levied due to delayed repayments,Ovaj će se račun koristiti za rezerviranje penala zbog odgode otplate,
Variant BOM,Varijanta BOM,
Template Item,Predložak,
Select template item,Odaberite stavku predloška,
Select variant item code for the template item {0},Odaberite kod varijante stavke za stavku predloška {0},
Downtime Entry,Ulazak u stanke,
DT-,DT-,
Workstation / Machine,Radna stanica / mašina,
Operator,Operater,
In Mins,In Mins,
Downtime Reason,Razlog zastoja,
Stop Reason,Stop razumu,
Excessive machine set up time,Pretjerano vrijeme postavljanja stroja,
Unplanned machine maintenance,Neplanirano održavanje mašine,
On-machine press checks,Provjere tiska na mašini,
Machine operator errors,Greške rukovaoca mašine,
Machine malfunction,Kvar mašine,
Electricity down,Ispala struja,
Operation Row Number,Broj reda operacije,
Operation {0} added multiple times in the work order {1},Operacija {0} dodana više puta u radnom nalogu {1},
"If ticked, multiple materials can be used for a single Work Order. This is useful if one or more time consuming products are being manufactured.","Ako se označi, za jedan radni nalog može se koristiti više materijala. Ovo je korisno ako se proizvodi jedan ili više dugotrajnih proizvoda.",
Backflush Raw Materials,Backflush sirovine,
"The Stock Entry of type 'Manufacture' is known as backflush. Raw materials being consumed to manufacture finished goods is known as backflushing. <br><br> When creating Manufacture Entry, raw-material items are backflushed based on BOM of production item. If you want raw-material items to be backflushed based on Material Transfer entry made against that Work Order instead, then you can set it under this field.","Unos zaliha tipa &#39;Proizvodnja&#39; poznat je kao povratno ispiranje. Sirovine koje se troše za proizvodnju gotovih proizvoda poznate su kao povratno ispiranje.<br><br> Prilikom kreiranja stavke o proizvodnji, sirovinski proizvodi se vraćaju prema BOM proizvodnom proizvodu. Ako želite da se sirovinske stavke ponovo ispiru na osnovu unosa za prijenos materijala izvršenog prema tom radnom nalogu, onda ga možete postaviti u ovom polju.",
Work In Progress Warehouse,Skladište u toku,
This Warehouse will be auto-updated in the Work In Progress Warehouse field of Work Orders.,Ovo skladište će se automatski ažurirati u polju Skladište u toku u radnim nalozima.,
Finished Goods Warehouse,Skladište gotove robe,
This Warehouse will be auto-updated in the Target Warehouse field of Work Order.,Ovo skladište će se automatski ažurirati u polju ciljanog skladišta radnog naloga.,
"If ticked, the BOM cost will be automatically updated based on Valuation Rate / Price List Rate / last purchase rate of raw materials.","Ako se označi, BOM trošak će se automatski ažurirati na osnovu stope procjene / stope cjenika / posljednje stope otkupa sirovina.",
Source Warehouses (Optional),Izvorna skladišta (neobavezna),
"System will pickup the materials from the selected warehouses. If not specified, system will create material request for purchase.","Sistem će preuzeti materijale iz odabranih skladišta. Ako nije navedeno, sistem će stvoriti zahtjev za materijalom za kupovinu.",
Lead Time,Vodeće vrijeme,
PAN Details,PAN detalji,
Create Customer,Stvori kupca,
Invoicing,Fakturisanje,
Enable Auto Invoicing,Omogućite automatsko fakturiranje,
Send Membership Acknowledgement,Pošaljite potvrdu o članstvu,
Send Invoice with Email,Pošaljite fakturu e-poštom,
Membership Print Format,Format za ispis članstva,
Invoice Print Format,Format ispisa fakture,
Revoke <Key></Key>,Opozovi&lt;Key&gt;&lt;/Key&gt;,
You can learn more about memberships in the manual. ,U članku možete saznati više o članstvu.,
ERPNext Docs,ERPNext Docs,
Regenerate Webhook Secret,Obnovite tajnu Webhook-a,
Generate Webhook Secret,Generiraj Webhook Secret,
Copy Webhook URL,Kopirajte URL webhooka,
Linked Item,Povezani predmet,
Feedback By,Povratne informacije od,
Manufacturing Section,Odjel za proizvodnju,
"By default, the Customer Name is set as per the Full Name entered. If you want Customers to be named by a ","Po defaultu, Korisničko ime je postavljeno prema punom imenu. Ako želite da kupce imenuje a",
Configure the default Price List when creating a new Sales transaction. Item prices will be fetched from this Price List.,Konfigurirajte zadani cjenik prilikom kreiranja nove prodajne transakcije. Cijene stavki će se preuzeti iz ovog cjenika.,
"If this option is configured 'Yes', ERPNext will prevent you from creating a Sales Invoice or Delivery Note without creating a Sales Order first. This configuration can be overridden for a particular Customer by enabling the 'Allow Sales Invoice Creation Without Sales Order' checkbox in the Customer master.","Ako je ova opcija konfigurirana kao &quot;Da&quot;, ERPNext će vas spriječiti da kreirate fakturu ili napomenu o isporuci bez prethodnog kreiranja narudžbenice. Ovu konfiguraciju može se nadjačati za određenog Kupca omogućavanjem potvrdnog okvira &#39;Omogući izradu fakture za prodaju bez prodajnog naloga&#39; u masteru kupca.",
"If this option is configured 'Yes', ERPNext will prevent you from creating a Sales Invoice without creating a Delivery Note first. This configuration can be overridden for a particular Customer by enabling the 'Allow Sales Invoice Creation Without Delivery Note' checkbox in the Customer master.","Ako je ova opcija konfigurisana kao &quot;Da&quot;, ERPNext će vas spriječiti u stvaranju fakture prodaje bez prethodnog kreiranja bilješke o isporuci. Ovu konfiguraciju možete nadjačati za određenog kupca tako što ćete omogućiti potvrdni okvir &#39;Omogući izradu fakture za prodaju bez napomene o isporuci&#39; u masteru kupca.",
Default Warehouse for Sales Return,Zadani magacin za povratak prodaje,
Default In Transit Warehouse,Zadani u tranzitnom skladištu,
Enable Perpetual Inventory For Non Stock Items,Omogućite trajni inventar za stavke koje nisu na zalihi,
HRA Settings,Postavke HRA,
Basic Component,Osnovna komponenta,
HRA Component,HRA komponenta,
Arrear Component,Komponenta zaostatka,
Please enter the company name to confirm,Unesite naziv kompanije za potvrdu,
Quotation Lost Reason Detail,Detalj izgubljenog razloga ponude,
Enable Variants,Omogući varijante,
Save Quotations as Draft,Sačuvajte ponude kao skice,
MAT-DN-RET-.YYYY.-,MAT-DN-RET-.GGGG.-,
Please Select a Customer,Molimo odaberite kupca,
Against Delivery Note Item,Protiv stavke naloga za isporuku,
Is Non GST ,Nije GST,
Image Description,Opis slike,
Transfer Status,Status prijenosa,
MAT-PR-RET-.YYYY.-,MAT-PR-RET-.GGGG.-,
Track this Purchase Receipt against any Project,Pratite ovu potvrdu o kupovini prema bilo kojem projektu,
Please Select a Supplier,Molimo odaberite dobavljača,
Add to Transit,Dodaj u tranzit,
Set Basic Rate Manually,Ručno postavite osnovnu stopu,
"By default, the Item Name is set as per the Item Code entered. If you want Items to be named by a ","Prema zadanim postavkama, naziv predmeta je postavljen prema unesenom kodu artikla. Ako želite da stavke imenuje",
Set a Default Warehouse for Inventory Transactions. This will be fetched into the Default Warehouse in the Item master.,Postavljanje zadanog skladišta za transakcije zalihama. Ovo će se dohvatiti u Zadani magacin u masteru predmeta.,
"This will allow stock items to be displayed in negative values. Using this option depends on your use case. With this option unchecked, the system warns before obstructing a transaction that is causing negative stock.","To će omogućiti prikazivanje zaliha u negativnim vrijednostima. Korištenje ove opcije ovisi o vašem slučaju korištenja. Ako ova opcija nije potvrđena, sistem upozorava prije nego što ometa transakciju koja uzrokuje negativne zalihe.",
Choose between FIFO and Moving Average Valuation Methods. Click ,Izaberite između metoda FIFO i metoda procjene pokretnog prosjeka. Kliknite,
 to know more about them.,da znam više o njima.,
Show 'Scan Barcode' field above every child table to insert Items with ease.,Pokažite polje „Skeniraj crtični kod“ iznad svake podređene tablice da biste s lakoćom umetnuli predmete.,
"Serial numbers for stock will be set automatically based on the Items entered based on first in first out in transactions like Purchase/Sales Invoices, Delivery Notes, etc.","Serijski brojevi zaliha automatski će se postaviti na osnovu stavki koje se unose na osnovu first in first out u transakcijama poput faktura kupovine / prodaje, otpremnica itd.",
"If blank, parent Warehouse Account or company default will be considered in transactions","Ako je prazno, u transakcijama će se uzeti u obzir matični račun skladišta ili zadana vrijednost kompanije",
Service Level Agreement Details,Detalji sporazuma o nivou usluge,
Service Level Agreement Status,Status sporazuma o nivou usluge,
On Hold Since,Na čekanju od,
Total Hold Time,Ukupno vrijeme zadržavanja,
Response Details,Detalji odgovora,
Average Response Time,Prosječno vrijeme odziva,
User Resolution Time,Vrijeme razlučivanja korisnika,
SLA is on hold since {0},SLA je na čekanju od {0},
Pause SLA On Status,Pauzirajte SLA na statusu,
Pause SLA On,Pauzirajte SLA Uključeno,
Greetings Section,Pozdravni odjeljak,
Greeting Title,Pozdravni naslov,
Greeting Subtitle,Pozdravni titl,
Youtube ID,Youtube ID,
Youtube Statistics,Youtube Statistika,
Views,Pregledi,
Dislikes,Ne voli,
Video Settings,Video Settings,
Enable YouTube Tracking,Omogućite YouTube praćenje,
30 mins,30 min,
1 hr,1 h,
6 hrs,6 sati,
Patient Progress,Napredak pacijenta,
Targetted,Ciljano,
Score Obtained,Rezultat dobijen,
Sessions,Sesije,
Average Score,Prosječna ocjena,
Select Assessment Template,Odaberite predložak procjene,
 out of ,van,
Select Assessment Parameter,Odaberite parametar procjene,
Gender: ,Spol:,
Contact: ,Kontakt:,
Total Therapy Sessions: ,Ukupno terapijskih sesija:,
Monthly Therapy Sessions: ,Mjesečne terapijske sesije:,
Patient Profile,Profil pacijenta,
Point Of Sale,Mjestu prodaje,
Email sent successfully.,E-pošta je uspješno poslana.,
Search by invoice id or customer name,Pretražujte prema ID-u fakture ili imenu kupca,
Invoice Status,Status fakture,
Filter by invoice status,Filtriraj prema statusu fakture,
Select item group,Odaberite grupu stavki,
No items found. Scan barcode again.,Predmeti nisu pronađeni. Ponovo skenirajte crtični kod.,
"Search by customer name, phone, email.","Pretražujte po imenu kupca, telefonu, e-pošti.",
Enter discount percentage.,Unesite postotak popusta.,
Discount cannot be greater than 100%,Popust ne može biti veći od 100%,
Enter customer's email,Unesite e-poštu kupca,
Enter customer's phone number,Unesite telefonski broj kupca,
Customer contact updated successfully.,Kontakt s kupcem je uspješno ažuriran.,
Item will be removed since no serial / batch no selected.,Stavka će biti uklonjena jer nije odabrana nijedna serijska serija.,
Discount (%),Popust (%),
You cannot submit the order without payment.,Ne možete poslati narudžbu bez plaćanja.,
You cannot submit empty order.,Ne možete poslati praznu narudžbu.,
To Be Paid,Da se plati,
Create POS Opening Entry,Kreirajte unos za otvaranje POS-a,
Please add Mode of payments and opening balance details.,Molimo dodajte detalje o načinu plaćanja i početnom stanju.,
Toggle Recent Orders,Uključi / isključi nedavne narudžbe,
Save as Draft,Spremiti kao nacrt,
You must add atleast one item to save it as draft.,Morate dodati najmanje jednu stavku da biste je sačuvali kao skicu.,
There was an error saving the document.,Došlo je do greške prilikom spremanja dokumenta.,
You must select a customer before adding an item.,Morate odabrati kupca prije dodavanja stavke.,
Please Select a Company,Molimo odaberite kompaniju,
Active Leads,Active Leads,
Please Select a Company.,Molimo odaberite kompaniju.,
BOM Operations Time,BOM operativno vrijeme,
BOM ID,BOM ID,
BOM Item Code,Šifra predmeta BOM,
Time (In Mins),Vrijeme (u minutama),
Sub-assembly BOM Count,Broj sastavnih dijelova podsklopa,
View Type,Vrsta prikaza,
Total Delivered Amount,Ukupni isporučeni iznos,
Downtime Analysis,Analiza zastoja,
Machine,Mašina,
Downtime (In Hours),Zastoji (u satima),
Employee Analytics,Analitika zaposlenih,
"""From date"" can not be greater than or equal to ""To date""",&quot;Od datuma&quot; ne može biti veći ili jednak &quot;Do danas&quot;,
Exponential Smoothing Forecasting,Eksponencijalno izglađivanje predviđanja,
First Response Time for Issues,Vrijeme prvog odgovora na izdanja,
First Response Time for Opportunity,Prvo vrijeme odgovora za priliku,
Depreciatied Amount,Amortizirani iznos,
Period Based On,Period zasnovan na,
Date Based On,Datum zasnovan,
{0} and {1} are mandatory,{0} i {1} su obavezni,
Consider Accounting Dimensions,Razmotrite računovodstvene dimenzije,
Reserved Quantity for Production,Rezervisana količina za proizvodnju,
Projected Quantity,Predviđena količina,
 Total Sales Amount,Ukupan iznos prodaje,
Job Card Summary,Sažetak kartice posla,
Id,Id,
Time Required (In Mins),Potrebno vrijeme (u minutama),
From Posting Date,Od datuma knjiženja,
To Posting Date,Do datuma knjiženja,
No records found,Nije pronađen nijedan zapis,
Customer/Lead Name,Ime kupca / potencijalnog klijenta,
Production Planning Report,Izvještaj o planiranju proizvodnje,
Order Qty,Naruči Kol,
Raw Material Code,Šifra sirovina,
Raw Material Name,Naziv sirovine,
Allotted Qty,Dodijeljena količina,
Expected Arrival Date,Očekivani datum dolaska,
Arrival Quantity,Količina dolaska,
Raw Material Warehouse,Skladište sirovina,
Order By,Poredak po,
Include Sub-assembly Raw Materials,Uključite sirovine podsklopa,
Program wise Fee Collection,Programska naplata naknada,
Fees Collected,Naknade naplaćene,
Project Summary,Sažetak projekta,
Total Tasks,Ukupno zadataka,
Tasks Completed,Zadaci izvršeni,
Tasks Overdue,Zadaci kasne,
Completion,Završetak,
Purchase Order Analysis,Analiza narudžbenice,
From and To Dates are required.,Potrebni su datumi od i do.,
To Date cannot be before From Date.,Do datuma ne može biti prije od datuma.,
Qty to Bill,Količina za Billa,
Group by Purchase Order,Grupiraj prema narudžbenici,
 Purchase Value,Nabavna vrijednost,
Total Received Amount,Ukupni primljeni iznos,
Quality Inspection Summary,Sažetak inspekcije kvaliteta,
 Quoted Amount,Citirani iznos,
Lead Time (Days),Vrijeme izvođenja (dani),
Include Expired,Uključi Isteklo,
Requested Items to Order and Receive,Tražene stavke za naručivanje i primanje,
Sales Order Analysis,Analiza naloga za prodaju,
Amount Delivered,Isporučeni iznos,
Delay (in Days),Kašnjenje (u danima),
Group by Sales Order,Grupiranje prema prodajnom nalogu,
 Sales Value,Vrijednost prodaje,
Stock Qty vs Serial No Count,Količina zaliha u odnosu na serijski broj,
Serial No Count,Broj serijskog broja,
Work Order Summary,Sažetak radnog naloga,
Produce Qty,Količina proizvoda,
Lead Time (in mins),Vrijeme izvođenja (u minutama),
Charts Based On,Grafikoni zasnovani na,
YouTube Interactions,YouTube interakcije,
Published Date,Datum objavljivanja,
Barnch,Barnch,
Select a Company,Odaberite kompaniju,
Opportunity {0} created,Stvorena prilika {0},
Kindly select the company first,Molimo vas da prvo odaberete kompaniju,
Please enter From Date and To Date to generate JSON,Unesite From Date i To Date da biste generirali JSON,
Download DATEV File,Preuzmite datoteku DATEV,
Numero has not set in the XML file,Numero nije postavljen u XML datoteku,
Inward Supplies(liable to reverse charge),Unutarnje zalihe (podložne storniranju),
This is based on the course schedules of this Instructor,Ovo se zasniva na rasporedu kurseva ovog instruktora,
Course and Assessment,Kurs i procjena,
Course {0} has been added to all the selected programs successfully.,Kurs {0} je uspješno dodan svim odabranim programima.,
Programs updated,Programi ažurirani,
Program and Course,Program i kurs,
{0} or {1} is mandatory,{0} ili {1} je obavezno,
Mandatory Fields,Obavezna polja,
Student {0}: {1} does not belong to Student Group {2},Student {0}: {1} ne pripada studentskoj grupi {2},
Student Attendance record {0} already exists against the Student {1},Evidencija o posjećenosti učenika {0} već postoji protiv učenika {1},
Course and Fee,Kurs i naknada,
Not eligible for the admission in this program as per Date Of Birth,Ne ispunjava uslove za prijem u ovaj program prema datumu rođenja,
Topic {0} has been added to all the selected courses successfully.,Tema {0} uspješno je dodana na sve odabrane kurseve.,
Courses updated,Kursevi ažurirani,
{0} {1} has been added to all the selected topics successfully.,{0} {1} je uspješno dodan u sve odabrane teme.,
Topics updated,Teme ažurirane,
Academic Term and Program,Akademski termin i program,
Please remove this item and try to submit again or update the posting time.,Uklonite ovu stavku i pokušajte je ponovo poslati ili ažurirajte vrijeme objavljivanja.,
Failed to Authenticate the API key.,Autentifikacija API ključa nije uspjela.,
Invalid Credentials,Nevažeće vjerodajnice,
URL can only be a string,URL može biti samo niz,
"Here is your webhook secret, this will be shown to you only once.","Evo vaše tajne webhook-a, ovo će vam biti prikazano samo jednom.",
The payment for this membership is not paid. To generate invoice fill the payment details,Plaćanje za ovo članstvo nije plaćeno. Za generiranje fakture popunite detalje o plaćanju,
An invoice is already linked to this document,Račun je već povezan s ovim dokumentom,
No customer linked to member {},Nijedan kupac nije povezan sa članom {},
You need to set <b>Debit Account</b> in Membership Settings,U postavkama članstva morate postaviti <b>račun za zaduživanje</b>,
You need to set <b>Default Company</b> for invoicing in Membership Settings,U postavkama članstva morate postaviti <b>zadanu kompaniju</b> za fakturiranje,
You need to enable <b>Send Acknowledge Email</b> in Membership Settings,U postavkama članstva morate omogućiti <b>e-poštu</b> za <b>slanje potvrde</b>,
Error creating membership entry for {0},Greška pri kreiranju unosa za članstvo za {0},
A customer is already linked to this Member,Kupac je već povezan s ovim članom,
End Date must not be lesser than Start Date,Datum završetka ne smije biti manji od datuma početka,
Employee {0} already has Active Shift {1}: {2},Zaposlenik {0} već ima aktivnu smjenu {1}: {2},
 from {0},od {0},
 to {0},do {0},
Please set {0} for the Employee or for Department: {1},Postavite {0} za zaposlenika ili za odjel: {1},
Employee Onboarding: {0} is already for Job Applicant: {1},Ukrcavanje zaposlenih: {0} je već za kandidata za posao: {1},
Asset Value Analytics,Analitika vrijednosti imovine,
Category-wise Asset Value,Vrijednost imovine prema kategorijama,
Total Assets,Ukupna imovina,
New Assets (This Year),Nova imovina (ove godine),
Row #{}: Depreciation Posting Date should not be equal to Available for Use Date.,Red # {}: Datum knjiženja amortizacije ne bi trebao biti jednak datumu Dostupno za upotrebu.,
Incorrect Date,Netačan datum,
Invalid Gross Purchase Amount,Nevažeći bruto iznos kupovine,
There are active maintenance or repairs against the asset. You must complete all of them before cancelling the asset.,Aktivno se održavaju ili popravljaju sredstva. Morate ih popuniti prije nego što otkažete sredstvo.,
% Complete,% Kompletno,
Back to Course,Povratak na kurs,
Finish Topic,Završi temu,
Mins,Min,
by,by,
Back to,Povratak na,
Enrolling...,Upis ...,
You have successfully enrolled for the program ,Uspješno ste se prijavili za program,
Enrolled,Upisan,
Watch Intro,Pogledajte uvod,
We're here to help!,Ovdje smo da vam pomognemo!,
Frequently Read Articles,Članci koji se često čitaju,
Please set a default company address,Molimo postavite zadanu adresu kompanije,
{0} is not a valid state! Check for typos or enter the ISO code for your state.,{0} nije važeće stanje! Provjerite ima li grešaka u kucanju ili unesite ISO kod za svoje stanje.,
Error occured while parsing Chart of Accounts: Please make sure that no two accounts have the same name,Došlo je do greške prilikom raščlanjivanja kontnog plana: Uvjerite se da niti jedan račun nema isto ime,
Plaid invalid request error,Pogreška nevažećeg zahtjeva karira,
Please check your Plaid client ID and secret values,Molimo provjerite svoj ID klijenta i tajne vrijednosti,
Bank transaction creation error,Greška u kreiranju bankovne transakcije,
Unit of Measurement,Mjerna jedinica,
Fiscal Year {0} Does Not Exist,Fiskalna godina {0} ne postoji,
Row # {0}: Returned Item {1} does not exist in {2} {3},Redak {0}: Vraćena stavka {1} ne postoji u {2} {3},
Valuation type charges can not be marked as Inclusive,Naknade za vrstu vrednovanja ne mogu se označiti kao sveobuhvatne,
You do not have permissions to {} items in a {}.,Nemate dozvole za {} stavki u {}.,
Insufficient Permissions,Nedovoljna dozvola,
You are not allowed to update as per the conditions set in {} Workflow.,Nije vam dozvoljeno ažuriranje prema uvjetima postavljenim u {} Tok rada.,
Expense Account Missing,Račun troškova nedostaje,
{0} is not a valid Value for Attribute {1} of Item {2}.,{0} nije važeća vrijednost za atribut {1} stavke {2}.,
Invalid Value,Nevažeća vrijednost,
The value {0} is already assigned to an existing Item {1}.,Vrijednost {0} je već dodijeljena postojećoj stavci {1}.,
"To still proceed with editing this Attribute Value, enable {0} in Item Variant Settings.","Da i dalje nastavite s uređivanjem ove vrijednosti atributa, omogućite {0} u Postavkama varijante stavke.",
Edit Not Allowed,Uređivanje nije dozvoljeno,
Row #{0}: Item {1} is already fully received in Purchase Order {2},Redak {0}: Stavka {1} je već u potpunosti primljena u narudžbenici {2},
You cannot create or cancel any accounting entries with in the closed Accounting Period {0},Ne možete kreirati ili otkazati nijedan knjigovodstveni zapis u zatvorenom obračunskom periodu {0},
POS Invoice should have {} field checked.,POS račun mora imati označeno polje {}.,
Invalid Item,Nevažeća stavka,
Row #{}: You cannot add postive quantities in a return invoice. Please remove item {} to complete the return.,Red # {}: Ne možete dodati pozitivne količine u fakturu za povrat. Uklonite stavku {} da biste dovršili povrat.,
The selected change account {} doesn't belongs to Company {}.,Odabrani račun za promjenu {} ne pripada Kompaniji {}.,
Atleast one invoice has to be selected.,Mora biti izabrana najmanje jedna faktura.,
Payment methods are mandatory. Please add at least one payment method.,Načini plaćanja su obavezni. Dodajte barem jedan način plaćanja.,
Please select a default mode of payment,Odaberite zadani način plaćanja,
You can only select one mode of payment as default,Možete odabrati samo jedan način plaćanja kao zadani,
Missing Account,Nedostaje račun,
Customers not selected.,Kupci nisu odabrani.,
Statement of Accounts,Izvod računa,
Ageing Report Based On ,Izvještaj o starenju na osnovu,
Please enter distributed cost center,Unesite raspodijeljeno mjesto troškova,
Total percentage allocation for distributed cost center should be equal to 100,Ukupna alokacija u procentima za raspodijeljeno mjesto troškova trebala bi biti jednaka 100,
Cannot enable Distributed Cost Center for a Cost Center already allocated in another Distributed Cost Center,Ne može se omogućiti raspodijeljeno mjesto troškova za mjesto troškova koje je već dodijeljeno u drugom raspodijeljenom mjestu troškova,
Parent Cost Center cannot be added in Distributed Cost Center,Nadređeno mjesto troškova ne može se dodati u distribuirano mjesto troškova,
A Distributed Cost Center cannot be added in the Distributed Cost Center allocation table.,Distribuirano mjesto troškova ne može se dodati u tablicu raspodjele mjesta troškova.,
Cost Center with enabled distributed cost center can not be converted to group,Mjesto troškova s omogućenim distribuiranim mjestom troškova ne može se pretvoriti u grupu,
Cost Center Already Allocated in a Distributed Cost Center cannot be converted to group,Već dodijeljeno mjesto troškova u distribuiranom mjestu troškova ne može se pretvoriti u grupu,
Trial Period Start date cannot be after Subscription Start Date,Datum početka probnog razdoblja ne može biti nakon datuma početka pretplate,
Subscription End Date must be after {0} as per the subscription plan,Datum završetka pretplate mora biti nakon {0} prema planu pretplate,
Subscription End Date is mandatory to follow calendar months,Krajnji datum pretplate je obavezan za kalendarske mjesece,
Row #{}: POS Invoice {} is not against customer {},Red # {}: POS faktura {} nije protiv kupca {},
Row #{}: POS Invoice {} is not submitted yet,Redak {{}: POS faktura {} još nije dostavljena,
Row #{}: POS Invoice {} has been {},Red # {}: POS faktura {} je {},
No Supplier found for Inter Company Transactions which represents company {0},Nije pronađen dobavljač za transakcije među kompanijama koji predstavljaju kompaniju {0},
No Customer found for Inter Company Transactions which represents company {0},Nije pronađen nijedan kupac za transakcije kompanije koje predstavljaju kompaniju {0},
Invalid Period,Nevažeće razdoblje,
Selected POS Opening Entry should be open.,Odabrani unos za otvaranje POS-a trebao bi biti otvoren.,
Invalid Opening Entry,Nevažeći uvodni unos,
Please set a Company,Molimo postavite kompaniju,
"Sorry, this coupon code's validity has not started","Nažalost, valjanost ovog koda kupona nije započela",
"Sorry, this coupon code's validity has expired","Nažalost, valjanost ovog koda kupona je istekla",
"Sorry, this coupon code is no longer valid","Žao nam je, ovaj kod kupona više nije važeći",
For the 'Apply Rule On Other' condition the field {0} is mandatory,Za uvjet &quot;Primijeni pravilo na ostalo&quot; polje {0} je obavezno,
{1} Not in Stock,{1} Nije na lageru,
Only {0} in Stock for item {1},Na skladištu za artikal {1} samo {0},
Please enter a coupon code,Unesite kod kupona,
Please enter a valid coupon code,Unesite važeći kôd kupona,
Invalid Child Procedure,Nevažeća procedura za dijete,
Import Italian Supplier Invoice.,Uvoz fakture italijanskog dobavljača.,
"Valuation Rate for the Item {0}, is required to do accounting entries for {1} {2}.",Stopa procjene za stavku {0} potrebna je za knjiženje knjigovodstvenih evidencija za {1} {2}.,
 Here are the options to proceed:,Evo opcija za nastavak:,
"If the item is transacting as a Zero Valuation Rate item in this entry, please enable 'Allow Zero Valuation Rate' in the {0} Item table.","Ako stavka trguje kao stavka nulte stope vrednovanja u ovom unosu, omogućite &#39;Dopusti nultu stopu vrednovanja&#39; u tablici {0} Stavka.",
"If not, you can Cancel / Submit this entry ","Ako ne, možete otkazati / poslati ovaj unos",
 performing either one below:,izvodeći bilo koji dole:,
Create an incoming stock transaction for the Item.,Kreirajte dolaznu transakciju zaliha za Artikal.,
Mention Valuation Rate in the Item master.,Spomenite stopu vrednovanja u glavnom predmetu.,
Valuation Rate Missing,Nedostaje stopa procjene,
Serial Nos Required,Potrebni su serijski brojevi,
Quantity Mismatch,Količina neusklađenosti,
"Please Restock Items and Update the Pick List to continue. To discontinue, cancel the Pick List.","Molimo vas da ponovo nastavite sa proizvodima i ažurirate listu za odabir da biste nastavili. Da biste prekinuli, otkažite Pick List.",
Out of Stock,Nema na zalihi,
{0} units of Item {1} is not available.,{0} jedinica stavke {1} nije dostupno.,
Item for row {0} does not match Material Request,Stavka za red {0} se ne podudara sa zahtjevom za materijal,
Warehouse for row {0} does not match Material Request,Skladište za red {0} ne odgovara zahtjevu za materijalom,
Accounting Entry for Service,Knjigovodstveni unos usluge,
All items have already been Invoiced/Returned,Sve stavke su već fakturirane / vraćene,
All these items have already been Invoiced/Returned,Sve ove stavke su već fakturirane / vraćene,
Stock Reconciliations,Pomirenje dionica,
Merge not allowed,Spajanje nije dozvoljeno,
The following deleted attributes exist in Variants but not in the Template. You can either delete the Variants or keep the attribute(s) in template.,"Sljedeći izbrisani atributi postoje u varijantama, ali ne i u predlošku. Možete izbrisati varijante ili zadržati atribut (e) u predlošku.",
Variant Items,Variant Items,
Variant Attribute Error,Pogreška varijante atributa,
The serial no {0} does not belong to item {1},Serijski broj {0} ne pripada stavci {1},
There is no batch found against the {0}: {1},Nije pronađena serija protiv {0}: {1},
Completed Operation,Završena operacija,
Work Order Analysis,Analiza radnog naloga,
Quality Inspection Analysis,Analiza inspekcije kvaliteta,
Pending Work Order,Na čekanju radni nalog,
Last Month Downtime Analysis,Analiza zastoja posljednjeg mjeseca,
Work Order Qty Analysis,Analiza količine radnog naloga,
Job Card Analysis,Analiza radnih mjesta,
Monthly Total Work Orders,Ukupni mjesečni nalozi za rad,
Monthly Completed Work Orders,Mjesečno izvršeni nalozi za rad,
Ongoing Job Cards,Kartice za posao u toku,
Monthly Quality Inspections,Mjesečne provjere kvaliteta,
(Forecast),(Prognoza),
Total Demand (Past Data),Ukupna potražnja (prošli podaci),
Total Forecast (Past Data),Ukupna prognoza (prošli podaci),
Total Forecast (Future Data),Ukupna prognoza (budući podaci),
Based On Document,Na osnovu dokumenta,
Based On Data ( in years ),Na osnovu podataka (u godinama),
Smoothing Constant,Smoothing Constant,
Please fill the Sales Orders table,Molimo popunite tablicu Prodajni nalozi,
Sales Orders Required,Potrebni nalozi za prodaju,
Please fill the Material Requests table,Molimo popunite tablicu Zahtjevi za materijalom,
Material Requests Required,Zahtjevi za materijal,
Items to Manufacture are required to pull the Raw Materials associated with it.,Proizvodi za proizvodnju dužni su povući sirovine povezane s tim.,
Items Required,Predmeti potrebni,
Operation {0} does not belong to the work order {1},Operacija {0} ne pripada radnom nalogu {1},
Print UOM after Quantity,Ispis UOM nakon količine,
Set default {0} account for perpetual inventory for non stock items,Postavite zadani {0} račun za vječni inventar za stavke koje nisu na zalihi,
Row #{0}: Child Item should not be a Product Bundle. Please remove Item {1} and Save,Redak {0}: Podređena stavka ne bi trebala biti paket proizvoda. Uklonite stavku {1} i spremite,
Credit limit reached for customer {0},Dosegnuto kreditno ograničenje za kupca {0},
Could not auto create Customer due to the following missing mandatory field(s):,Nije moguće automatski kreirati kupca zbog sljedećih obaveznih polja koja nedostaju:,
Please create Customer from Lead {0}.,Kreirajte kupca od potencijalnog klijenta {0}.,
Mandatory Missing,Obavezno nedostaje,
From Date can not be greater than To Date.,Od datuma ne može biti veći od datuma.,
Row #{0}: Please enter the result value for {1},Redak {0}: Unesite vrijednost rezultata za {1},
Mandatory Results,Obavezni rezultati,
Sales Invoice or Patient Encounter is required to create Lab Tests,Račun za prodaju ili susret pacijenta potreban je za izradu laboratorijskih testova,
Insufficient Data,Nedovoljno podataka,
Lab Test(s) {0} created successfully,Laboratorijski testovi {0} su uspješno stvoreni,
Test :,Test:,
Sample Collection {0} has been created,Zbirka uzoraka {0} je kreirana,
Normal Range: ,Uobičajeni domet:,
Row #{0}: Check Out datetime cannot be less than Check In datetime,Redak {0}: Datum odjave ne može biti manji od datuma i vremena prijave,
"Missing required details, did not create Inpatient Record","Nedostaju potrebni detalji, nije stvorena stacionarna evidencija",
Unbilled Invoices,Nefakturirane fakture,
Standard Selling Rate should be greater than zero.,Standardna stopa prodaje trebala bi biti veća od nule.,
Conversion Factor is mandatory,Faktor konverzije je obavezan,
Row #{0}: Conversion Factor is mandatory,Redak {0}: Faktor konverzije je obavezan,
Sample Quantity cannot be negative or 0,Količina uzorka ne može biti negativna ili 0,
Invalid Quantity,Nevažeća količina,
"Please set defaults for Customer Group, Territory and Selling Price List in Selling Settings","Molimo postavite zadane postavke za Grupu kupaca, Teritoriju i Cjenik prodaje u Postavkama prodaje",
{0} on {1},{0} na {1},
{0} with {1},{0} sa {1},
Appointment Confirmation Message Not Sent,Poruka o potvrdi imenovanja nije poslana,
"SMS not sent, please check SMS Settings","SMS nije poslan, provjerite postavke SMS-a",
Healthcare Service Unit Type cannot have both {0} and {1},Tip jedinice zdravstvene službe ne može imati i {0} i {1},
Healthcare Service Unit Type must allow atleast one among {0} and {1},Tip zdravstvene jedinice mora dopustiti najmanje jedan između {0} i {1},
Set Response Time and Resolution Time for Priority {0} in row {1}.,Postavite vrijeme odziva i vrijeme razlučivanja za prioritet {0} u redu {1}.,
Response Time for {0} priority in row {1} can't be greater than Resolution Time.,Vrijeme odziva za {0} prioritet u redu {1} ne može biti veće od vremena razlučivanja.,
{0} is not enabled in {1},{0} nije omogućen u {1},
Group by Material Request,Grupiraj prema zahtjevu za materijal,
Email Sent to Supplier {0},E-pošta poslana dobavljaču {0},
"The Access to Request for Quotation From Portal is Disabled. To Allow Access, Enable it in Portal Settings.","Pristup zahtjevu za ponudu sa portala je onemogućen. Da biste omogućili pristup, omogućite ga u postavkama portala.",
Supplier Quotation {0} Created,Ponuda dobavljača {0} kreirana,
Valid till Date cannot be before Transaction Date,Važi do datuma ne može biti prije datuma transakcije,
Unlink Advance Payment on Cancellation of Order,Prekinite vezu s avansnim plaćanjem nakon otkazivanja narudžbe,
"Simple Python Expression, Example: territory != 'All Territories'","Jednostavan Python izraz, primjer: teritorij! = &#39;Sve teritorije&#39;",
Sales Contributions and Incentives,Doprinosi prodaji i podsticaji,
Sourced by Supplier,Izvor dobavljača,
Total weightage assigned should be 100%.<br>It is {0},Ukupna dodijeljena težina treba biti 100%.<br> {0} je,
Account {0} exists in parent company {1}.,Račun {0} postoji u matičnoj kompaniji {1}.,
"To overrule this, enable '{0}' in company {1}","Da biste ovo prevladali, omogućite &#39;{0}&#39; u kompaniji {1}",
Invalid condition expression,Nevažeći izraz stanja,
Please Select a Company First,Prvo odaberite kompaniju,
Please Select Both Company and Party Type First,Molimo odaberite prvo vrstu kompanije i stranke,
Provide the invoice portion in percent,Navedite dio fakture u procentima,
Give number of days according to prior selection,Navedite broj dana prema prethodnom odabiru,
Email Details,Detalji e-pošte,
"Select a greeting for the receiver. E.g. Mr., Ms., etc.","Odaberite pozdrav za prijemnik. Npr. Gospodin, gospođa itd.",
Preview Email,Pregled e-pošte,
Please select a Supplier,Molimo odaberite dobavljača,
Supplier Lead Time (days),Vrijeme isporuke dobavljača (dana),
"Home, Work, etc.","Kuća, posao itd.",
Exit Interview Held On,Izlazni intervju održan,
Sets 'Target Warehouse' in each row of the Items table.,Postavlja &#39;Ciljno skladište&#39; u svaki red tabele Predmeti.,
Sets 'Source Warehouse' in each row of the Items table.,Postavlja &#39;Izvorno skladište&#39; u svaki red tabele Predmeti.,
POS Register,POS registar,
"Can not filter based on POS Profile, if grouped by POS Profile","Ne može se filtrirati na osnovu POS profila, ako je grupirano po POS profilu",
"Can not filter based on Customer, if grouped by Customer","Ne može se filtrirati prema kupcu, ako ga grupiše kupac",
"Can not filter based on Cashier, if grouped by Cashier","Ne može se filtrirati na osnovu blagajne, ako je grupirana po blagajni",
Payment Method,Način plaćanja,
"Can not filter based on Payment Method, if grouped by Payment Method","Ne može se filtrirati na osnovu načina plaćanja, ako je grupirano prema načinu plaćanja",
Supplier Quotation Comparison,Usporedba ponuda dobavljača,
Price per Unit (Stock UOM),Cijena po jedinici (zaliha UOM),
Group by Supplier,Grupa prema dobavljaču,
Group by Item,Grupiraj po stavkama,
Remember to set {field_label}. It is required by {regulation}.,Ne zaboravite postaviti {field_label}. To zahtijeva {propis}.,
Enrollment Date cannot be before the Start Date of the Academic Year {0},Datum upisa ne može biti pre datuma početka akademske godine {0},
Enrollment Date cannot be after the End Date of the Academic Term {0},Datum upisa ne može biti nakon datuma završetka akademskog roka {0},
Enrollment Date cannot be before the Start Date of the Academic Term {0},Datum upisa ne može biti pre datuma početka akademskog roka {0},
Future Posting Not Allowed,Objavljivanje u budućnosti nije dozvoljeno,
"To enable Capital Work in Progress Accounting, ","Da bi se omogućilo računovodstvo kapitalnog rada u toku,",
you must select Capital Work in Progress Account in accounts table,u tablici računa morate odabrati Račun kapitalnog rada u toku,
You can also set default CWIP account in Company {},Također možete postaviti zadani CWIP račun u kompaniji {},
The Request for Quotation can be accessed by clicking on the following button,Zahtjevu za ponudu možete pristupiti klikom na sljedeće dugme,
Regards,Pozdrav,
Please click on the following button to set your new password,Kliknite na sljedeći gumb da biste postavili novu lozinku,
Update Password,Ažuriraj lozinku,
Row #{}: Selling rate for item {} is lower than its {}. Selling {} should be atleast {},Red # {}: Stopa prodaje predmeta {} niža je od njegove {}. Prodaja {} treba biti najmanje {},
You can alternatively disable selling price validation in {} to bypass this validation.,Alternativno možete onemogućiti provjeru prodajne cijene u {} da biste zaobišli ovu provjeru.,
Invalid Selling Price,Nevažeća prodajna cijena,
Address needs to be linked to a Company. Please add a row for Company in the Links table.,Adresa mora biti povezana sa kompanijom. Dodajte red za kompaniju u tabelu veza.,
Company Not Linked,Kompanija nije povezana,
Import Chart of Accounts from CSV / Excel files,Uvezite kontni plan iz CSV / Excel datoteka,
Completed Qty cannot be greater than 'Qty to Manufacture',Završena količina ne može biti veća od &#39;Količina za proizvodnju&#39;,
"Row {0}: For Supplier {1}, Email Address is Required to send an email",Red {0}: Za dobavljača {1} za slanje e-pošte potrebna je adresa e-pošte,
"If enabled, the system will post accounting entries for inventory automatically","Ako je omogućeno, sistem će automatski knjižiti knjigovodstvene evidencije zaliha",
Accounts Frozen Till Date,Računi zamrznuti do datuma,
Accounting entries are frozen up to this date. Nobody can create or modify entries except users with the role specified below,Knjigovodstvene stavke su zamrznute do danas. Nitko ne može stvarati ili mijenjati unose osim korisnika s ulogom navedenom u nastavku,
Role Allowed to Set Frozen Accounts and Edit Frozen Entries,Dopuštena uloga za postavljanje zamrznutih računa i uređivanje zamrznutih unosa,
Address used to determine Tax Category in transactions,Adresa koja se koristi za određivanje kategorije poreza u transakcijama,
"The percentage you are allowed to bill more against the amount ordered. For example, if the order value is $100 for an item and tolerance is set as 10%, then you are allowed to bill up to $110 ","Procenat koji vam je dozvoljen da naplatite više u odnosu na naručeni iznos. Na primjer, ako vrijednost narudžbe iznosi 100 USD za artikl, a tolerancija je postavljena na 10%, tada možete naplatiti do 110 USD",
This role is allowed to submit transactions that exceed credit limits,Ovoj ulozi je dozvoljeno podnošenje transakcija koje premašuju kreditna ograničenja,
"If ""Months"" is selected, a fixed amount will be booked as deferred revenue or expense for each month irrespective of the number of days in a month. It will be prorated if deferred revenue or expense is not booked for an entire month","Ako je odabrano &quot;Mjeseci&quot;, fiksni iznos knjižiti će se kao odgođeni prihod ili rashod za svaki mjesec, bez obzira na broj dana u mjesecu. Proportirat će se ako odgođeni prihodi ili rashodi ne budu knjiženi cijeli mjesec",
"If this is unchecked, direct GL entries will be created to book deferred revenue or expense","Ako ovo nije označeno, stvorit će se izravni GL unosi za knjiženje odgođenih prihoda ili troškova",
Show Inclusive Tax in Print,Prikaži uključeni porez u štampi,
Only select this if you have set up the Cash Flow Mapper documents,Odaberite ovo samo ako ste postavili dokumente Mape tokova gotovine,
Payment Channel,Kanal plaćanja,
Is Purchase Order Required for Purchase Invoice & Receipt Creation?,Da li je narudžbenica potrebna za fakturisanje i izradu računa?,
Is Purchase Receipt Required for Purchase Invoice Creation?,Da li je za izradu računa za kupovinu potrebna potvrda o kupovini?,
Maintain Same Rate Throughout the Purchase Cycle,Održavajte istu stopu tokom ciklusa kupovine,
Allow Item To Be Added Multiple Times in a Transaction,Omogućite dodavanje predmeta više puta u transakciji,
Suppliers,Dobavljači,
Send Emails to Suppliers,Pošaljite e-poštu dobavljačima,
Select a Supplier,Odaberite dobavljača,
Cannot mark attendance for future dates.,Nije moguće označiti prisustvo za buduće datume.,
Do you want to update attendance? <br> Present: {0} <br> Absent: {1},Želite li ažurirati prisustvo?<br> Prisutan: {0}<br> Odsutan: {1},
Mpesa Settings,Mpesa Settings,
Initiator Name,Ime inicijatora,
Till Number,Do broja,
Sandbox,Sandbox,
 Online PassKey,Online PassKey,
Security Credential,Sigurnosne vjerodajnice,
Get Account Balance,Nabavite stanje na računu,
Please set the initiator name and the security credential,Molimo postavite ime inicijatora i sigurnosne vjerodajnice,
Inpatient Medication Entry,Stacionarni unos lijekova,
HLC-IME-.YYYY.-,FHP-IME-.GGGG.-,
Item Code (Drug),Šifra artikla (lijek),
Medication Orders,Narudžbe lijekova,
Get Pending Medication Orders,Nabavite lijekove na čekanju,
Inpatient Medication Orders,Stacionarni lijekovi,
Medication Warehouse,Skladište lijekova,
Warehouse from where medication stock should be consumed,Skladište odakle treba potrošiti zalihe lijekova,
Fetching Pending Medication Orders,Preuzimanje naloga za lijekove na čekanju,
Inpatient Medication Entry Detail,Pojedinosti o ulazu u stacionarne lijekove,
Medication Details,Detalji lijekova,
Drug Code,Kod droge,
Drug Name,Ime lijeka,
Against Inpatient Medication Order,Protiv naloga za stacionarno liječenje,
Against Inpatient Medication Order Entry,Protiv ulaza u stacionarne lijekove,
Inpatient Medication Order,Stacionarni nalog za lijekove,
HLC-IMO-.YYYY.-,FHP-IMO-.GGGG.-,
Total Orders,Ukupno narudžbi,
Completed Orders,Završene narudžbe,
Add Medication Orders,Dodajte naredbe za lijekove,
Adding Order Entries,Dodavanje unosa naloga,
{0} medication orders completed,Završeno je {0} narudžbi lijekova,
{0} medication order completed,{0} narudžba lijekova završena,
Inpatient Medication Order Entry,Unos naloga za stacionarne lijekove,
Is Order Completed,Da li je narudžba završena,
Employee Records to Be Created By,Evidencija zaposlenih koju će kreirati,
Employee records are created using the selected field,Evidencija zaposlenih kreira se pomoću izabranog polja,
Don't send employee birthday reminders,Ne šaljite podsjetnike za rođendan zaposlenika,
Restrict Backdated Leave Applications,Ograničite aplikacije za napuštanje sa zadnjim datumom,
Sequence ID,ID sekvence,
Sequence Id,Sekvenca Id,
Allow multiple material consumptions against a Work Order,Omogućite višestruku potrošnju materijala prema radnom nalogu,
Plan time logs outside Workstation working hours,Planirajte evidenciju vremena izvan radnog vremena radne stanice,
Plan operations X days in advance,Planirajte operacije X dana unaprijed,
Time Between Operations (Mins),Vrijeme između operacija (minuta),
Default: 10 mins,Zadano: 10 min,
Overproduction for Sales and Work Order,Prekomerna proizvodnja za prodaju i radni nalog,
"Update BOM cost automatically via scheduler, based on the latest Valuation Rate/Price List Rate/Last Purchase Rate of raw materials","Ažurirajte BOM troškove automatski putem planera, na osnovu najnovije stope procjene / stope cjenika / stope zadnje kupovine sirovina",
Purchase Order already created for all Sales Order items,Narudžbenica je već kreirana za sve stavke narudžbenice,
Select Items,Odaberite stavke,
Against Default Supplier,Protiv zadanog dobavljača,
Auto close Opportunity after the no. of days mentioned above,Automatsko zatvaranje prilika nakon br. dana gore spomenutih,
Is Sales Order Required for Sales Invoice & Delivery Note Creation?,Da li je narudžbenica za kupovinu potrebna za izradu fakture i naloga za isporuku?,
Is Delivery Note Required for Sales Invoice Creation?,Da li je za izradu fakture za prodaju potrebna dostavnica?,
How often should Project and Company be updated based on Sales Transactions?,Koliko često treba ažurirati projekat i kompaniju na osnovu prodajnih transakcija?,
Allow User to Edit Price List Rate in Transactions,Omogućite korisniku da uređuje cijenu cjenika u transakcijama,
Allow Item to Be Added Multiple Times in a Transaction,Dopusti dodavanje predmeta u transakciji više puta,
Allow Multiple Sales Orders Against a Customer's Purchase Order,Omogućite više naloga za prodaju u odnosu na narudžbenice kupca,
Validate Selling Price for Item Against Purchase Rate or Valuation Rate,Potvrdite prodajnu cijenu za stavku naspram stope kupovine ili stope procjene,
Hide Customer's Tax ID from Sales Transactions,Sakrijte poreski broj kupca iz prodajnih transakcija,
"The percentage you are allowed to receive or deliver more against the quantity ordered. For example, if you have ordered 100 units, and your Allowance is 10%, then you are allowed to receive 110 units.","Procenat koji smijete primiti ili isporučiti više u odnosu na naručenu količinu. Na primjer, ako ste naručili 100 jedinica, a Vaš dodatak je 10%, tada možete primiti 110 jedinica.",
Action If Quality Inspection Is Not Submitted,Akcija ako se inspekcija kvaliteta ne podnese,
Auto Insert Price List Rate If Missing,Automatsko umetanje cijene cjenika ako nedostaje,
Automatically Set Serial Nos Based on FIFO,Automatski postavi serijske brojeve na osnovu FIFO-a,
Set Qty in Transactions Based on Serial No Input,Postavi količinu u transakcijama na osnovu serijskog unosa,
Raise Material Request When Stock Reaches Re-order Level,Podignite zahtjev za materijal kada zalihe dosegnu nivo narudžbe,
Notify by Email on Creation of Automatic Material Request,Obavijestite e-poštom o stvaranju automatskog zahtjeva za materijalom,
Allow Material Transfer from Delivery Note to Sales Invoice,Omogućite prijenos materijala iz otpremnice na fakturu prodaje,
Allow Material Transfer from Purchase Receipt to Purchase Invoice,Omogućite prijenos materijala sa računa o kupovini na račun za kupovinu,
Freeze Stocks Older Than (Days),Zamrznite zalihe starije od (dana),
Role Allowed to Edit Frozen Stock,Dopuštena uloga za uređivanje smrznutih zaliha,
The unallocated amount of Payment Entry {0} is greater than the Bank Transaction's unallocated amount,Neraspoređeni iznos Unosa za plaćanje {0} veći je od neraspoređenog iznosa Bankovne transakcije,
Payment Received,Primljena uplata,
Attendance cannot be marked outside of Academic Year {0},Prisustvo se ne može označiti van akademske godine {0},
Student is already enrolled via Course Enrollment {0},Student je već upisan putem upisa na predmet {0},
Attendance cannot be marked for future dates.,Prisustvo se ne može označiti za buduće datume.,
Please add programs to enable admission application.,Dodajte programe kako biste omogućili prijavu.,
The following employees are currently still reporting to {0}:,Sljedeći zaposlenici trenutno još uvijek izvještavaju {0}:,
Please make sure the employees above report to another Active employee.,Molimo osigurajte da se gore navedeni zaposlenici prijave drugom aktivnom zaposleniku.,
Cannot Relieve Employee,Ne mogu osloboditi zaposlenika,
Please enter {0},Unesite {0},
Please select another payment method. Mpesa does not support transactions in currency '{0}',Odaberite drugi način plaćanja. Mpesa ne podržava transakcije u valuti &#39;{0}&#39;,
Transaction Error,Greška u transakciji,
Mpesa Express Transaction Error,Mpesa Express Transaction Greška,
"Issue detected with Mpesa configuration, check the error logs for more details","Otkriven je problem s Mpesa konfiguracijom, za više detalja provjerite zapisnike grešaka",
Mpesa Express Error,Mpesa Express greška,
Account Balance Processing Error,Pogreška pri obradi stanja računa,
Please check your configuration and try again,Provjerite svoju konfiguraciju i pokušajte ponovo,
Mpesa Account Balance Processing Error,Greška u obradi stanja računa Mpesa,
Balance Details,Detalji stanja,
Current Balance,Trenutno stanje,
Available Balance,Dostupno stanje,
Reserved Balance,Rezervisano stanje,
Uncleared Balance,Nerazjašnjeni bilans,
Payment related to {0} is not completed,Isplata vezana za {0} nije završena,
Row #{}: Item Code: {} is not available under warehouse {}.,Red # {}: Kod artikla: {} nije dostupan u skladištu {}.,
Row #{}: Stock quantity not enough for Item Code: {} under warehouse {}. Available quantity {}.,Red # {}: Količina zaliha nije dovoljna za šifru artikla: {} ispod skladišta {}. Dostupna količina {}.,
Row #{}: Please select a serial no and batch against item: {} or remove it to complete transaction.,Red # {}: Odaberite serijski broj i seriju stavke: {} ili ga uklonite da biste dovršili transakciju.,
Row #{}: No serial number selected against item: {}. Please select one or remove it to complete transaction.,Red # {}: Nije odabran serijski broj za stavku: {}. Odaberite jedan ili ga uklonite da biste dovršili transakciju.,
Row #{}: No batch selected against item: {}. Please select a batch or remove it to complete transaction.,Red # {}: Nije odabrana serija za stavku: {}. Odaberite grupu ili je uklonite da biste dovršili transakciju.,
Payment amount cannot be less than or equal to 0,Iznos uplate ne može biti manji ili jednak 0,
Please enter the phone number first,Prvo unesite broj telefona,
Row #{}: {} {} does not exist.,Red # {}: {} {} ne postoji.,
Row #{0}: {1} is required to create the Opening {2} Invoices,Redak {0}: {1} potreban je za kreiranje početnih {2} faktura,
You had {} errors while creating opening invoices. Check {} for more details,Imali ste {} grešaka prilikom kreiranja faktura za otvaranje. Pogledajte {} za više detalja,
Error Occured,Dogodila se greška,
Opening Invoice Creation In Progress,Otvaranje fakture u toku,
Creating {} out of {} {},Izrada {} od {} {},
(Serial No: {0}) cannot be consumed as it's reserverd to fullfill Sales Order {1}.,(Serijski broj: {0}) ne može se potrošiti jer je rezerviran za potpuno popunjavanje prodajnog naloga {1}.,
Item {0} {1},Stavka {0} {1},
Last Stock Transaction for item {0} under warehouse {1} was on {2}.,Posljednja transakcija zaliha za artikal {0} u skladištu {1} bila je {2}.,
Stock Transactions for Item {0} under warehouse {1} cannot be posted before this time.,Transakcije dionicama za stavku {0} u skladištu {1} ne mogu se objaviti prije ovog vremena.,
Posting future stock transactions are not allowed due to Immutable Ledger,Knjiženje budućih transakcija dionicama nije dopušteno zbog Nepromjenjive knjige,
A BOM with name {0} already exists for item {1}.,BOM sa imenom {0} već postoji za stavku {1}.,
{0}{1} Did you rename the item? Please contact Administrator / Tech support,{0} {1} Jeste li preimenovali stavku? Molimo kontaktirajte administratora / tehničku podršku,
At row #{0}: the sequence id {1} cannot be less than previous row sequence id {2},U retku # {0}: ID sekvence {1} ne može biti manji od ID-a sekvence prethodnog reda {2},
The {0} ({1}) must be equal to {2} ({3}),{0} ({1}) mora biti jednako {2} ({3}),
"{0}, complete the operation {1} before the operation {2}.","{0}, dovršite operaciju {1} prije operacije {2}.",
Cannot ensure delivery by Serial No as Item {0} is added with and without Ensure Delivery by Serial No.,Ne možemo osigurati isporuku serijskim brojem jer se dodaje stavka {0} sa i bez osiguranja isporuke serijskim br.,
Item {0} has no Serial No. Only serilialized items can have delivery based on Serial No,Stavka {0} nema serijski broj. Samo serilizirani predmeti mogu isporučivati na osnovu serijskog broja,
No active BOM found for item {0}. Delivery by Serial No cannot be ensured,Nije pronađena aktivna BOM za stavku {0}. Dostava serijskim brojem ne može se osigurati,
No pending medication orders found for selected criteria,Nije pronađena nijedna narudžba lijekova za odabrane kriterije,
From Date cannot be after the current date.,Od datuma ne može biti nakon trenutnog datuma.,
To Date cannot be after the current date.,Do datuma ne može biti nakon trenutnog datuma.,
From Time cannot be after the current time.,Iz vremena ne može biti nakon trenutnog vremena.,
To Time cannot be after the current time.,To Time ne može biti nakon trenutnog vremena.,
Stock Entry {0} created and ,Unos dionica {0} stvoren i,
Inpatient Medication Orders updated successfully,Nalozi za stacionarne lijekove su uspješno ažurirani,
Row {0}: Cannot create Inpatient Medication Entry against cancelled Inpatient Medication Order {1},Red {0}: Ne može se stvoriti unos za stacionarne lijekove protiv otkazanog naloga za stacionarno liječenje {1},
Row {0}: This Medication Order is already marked as completed,Redak {0}: Ovaj nalog za lijekove već je označen kao ispunjen,
Quantity not available for {0} in warehouse {1},Količina nije dostupna za {0} u skladištu {1},
Please enable Allow Negative Stock in Stock Settings or create Stock Entry to proceed.,Omogućite Dozvoli negativne zalihe u postavkama zaliha ili kreirajte unos zaliha da biste nastavili.,
No Inpatient Record found against patient {0},Nije pronađen nijedan stacionarni zapis protiv pacijenta {0},
An Inpatient Medication Order {0} against Patient Encounter {1} already exists.,Nalog stacionarnih lijekova {0} protiv susreta s pacijentima {1} već postoji.,
Allow In Returns,Omogući povratak,
Hide Unavailable Items,Sakrij nedostupne stavke,
Apply Discount on Discounted Rate,Primijenite popust na sniženu stopu,
Therapy Plan Template,Predložak plana terapije,
Fetching Template Details,Preuzimanje podataka o predlošku,
Linked Item Details,Povezani detalji predmeta,
Therapy Types,Vrste terapije,
Therapy Plan Template Detail,Pojedinosti predloška plana terapije,
Non Conformance,Neusklađenost,
Process Owner,Vlasnik procesa,
Corrective Action,Korektivna akcija,
Preventive Action,Preventivna akcija,
Problem,Problem,
Responsible,Odgovorno,
Completion By,Završetak,
Process Owner Full Name,Puno ime vlasnika procesa,
Right Index,Desni indeks,
Left Index,Lijevi indeks,
Sub Procedure,Potprocedura,
Passed,Prošao,
Print Receipt,Potvrda o ispisu,
Edit Receipt,Uredi potvrdu,
Focus on search input,Usredotočite se na unos pretraživanja,
Focus on Item Group filter,Usredotočite se na filter grupe predmeta,
Checkout Order / Submit Order / New Order,Narudžba za plaćanje / Predaja naloga / Nova narudžba,
Add Order Discount,Dodajte popust za narudžbinu,
Item Code: {0} is not available under warehouse {1}.,Šifra artikla: {0} nije dostupno u skladištu {1}.,
Serial numbers unavailable for Item {0} under warehouse {1}. Please try changing warehouse.,Serijski brojevi nisu dostupni za artikl {0} u skladištu {1}. Pokušajte promijeniti skladište.,
Fetched only {0} available serial numbers.,Preuzeto je samo {0} dostupnih serijskih brojeva.,
Switch Between Payment Modes,Prebacivanje između načina plaćanja,
Enter {0} amount.,Unesite iznos od {0}.,
You don't have enough points to redeem.,Nemate dovoljno bodova za iskorištavanje.,
You can redeem upto {0}.,Možete iskoristiti do {0}.,
Enter amount to be redeemed.,Unesite iznos koji treba iskoristiti.,
You cannot redeem more than {0}.,Ne možete iskoristiti više od {0}.,
Open Form View,Otvorite prikaz obrasca,
POS invoice {0} created succesfully,POS račun {0} je uspješno kreiran,
Stock quantity not enough for Item Code: {0} under warehouse {1}. Available quantity {2}.,Količina zaliha nije dovoljna za šifru artikla: {0} ispod skladišta {1}. Dostupna količina {2}.,
Serial No: {0} has already been transacted into another POS Invoice.,Serijski broj: {0} je već prebačen na drugu POS fakturu.,
Balance Serial No,Serijski br. Stanja,
Warehouse: {0} does not belong to {1},Skladište: {0} ne pripada {1},
Please select batches for batched item {0},Odaberite serije za serijsku stavku {0},
Please select quantity on row {0},Odaberite količinu u retku {0},
Please enter serial numbers for serialized item {0},Unesite serijske brojeve za serijsku stavku {0},
Batch {0} already selected.,Paket {0} je već odabran.,
Please select a warehouse to get available quantities,Odaberite skladište da biste dobili dostupne količine,
"For transfer from source, selected quantity cannot be greater than available quantity","Za prijenos iz izvora, odabrana količina ne može biti veća od dostupne količine",
Cannot find Item with this Barcode,Ne mogu pronaći predmet sa ovim crtičnim kodom,
{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2},{0} je obavezno. Možda zapis mjenjačnice nije kreiran za {1} do {2},
{} has submitted assets linked to it. You need to cancel the assets to create purchase return.,{} je poslao sredstva povezana s tim. Morate otkazati imovinu da biste stvorili povrat kupovine.,
Cannot cancel this document as it is linked with submitted asset {0}. Please cancel it to continue.,Ovaj dokument nije moguće otkazati jer je povezan sa dostavljenim materijalom {0}. Otkažite ga da biste nastavili.,
Row #{}: Serial No. {} has already been transacted into another POS Invoice. Please select valid serial no.,Red # {}: Serijski broj {} je već prebačen na drugu POS fakturu. Odaberite važeći serijski broj.,
Row #{}: Serial Nos. {} has already been transacted into another POS Invoice. Please select valid serial no.,Red # {}: Serijski brojevi. {} Je već prebačen na drugu POS fakturu. Odaberite važeći serijski broj.,
Item Unavailable,Predmet nije dostupan,
Row #{}: Serial No {} cannot be returned since it was not transacted in original invoice {},Red # {}: Serijski broj {} se ne može vratiti jer nije izvršen u originalnoj fakturi {},
Please set default Cash or Bank account in Mode of Payment {},Postavite zadani gotovinski ili bankovni račun u načinu plaćanja {},
Please set default Cash or Bank account in Mode of Payments {},Postavite zadani gotovinski ili bankovni račun u načinu plaćanja {},
Please ensure {} account is a Balance Sheet account. You can change the parent account to a Balance Sheet account or select a different account.,Molimo provjerite je li račun {} račun bilance stanja. Možete promijeniti roditeljski račun u račun bilansa stanja ili odabrati drugi račun.,
Please ensure {} account is a Payable account. Change the account type to Payable or select a different account.,Molimo provjerite je li račun {} račun koji se plaća. Promijenite vrstu računa u Plativo ili odaberite drugi račun.,
Row {}: Expense Head changed to {} ,Red {}: Glava rashoda promijenjena u {},
because account {} is not linked to warehouse {} ,jer račun {} nije povezan sa skladištem {},
or it is not the default inventory account,ili to nije zadani račun zaliha,
Expense Head Changed,Promijenjena glava rashoda,
because expense is booked against this account in Purchase Receipt {},jer je račun evidentiran na ovom računu u potvrdi o kupovini {},
as no Purchase Receipt is created against Item {}. ,jer se prema stavci {} ne kreira potvrda o kupovini.,
This is done to handle accounting for cases when Purchase Receipt is created after Purchase Invoice,To se radi radi obračunavanja slučajeva kada se potvrda o kupovini kreira nakon fakture za kupovinu,
Purchase Order Required for item {},Narudžbenica potrebna za stavku {},
To submit the invoice without purchase order please set {} ,"Da biste predali račun bez narudžbenice, postavite {}",
as {} in {},kao u {},
Mandatory Purchase Order,Obavezna narudžbenica,
Purchase Receipt Required for item {},Potvrda o kupovini za stavku {},
To submit the invoice without purchase receipt please set {} ,"Da biste predali račun bez potvrde o kupovini, postavite {}",
Mandatory Purchase Receipt,Obavezna potvrda o kupovini,
POS Profile {} does not belongs to company {},POS profil {} ne pripada kompaniji {},
User {} is disabled. Please select valid user/cashier,Korisnik {} je onemogućen. Odaberite valjanog korisnika / blagajnika,
Row #{}: Original Invoice {} of return invoice {} is {}. ,Redak {{}: Originalna faktura {} fakture za povrat {} je {}.,
Original invoice should be consolidated before or along with the return invoice.,Originalnu fakturu treba konsolidirati prije ili zajedno s povratnom fakturom.,
You can add original invoice {} manually to proceed.,Možete nastaviti originalnu fakturu {} ručno da biste nastavili.,
Please ensure {} account is a Balance Sheet account. ,Molimo provjerite je li račun {} račun bilance stanja.,
You can change the parent account to a Balance Sheet account or select a different account.,Možete promijeniti roditeljski račun u račun bilansa stanja ili odabrati drugi račun.,
Please ensure {} account is a Receivable account. ,Molimo provjerite je li račun} račun potraživanja.,
Change the account type to Receivable or select a different account.,Promijenite vrstu računa u Potraživanje ili odaberite drugi račun.,
{} can't be cancelled since the Loyalty Points earned has been redeemed. First cancel the {} No {},{} se ne može otkazati jer su iskorišteni bodovi za lojalnost iskorišteni. Prvo otkažite {} Ne {},
already exists,već postoji,
POS Closing Entry {} against {} between selected period,Zatvaranje unosa POS-a {} protiv {} između izabranog perioda,
POS Invoice is {},POS račun je {},
POS Profile doesn't matches {},POS profil se ne podudara sa {},
POS Invoice is not {},POS račun nije {},
POS Invoice isn't created by user {},POS račun ne kreira korisnik {},
Row #{}: {},Red # {}: {},
Invalid POS Invoices,Nevažeći POS računi,
Please add the account to root level Company - {},Molimo dodajte račun korijenskom nivou kompanije - {},
"While creating account for Child Company {0}, parent account {1} not found. Please create the parent account in corresponding COA","Tokom kreiranja računa za kompaniju Child Child {0}, nadređeni račun {1} nije pronađen. Molimo kreirajte roditeljski račun u odgovarajućem COA",
Account Not Found,Račun nije pronađen,
"While creating account for Child Company {0}, parent account {1} found as a ledger account.","Prilikom kreiranja računa za Child Company {0}, roditeljski račun {1} je pronađen kao račun glavne knjige.",
Please convert the parent account in corresponding child company to a group account.,Molimo konvertujte roditeljski račun u odgovarajućem podređenom preduzeću u grupni račun.,
Invalid Parent Account,Nevažeći račun roditelja,
"Renaming it is only allowed via parent company {0}, to avoid mismatch.","Preimenovanje je dozvoljeno samo preko matične kompanije {0}, kako bi se izbjegla neusklađenost.",
"If you {0} {1} quantities of the item {2}, the scheme {3} will be applied on the item.","Ako {0} {1} količinu predmeta {2}, shema {3} primijenit će se na stavku.",
"If you {0} {1} worth item {2}, the scheme {3} will be applied on the item.","Ako {0} {1} vrijedite stavku {2}, shema {3} primijenit će se na stavku.",
"As the field {0} is enabled, the field {1} is mandatory.","Kako je polje {0} omogućeno, polje {1} je obavezno.",
"As the field {0} is enabled, the value of the field {1} should be more than 1.","Kako je polje {0} omogućeno, vrijednost polja {1} trebala bi biti veća od 1.",
Cannot deliver Serial No {0} of item {1} as it is reserved to fullfill Sales Order {2},Nije moguće isporučiti serijski broj {0} stavke {1} jer je rezervisan za puni popunjeni prodajni nalog {2},
"Sales Order {0} has reservation for the item {1}, you can only deliver reserved {1} against {0}.","Prodajni nalog {0} ima rezervaciju za artikal {1}, rezervisani {1} možete dostaviti samo protiv {0}.",
{0} Serial No {1} cannot be delivered,{0} Serijski broj {1} nije moguće isporučiti,
Row {0}: Subcontracted Item is mandatory for the raw material {1},Red {0}: Predmet podugovaranja je obavezan za sirovinu {1},
"As there are sufficient raw materials, Material Request is not required for Warehouse {0}.","Budući da postoji dovoljno sirovina, zahtjev za materijal nije potreban za Skladište {0}.",
" If you still want to proceed, please enable {0}.","Ako i dalje želite nastaviti, omogućite {0}.",
The item referenced by {0} - {1} is already invoiced,Stavka na koju se poziva {0} - {1} već je fakturirana,
Therapy Session overlaps with {0},Sjednica terapije preklapa se sa {0},
Therapy Sessions Overlapping,Preklapanje terapijskih sesija,
Therapy Plans,Planovi terapije,
"Item Code, warehouse, quantity are required on row {0}","Šifra artikla, skladište, količina su obavezni na retku {0}",
Get Items from Material Requests against this Supplier,Nabavite predmete od materijalnih zahtjeva protiv ovog dobavljača,
Enable European Access,Omogućiti evropski pristup,
Creating Purchase Order ...,Kreiranje narudžbenice ...,
"Select a Supplier from the Default Suppliers of the items below. On selection, a Purchase Order will be made against items belonging to the selected Supplier only.","Odaberite dobavljača od zadanih dobavljača dolje navedenih stavki. Nakon odabira, narudžbenica će se izvršiti samo za proizvode koji pripadaju odabranom dobavljaču.",
Row #{}: You must select {} serial numbers for item {}.,Red # {}: Morate odabrati {} serijske brojeve za stavku {}.,
Add Comment,Dodaj komentar,
More...,Više ...,
Notes,Bilješke,
Payment Gateway,Payment Gateway,
Payment Gateway Name,Naziv Gateway Gateway-a,
Payments,Plaćanja,
Plan Name,Ime plana,
Portal,Portal,
Scan Barcode,Skenirajte bar kod,
Some information is missing,Neke informacije nedostaju,
Successful,Uspešno,
Tools,Alati,
Use Sandbox,Koristite Sandbox,
Busy,Zauzeto,
Completed By,Završio,
Payment Failed,plaćanje nije uspjelo,
Column {0},Stupac {0},
Field Mapping,Mapiranje polja,
Not Specified,Nije određeno,
Update Type,Tip ažuriranja,
Dr,Doktor,
End Time,End Time,
Fetching...,Dohvaćanje ...,
"It seems that there is an issue with the server's stripe configuration. In case of failure, the amount will get refunded to your account.","Čini se da postoji problem sa konfiguracijom trake servera. U slučaju neuspeha, iznos će biti vraćen na vaš račun.",
Looks like someone sent you to an incomplete URL. Please ask them to look into it.,Izgleda kao da je neko poslao na nepotpune URL. Zamolite ih da pogleda u nju.,
Master,Majstor,
Pay,Platiti,
You can also copy-paste this link in your browser,Također možete copy-paste ovaj link u vašem pregledniku,
Verified By,Ovjeren od strane,
Invalid naming series (. missing) for {0},Nevažeća serija imenovanja (. Nedostaje) za {0},
Phone Number,Telefonski broj,
Account SID,SID računa,
Global Defaults,Globalne zadane postavke,
Is Mandatory,Je obavezna,
WhatsApp,WhatsApp,
Make a call,Pozovite,
Approve,odobriti,
Reject,odbiti,
