"""Customer Provided Item"" cannot be Purchase Item also","&quot;Artikel, ki ga zagotavlja stranka&quot;, tudi ni mogoče kupiti",
"""Customer Provided Item"" cannot have Valuation Rate","&quot;Izdelek, ki ga zagotavlja stranka&quot;, ne more imeti stopnje vrednotenja",
"""Is Fixed Asset"" cannot be unchecked, as Asset record exists against the item","""Ali je osnovno sredstvo"" ne more biti neizbrano, saj obstaja evidenca sredstev po postavki",
'Based On' and 'Group By' can not be same,"""Na podlagi"" in ""Združi po"" ne more biti enaka",
'Days Since Last Order' must be greater than or equal to zero,"""Dnevi od zadnjega naročila"" morajo biti večji ali enak nič",
'Entries' cannot be empty,"""Vnos"" ne more biti prazen",
'From Date' is required,"Zahtevano je ""Od datuma""",
'From Date' must be after 'To Date','Od datuma' mora biti za 'Do datuma ',
'Has Serial No' can not be 'Yes' for non-stock item,"""Ima serijsko številko"" ne more biti 'Da' za postavko brez zalog",
'Opening',&quot;Odpiranje&quot;,
'To Case No.' cannot be less than 'From Case No.','Do št. primera' ne more biti nižja od 'Od št. primera',
'To Date' is required,"""Do datuma"" je obvezno polje",
'Total',&quot;Skupaj&quot;,
'Update Stock' can not be checked because items are not delivered via {0},"'Posodobi zalogo' ne more biti izbrano, saj artikli niso dostavljeni prek {0}",
'Update Stock' cannot be checked for fixed asset sale,"&quot;Update Stock&quot;, ni mogoče preveriti za prodajo osnovnih sredstev",
) for {0},) za {0},
1 exact match.,1 natančno ujemanje.,
90-Above,90-Nad,
A Customer Group exists with same name please change the Customer name or rename the Customer Group,"A Skupina kupcev obstaja z istim imenom, prosimo spremenite ime stranke ali preimenovati skupino odjemalcev",
A Default Service Level Agreement already exists.,Pogodba o ravni privzete storitve že obstaja.,
A Lead requires either a person's name or an organization's name,Vodnik zahteva ime osebe ali ime organizacije,
A customer with the same name already exists,Kupec z istim imenom že obstaja,
A question must have more than one options,Vprašanje mora imeti več možnosti,
A qustion must have at least one correct options,Karakter mora imeti vsaj eno pravilno možnost,
A {0} exists between {1} and {2} (,A {0} obstaja med {1} in {2} (,
A4,A4,
API Endpoint,Končna točka API,
API Key,ključ API,
Abbr can not be blank or space,Abbr ne more biti prazna ali presledek,
Abbreviation already used for another company,Kratica že uporabljena za druge družbe,
Abbreviation cannot have more than 5 characters,Kratica ne more imeti več kot 5 znakov,
Abbreviation is mandatory,Kratica je obvezna,
About the Company,O podjetju,
About your company,O vaši družbi,
Above,Nad,
Absent,Odsoten,
Academic Term,Academic Term,
Academic Term: ,Akademski izraz:,
Academic Year,Študijsko leto,
Academic Year: ,Študijsko leto:,
Accepted + Rejected Qty must be equal to Received quantity for Item {0},Sprejeta + Zavrnjeno Količina mora biti enaka Prejeto količini za postavko {0},
Access Token,Dostopni žeton,
Accessable Value,Dostopna vrednost,
Account,račun,
Account Number,Številka računa,
Account Number {0} already used in account {1},Številka računa {0} je že uporabljena v računu {1},
Account Pay Only,Račun Pay samo,
Account Type,Vrsta računa,
Account Type for {0} must be {1},Vrsta računa za {0} mora biti {1},
"Account balance already in Credit, you are not allowed to set 'Balance Must Be' as 'Debit'","Stanje na računu je že v ""kredit"", ni dovoljeno nastaviti ""Stanje mora biti"" kot ""bremenitev""",
"Account balance already in Debit, you are not allowed to set 'Balance Must Be' as 'Credit'","Stanje na računu je že ""bremenitev"", ni dovoljeno nastaviti ""Stanje mora biti"" kot ""kredit""",
Account number for account {0} is not available.<br> Please setup your Chart of Accounts correctly.,Številka računa za račun {0} ni na voljo. <br> Pravilno nastavite svoj račun.,
Account with child nodes cannot be converted to ledger,Račun z zapirali vozlišč ni mogoče pretvoriti v knjigo terjatev,
Account with child nodes cannot be set as ledger,Račun z zapirali vozlišč ni mogoče nastaviti kot knjigo,
Account with existing transaction can not be converted to group.,Račun z obstoječim poslom ni mogoče pretvoriti v skupini.,
Account with existing transaction can not be deleted,Račun z obstoječim poslom ni mogoče izbrisati,
Account with existing transaction cannot be converted to ledger,Račun z obstoječim poslom ni mogoče pretvoriti v knjigo terjatev,
Account {0} does not belong to company: {1},Račun {0} ne pripada podjetju: {1},
Account {0} does not belongs to company {1},Račun {0} ne pripada podjetju {1},
Account {0} does not exist,Račun {0} ne obstaja,
Account {0} does not exists,Račun {0} ne obstaja,
Account {0} does not match with Company {1} in Mode of Account: {2},Račun {0} ne ujema z družbo {1} v načinu račun: {2},
Account {0} has been entered multiple times,Račun {0} je bil vpisan večkrat,
Account {0} is added in the child company {1},Račun {0} je dodan v otroškem podjetju {1},
Account {0} is frozen,Račun {0} je zamrznjen,
Account {0} is invalid. Account Currency must be {1},Račun {0} ni veljaven. Valuta računa mora biti {1},
Account {0}: Parent account {1} can not be a ledger,Račun {0}: Matični račun {1} ne more biti Glavna knjiga,
Account {0}: Parent account {1} does not belong to company: {2},Račun {0}: Matični račun {1} ne pripada podjetju: {2},
Account {0}: Parent account {1} does not exist,Račun {0}: Matični račun {1} ne obstaja,
Account {0}: You can not assign itself as parent account,Račun {0}: ne moreš dodeliti samega sebe kot matični račun,
Account: {0} can only be updated via Stock Transactions,Račun: {0} se lahko posodobi samo preko delniških poslov,
Account: {0} with currency: {1} can not be selected,Račun: {0} z valuti: ne more biti izbran {1},
Accountant,Računovodja,
Accounting,Računovodstvo,
Accounting Entry for Asset,Računovodski vpis za sredstvo,
Accounting Entry for Stock,Računovodstvo Vstop za zalogi,
Accounting Entry for {0}: {1} can only be made in currency: {2},"Računovodstvo Vstop za {0}: lahko {1}, se izvede le v valuti: {2}",
Accounting Ledger,Računovodstvo Ledger,
Accounting journal entries.,Vpisi računovodstvo lista.,
Accounts,Računi,
Accounts Manager,Accounts Manager,
Accounts Payable,Računi se plačuje,
Accounts Payable Summary,Računi plačljivo Povzetek,
Accounts Receivable,Terjatve,
Accounts Receivable Summary,Povzetek terjatev,
Accounts User,Računi uporabnikov,
Accounts table cannot be blank.,Predstavlja tabela ne more biti prazno.,
Accrual Journal Entry for salaries from {0} to {1},Vpis v časopisni razgovor za plače od {0} do {1},
Accumulated Depreciation,Bilančni Amortizacija,
Accumulated Depreciation Amount,Bilančni Amortizacija Znesek,
Accumulated Depreciation as on,"Nabrano amortizacijo, na",
Accumulated Monthly,Bilančni Mesečni,
Accumulated Values,nakopičene Vrednosti,
Accumulated Values in Group Company,Akumulirane vrednosti v družbi v skupini,
Achieved ({}),Doseženo ({}),
Action,Dejanje,
Action Initialised,Ukrep je sprožen,
Actions,Dejanja,
Active,Aktivno,
Activity Cost exists for Employee {0} against Activity Type - {1},Obstaja Stroški dejavnosti za Employee {0} proti vrsti dejavnosti - {1},
Activity Cost per Employee,Stroški dejavnost na zaposlenega,
Activity Type,Vrsta dejavnosti,
Actual Cost,Dejanski stroški,
Actual Delivery Date,Dejanski datum dostave,
Actual Qty,Dejanska količina,
Actual Qty is mandatory,Dejanska količina je obvezna,
Actual Qty {0} / Waiting Qty {1},Dejanska Kol {0} / čakajoči Kol {1},
Actual Qty: Quantity available in the warehouse.,"Dejanska količina: količina, ki je na voljo v skladišču.",
Actual qty in stock,Dejanska kol v zalogi,
Actual type tax cannot be included in Item rate in row {0},Dejanska davčna vrsta ne more biti vključen v ceno postavko v vrstici {0},
Add,Dodaj,
Add / Edit Prices,Dodaj / uredi cene,
Add Comment,Dodaj komentar,
Add Customers,Dodaj stranke,
Add Employees,Dodaj Zaposleni,
Add Item,Dodaj predmet,
Add Items,Dodaj artikel,
Add Leads,Dodaj jezike,
Add Multiple Tasks,Dodaj več nalog,
Add Row,Dodaj vrstico,
Add Sales Partners,Dodaj prodajne partnerje,
Add Serial No,Dodaj Serijska št,
Add Students,Dodaj študente,
Add Suppliers,Dodaj dobavitelje,
Add Time Slots,Dodaj časovne reže,
Add Timesheets,Dodaj časovnice,
Add Timeslots,Dodaj Timeslots,
Add Users to Marketplace,Dodaj uporabnike v Marketplace,
Add a new address,Dodajte nov naslov,
Add cards or custom sections on homepage,Na domačo stran dodajte kartice ali razdelke po meri,
Add more items or open full form,Dodajte več predmetov ali odprto popolno obliko,
Add notes,Dodajte opombe,
Add the rest of your organization as your users. You can also add invite Customers to your portal by adding them from Contacts,Dodajte preostanek organizacije kot uporabnike. Dodate lahko tudi povabi stranke na vašem portalu jih dodate iz imenika,
Add to Details,Dodaj v podrobnosti,
Add/Remove Recipients,Dodaj / odstrani prejemnike,
Added,Dodano,
Added to details,Dodano v podrobnosti,
Added {0} users,Dodal {0} uporabnike,
Additional Salary Component Exists.,Dodatne komponente plače obstajajo.,
Address,Naslov,
Address Line 2,Naslov Line 2,
Address Name,naslov Ime,
Address Title,Naslov Naslov,
Address Type,Naslov Type,
Administrative Expenses,Administrativni stroški,
Administrative Officer,Upravni uradnik,
Administrator,Administrator,
Admission,Sprejem,
Admission and Enrollment,Vpis in vpis,
Admissions for {0},Vstopnine za {0},
Admit,Priznaj,
Admitted,priznal,
Advance Amount,Advance Znesek,
Advance Payments,Predplačila,
Advance account currency should be same as company currency {0},Predplačilna valuta mora biti enaka valuti podjetja {0},
Advance amount cannot be greater than {0} {1},Advance znesek ne sme biti večja od {0} {1},
Advertising,Oglaševanje,
Aerospace,Aerospace,
Against,Proti,
Against Account,Proti račun,
Against Journal Entry {0} does not have any unmatched {1} entry,Proti listu Začetek {0} nima neprimerljivo {1} vnos,
Against Journal Entry {0} is already adjusted against some other voucher,Proti listu Začetek {0} je že prilagojena proti neki drugi kupon,
Against Supplier Invoice {0} dated {1},Zoper dobavitelja Račun {0} dne {1},
Against Voucher,Proti Voucher,
Against Voucher Type,Proti bon Type,
Age,Starost,
Age (Days),Starost (dnevi),
Ageing Based On,"Staranje, ki temelji na",
Ageing Range 1,Staranje Razpon 1,
Ageing Range 2,Staranje Razpon 2,
Ageing Range 3,Staranje Območje 3,
Agriculture,Kmetijstvo,
Agriculture (beta),Kmetijstvo (beta),
Airline,Airline,
All Accounts,Vsi računi,
All Addresses.,Vsi naslovi.,
All Assessment Groups,Vse skupine za ocenjevanje,
All BOMs,Vse BOMs,
All Contacts.,Vsi stiki.,
All Customer Groups,Vse skupine strank,
All Day,Cel dan,
All Departments,Vsi oddelki,
All Healthcare Service Units,Vse enote zdravstvenega varstva,
All Item Groups,Vse Postavka Skupine,
All Jobs,Vsa delovna mesta,
All Products,Vsi izdelki,
All Products or Services.,Vse izdelke ali storitve.,
All Student Admissions,Vse Študentski Sprejemi,
All Supplier Groups,Vse skupine dobaviteljev,
All Supplier scorecards.,Vse ocenjevalne table dobaviteljev.,
All Territories,Vse Territories,
All Warehouses,Vse Skladišča,
All communications including and above this shall be moved into the new Issue,"Vsa sporočila, vključno z in nad tem, se premaknejo v novo številko",
All items have already been transferred for this Work Order.,Vsi elementi so bili že preneseni za ta delovni nalog.,
All other ITC,Vsi ostali ITC,
All the mandatory Task for employee creation hasn't been done yet.,Vsa obvezna naloga za ustvarjanje zaposlenih še ni bila opravljena.,
Allocate Payment Amount,Dodeli znesek plačila,
Allocated Amount,Dodeljen znesek,
Allocated Leaves,Dodeljeni listi,
Allocating leaves...,Dodeljevanje listov ...,
Already record exists for the item {0},Že obstaja zapis za postavko {0},
"Already set default in pos profile {0} for user {1}, kindly disabled default","Že nastavljeno privzeto v profilu pos {0} za uporabnika {1}, prijazno onemogočeno privzeto",
Alternate Item,Nadomestna postavka,
Alternative item must not be same as item code,Alternativna postavka ne sme biti enaka kot oznaka izdelka,
Amended From,Spremenjeni Od,
Amount,Znesek,
Amount After Depreciation,Znesek Po amortizacijo,
Amount of Integrated Tax,Znesek integriranega davka,
Amount of TDS Deducted,Znesek TDS odbitega,
Amount should not be less than zero.,Znesek ne sme biti manjši od nič.,
Amount to Bill,Znesek za Bill,
Amount {0} {1} against {2} {3},Znesek {0} {1} proti {2} {3},
Amount {0} {1} deducted against {2},Znesek {0} {1} odšteti pred {2},
Amount {0} {1} transferred from {2} to {3},Znesek {0} {1} je preselil iz {2} na {3},
Amount {0} {1} {2} {3},Znesek {0} {1} {2} {3},
Amt,Amt,
"An Item Group exists with same name, please change the item name or rename the item group","Element, skupina obstaja z istim imenom, vas prosimo, spremenite ime elementa ali preimenovati skupino element",
An academic term with this 'Academic Year' {0} and 'Term Name' {1} already exists. Please modify these entries and try again.,"Akademski izraz s tem &quot;študijskem letu &#39;{0} in&quot; Trajanje Ime&#39; {1} že obstaja. Prosimo, spremenite te vnose in poskusite znova.",
An error occurred during the update process,Pri postopku posodabljanja je prišlo do napake,
"An item exists with same name ({0}), please change the item group name or rename the item","Element obstaja z istim imenom ({0}), prosimo, spremenite ime postavka skupine ali preimenovanje postavke",
Analyst,Analitik,
Analytics,Analytics,
Annual Billing: {0},Letni obračun: {0},
Annual Salary,Letne plače,
Anonymous,Anonimno,
Another Budget record '{0}' already exists against {1} '{2}' and account '{3}' for fiscal year {4},Drugi proračunski zapis &#39;{0}&#39; že obstaja {1} &#39;{2}&#39; in račun &#39;{3}&#39; za proračunsko leto {4},
Another Period Closing Entry {0} has been made after {1},Drug zaključnem obdobju Začetek {0} je bil dosežen po {1},
Another Sales Person {0} exists with the same Employee id,Obstaja še ena Sales Oseba {0} z enako id zaposlenih,
Antibiotic,Antibiotik,
Apparel & Accessories,Oblačila in dodatki,
Applicable For,Velja za,
"Applicable if the company is SpA, SApA or SRL","Uporablja se, če je podjetje SpA, SApA ali SRL",
Applicable if the company is a limited liability company,"Uporablja se, če je družba z omejeno odgovornostjo",
Applicable if the company is an Individual or a Proprietorship,"Uporablja se, če je podjetje posameznik ali lastnik",
Applicant,Vlagatelj,
Applicant Type,Vrsta vlagatelja,
Application of Funds (Assets),Uporaba sredstev (sredstva),
Application period cannot be across two allocation records,Obdobje uporabe ne more biti v dveh evidencah dodelitve,
Application period cannot be outside leave allocation period,Prijavni rok ne more biti obdobje dodelitve izven dopusta,
Applied,Applied,
Apply Now,Prijavi se zdaj,
Appointment Confirmation,Potrditev imenovanja,
Appointment Duration (mins),Trajanje imenovanja (min),
Appointment Type,Vrsta imenovanja,
Appointment {0} and Sales Invoice {1} cancelled,Imenovanje {0} in račun za prodajo {1} sta bila preklicana,
Appointments and Encounters,Imenovanja in srečanja,
Appointments and Patient Encounters,Imenovanja in srečanja s pacienti,
Appraisal {0} created for Employee {1} in the given date range,Cenitev {0} ustvarjena za Employee {1} v določenem časovnem obdobju,
Apprentice,Vajenec,
Approval Status,Stanje odobritve,
Approval Status must be 'Approved' or 'Rejected',Stanje odobritve mora biti &quot;Approved&quot; ali &quot;Zavrnjeno&quot;,
Approve,Odobri,
Approving Role cannot be same as role the rule is Applicable To,"Odobritvi vloge ne more biti enaka kot vloga je pravilo, ki veljajo za",
Approving User cannot be same as user the rule is Applicable To,"Odobritvi Uporabnik ne more biti isto kot uporabnika je pravilo, ki veljajo za",
"Apps using current key won't be able to access, are you sure?","Aplikacije, ki uporabljajo trenutni ključ, ne bodo imele dostopa, ali ste prepričani?",
Are you sure you want to cancel this appointment?,"Ali ste prepričani, da želite preklicati ta sestanek?",
Arrear,arrear,
As Examiner,Kot preizkuševalec,
As On Date,Kot na datum,
As Supervisor,Kot nadzornik,
As per rules 42 & 43 of CGST Rules,Po pravilih 42 in 43 pravil CGST,
As per section 17(5),Po oddelku 17 (5),
As per your assigned Salary Structure you cannot apply for benefits,Glede na dodeljeno strukturo plače ne morete zaprositi za ugodnosti,
Assessment,Ocena,
Assessment Criteria,Merila ocenjevanja,
Assessment Group,Skupina ocena,
Assessment Group: ,Ocenjevalna skupina:,
Assessment Plan,Načrt ocenjevanja,
Assessment Plan Name,Ime načrta ocenjevanja,
Assessment Report,Ocenjevalno poročilo,
Assessment Reports,Poročila o oceni,
Assessment Result,ocena Rezultat,
Assessment Result record {0} already exists.,Ocenjevanje Rezultat zapisa {0} že obstaja.,
Asset,Asset,
Asset Category,sredstvo Kategorija,
Asset Category is mandatory for Fixed Asset item,Sredstvo kategorije je obvezna za fiksno postavko sredstev,
Asset Maintenance,Vzdrževanje sredstev,
Asset Movement,Gibanje sredstvo,
Asset Movement record {0} created,zapis Gibanje sredstvo {0} ustvaril,
Asset Name,Ime sredstvo,
Asset Received But Not Billed,"Prejeta sredstva, vendar ne zaračunana",
Asset Value Adjustment,Prilagoditev vrednosti sredstva,
"Asset cannot be cancelled, as it is already {0}","Sredstvo ni mogoče preklicati, saj je že {0}",
Asset scrapped via Journal Entry {0},Sredstvo izločeni preko Journal Entry {0},
"Asset {0} cannot be scrapped, as it is already {1}","Sredstvo {0} ne more biti izločeni, saj je že {1}",
Asset {0} does not belong to company {1},Sredstvo {0} ne pripada družbi {1},
Asset {0} must be submitted,Sredstvo {0} je treba predložiti,
Assets,Sredstva,
Assign,Dodeli,
Assign Salary Structure,Dodeli strukturo plač,
Assign To,Dodeli,
Assign to Employees,Dodeljeno zaposlenim,
Assigning Structures...,Dodeljujem strukture...,
Associate,Sodelavec,
At least one mode of payment is required for POS invoice.,za POS računa je potreben vsaj en način plačila.,
Atleast one item should be entered with negative quantity in return document,"Atleast en element, se vpiše z negativnim količino v povratni dokument",
Atleast one of the Selling or Buying must be selected,Mora biti izbran Atleast eden prodaji ali nakupu,
Atleast one warehouse is mandatory,Atleast eno skladišče je obvezna,
Attach Logo,Priložite Logo,
Attachment,Attachment,
Attachments,Priponke,
Attendance,Udeležba,
Attendance From Date and Attendance To Date is mandatory,Udeležba Od datuma in udeležba na Datum je obvezna,
Attendance can not be marked for future dates,Udeležba ni mogoče označiti za prihodnje datume,
Attendance date can not be less than employee's joining date,Datum udeležba ne sme biti manjša od povezuje datumu zaposlenega,
Attendance for employee {0} is already marked,Udeležba na zaposlenega {0} je že označeno,
Attendance for employee {0} is already marked for this day,Udeležba na zaposlenega {0} je že označen za ta dan,
Attendance has been marked successfully.,Udeležba je bila uspešno označena.,
Attendance not submitted for {0} as it is a Holiday.,"Udeležba ni bila oddana za {0}, ker je praznik.",
Attendance not submitted for {0} as {1} on leave.,Udeležba ni potrjena {0} kot {1} na dopustu.,
Attribute table is mandatory,Lastnost miza je obvezna,
Attribute {0} selected multiple times in Attributes Table,Lastnost {0} izbrana večkrat v atributih tabeli,
Author,Avtor,
Authorized Signatory,Pooblaščeni podpisnik,
Auto Material Requests Generated,Auto Material Zahteve Izdelano,
Auto Repeat,Samodejno ponavljanje,
Auto repeat document updated,Posodobljen samodejno ponavljanje dokumenta,
Automotive,Avtomobilizem,
Available,Na voljo,
Available Leaves,Na voljo listi,
Available Qty,Na voljo Količina,
Available Selling,Razpoložljiva prodaja,
Available for use date is required,Potreben je datum uporabe,
Available slots,Razpoložljive slote,
Available {0},Na voljo {0},
Available-for-use Date should be after purchase date,"Datum, ki je na voljo za uporabo, mora biti po datumu nakupa",
Average Age,Povprečna starost,
Average Rate,Povprečna hitrost,
Avg Daily Outgoing,Avg Daily Odhodni,
Avg. Buying Price List Rate,Povpr. Nakup cenik seznam,
Avg. Selling Price List Rate,Povpr. Prodajna cenik tečaja,
Avg. Selling Rate,Avg. Prodajni tečaj,
BOM,Surovine,
BOM Browser,BOM Browser,
BOM No,BOM Ne,
BOM Rate,BOM Rate,
BOM Stock Report,BOM Stock Poročilo,
BOM and Manufacturing Quantity are required,BOM and Manufacturing Količina so obvezna,
BOM does not contain any stock item,BOM ne vsebuje nobenega elementa zaloge,
BOM {0} does not belong to Item {1},BOM {0} ne pripada postavki {1},
BOM {0} must be active,Surovina {0} mora biti aktivna,
BOM {0} must be submitted,Surovino {0} je potrebno predložiti,
Balance,Bilanca,
Balance (Dr - Cr),Ravnotežje (Dr - Cr),
Balance ({0}),Stanje ({0}),
Balance Qty,Balance Kol,
Balance Sheet,Bilanca stanja,
Balance Value,Balance Vrednost,
Balance for Account {0} must always be {1},"Saldo račun {0}, morajo biti vedno {1}",
Bank,Banka,
Bank Account,Bančni račun,
Bank Accounts,Bančni računi,
Bank Draft,Bank Osnutek,
Bank Entries,Bančni vnosi,
Bank Name,Ime banke,
Bank Overdraft Account,Bančnem računu računa,
Bank Reconciliation,Banka Sprava,
Bank Reconciliation Statement,Izjava Bank Sprava,
Bank Statement,Bančni izpisek,
Bank Statement Settings,Nastavitve bančne izjave,
Bank Statement balance as per General Ledger,Banka Izjava ravnotežje kot na glavno knjigo,
Bank account cannot be named as {0},Bančni račun ne more biti imenovan kot {0},
Bank/Cash transactions against party or for internal transfer,Bank / denarni posli proti osebi ali za notranjo prerazporeditvijo,
Banking,Bančništvo,
Banking and Payments,Bančništvo in plačila,
Barcode {0} already used in Item {1},Barcode {0} že uporabljajo v postavki {1},
Barcode {0} is not a valid {1} code,Črtna koda {0} ni veljavna {1} koda,
Base,Osnovna,
Base URL,Osnovni URL,
Based On,Temelji na,
Based On Payment Terms,Na podlagi plačilnih pogojev,
Basic,Osnovni,
Batch,Serija,
Batch Entries,Vstopne serije,
Batch ID is mandatory,Serija ID je obvezen,
Batch Inventory,Serija Inventory,
Batch Name,serija Ime,
Batch No,Serija Ne,
Batch number is mandatory for Item {0},Serijska številka je obvezna za postavko {0},
Batch {0} of Item {1} has expired.,Serija {0} od Postavka {1} je potekla.,
Batch {0} of Item {1} is disabled.,Paket {0} postavke {1} je onemogočen.,
Batch: ,Serija:,
Batches,Paketi,
Become a Seller,Postanite prodajalec,
Beginner,začetnik,
Bill,Bill,
Bill Date,Bill Datum,
Bill No,Bill Ne,
Bill of Materials,Kosovnica,
Bill of Materials (BOM),Kosovnica (BOM),
Billable Hours,Obračunske ure,
Billed,Zaračunavajo,
Billed Amount,Zaračunavajo Znesek,
Billing,Zaračunavanje,
Billing Address,Naslov za pošiljanje računa,
Billing Address is same as Shipping Address,Naslov za izstavitev računa je isti kot naslov za pošiljanje,
Billing Amount,Zaračunavanje Znesek,
Billing Status,Status zaračunavanje,
Billing currency must be equal to either default company's currency or party account currency,Valuta za obračun mora biti enaka valuti podjetja ali valuti stranke,
Bills raised by Suppliers.,"Računi, ki jih dobavitelji postavljeno.",
Bills raised to Customers.,Računi zbrana strankam.,
Biotechnology,Biotehnologija,
Birthday Reminder,Opomnik za rojstni dan,
Black,Črna,
Blanket Orders from Costumers.,Odeja naročila od kupcev.,
Block Invoice,Blokiraj račun,
Boms,Boms,
Bonus Payment Date cannot be a past date,Datum plačila bonusa ne more biti pretekli datum,
Both Trial Period Start Date and Trial Period End Date must be set,Določiti je treba začetni datum preizkusnega obdobja in datum konca poskusnega obdobja,
Both Warehouse must belong to same Company,Oba Skladišče mora pripadati isti družbi,
Branch,Podružnica,
Broadcasting,Broadcasting,
Brokerage,Posredništvo,
Browse BOM,Prebrskaj BOM,
Budget Against,Proračun proti,
Budget List,Proračunski seznam,
Budget Variance Report,Proračun Varianca Poročilo,
Budget cannot be assigned against Group Account {0},Proračun ne more biti dodeljena pred Group račun {0},
"Budget cannot be assigned against {0}, as it's not an Income or Expense account","Proračun ne more biti dodeljena pred {0}, ker to ni prihodek ali odhodek račun",
Buildings,Zgradbe,
Bundle items at time of sale.,Bundle predmeti v času prodaje.,
Business Development Manager,Business Development Manager,
Buy,Nakup,
Buying,Nabava,
Buying Amount,Znesek nabave,
Buying Price List,Nakupni cenik,
Buying Rate,Nakupna cena,
"Buying must be checked, if Applicable For is selected as {0}","Odkup je treba preveriti, če se uporablja za izbrana kot {0}",
By {0},Do {0},
Bypass credit check at Sales Order ,Bypass preverjanje kredita na prodajnem naročilu,
C-Form records,Zapisi C-Form,
C-form is not applicable for Invoice: {0},C-oblika ne velja za računa: {0},
CEO,direktor,
CESS Amount,CESS Znesek,
CGST Amount,CGST Znesek,
CRM,CRM,
CWIP Account,Račun CWIP,
Calculated Bank Statement balance,Izračunan Izjava bilance banke,
Calls,Poziva,
Campaign,Kampanja,
Can be approved by {0},Mogoče odobriti {0},
"Can not filter based on Account, if grouped by Account","Filter ne more temeljiti na račun, če je združena s račun",
"Can not filter based on Voucher No, if grouped by Voucher","Filter ne more temeljiti na kupona št, če je združena s Voucher",
"Can not mark Inpatient Record Discharged, there are Unbilled Invoices {0}","Označevanje bolnišničnega zapisa ni mogoče označiti kot prazno, obstajajo neizbrisani računi {0}",
Can only make payment against unbilled {0},Lahko le plačilo proti neobračunano {0},
Can refer row only if the charge type is 'On Previous Row Amount' or 'Previous Row Total',"Lahko sklicuje vrstico le, če je tip naboj &quot;Na prejšnje vrstice Znesek&quot; ali &quot;prejšnje vrstice Total&quot;",
"Can't change valuation method, as there are transactions against some items which does not have it's own valuation method","ne more spremeniti metode vrednotenja, kot so transakcije pred nekaj elementov, ki ga ne imeti svojo lastno metodo vrednotenja",
Can't create standard criteria. Please rename the criteria,Ne morem ustvariti standardnih meril. Preimenujte merila,
Cancel,Prekliči,
Cancel Material Visit {0} before cancelling this Warranty Claim,Opusti Material obisk {0} pred preklicem te garancije,
Cancel Material Visits {0} before cancelling this Maintenance Visit,Preklic Material Obiski {0} pred preklicem to vzdrževanje obisk,
Cancel Subscription,Prekliči naročnino,
Cancel the journal entry {0} first,Najprej prekličite vnos v dnevnik {0},
Canceled,Prekinjeno,
"Cannot Submit, Employees left to mark attendance","Ni mogoče poslati, zaposleni so pustili, da označijo udeležbo",
Cannot be a fixed asset item as Stock Ledger is created.,"Ne more biti postavka osnovnega sredstva, kot je ustvarjena knjiga zalog.",
Cannot cancel because submitted Stock Entry {0} exists,"Ni mogoče preklicati, ker je predložila Stock Začetek {0} obstaja",
Cannot cancel transaction for Completed Work Order.,Transakcije za zaključeno delovno nalogo ni mogoče preklicati.,
Cannot cancel {0} {1} because Serial No {2} does not belong to the warehouse {3},"Ni mogoče preklicati {0} {1}, ker serijska številka {2} ne pripada skladišču {3}",
Cannot change Attributes after stock transaction. Make a new Item and transfer stock to the new Item,Ne morem spremeniti atributov po transakciji z delnicami. Na novo postavko naredite nov element in prenesite zalogo,
Cannot change Fiscal Year Start Date and Fiscal Year End Date once the Fiscal Year is saved.,"Ne more spremeniti poslovno leto začetni datum in fiskalnem letu End Datum, ko je poslovno leto shranjen.",
Cannot change Service Stop Date for item in row {0},Datum zaustavitve storitve ni mogoče spremeniti za predmet v vrstici {0},
Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,Lastnosti variant ni mogoče spremeniti po transakciji z delnicami. Za to morate narediti novo postavko.,
"Cannot change company's default currency, because there are existing transactions. Transactions must be cancelled to change the default currency.","Ne more spremeniti privzeto valuto družbe, saj so obstoječi posli. Transakcije se treba odpovedati, da spremenite privzeto valuto.",
Cannot change status as student {0} is linked with student application {1},"status študenta, ne more spremeniti {0} je povezana z uporabo študentskega {1}",
Cannot convert Cost Center to ledger as it has child nodes,"Ni mogoče pretvoriti v stroškovni center za knjigo, saj ima otrok vozlišč",
Cannot covert to Group because Account Type is selected.,"Ne more prikrite skupini, saj je izbrana vrsta računa.",
Cannot create Retention Bonus for left Employees,Ne morete ustvariti zadrževalnega bonusa za leve zaposlene,
Cannot create a Delivery Trip from Draft documents.,Iz osnutkov dokumentov ni mogoče ustvariti potovanja.,
Cannot deactivate or cancel BOM as it is linked with other BOMs,Ne more izključiti ali preklicati BOM saj je povezan z drugimi BOMs,
"Cannot declare as lost, because Quotation has been made.","Ne more razglasiti kot izgubljena, ker je bil predračun postavil.",
Cannot deduct when category is for 'Valuation' or 'Valuation and Total',"Ne more odbiti, če je kategorija za &quot;vrednotenje&quot; ali &quot;Vrednotenje in Total&quot;",
Cannot deduct when category is for 'Valuation' or 'Vaulation and Total',"ne more odbiti, če je kategorija za &quot;vrednotenje&quot; ali &quot;Vaulation in Total&quot;",
"Cannot delete Serial No {0}, as it is used in stock transactions","Ne morem izbrisati Serijska št {0}, saj je uporabljen v transakcijah zalogi",
Cannot enroll more than {0} students for this student group.,ne more vpisati več kot {0} študentov za to študentsko skupino.,
Cannot find active Leave Period,Aktivnega obdobja puščanja ni mogoče najti,
Cannot produce more Item {0} than Sales Order quantity {1},Ne more proizvajati več item {0} od prodaje kol {1},
Cannot promote Employee with status Left,Zaposlenca s statusom Levo ni mogoče spodbujati,
Cannot refer row number greater than or equal to current row number for this Charge type,Ne more sklicevati številko vrstice večja ali enaka do trenutne številke vrstice za to vrsto Charge,
Cannot select charge type as 'On Previous Row Amount' or 'On Previous Row Total' for first row,Ne morete izbrati vrsto naboja kot &quot;On prejšnje vrstice Znesek&quot; ali &quot;Na prejšnje vrstice Total&quot; za prvi vrsti,
Cannot set as Lost as Sales Order is made.,"Ni mogoče nastaviti kot izgubili, kot je narejena Sales Order.",
Cannot set authorization on basis of Discount for {0},Ni mogoče nastaviti dovoljenja na podlagi popust za {0},
Cannot set multiple Item Defaults for a company.,Ne morete nastaviti več privzetih postavk za podjetje.,
Cannot set quantity less than delivered quantity,"Količine ni mogoče nastaviti, kot je bila dobavljena količina",
Cannot set quantity less than received quantity,Količine ni mogoče nastaviti manj kot prejeto količino,
Cannot set the field <b>{0}</b> for copying in variants,Polja <b>{0}</b> ni mogoče nastaviti za kopiranje v različicah,
Cannot transfer Employee with status Left,Uslužbenca ni mogoče prenesti s statusom Levo,
Cannot {0} {1} {2} without any negative outstanding invoice,"Ne more {0} {1} {2}, brez kakršne koli negativne izjemno račun",
Capital Equipments,Kapitalski Oprema,
Capital Stock,Osnovni kapital,
Capital Work in Progress,Kapitalsko delo v teku,
Cart,Košarica,
Cart is Empty,Košarica je prazna,
Case No(s) already in use. Try from Case No {0},Zadeva št (y) že v uporabi. Poskusite z zadevo št {0},
Cash,Gotovina,
Cash Flow Statement,Izkaz denarnih tokov,
Cash Flow from Financing,Denarni tok iz financiranja,
Cash Flow from Investing,Denarni tokovi iz naložbenja,
Cash Flow from Operations,Denarni tok iz poslovanja,
Cash In Hand,Denarna sredstva v blagajni,
Cash or Bank Account is mandatory for making payment entry,Gotovina ali bančnega računa je obvezen za izdelavo vnos plačila,
Cashier Closing,Zaprta blagajna,
Casual Leave,Casual Zapusti,
Category,Kategorija,
Category Name,Ime kategorije,
Caution,Previdno,
Central Tax,Centralni davek,
Certification,Certificiranje,
Cess,Cess,
Change Amount,Znesek spremembe,
Change Item Code,Koda postavke spremenite,
Change Release Date,Sprememba datuma izdaje,
Change Template Code,Spremeni kodo šablone,
Changing Customer Group for the selected Customer is not allowed.,Spreminjanje skupine strank za izbrano stranko ni dovoljeno.,
Chapter,Poglavje,
Chapter information.,Podatki o poglavju.,
Charge of type 'Actual' in row {0} cannot be included in Item Rate,Naboj tip &quot;Dejanski&quot; v vrstici {0} ni mogoče vključiti v postavko Rate,
Chargeble,Polnilna,
Charges are updated in Purchase Receipt against each item,Dajatve so posodobljeni v Potrdilo o nakupu ob vsaki postavki,
"Charges will be distributed proportionately based on item qty or amount, as per your selection","Dajatve bodo razdeljeni sorazmerno na podlagi postavka Kol ali znesek, glede na vašo izbiro",
Chart of Cost Centers,Grafikon stroškovnih mest,
Check all,Preveri vse,
Checkout,Naročilo,
Chemical,Chemical,
Cheque,Ček,
Cheque/Reference No,Ček / referenčna številka,
Cheques Required,Potrebna je preverjanja,
Cheques and Deposits incorrectly cleared,Čeki in depoziti nepravilno izbil,
Child Task exists for this Task. You can not delete this Task.,Otroška naloga obstaja za to nalogo. Te naloge ne morete izbrisati.,
Child nodes can be only created under 'Group' type nodes,Otroški vozlišča lahko ustvari samo na podlagi tipa vozlišča &quot;skupina&quot;,
Child warehouse exists for this warehouse. You can not delete this warehouse.,"Otrok skladišče obstaja za to skladišče. Ne, ne moreš izbrisati to skladišče.",
Circular Reference Error,Krožna Reference Error,
City,Mesto,
City/Town,Mesto / Kraj,
Claimed Amount,Zahtevani znesek,
Clay,Glina,
Clear filters,Počistite filtre,
Clear values,Jasne vrednosti,
Clearance Date,Potrditev Datum,
Clearance Date not mentioned,Potrditev Datum ni omenjena,
Clearance Date updated,Potrditev Datum posodobljeni,
Client,Client,
Client ID,ID stranke,
Client Secret,Naročnik Secret,
Clinical Procedure,Klinični postopek,
Clinical Procedure Template,Klinična proceduralna predloga,
Close Balance Sheet and book Profit or Loss.,Zapri Bilanca stanja in rezervirajte poslovnem izidu.,
Close Loan,Zaprite posojilo,
Close the POS,Zaprite POS,
Closed,Zaprto,
Closed order cannot be cancelled. Unclose to cancel.,Zaprta naročila ni mogoče preklicati. Unclose za preklic.,
Closing (Cr),Zapiranje (Cr),
Closing (Dr),Zapiranje (Dr),
Closing (Opening + Total),Zapiranje (odpiranje + skupno),
Closing Account {0} must be of type Liability / Equity,Zapiranje račun {0} mora biti tipa odgovornosti / kapital,
Closing Balance,Zaključni saldo,
Code,Koda,
Collapse All,Strniti vse,
Color,Barva,
Colour,Barva,
Combined invoice portion must equal 100%,Kombinirani del na računu mora biti enak 100%,
Commercial,Commercial,
Commission,Komisija,
Commission Rate %,Stopnja Komisije%,
Commission on Sales,Komisija za prodajo,
Commission rate cannot be greater than 100,Stopnja Komisija ne more biti večja od 100,
Community Forum,Forum Skupnost,
Company (not Customer or Supplier) master.,Company (ne stranka ali dobavitelj) gospodar.,
Company Abbreviation,Kratica podjetja,
Company Abbreviation cannot have more than 5 characters,Kratica podjetja ne sme imeti več kot 5 znakov,
Company Name,ime podjetja,
Company Name cannot be Company,Ime podjetja ne more biti podjetje,
Company currencies of both the companies should match for Inter Company Transactions.,Valutne družbe obeh družb se morajo ujemati s transakcijami Inter Company.,
Company is manadatory for company account,Podjetje je manipulativno za račun podjetja,
Company name not same,Ime podjetja ni isto,
Company {0} does not exist,Podjetje {0} ne obstaja,
Compensatory Off,Kompenzacijske Off,
Compensatory leave request days not in valid holidays,Zahtevki za nadomestni dopust ne veljajo v veljavnih praznikih,
Complaint,Pritožba,
Completion Date,datum dokončanja,
Computer,Računalnik,
Condition,Pogoj,
Configure,Konfigurirajte,
Configure {0},Konfigurirajte {0},
Confirmed orders from Customers.,Potrjena naročila od strank.,
Connect Amazon with ERPNext,Povežite Amazon z ERPNext,
Connect Shopify with ERPNext,Poveži Shopify z ERPNext,
Connect to Quickbooks,Povežite se s QuickBooks,
Connected to QuickBooks,Povezava na QuickBooks,
Connecting to QuickBooks,Povezava na QuickBooks,
Consultation,Posvetovanje,
Consultations,Posvetovanja,
Consulting,Consulting,
Consumable,Potrošni,
Consumed,Porabljeno,
Consumed Amount,Porabljeni znesek,
Consumed Qty,Porabljeno Kol,
Consumer Products,Consumer Products,
Contact,Kontakt,
Contact Details,Kontaktni podatki,
Contact Number,Kontaktna številka,
Contact Us,Kontaktiraj nas,
Content,Vsebina,
Content Masters,Vsebine,
Content Type,Vrsta vsebine,
Continue Configuration,Nadaljujte s konfiguracijo,
Contract,Pogodba,
Contract End Date must be greater than Date of Joining,Naročilo Končni datum mora biti večja od Datum pridružitve,
Contribution %,Prispevek%,
Contribution Amount,Prispevek Znesek,
Conversion factor for default Unit of Measure must be 1 in row {0},"Faktor pretvorbe za privzeto mersko enoto, mora biti 1 v vrstici {0}",
Conversion rate cannot be 0 or 1,Menjalno razmerje ne more biti 0 ali 1,
Convert to Group,Pretvarjanje skupini,
Convert to Non-Group,"Pretvarjanje, da non-Group",
Cosmetics,Kozmetika,
Cost Center,Stroškovno Center,
Cost Center Number,Številka stroškovnega centra,
Cost Center and Budgeting,Mesto stroškov in oblikovanje proračuna,
Cost Center is required in row {0} in Taxes table for type {1},"Stroškov Center, je potrebno v vrstici {0} v Davki miza za tip {1}",
Cost Center with existing transactions can not be converted to group,Stroškovno Center z obstoječimi transakcij ni mogoče pretvoriti v skupini,
Cost Center with existing transactions can not be converted to ledger,Stroškovno Center z obstoječimi transakcij ni mogoče pretvoriti v knjigo terjatev,
Cost Centers,Stroškovna mesta,
Cost Updated,Stroškovno Posodobljeno,
Cost as on,Stane na,
Cost of Delivered Items,Nabavna vrednost dobavljenega predmeta,
Cost of Goods Sold,Nabavna vrednost prodanega blaga,
Cost of Issued Items,Strošek izdanih postavk,
Cost of New Purchase,Stroški New Nakup,
Cost of Purchased Items,Vrednost kupljenih artiklov,
Cost of Scrapped Asset,Stroški izločeni sredstvi,
Cost of Sold Asset,Stroški Prodano sredstvi,
Cost of various activities,Stroške različnih dejavnosti,
"Could not create Credit Note automatically, please uncheck 'Issue Credit Note' and submit again","Samodejno ustvarjanje kreditne kartice ni bilo mogoče samodejno ustvariti, počistite potrditveno polje »Issue Credit Credit« in znova pošljite",
Could not generate Secret,Ni mogoče ustvariti Skrivnosti,
Could not retrieve information for {0}.,Podatkov za {0} ni bilo mogoče pridobiti.,
Could not solve criteria score function for {0}. Make sure the formula is valid.,"Za {0} ni bilo mogoče rešiti funkcije ocene rezultatov. Prepričajte se, da formula velja.",
Could not solve weighted score function. Make sure the formula is valid.,"Funkcije uteženih rezultatov ni bilo mogoče rešiti. Prepričajte se, da formula velja.",
Could not submit some Salary Slips,Ne morem poslati nekaterih plačnih lističev,
"Could not update stock, invoice contains drop shipping item.","Ni mogel posodobiti vozni park, faktura vsebuje padec element ladijskega prometa.",
Country wise default Address Templates,Država pametno privzeti naslov Predloge,
Course,Tečaj,
Course Code: ,Šifra predmeta:,
Course Enrollment {0} does not exists,Vpis na tečaj {0} ne obstaja,
Course Schedule,Razpored za golf,
Course: ,Tečaj:,
Cr,Cr,
Create,Ustvari,
Create BOM,Ustvari BOM,
Create Delivery Trip,Ustvari dostavo,
Create Disbursement Entry,Ustvari vnos izplačil,
Create Employee,Ustvari zaposlenega,
Create Employee Records,Ustvari zaposlencev zapisov,
"Create Employee records to manage leaves, expense claims and payroll","Ustvarjanje zapisov zaposlencev za upravljanje listje, odhodkov terjatev in na izplačane plače",
Create Fee Schedule,Ustvari urnik pristojbin,
Create Fees,Ustvari pristojbine,
Create Inter Company Journal Entry,Ustvari vpis v revijo Inter Company,
Create Invoice,Ustvari račun,
Create Invoices,Ustvari račune,
Create Job Card,Ustvari Job Card,
Create Journal Entry,Ustvari vnos v časopis,
Create Lead,Ustvari potencial,
Create Leads,Ustvari Interesenti,
Create Maintenance Visit,Ustvari obisk vzdrževanja,
Create Material Request,Ustvari materialno zahtevo,
Create Multiple,Ustvari večkrat,
Create Opening Sales and Purchase Invoices,Ustvarite začetne račune za prodajo in nakup,
Create Payment Entries,Ustvari plačilne vnose,
Create Payment Entry,Ustvari plačilo,
Create Print Format,Ustvari Print Format,
Create Purchase Order,Ustvarite naročilnico,
Create Purchase Orders,Ustvari naročilnice,
Create Quotation,Ustvarite predračun,
Create Salary Slip,Ustvarite plačilnega lista,
Create Salary Slips,Ustvarite plači,
Create Sales Invoice,Ustvari prodajni račun,
Create Sales Order,Ustvari prodajno naročilo,
Create Sales Orders to help you plan your work and deliver on-time,"Ustvarite prodajna naročila, ki vam bodo pomagala načrtovati delo in dostaviti pravočasno",
Create Sample Retention Stock Entry,Ustvari vnos zalog za vzorčenje,
Create Student,Ustvari študenta,
Create Student Batch,Ustvari študentsko serijo,
Create Student Groups,Ustvarjanje skupin študentov,
Create Supplier Quotation,Ustvari ponudbo,
Create Tax Template,Ustvari davčno predlogo,
Create Timesheet,Ustvari časopis,
Create User,Ustvari uporabnika,
Create Users,Ustvari uporabnike,
Create Variant,Ustvari varianto,
Create Variants,Ustvari različice,
"Create and manage daily, weekly and monthly email digests.","Ustvarjanje in upravljanje dnevne, tedenske in mesečne email prebavlja.",
Create customer quotes,Ustvari ponudbe kupcev,
Create rules to restrict transactions based on values.,"Ustvarite pravila za omejitev transakcije, ki temeljijo na vrednotah.",
Created {0} scorecards for {1} between: ,Ustvarjene {0} kazalnike za {1} med:,
Creating Company and Importing Chart of Accounts,Ustvarjanje podjetja in uvoz računa,
Creating Fees,Ustvarjanje pristojbin,
Creating Payment Entries......,Ustvarjanje plačilnih vnosov ......,
Creating Salary Slips...,Ustvarjanje plačnih lističev ...,
Creating student groups,Ustvarjanje študentskih skupin,
Creating {0} Invoice,Ustvarjanje računa {0},
Credit,Credit,
Credit ({0}),Kredit ({0}),
Credit Account,Credit račun,
Credit Balance,Kreditno stanje,
Credit Card,Credit Card,
Credit Days cannot be a negative number,Kreditni dnevi ne smejo biti negativni,
Credit Limit,Kreditni limit,
Credit Note,Dobropis,
Credit Note Amount,Credit Opomba Znesek,
Credit Note Issued,Dobropis Izdano,
Credit Note {0} has been created automatically,Kreditna kartica {0} je bila ustvarjena samodejno,
Credit limit has been crossed for customer {0} ({1}/{2}),Kreditna meja je prešla za stranko {0} ({1} / {2}),
Creditors,Upniki,
Criteria weights must add up to 100%,Uteži meril morajo biti do 100%,
Crop Cycle,Crop Crop,
Crops & Lands,Rastline in zemljišča,
Currency Exchange must be applicable for Buying or for Selling.,Menjalnica mora veljati za nakup ali prodajo.,
Currency can not be changed after making entries using some other currency,"Valuta ni mogoče spremeniti, potem ko vnose uporabljate kakšno drugo valuto",
Currency exchange rate master.,Menjalnega tečaja valute gospodar.,
Currency for {0} must be {1},Valuta za {0} mora biti {1},
Currency is required for Price List {0},Valuta je potrebna za tečajnico {0},
Currency of the Closing Account must be {0},Valuta zaključni račun mora biti {0},
Currency of the price list {0} must be {1} or {2},Valuta cenika {0} mora biti {1} ali {2},
Currency should be same as Price List Currency: {0},Valuta mora biti enaka ceni valute: {0},
Current,Trenutna,
Current Assets,Kratkoročna sredstva,
Current BOM and New BOM can not be same,Trenutni BOM in New BOM ne more biti enaka,
Current Job Openings,Razpisana delovna,
Current Liabilities,Kratkoročne obveznosti,
Current Qty,Trenutni Kol,
Current invoice {0} is missing,Trenuten račun {0} manjka,
Custom HTML,Custom HTML,
Custom?,Po meri?,
Customer,Stranka,
Customer Addresses And Contacts,Naslovi strank in kontakti,
Customer Contact,Stranka Kontakt,
Customer Database.,Baza podatkov o strankah.,
Customer Group,Skupina za stranke,
Customer LPO,Stranka LPO,
Customer LPO No.,Stranka LPO št.,
Customer Name,Ime stranke,
Customer POS Id,ID POS stranka,
Customer Service,Storitev za stranke,
Customer and Supplier,Kupec in dobavitelj,
Customer is required,Je potrebno kupca,
Customer isn't enrolled in any Loyalty Program,Stranka ni vpisana v program zvestobe,
Customer required for 'Customerwise Discount',Stranka zahteva za &quot;Customerwise popust&quot;,
Customer {0} does not belong to project {1},"Stranka {0} ne pripada, da projekt {1}",
Customer {0} is created.,Stranka {0} je ustvarjena.,
Customers in Queue,Stranke v vrsti,
Customize Homepage Sections,Prilagodite odseke domače strani,
Customizing Forms,Prilagajanje Obrazci,
Daily Project Summary for {0},Dnevni povzetek projekta za {0},
Daily Reminders,Dnevni opomniki,
Daily Work Summary,Dnevni Delo Povzetek,
Daily Work Summary Group,Skupina dnevnih del,
Data Import and Export,Uvoz in izvoz podatkov,
Data Import and Settings,Uvoz in nastavitve podatkov,
Database of potential customers.,Podatkovna baza potencialnih strank.,
Date Format,Oblika datuma,
Date Of Retirement must be greater than Date of Joining,Datum upokojitve mora biti večji od datuma pridružitve,
Date is repeated,Datum se ponovi,
Date of Birth,Datum rojstva,
Date of Birth cannot be greater than today.,"Datum rojstva ne more biti večji, od današnjega.",
Date of Commencement should be greater than Date of Incorporation,Datum začetka je večji od datuma začetka registracije,
Date of Joining,Datum pridružitve,
Date of Joining must be greater than Date of Birth,Datum pridružitva mora biti večji od datuma rojstva,
Date of Transaction,Datum transakcije,
Datetime,Datum in čas,
Day,Dan,
Debit,Debet,
Debit ({0}),Debet ({0}),
Debit A/C Number,Številka A / C,
Debit Account,Debetni račun,
Debit Note,Opomin,
Debit Note Amount,Opomin Znesek,
Debit Note Issued,Opomin Izdano,
Debit To is required,Bremenitev je potrebno,
Debit and Credit not equal for {0} #{1}. Difference is {2}.,Debetnih in kreditnih ni enaka za {0} # {1}. Razlika je {2}.,
Debtors,Dolžniki,
Debtors ({0}),Dolžniki ({0}),
Declare Lost,Razglasi izgubljenega,
Deduction,Odbitek,
Default Activity Cost exists for Activity Type - {0},Obstaja Stroški Privzeta aktivnost za vrsto dejavnosti - {0},
Default BOM ({0}) must be active for this item or its template,Privzeto BOM ({0}) mora biti aktiven za to postavko ali njeno predlogo,
Default BOM for {0} not found,Privzeti BOM za {0} ni bilo mogoče najti,
Default BOM not found for Item {0} and Project {1},Privzeti BOM nismo našli v postavki {0} in projektno {1},
Default Letter Head,Privzeta glava pisma,
Default Tax Template,Privzeta davčna predloga,
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.,"Privzeto mersko enoto za postavko {0} ni mogoče neposredno spremeniti, ker ste že naredili nekaj transakcije (-e) z drugo UOM. Boste morali ustvariti nov element, da uporabi drugačno Privzeti UOM.",
Default Unit of Measure for Variant '{0}' must be same as in Template '{1}',Privzeto mersko enoto za Variant &#39;{0}&#39; mora biti enaka kot v predlogo &#39;{1}&#39;,
Default settings for buying transactions.,Privzete nastavitve za nabavo,
Default settings for selling transactions.,Privzete nastavitve za prodajne transakcije.,
Default tax templates for sales and purchase are created.,Ustvari so privzete davčne predloge za prodajo in nakup.,
Defaults,Privzete,
Defense,Obramba,
Define Project type.,Določite vrsto projekta.,
Define budget for a financial year.,Določite proračuna za proračunsko leto.,
Define various loan types,Opredeliti različne vrste posojil,
Del,Del,
Delay in payment (Days),Zamuda pri plačilu (dnevi),
Delete all the Transactions for this Company,Izbriši vse transakcije za to družbo,
Deletion is not permitted for country {0},Brisanje ni dovoljeno za državo {0},
Delivered,Dostavljeno,
Delivered Amount,Delivered Znesek,
Delivered Qty,Delivered Kol,
Delivered: {0},Dobava: {0},
Delivery,Dostava,
Delivery Date,Datum dostave,
Delivery Note,Poročilo o dostavi,
Delivery Note {0} is not submitted,Dobavnica {0} ni predložila,
Delivery Note {0} must not be submitted,Dobavnica {0} ni treba predložiti,
Delivery Notes {0} must be cancelled before cancelling this Sales Order,Dobavnic {0} je treba preklicati pred preklicem te Sales Order,
Delivery Notes {0} updated,Opombe o dostavi {0} posodobljeni,
Delivery Status,Dostava Status,
Delivery Trip,Dostava potovanje,
Delivery warehouse required for stock item {0},Dostava skladišče potreben za postavko parka {0},
Department,Oddelek,
Department Stores,Veleblagovnice,
Depreciation,Amortizacija,
Depreciation Amount,Amortizacija Znesek,
Depreciation Amount during the period,Amortizacija Znesek v obdobju,
Depreciation Date,Amortizacija Datum,
Depreciation Eliminated due to disposal of assets,Amortizacija je izpadlo zaradi odprodaje premoženja,
Depreciation Entry,Amortizacija Začetek,
Depreciation Method,Metoda amortiziranja,
Depreciation Row {0}: Depreciation Start Date is entered as past date,Amortizacijski vrstici {0}: začetni datum amortizacije se vnese kot pretekli datum,
Depreciation Row {0}: Expected value after useful life must be greater than or equal to {1},Vrednost amortizacije {0}: pričakovana vrednost po življenjski dobi mora biti večja ali enaka {1},
Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,"Amortizacijski vrstici {0}: Naslednji Amortizacijski datum ne sme biti pred datumom, ki je na voljo za uporabo",
Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,Amortizacijski vrstici {0}: Naslednji amortizacijski datum ne more biti pred datumom nakupa,
Designer,Oblikovalec,
Detailed Reason,Podroben razlog,
Details,Podrobnosti,
Details of Outward Supplies and inward supplies liable to reverse charge,"Podrobnosti o zunanjih potrebščinah in notranjih zalogah, za katere je mogoče povratno polnjenje",
Details of the operations carried out.,Podrobnosti o poslovanju izvajajo.,
Diagnosis,Diagnoza,
Did not find any item called {0},Ni našla nobenega elementa z imenom {0},
Diff Qty,Diff Količina,
Difference Account,Razlika račun,
"Difference Account must be a Asset/Liability type account, since this Stock Reconciliation is an Opening Entry","Razlika računa mora biti tip Asset / Liability račun, saj je ta Stock Sprava je Entry Otvoritev",
Difference Amount,Razlika Znesek,
Difference Amount must be zero,Razlika Znesek mora biti nič,
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.,"Drugačna UOM za artikle bo privedlo do napačne (skupno) Neto teža vrednosti. Prepričajte se, da je neto teža vsake postavke v istem UOM.",
Direct Expenses,Neposredni stroški,
Direct Income,Neposredne dohodkovne,
Disable,Onemogoči,
Disabled template must not be default template,Onemogočeno predloga ne sme biti kot privzeto,
Disburse Loan,Izplačilo posojila,
Disbursed,Izplačano,
Disc,Disc,
Discharge,praznjenje,
Discount,Popust,
Discount Percentage can be applied either against a Price List or for all Price List.,Popust Odstotek se lahko uporablja bodisi proti ceniku ali za vse cenik.,
Discount must be less than 100,"Popust, mora biti manj kot 100",
Diseases & Fertilizers,Bolezni in gnojila,
Dispatch,Dispatch,
Dispatch Notification,Obvestilo o odpremi,
Dispatch State,Država odpreme,
Distance,Razdalja,
Distribution,Porazdelitev,
Distributor,Distributer,
Dividends Paid,Plačane dividende,
Do you really want to restore this scrapped asset?,Ali res želite obnoviti ta izločeni sredstva?,
Do you really want to scrap this asset?,"Ali res želite, da ostanki ta sredstva?",
Do you want to notify all the customers by email?,Ali želite obvestiti vse stranke po elektronski pošti?,
Doc Date,Doc Datum,
Doc Name,Doc Name,
Doc Type,Doc Type,
Docs Search,Iskanje dokumentov,
Document Name,Ime dokument,
Document Status,Stanje dokumenta,
Document Type,Vrsta dokumenta,
Domain,Domena,
Domains,Domene,
Done,Končano,
Donor,Darovalec,
Donor Type information.,Podatki o donatorju.,
Donor information.,Podatki o donatorju.,
Download JSON,Prenesite JSON,
Draft,Osnutek,
Drop Ship,Drop Ship,
Drug,Zdravilo,
Due / Reference Date cannot be after {0},Zaradi / Referenčni datum ne more biti po {0},
Due Date cannot be before Posting / Supplier Invoice Date,Datum zapadlosti ne more biti pred datumom napotitve / računa,
Due Date is mandatory,Datum zapadlosti je obvezno,
Duplicate Entry. Please check Authorization Rule {0},"Podvojenega vnosa. Prosimo, preverite Dovoljenje Pravilo {0}",
Duplicate Serial No entered for Item {0},Podvajati Zaporedna številka vpisana v postavko {0},
Duplicate customer group found in the cutomer group table,Dvojnik skupina kupcev so v tabeli cutomer skupine,
Duplicate entry,Dvojnik vnos,
Duplicate item group found in the item group table,Dvojnik postavka skupina je našla v tabeli točka skupine,
Duplicate roll number for student {0},Podvojena številka rola študent {0},
Duplicate row {0} with same {1},Dvojnik vrstica {0} z enako {1},
Duplicate {0} found in the table,Podvojeni {0} v tabeli,
Duration in Days,Trajanje v dnevih,
Duties and Taxes,Dajatve in davki,
E-Invoicing Information Missing,Podatki o e-računu manjkajo,
ERPNext Demo,ERPNext Demo,
ERPNext Settings,Nastavitve ERPNext,
Earliest,Najzgodnejša,
Earnest Money,Kapara,
Earning,Služenje,
Edit,Uredi,
Edit Publishing Details,Uredite podrobnosti objave,
"Edit in full page for more options like assets, serial nos, batches etc.","Uredite na celotni strani za več možnosti, kot so sredstva, serijski nosi, serije itd.",
Education,Izobraževanje,
Either location or employee must be required,Mora biti potrebna lokacija ali zaposleni,
Either target qty or target amount is mandatory,Bodisi ciljna kol ali ciljna vrednost je obvezna,
Either target qty or target amount is mandatory.,Bodisi ciljna kol ali ciljna vrednost je obvezna.,
Electrical,Električno,
Electronic Equipments,elektronske naprave,
Electronics,Electronics,
Eligible ITC,Upravičeni ITC,
Email Account,Email račun,
Email Address,Email naslov,
"Email Address must be unique, already exists for {0}","E-poštni naslov mora biti edinstven, že obstaja za {0}",
Email Digest: ,Email Digest:,
Email Reminders will be sent to all parties with email contacts,E-pošta Opomniki bodo poslani vsem strankam z e-poštnimi stiki,
Email Sent,Email Sent,
Email Template,Predloga za e-pošto,
Email not found in default contact,V privzetem stiku ni mogoče najti e-pošte,
Email sent to {0},E-pošta je poslana na {0},
Employee,Zaposleni,
Employee A/C Number,Številka zaposlenega / C,
Employee Advances,Napredek zaposlenih,
Employee Benefits,Zaslužki zaposlencev,
Employee Grade,Razred zaposlenih,
Employee ID,ID zaposlenega,
Employee Lifecycle,Lifecycle zaposlenih,
Employee Name,ime zaposlenega,
Employee Promotion cannot be submitted before Promotion Date ,Promocija zaposlenih ni mogoče vložiti pred datumom uveljavitve,
Employee Referral,Napotitev zaposlenih,
Employee Transfer cannot be submitted before Transfer Date ,Prenos zaposlencev ni mogoče predati pred datumom prenosa,
Employee cannot report to himself.,Delavec ne more poročati zase.,
Employee relieved on {0} must be set as 'Left',Zaposleni razrešen na {0} mora biti nastavljen kot &quot;levo&quot;,
Employee {0} already submited an apllication {1} for the payroll period {2},Zaposleni {0} je že podaljšal aplikacijo {1} za obdobje plačevanja {2},
Employee {0} has already applied for {1} between {2} and {3} : ,Zaposleni {0} je že zaprosil za {1} med {2} in {3}:,
Employee {0} has no maximum benefit amount,Zaposleni {0} nima največjega zneska nadomestila,
Employee {0} is not active or does not exist,Employee {0} ni aktiven ali pa ne obstaja,
Employee {0} is on Leave on {1},Zaposleni {0} je na Pusti {1},
Employee {0} of grade {1} have no default leave policy,Zaposleni {0} razreda {1} nimajo pravilnika o privzetem dopustu,
Employee {0} on Half day on {1},Zaposlenih {0} v pol dneva na {1},
Enable,Omogoči,
Enable / disable currencies.,Omogoči / onemogoči valute.,
Enabled,Omogočeno,
"Enabling 'Use for Shopping Cart', as Shopping Cart is enabled and there should be at least one Tax Rule for Shopping Cart","Omogočanje &quot;uporabiti za košarico&quot;, kot je omogočeno Košarica in da mora biti vsaj ena Davčna pravilo za Košarica",
End Date,Končni datum,
End Date can not be less than Start Date,Datum konca ne sme biti krajši od začetnega datuma,
End Date cannot be before Start Date.,Končni datum ne sme biti pred datumom začetka.,
End Year,Leto zaključka,
End Year cannot be before Start Year,Konec leta ne more biti pred začetkom leta,
End on,Končaj naprej,
End time cannot be before start time,Končni čas ne more biti pred začetkom,
Ends On date cannot be before Next Contact Date.,Konec na datum ne more biti pred naslednjim datumom stika.,
Energy,Energy,
Engineer,Inženir,
Enough Parts to Build,Dovolj deli za izgradnjo,
Enroll,Včlanite se,
Enrolling student,Vpisovanje študentov,
Enrolling students,Vpis študentov,
Enter depreciation details,Vnesite podatke o amortizaciji,
Enter the Bank Guarantee Number before submittting.,Vnesti bančno garancijsko številko pred predložitvijo.,
Enter the name of the Beneficiary before submittting.,Vnesite ime upravičenca pred predložitvijo.,
Enter the name of the bank or lending institution before submittting.,Pred predložitvijo navedite ime banke ali posojilne institucije.,
Enter value betweeen {0} and {1},Vnesite vrednost betweeen {0} in {1},
Entertainment & Leisure,Zabava &amp; prosti čas,
Entertainment Expenses,Zabava Stroški,
Equity,Kapital,
Error Log,Error Log,
Error evaluating the criteria formula,Napaka pri ocenjevanju formule za merila,
Error in formula or condition: {0},Napaka v formuli ali stanja: {0},
Error: Not a valid id?,Napaka: ni veljaven ID?,
Estimated Cost,Ocenjeni strošek,
Evaluation,Vrednotenje,
"Even if there are multiple Pricing Rules with highest priority, then following internal priorities are applied:","Tudi če obstaja več cenovnih Pravila z najvišjo prioriteto, se uporabljajo nato naslednji notranje prednostne naloge:",
Event,Dogodek,
Event Location,Lokacija dogodka,
Event Name,Ime dogodka,
Exchange Gain/Loss,Exchange dobiček / izguba,
Exchange Rate Revaluation master.,Poveljnik prevrednotenja deviznega tečaja,
Exchange Rate must be same as {0} {1} ({2}),Menjalni tečaj mora biti enaka kot {0} {1} ({2}),
Excise Invoice,Trošarina Račun,
Execution,Izvedba,
Executive Search,Executive Search,
Expand All,Razširi vse,
Expected Delivery Date,Pričakuje Dostava Datum,
Expected Delivery Date should be after Sales Order Date,Pričakovani rok dobave je po datumu prodajnega naročila,
Expected End Date,Pričakovani datum zaključka,
Expected Hrs,Pričakovana ura,
Expected Start Date,Pričakovani datum začetka,
Expense,Expense,
Expense / Difference account ({0}) must be a 'Profit or Loss' account,Expense / Razlika račun ({0}) mora biti račun &quot;poslovni izid&quot;,
Expense Account,Expense račun,
Expense Claim,Expense zahtevek,
Expense Claim for Vehicle Log {0},Expense Zahtevek za vozila Prijavi {0},
Expense Claim {0} already exists for the Vehicle Log,Expense Zahtevek {0} že obstaja za Prijavi vozil,
Expense Claims,Odhodkov Terjatve,
Expense account is mandatory for item {0},Expense račun je obvezna za postavko {0},
Expenses,Stroški,
Expenses Included In Asset Valuation,Vključeni stroški v vrednotenje premoženja,
Expenses Included In Valuation,Stroški Vključeno v vrednotenju,
Expired Batches,Potekli paketi,
Expires On,Poteče,
Expiring On,Izteče se,
Expiry (In Days),Iztek (v dnevih),
Explore,Razišči,
Export E-Invoices,Izvozi e-račune,
Extra Large,Extra Large,
Extra Small,Extra Small,
Fail,Ne uspe,
Failed,Ni uspelo,
Failed to create website,Spletne strani ni bilo mogoče ustvariti,
Failed to install presets,Namestitev prednastavitev ni uspela,
Failed to login,Prijava ni uspel,
Failed to setup company,Podjetje za nastavitev ni uspelo,
Failed to setup defaults,Nastavitve privzetih nastavitev ni bilo mogoče,
Failed to setup post company fixtures,Naprave za namestitev objav ni uspelo,
Fax,Fax,
Fee,Fee,
Fee Created,Ustvarjena provizija,
Fee Creation Failed,Ustvarjanje provizij ni uspelo,
Fee Creation Pending,Čakanje v kreiranju,
Fee Records Created - {0},Fee Records Created - {0},
Feedback,Povratne informacije,
Fees,Pristojbine,
Female,Ženska,
Fetch Data,Pridobi podatke,
Fetch Subscription Updates,Prenesi posodobitve naročnine,
Fetch exploded BOM (including sub-assemblies),Fetch eksplodiral BOM (vključno podsklopov),
Fetching records......,Pridobivanje zapisov ......,
Field Name,Ime polja,
Fieldname,Fieldname,
Fields,Polja,
Fill the form and save it,Izpolnite obrazec in ga shranite,
Filter Employees By (Optional),Filtriraj zaposlene po (neobvezno),
"Filter Fields Row #{0}: Fieldname <b>{1}</b> must be of type ""Link"" or ""Table MultiSelect""",Vrstica filtrov polja št. {0}: Ime polja <b>{1}</b> mora biti tipa &quot;Link&quot; ali &quot;Table MultiSelect&quot;,
Filter Total Zero Qty,Filter Total Zero Qty,
Finance Book,Finance knjiga,
Financial / accounting year.,Finančni / računovodstvo leto.,
Financial Services,Finančne storitve,
Financial Statements,Finančne izjave,
Financial Year,Finančno leto,
Finish,Finish,
Finished Good,Končano dobro,
Finished Good Item Code,Končana koda dobrega izdelka,
Finished Goods,"Končnih izdelkov,",
Finished Item {0} must be entered for Manufacture type entry,Končano Postavka {0} je treba vpisati za vpis tipa Proizvodnja,
Finished product quantity <b>{0}</b> and For Quantity <b>{1}</b> cannot be different,Končana količina izdelka <b>{0}</b> in Za količino <b>{1}</b> ne moreta biti drugačna,
First Name,Ime,
"Fiscal Regime is mandatory, kindly set the fiscal regime in the company {0}","Davčni režim je obvezen, vljudno določite fiskalni režim v podjetju {0}",
Fiscal Year,Poslovno leto,
Fiscal Year End Date should be one year after Fiscal Year Start Date,Končni datum proračunskega leta mora biti eno leto po datumu začetka fiskalnega leta,
Fiscal Year Start Date and Fiscal Year End Date are already set in Fiscal Year {0},Fiskalna Leto Start Date in fiskalno leto End Date so že določeni v proračunskem letu {0},
Fiscal Year Start Date should be one year earlier than Fiscal Year End Date,Datum začetka proračunskega leta mora biti eno leto prej kot končni datum proračunskega leta,
Fiscal Year {0} does not exist,Poslovno leto {0} ne obstaja,
Fiscal Year {0} is required,Poslovno leto {0} je potrebno,
Fiscal Year {0} not found,Poslovno leto {0} ni bilo mogoče najti,
Fixed Asset,Osnovno sredstvo,
Fixed Asset Item must be a non-stock item.,Osnovno sredstvo točka mora biti postavka ne-stock.,
Fixed Assets,Osnovna sredstva,
Following Material Requests have been raised automatically based on Item's re-order level,Po Material Zahteve so bile samodejno dvigne temelji na ravni re-naročilnico elementa,
Following accounts might be selected in GST Settings:,V nastavitvah GST se lahko izberejo naslednji računi:,
Following course schedules were created,Ustanovljeni so bili naslednji razporedi tečaja,
Following item {0} is not marked as {1} item. You can enable them as {1} item from its Item master,Po elementu {0} ni označen kot {1} element. Lahko jih omogočite kot {1} element iz glavnega elementa,
Following items {0} are not marked as {1} item. You can enable them as {1} item from its Item master,Naslednji elementi {0} niso označeni kot {1} element. Lahko jih omogočite kot {1} element iz glavnega elementa,
Food,Hrana,
"Food, Beverage & Tobacco","Hrana, pijača, tobak",
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 &quot;izdelek Bundle &#39;predmetov, skladišče, serijska številka in serijska se ne šteje od&quot; seznam vsebine &quot;mizo. Če so skladišča in serija ni enaka za vso embalažo postavke za kakršno koli &quot;izdelek Bundle &#39;postavko, lahko te vrednosti je treba vnesti v glavnem Element tabele, bodo vrednosti, ki se kopira na&quot; seznam vsebine &quot;mizo.",
For Employee,Za zaposlenega,
For Quantity (Manufactured Qty) is mandatory,Za Količina (Izdelano Kol) obvezna,
For Supplier,Za dobavitelja,
For Warehouse,Za skladišče,
For Warehouse is required before Submit,Za skladišče je pred potreben Submit,
"For an item {0}, quantity must be negative number",Za element {0} mora biti količina negativna,
"For an item {0}, quantity must be positive number",Za element {0} mora biti količina pozitivna,
"For job card {0}, you can only make the 'Material Transfer for Manufacture' type stock entry",Za delovno izkaznico {0} lahko vnesete samo zalogo vrste &quot;Prenos materiala za proizvodnjo&quot;,
"For row {0} in {1}. To include {2} in Item rate, rows {3} must also be included","Za vrstico {0} v {1}. Če želite vključiti {2} v stopnji Element, {3}, mora biti vključena tudi vrstice",
For row {0}: Enter Planned Qty,Za vrstico {0}: vnesite načrtovani qty,
"For {0}, only credit accounts can be linked against another debit entry","Za {0}, lahko le kreditne račune povezati proti drugemu vstop trajnika",
"For {0}, only debit accounts can be linked against another credit entry","Za {0}, lahko le debetne račune povezati proti drugemu knjiženje",
Forum Activity,Forumska dejavnost,
Free item code is not selected,Brezplačna koda izdelka ni izbrana,
Freight and Forwarding Charges,Tovorni in Forwarding Stroški,
Frequency,frekvenca,
Friday,Petek,
From,iz,
From Address 1,Od naslova 1,
From Address 2,Od naslova 2,
From Currency and To Currency cannot be same,Od denarja in denarja ne more biti enaka,
From Date and To Date lie in different Fiscal Year,Od Datum in do datuma se nahajajo v drugem fiskalnem letu,
From Date cannot be greater than To Date,Od datum ne more biti večja kot doslej,
From Date must be before To Date,Od datuma mora biti pred Do Datum,
From Date should be within the Fiscal Year. Assuming From Date = {0},Od datuma mora biti v poslovnem letu. Ob predpostavki Od datuma = {0},
From Date {0} cannot be after employee's relieving Date {1},Od datuma {0} ne more biti po razrešitvi delavca Datum {1},
From Date {0} cannot be before employee's joining Date {1},Od datuma {0} ne more biti preden se zaposleni pridružijo datumu {1},
From Datetime,Od datetime,
From Delivery Note,Od dobavnica,
From Fiscal Year,Od fiskalnega leta,
From GSTIN,Iz GSTIN-a,
From Party Name,Iz imena stranke,
From Pin Code,Iz kode PIN,
From Place,Od kraja,
From Range has to be less than To Range,Od mora biti manj Razpon kot gibala,
From State,Iz države,
From Time,Od časa,
From Time Should Be Less Than To Time,Od časa bi moral biti manj kot čas,
From Time cannot be greater than To Time.,Od časa ne sme biti večja od do časa.,
"From a supplier under composition scheme, Exempt and Nil rated","Od dobavitelja po sestavi sheme, izvzeto in nično",
From and To dates required,Od in Do datumov zahtevanih,
From date can not be less than employee's joining date,Od datuma ne more biti krajši od datuma pridružitve zaposlenega,
From value must be less than to value in row {0},Iz mora biti vrednost manj kot na vrednosti v vrstici {0},
From {0} | {1} {2},Od {0} | {1} {2},
Fuel Price,gorivo Cena,
Fuel Qty,gorivo Kol,
Fulfillment,Izpolnitev,
Full,Poln,
Full Name,Polno ime,
Full-time,Polni delovni čas,
Fully Depreciated,celoti amortizirana,
Furnitures and Fixtures,Pohištvo in Fixtures,
"Further accounts can be made under Groups, but entries can be made against non-Groups","Nadaljnje računi se lahko izvede v skupinah, vendar vnosi lahko zoper niso skupin",
Further cost centers can be made under Groups but entries can be made against non-Groups,"Nadaljnje stroškovna mesta se lahko izvede v skupinah, vendar vnosi lahko zoper niso skupin",
Further nodes can be only created under 'Group' type nodes,Nadaljnje vozlišča lahko ustvari samo na podlagi tipa vozlišča &quot;skupina&quot;,
Future dates not allowed,Prihodnji datumi niso dovoljeni,
GSTIN,GSTIN,
GSTR3B-Form,Obrazec GSTR3B,
Gain/Loss on Asset Disposal,Dobiček / izgube pri prodaji premoženja,
Gantt Chart,Gantogram,
Gantt chart of all tasks.,Ganttov diagram vseh nalog.,
Gender,Spol,
General,Splošno,
General Ledger,Glavna knjiga,
Generate Material Requests (MRP) and Work Orders.,Ustvari materialne zahteve (MRP) in delovne naloge.,
Generate Secret,Ustvari skrivnost,
Get Details From Declaration,Preberite podrobnosti iz izjave,
Get Employees,Pridobite zaposlene,
Get Invocies,Pridobite račune,
Get Invoices,Pridobite račune,
Get Invoices based on Filters,Pridobite račune na podlagi filtrov,
Get Items from BOM,Pridobi artikle iz BOM,
Get Items from Healthcare Services,Pridobite predmete iz zdravstvenih storitev,
Get Items from Prescriptions,Pridobi elemente iz receptov,
Get Items from Product Bundle,Dobili predmetov iz Bundle izdelkov,
Get Suppliers,Pridobite dobavitelje,
Get Suppliers By,Pridobite dobavitelje po,
Get Updates,Dobite posodobitve,
Get customers from,Pridobite stranke od,
Get from Patient Encounter,Pojdite iz srečanja s pacientom,
Getting Started,Uvod,
GitHub Sync ID,ID za GitHub Sync,
Global settings for all manufacturing processes.,Globalne nastavitve za vseh proizvodnih procesov.,
Go to the Desktop and start using ERPNext,Pojdite na namizje in začeti uporabljati ERPNext,
GoCardless SEPA Mandate,GoCardless Mandat SEPA,
GoCardless payment gateway settings,GoCardless nastavitve plačilnih prehodov,
Goal and Procedure,Cilj in postopek,
Goals cannot be empty,Cilji ne morejo biti prazna,
Goods In Transit,Blago v tranzitu,
Goods Transferred,Preneseno blago,
Goods and Services Tax (GST India),Davčna blago in storitve (DDV Indija),
Goods are already received against the outward entry {0},Blago je že prejeto proti vhodnemu vnosu {0},
Government,Vlada,
Grand Total,Skupna vsota,
Grant,Grant,
Grant Application,Grant Application,
Grant Leaves,Grantovi listi,
Grant information.,Informacije o donaciji.,
Grocery,Trgovina z živili,
Gross Pay,Bruto Pay,
Gross Profit,Bruto dobiček,
Gross Profit %,Bruto dobiček %,
Gross Profit / Loss,Kosmati dobiček / izguba,
Gross Purchase Amount,Bruto znesek nakupa,
Gross Purchase Amount is mandatory,Bruto znesek nakupa je obvezna,
Group by Account,"Skupina, ki jo račun",
Group by Party,Skupina po pogodbenici,
Group by Voucher,Skupina kupon,
Group by Voucher (Consolidated),Skupina po vavčerju (prečiščeno),
Group node warehouse is not allowed to select for transactions,Skupina vozlišče skladišče ni dovoljeno izbrati za transakcije,
Group to Non-Group,Skupina Non-Group,
Group your students in batches,Skupina učenci v serijah,
Groups,Skupine,
Guardian1 Email ID,Guardian1 E-ID,
Guardian1 Mobile No,Guardian1 Mobile No,
Guardian1 Name,Ime Guardian1,
Guardian2 Email ID,Skrbnika2 E-ID,
Guardian2 Mobile No,Skrbnika2 Mobile No,
Guardian2 Name,Ime skrbnika2,
Guest,Gost,
HR Manager,Upravljanje človeških virov,
HSN,HSN,
HSN/SAC,TARIC,
Half Day,Poldnevni,
Half Day Date is mandatory,Datum poldnevnika je obvezen,
Half Day Date should be between From Date and To Date,Poldnevni datum mora biti med Od datuma in Do datuma,
Half Day Date should be in between Work From Date and Work End Date,Datum poldnevnega dneva mora biti med delovnim časom in končnim datumom dela,
Half Yearly,Polletni,
Half day date should be in between from date and to date,Poldnevni datum mora biti med datumom in datumom,
Half-Yearly,Polletni,
Hardware,Strojna oprema,
Head of Marketing and Sales,Vodja marketinga in prodaje,
Health Care,Zdravstvo,
Healthcare,Zdravstvo,
Healthcare (beta),Zdravstvo (beta),
Healthcare Practitioner,Zdravstveni delavec,
Healthcare Practitioner not available on {0},Zdravstveni delavec ni na voljo na {0},
Healthcare Practitioner {0} not available on {1},Zdravstveni delavec {0} ni na voljo na {1},
Healthcare Service Unit,Enota za zdravstveno varstvo,
Healthcare Service Unit Tree,Drevo enote zdravstvenega varstva,
Healthcare Service Unit Type,Vrsta enote zdravstvenega varstva,
Healthcare Services,Zdravstvene storitve,
Healthcare Settings,Nastavitve zdravstva,
Hello,Pozdravljeni,
Help Results for,Pomoč za,
High,Visoka,
High Sensitivity,Visoka občutljivost,
Hold,Drži,
Hold Invoice,Držite račun,
Holiday,Prazniki,
Holiday List,Seznam praznikov,
Hotel Rooms of type {0} are unavailable on {1},Sobe Hotela tipa {0} niso na voljo na {1},
Hotels,Hoteli,
Hourly,Na uro,
Hours,Ure,
House rent paid days overlapping with {0},Dnevi plačila najemnine se prekrivajo z {0},
House rented dates required for exemption calculation,"Datumi, najeti v najemu, potrebni za izraćun oprostitev",
House rented dates should be atleast 15 days apart,"Datumi, ki jih najamete v hiši, naj bodo vsaj 15 dni narazen",
How Pricing Rule is applied?,Kako se uporablja cenovno pravilo?,
Hub Category,Kategorija vozlišča,
Hub Sync ID,Sync ID vozlišča,
Human Resource,Človeški vir,
Human Resources,Človeški viri,
IFSC Code,Kodeks IFSC,
IGST Amount,Znesek IGST,
IP Address,IP naslov,
ITC Available (whether in full op part),ITC Na voljo (v celoti v delu),
ITC Reversed,ITC obrnjen,
Identifying Decision Makers,Prepoznavanje odločevalcev,
"If Auto Opt In is checked, then the customers will be automatically linked with the concerned Loyalty Program (on save)","Če se preveri samodejni izklop, bodo stranke samodejno povezane z zadevnim programom zvestobe (pri prihranku)",
"If multiple Pricing Rules continue to prevail, users are asked to set Priority manually to resolve conflict.","Če je več Rules Cenik še naprej prevladovala, so pozvane, da nastavite Priority ročno za reševanje morebitnih sporov.",
"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.","Če je izbrano cenovno pravilo za &quot;Oceni&quot;, bo prepisalo cenik. Cena pravilnika je končna obrestna mera, zato ni treba uporabljati dodatnega popusta. Zato se pri transakcijah, kot je prodajna naročilo, naročilnica itd., Dobijo v polju »Oceni«, ne pa na »cenik tečaja«.",
"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.","Če dva ali več Cenik Pravilnik ugotovila na podlagi zgoraj navedenih pogojev, se uporablja Prioriteta. Prednostno je število med 0 do 20, medtem ko privzeta vrednost nič (prazno). Višja številka pomeni, da bo prednost, če obstaja več cenovnih Pravila z enakimi pogoji.",
"If unlimited expiry for the Loyalty Points, keep the Expiry Duration empty or 0.","Če je za točke zvestobe neomejen rok trajanja, sledite praznim časom trajanja ali 0.",
"If you have any questions, please get back to us.","Če imate kakršnakoli vprašanja, vas prosimo, da nazaj k nam.",
Ignore Existing Ordered Qty,Prezri obstoječe urejene količine,
Image,Image,
Image View,Image View,
Import Data,Uvoz podatkov,
Import Day Book Data,Uvozi podatke o knjigah na dan,
Import Log,Dnevnik Uvozov,
Import Master Data,Uvozi glavne podatke,
Import in Bulk,Uvoz v večjih količinah,
Import of goods,Uvoz blaga,
Import of services,Uvoz storitev,
Importing Items and UOMs,Uvoz elementov in UOM-ov,
Importing Parties and Addresses,Uvozne stranke in naslovi,
In Maintenance,V vzdrževanju,
In Production,V izdelavi,
In Qty,V Kol,
In Stock Qty,Na zalogi Količina,
In Stock: ,Na zalogi:,
In Value,V vrednosti,
"In the case of multi-tier program, Customers will be auto assigned to the concerned tier as per their spent",V primeru večstopenjskega programa bodo stranke samodejno dodeljene zadevni stopnji glede na porabljene,
Inactive,Neaktivno,
Incentives,Spodbude,
Include Default Book Entries,Vključi privzete vnose v knjige,
Include Exploded Items,Vključi eksplodirane elemente,
Include POS Transactions,Vključite POS transakcije,
Include UOM,Vključi UOM,
Included in Gross Profit,Vključeno v bruto dobiček,
Income,Prihodki,
Income Account,Prihodki račun,
Income Tax,Davek na prihodek,
Incoming,Dohodni,
Incoming Rate,Dohodni Rate,
Incorrect number of General Ledger Entries found. You might have selected a wrong Account in the transaction.,Nepravilno število General Ledger Entries našel. Morda ste izbrali napačen račun v transakciji.,
Increment cannot be 0,Prirastek ne more biti 0,
Increment for Attribute {0} cannot be 0,Prirastek za Attribute {0} ne more biti 0,
Indirect Expenses,Posredni stroški,
Indirect Income,Posredna Prihodki,
Individual,Individualno,
Ineligible ITC,Neupravičena ITC,
Initiated,Začela,
Inpatient Record,Hišni bolezen,
Insert,Insert,
Installation Note,Namestitev Opomba,
Installation Note {0} has already been submitted,Je že bil predložen Namestitev Opomba {0},
Installation date cannot be before delivery date for Item {0},Datum namestitve ne more biti pred datumom dostave za postavko {0},
Installing presets,Namestitev prednastavitev,
Institute Abbreviation,Kratica inštituta,
Institute Name,Ime Institute,
Instructor,Inštruktor,
Insufficient Stock,Nezadostna zaloga,
Insurance Start date should be less than Insurance End date,Datum zavarovanje Začetek sme biti manjša od datuma zavarovanje End,
Integrated Tax,Integrirani davek,
Inter-State Supplies,Meddržavne dobrine,
Interest Amount,Obresti Znesek,
Interests,Zanima,
Intern,Intern,
Internet Publishing,Internet Založništvo,
Intra-State Supplies,Potrebščine znotraj države,
Introduction,Predstavitev,
Invalid Attribute,Neveljavna Lastnost,
Invalid Blanket Order for the selected Customer and Item,Neveljavna naročila za blago za izbrano stranko in postavko,
Invalid Company for Inter Company Transaction.,Neveljavno podjetje za transakcije med podjetji.,
Invalid GSTIN! A GSTIN must have 15 characters.,Neveljaven GSTIN! GSTIN mora imeti 15 znakov.,
Invalid GSTIN! First 2 digits of GSTIN should match with State number {0}.,Neveljaven GSTIN! Prvi dve števki GSTIN bi se morali ujemati z državno številko {0}.,
Invalid GSTIN! The input you've entered doesn't match the format of GSTIN.,Neveljaven GSTIN! Vneseni vnos ne ustreza formatu GSTIN.,
Invalid Posting Time,Neveljaven čas pošiljanja,
Invalid attribute {0} {1},Neveljaven atribut {0} {1},
Invalid quantity specified for item {0}. Quantity should be greater than 0.,"Neveljavna količina, določena za postavko {0}. Količina mora biti večja od 0.",
Invalid reference {0} {1},Neveljavna referenčna {0} {1},
Invalid {0},Neveljavna {0},
Invalid {0} for Inter Company Transaction.,Neveljaven {0} za transakcijo med podjetji.,
Invalid {0}: {1},Neveljavna {0}: {1},
Inventory,Popis,
Investment Banking,Investicijsko bančništvo,
Investments,Naložbe,
Invoice,Račun,
Invoice Created,Račun ustvarjen,
Invoice Discounting,Popust na račune,
Invoice Patient Registration,Registracija računa pacientov,
Invoice Posting Date,Račun Napotitev Datum,
Invoice Type,Račun Type,
Invoice already created for all billing hours,"Račun, ki je že ustvarjen za vse obračunske ure",
Invoice can't be made for zero billing hour,Račun ni mogoče naročiti za ničelno uro zaračunavanja,
Invoice {0} no longer exists,Račun {0} ne obstaja več,
Invoiced,Fakturirani,
Invoiced Amount,Obračunani znesek,
Invoices,Računi,
Invoices for Costumers.,Računi za kupce.,
Inward supplies from ISD,Vhodne zaloge ISD,
Inward supplies liable to reverse charge (other than 1 & 2 above),"Notranji zalogi, ki so podvrženi povratnemu polnjenju (razen 1 in 2 zgoraj)",
Is Active,Je aktiven,
Is Default,Je Privzeto,
Is Existing Asset,Je obstoječemu sredstvu,
Is Frozen,Je zamrznjena,
Is Group,Is Group,
Issue,Težava,
Issue Material,Vprašanje Material,
Issued,Izdala,
Issues,Vprašanja,
It is needed to fetch Item Details.,"To je potrebno, da prinese Element Podrobnosti.",
Item,Postavka,
Item 1,Postavka 1,
Item 2,Postavka 2,
Item 3,Postavka 3,
Item 4,Postavka 4,
Item 5,Postavka 5,
Item Cart,Točka košarico,
Item Code,Oznaka,
Item Code cannot be changed for Serial No.,Oznaka se ne more spremeniti za Serial No.,
Item Code required at Row No {0},Oznaka zahteva pri Row št {0},
Item Description,Postavka Opis,
Item Group,Element Group,
Item Group Tree,Element Group Tree,
Item Group not mentioned in item master for item {0},"Element Group, ki niso navedeni v točki mojster za postavko {0}",
Item Name,Ime predmeta,
Item Price added for {0} in Price List {1},Postavka Cena dodana za {0} v Ceniku {1},
"Item Price appears multiple times based on Price List, Supplier/Customer, Currency, Item, UOM, Qty and Dates.","Postavka Cena se prikaže večkrat na podlagi cenika, dobavitelja / naročnika, valute, postavke, UOM, količine in datumov.",
Item Price updated for {0} in Price List {1},Kos Cena posodabljati za {0} v ceniku {1},
Item Row {0}: {1} {2} does not exist in above '{1}' table,Element Red {0}: {1} {2} v tabeli &quot;{1}&quot; ne obstaja,
Item Tax Row {0} must have account of type Tax or Income or Expense or Chargeable,Postavka Davčna Row {0} morajo upoštevati vrste davka ali prihodek ali odhodek ali Obdavčljivi,
Item Template,Predloga postavke,
Item Variant Settings,Nastavitve različice postavke,
Item Variant {0} already exists with same attributes,Postavka Variant {0} že obstaja z enakimi atributi,
Item Variants,Artikel Variante,
Item Variants updated,Različice izdelkov so posodobljene,
Item has variants.,Element ima variante.,
Item must be added using 'Get Items from Purchase Receipts' button,Postavka je treba dodati uporabo &quot;dobili predmetov iz nakupu prejemki&quot; gumb,
Item valuation rate is recalculated considering landed cost voucher amount,Stopnja vrednotenje sredstev se preračuna razmišlja pristali stroškovno vrednost kupona,
Item variant {0} exists with same attributes,Obstaja postavka varianta {0} z enakimi atributi,
Item {0} does not exist,Element {0} ne obstaja,
Item {0} does not exist in the system or has expired,Element {0} ne obstaja v sistemu ali je potekla,
Item {0} has already been returned,Postavka {0} je bil že vrnjen,
Item {0} has been disabled,Točka {0} je bila onemogočena,
Item {0} has reached its end of life on {1},Postavka {0} je konec življenja na {1},
Item {0} ignored since it is not a stock item,"Postavka {0} prezrta, ker ne gre za element parka",
"Item {0} is a template, please select one of its variants","Postavka {0} je predlogo, izberite eno od njenih različic",
Item {0} is cancelled,Postavka {0} je odpovedan,
Item {0} is disabled,Postavka {0} je onemogočena,
Item {0} is not a serialized Item,Postavka {0} ni serialized postavka,
Item {0} is not a stock Item,Postavka {0} ni zaloge Item,
Item {0} is not active or end of life has been reached,Postavka {0} ni aktiven ali je bil dosežen konec življenja,
Item {0} is not setup for Serial Nos. Check Item master,Postavka {0} ni setup za Serijska št. Preverite item mojster,
Item {0} is not setup for Serial Nos. Column must be blank,Postavka {0} ni setup za Serijska št. Kolona mora biti prazno,
Item {0} must be a Fixed Asset Item,Točka {0} mora biti osnovno sredstvo postavka,
Item {0} must be a Sub-contracted Item,Postavka {0} mora biti podizvajalcev item,
Item {0} must be a non-stock item,"Točka {0} mora biti postavka, non-stock",
Item {0} must be a stock Item,Postavka {0} mora biti stock postavka,
Item {0} not found,Postavka {0} ni bilo mogoče najti,
Item {0} not found in 'Raw Materials Supplied' table in Purchase Order {1},"Postavka {0} ni bilo mogoče najti v &quot;surovin, dobavljenih&quot; mizo v narocilo {1}",
Item {0}: Ordered qty {1} cannot be less than minimum order qty {2} (defined in Item).,Postavka {0}: Ž Kol {1} ne more biti nižja od minimalne naročila Kol {2} (opredeljeno v točki).,
Item: {0} does not exist in the system,Postavka: {0} ne obstaja v sistemu,
Items,Predmeti,
Items Filter,Filter elementov,
Items and Pricing,Predmeti in Cene,
Items for Raw Material Request,Artikli za zahtevo surovin,
Job Card,Job Card,
Job Description,Opis dela,
Job Offer,Zaposlitvena ponudba,
Job card {0} created,Kartica za delo {0} je bila ustvarjena,
Jobs,Jobs,
Join,Pridruži se,
Journal Entries {0} are un-linked,Revija Vnosi {0} so un-povezani,
Journal Entry,Vnos v dnevnik,
Journal Entry {0} does not have account {1} or already matched against other voucher,Journal Entry {0} nima računa {1} ali že primerjali z drugimi kupon,
Kanban Board,Kanban svet,
Key Reports,Ključna poročila,
LMS Activity,LMS dejavnost,
Lab Test,Lab Test,
Lab Test Report,Poročilo o laboratorijskem testu,
Lab Test Sample,Vzorec laboratorijskega testa,
Lab Test Template,Lab Test Template,
Lab Test UOM,Lab Test UOM,
Lab Tests and Vital Signs,Laboratorijski testi in vitalni znaki,
Lab result datetime cannot be before testing datetime,Datetime rezultatov laboratorija ne more biti pred testiranjem datetime,
Lab testing datetime cannot be before collection datetime,Testiranje datotečnega laboratorija ne more biti pred zbiranjem datetime,
Label,Label,
Laboratory,Laboratorij,
Language Name,Jezik Ime,
Large,Velika,
Last Communication,Zadnje sporočilo,
Last Communication Date,Zadnje Sporočilo Datum,
Last Name,Priimek,
Last Order Amount,Zadnja naročite Znesek,
Last Order Date,Zadnja Datum naročila,
Last Purchase Price,Zadnja nakupna cena,
Last Purchase Rate,Zadnja Purchase Rate,
Latest,Zadnje,
Latest price updated in all BOMs,Najnovejša cena posodobljena v vseh BOM,
Lead,Ponudba,
Lead Count,svinec Štetje,
Lead Owner,Lastnik ponudbe,
Lead Owner cannot be same as the Lead,Svinec Lastnik ne more biti isto kot vodilni,
Lead Time Days,Dobavni rok dni,
Lead to Quotation,Privede do Kotacija,
"Leads help you get business, add all your contacts and more as your leads","Interesenti vam pomaga dobiti posel, dodamo vse svoje stike in več kot vaše vodi",
Learn,Naučite,
Leave Approval Notification,Pustite obvestilo o odobritvi,
Leave Blocked,Pustite blokiranih,
Leave Encashment,pustite Vnovčevanje,
Leave Management,Pustite upravljanje,
Leave Status Notification,Pustite obvestilo o stanju,
Leave Type,Zapusti Type,
Leave Type is madatory,Leave Type je premišljen,
Leave Type {0} cannot be allocated since it is leave without pay,"Pusti tipa {0} ni mogoče dodeliti, ker je zapustil brez plačila",
Leave Type {0} cannot be carry-forwarded,"Pustite Type {0} ni mogoče izvajati, posredovati",
Leave Type {0} is not encashable,Odstop tipa {0} ni zapletljiv,
Leave Without Pay,Leave brez plačila,
Leave and Attendance,Pusti in postrežbo,
Leave application {0} already exists against the student {1},Odstopni program {0} že obstaja proti študentu {1},
"Leave cannot be allocated before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}","Dopusta ni mogoče dodeliti pred {0}, saj je bilanca dopust že-carry posredujejo v evidenco dodeljevanja dopust prihodnji {1}",
"Leave cannot be applied/cancelled before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}","Pustite se ne more uporabiti / preklicana pred {0}, saj je bilanca dopust že-carry posredujejo v evidenco dodeljevanja dopust prihodnji {1}",
Leave of type {0} cannot be longer than {1},Dopust tipa {0} ne more biti daljši od {1},
Leaves,Listi,
Leaves Allocated Successfully for {0},Listi Dodeljena Uspešno za {0},
Leaves has been granted sucessfully,Listi so bili uspešno dodeljeni,
Leaves must be allocated in multiples of 0.5,Listi morajo biti dodeljen v večkratnikih 0.5,
Leaves per Year,Listi na leto,
Ledger,Ledger,
Legal,Pravna,
Legal Expenses,Pravni stroški,
Letter Head,Glava pisma,
Letter Heads for print templates.,Letter Glave za tiskane predloge.,
Level,Stopnja,
Liability,Odgovornost,
License,Licenca,
Lifecycle,Življenski krog,
Limit,Limit,
Limit Crossed,Limit navzkrižnim,
Link to Material Request,Povezava z zahtevo za material,
List of all share transactions,Seznam vseh deležev transakcij,
List of available Shareholders with folio numbers,Seznam razpoložljivih delničarjev s številkami folije,
Loading Payment System,Nalaganje plačilnega sistema,
Loan,Posojilo,
Loan Amount cannot exceed Maximum Loan Amount of {0},Kredita vrednosti ne sme preseči najvišji možen kredit znesku {0},
Loan Application,Loan Application,
Loan Management,Upravljanje posojil,
Loan Repayment,vračila posojila,
Loan Start Date and Loan Period are mandatory to save the Invoice Discounting,Datum začetka posojila in obdobje posojila sta obvezna za varčevanje s popustom na računu,
Loans (Liabilities),Posojili (obveznosti),
Loans and Advances (Assets),Posojila in predujmi (sredstva),
Local,Lokalno,
Log,dnevnik,
Logs for maintaining sms delivery status,Dnevniki za ohranjanje statusa dostave sms,
Lost,Lost,
Lost Reasons,Izgubljeni razlogi,
Low,Nizka,
Low Sensitivity,Nizka občutljivost,
Lower Income,Nižji od dobička,
Loyalty Amount,Znesek zvestobe,
Loyalty Point Entry,Vnos točke zvestobe,
Loyalty Points,Točke zvestobe,
"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.",Točke zvestobe bodo izračunane na podlagi porabljenega zneska (prek prodajnega računa) na podlagi navedenega faktorja zbiranja.,
Loyalty Points: {0},Točke zvestobe: {0},
Loyalty Program,Program zvestobe,
Main,Main,
Maintenance,Vzdrževanje,
Maintenance Log,Dnevnik vzdrževanja,
Maintenance Manager,Vzdrževanje Manager,
Maintenance Schedule,Vzdrževanje Urnik,
Maintenance Schedule is not generated for all the items. Please click on 'Generate Schedule',"Vzdrževanje Urnik se ne ustvari za vse postavke. Prosimo, kliknite na &quot;ustvarjajo Seznamu&quot;",
Maintenance Schedule {0} exists against {1},obstaja Vzdrževanje Razpored {0} proti {1},
Maintenance Schedule {0} must be cancelled before cancelling this Sales Order,Vzdrževanje Urnik {0} je treba odpovedati pred preklicem te Sales Order,
Maintenance Status has to be Cancelled or Completed to Submit,"Stanje vzdrževanja je treba preklicati ali končati, da ga pošljete",
Maintenance User,Vzdrževanje Uporabnik,
Maintenance Visit,Vzdrževalni obisk,
Maintenance Visit {0} must be cancelled before cancelling this Sales Order,Vzdrževanje obisk {0} je treba odpovedati pred preklicem te Sales Order,
Maintenance start date can not be before delivery date for Serial No {0},Datum začetka vzdrževanje ne more biti pred datumom dostave za serijsko št {0},
Make,Poskrbite,
Make Payment,Izvedi plačilo,
Make project from a template.,Izdelajte projekt iz predloge.,
Making Stock Entries,Izdelava vnosov Zalog,
Male,Moški,
Manage Customer Group Tree.,Upravljanje drevesa skupine kupcev.,
Manage Sales Partners.,Upravljanje prodajne partnerje.,
Manage Sales Person Tree.,Upravljanje drevesa prodajalca.,
Manage Territory Tree.,Upravljanje Territory drevo.,
Manage your orders,Upravljajte naročila,
Management,Vodstvo,
Manager,Manager,
Managing Projects,Upravljanje projektov,
Managing Subcontracting,Upravljanje Podizvajalcev,
Mandatory,Obvezno,
Mandatory field - Academic Year,Obvezno polje - študijsko leto,
Mandatory field - Get Students From,Obvezno polje - Pridobi študente iz,
Mandatory field - Program,Obvezno polje - Program,
Manufacture,Izdelava,
Manufacturer,Proizvajalec,
Manufacturer Part Number,Številka dela proizvajalca,
Manufacturing,Predelovalne dejavnosti,
Manufacturing Quantity is mandatory,Proizvodnja Količina je obvezna,
Mapping,Kartiranje,
Mapping Type,Vrsta mapiranja,
Mark Absent,Mark Odsoten,
Mark Attendance,Označi udeležbo,
Mark Half Day,Označi pol dneva,
Mark Present,Označi sedanjost,
Marketing,Trženje,
Marketing Expenses,Stroški trženja,
Marketplace,Tržnica,
Marketplace Error,Napaka na trgu,
Masters,Masters,
Match Payments with Invoices,Match plačila z računov,
Match non-linked Invoices and Payments.,Match nepovezane računov in plačil.,
Material,Material,
Material Consumption,Poraba materiala,
Material Consumption is not set in Manufacturing Settings.,Poraba materiala ni nastavljena v proizvodnih nastavitvah.,
Material Receipt,Material Prejem,
Material Request,Zahteva za material,
Material Request Date,Material Zahteva Datum,
Material Request No,Material Zahteva Ne,
"Material Request not created, as quantity for Raw Materials already available.","Prošnja za material ni ustvarjena, ker količina za Surove materiale zadostna.",
Material Request of maximum {0} can be made for Item {1} against Sales Order {2},Material Zahteva za največ {0} se lahko izvede za postavko {1} proti Sales Order {2},
Material Request to Purchase Order,Material Zahteva za narocilo,
Material Request {0} is cancelled or stopped,Material Zahteva {0} je odpovedan ali ustavi,
Material Request {0} submitted.,Prošnja za material {0} vložena.,
Material Transfer,Prenos materialov,
Material Transferred,Preneseno gradivo,
Material to Supplier,Material za dobavitelja,
Max Exemption Amount cannot be greater than maximum exemption amount {0} of Tax Exemption Category {1},Najvišji znesek oprostitve ne sme presegati najvišjega zneska oprostitve {0} kategorije oprostitev davkov {1},
Max benefits should be greater than zero to dispense benefits,"Najvišje koristi bi morale biti večje od nič, da bi se izplačale koristi",
Max discount allowed for item: {0} is {1}%,Max popust dovoljena za postavko: {0} je {1}%,
Max: {0},Max: {0},
Maximum Samples - {0} can be retained for Batch {1} and Item {2}.,Največje vzorce - {0} lahko hranite za paket {1} in element {2}.,
Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,Največji vzorci - {0} so bili že shranjeni za serijo {1} in element {2} v seriji {3}.,
Maximum amount eligible for the component {0} exceeds {1},Najvišji znesek primernega za sestavino {0} presega {1},
Maximum benefit amount of component {0} exceeds {1},Najvišja višina ugodnosti sestavnega dela {0} presega {1},
Maximum benefit amount of employee {0} exceeds {1},Najvišji znesek zaslužka zaposlenega {0} presega {1},
Maximum discount for Item {0} is {1}%,Najvišji popust za postavko {0} je {1}%,
Maximum leave allowed in the leave type {0} is {1},Največji dovoljeni dopust v tipu dopusta {0} je {1},
Medical,Medical,
Medical Code,Zdravstvena koda,
Medical Code Standard,Standard medicinske oznake,
Medical Department,Medicinski oddelek,
Medical Record,Medicinski zapis,
Medium,Medium,
Meeting,Srečanje,
Member Activity,Članska dejavnost,
Member ID,ID člana,
Member Name,Ime člana,
Member information.,Podatki o članih.,
Membership,Članstvo,
Membership Details,Podrobnosti o članstvu,
Membership ID,ID članstva,
Membership Type,Vrsta članstva,
Memebership Details,Podrobnosti o memorandumu,
Memebership Type Details,Podatki o tipu memebership,
Merge,Spoji se,
Merge Account,Združite račun,
Merge with Existing Account,Spoji z obstoječim računom,
"Merging is only possible if following properties are same in both records. Is Group, Root Type, Company","Spajanje je mogoče le, če so naslednje lastnosti enaka v obeh evidencah. Je skupina, Root Type, Company",
Message Examples,Sporočilo Primeri,
Message Sent,Sporočilo je bilo poslano,
Method,Metoda,
Middle Income,Bližnji Prihodki,
Middle Name,Srednje ime,
Middle Name (Optional),Middle Name (po želji),
Min Amt can not be greater than Max Amt,Min Amt ne more biti večji od Max Amt,
Min Qty can not be greater than Max Qty,Min Količina ne sme biti večja od Max Kol,
Minimum Lead Age (Days),Minimalna Svinec Starost (dnevi),
Miscellaneous Expenses,Razni stroški,
Missing Currency Exchange Rates for {0},Manjka Menjalni tečaji za {0},
Missing email template for dispatch. Please set one in Delivery Settings.,Manjka e-poštna predloga za odpošiljanje. Nastavite ga v nastavitvah za dostavo.,
"Missing value for Password, API Key or Shopify URL","Manjka vrednost za geslo, ključ API ali URL prodajanja",
Mode of Payment,Način plačila,
Mode of Payments,Način plačila,
Mode of Transport,Način prevoza,
Mode of Transportation,Način za promet,
Mode of payment is required to make a payment,"Način plačila je potrebno, da bi plačilo",
Model,Model,
Moderate Sensitivity,Zmerna občutljivost,
Monday,Ponedeljek,
Monthly,Mesečni,
Monthly Distribution,Mesečni Distribution,
Monthly Repayment Amount cannot be greater than Loan Amount,Mesečni Povračilo Znesek ne sme biti večja od zneska kredita,
More,Več,
More Information,Več informacij,
More than one selection for {0} not allowed,Več kot en izbor za {0} ni dovoljen,
More...,Več ...,
Motion Picture & Video,Motion Picture &amp; Video,
Move,poteza,
Move Item,Move Item,
Multi Currency,Multi Valuta,
Multiple Item prices.,Več cene postavko.,
Multiple Loyalty Program found for the Customer. Please select manually.,Za naročnika je bil najden več program zvestobe. Izberite ročno.,
"Multiple Price Rules exists with same criteria, please resolve conflict by assigning priority. Price Rules: {0}","Več Cena Pravila obstaja z enakimi merili, se rešujejo spore z dodelitvijo prednost. Cena Pravila: {0}",
Multiple Variants,Večkratne različice,
Multiple fiscal years exist for the date {0}. Please set company in Fiscal Year,"obstaja več proračunskih let za datum {0}. Prosim, nastavite podjetje v poslovnem letu",
Music,Glasba,
My Account,Moj račun,
Name error: {0},Ime napaka: {0},
Name of new Account. Note: Please don't create accounts for Customers and Suppliers,"Ime novega računa. Opomba: Prosimo, da ne ustvarjajo računov za kupce in dobavitelje",
Name or Email is mandatory,Ime ali e-pošta je obvezna,
Nature Of Supplies,Narava potrebščin,
Navigating,Krmarjenje,
Needs Analysis,Analiza potreb,
Negative Quantity is not allowed,Negativno Količina ni dovoljeno,
Negative Valuation Rate is not allowed,Negativno Oceni Vrednotenje ni dovoljeno,
Negotiation/Review,Pogajanja / pregled,
Net Asset value as on,"Čista vrednost sredstev, kot je na",
Net Cash from Financing,Neto denarni tokovi pri financiranju,
Net Cash from Investing,Čisti denarni tok iz naložbenja,
Net Cash from Operations,Čisti denarni tok iz poslovanja,
Net Change in Accounts Payable,Neto sprememba obveznosti do dobaviteljev,
Net Change in Accounts Receivable,Neto sprememba terjatev do kupcev,
Net Change in Cash,Neto sprememba v gotovini,
Net Change in Equity,Neto sprememba v kapitalu,
Net Change in Fixed Asset,Neto sprememba v osnovno sredstvo,
Net Change in Inventory,Neto sprememba v popisu,
Net ITC Available(A) - (B),Neto razpoložljivi ITC (A) - (B),
Net Pay,Neto plača,
Net Pay cannot be less than 0,Neto plača ne sme biti manjši od 0,
Net Profit,Čisti dobiček,
Net Salary Amount,Neto znesek plače,
Net Total,Neto Skupaj,
Net pay cannot be negative,Neto plača ne more biti negativna,
New Account Name,Novo ime računa,
New Address,New Naslov,
New BOM,New BOM,
New Batch ID (Optional),Nova Serija ID (po želji),
New Batch Qty,Nova Serija Kol,
New Company,Novo podjetje,
New Cost Center Name,New Stroški Center Ime,
New Customer Revenue,New Customer Prihodki,
New Customers,Nove stranke,
New Department,Nov oddelek,
New Employee,Novi zaposleni,
New Location,Nova lokacija,
New Quality Procedure,Nov postopek kakovosti,
New Sales Invoice,Nov račun,
New Sales Person Name,Ime New Sales oseba,
New Serial No cannot have Warehouse. Warehouse must be set by Stock Entry or Purchase Receipt,Nova serijska številka ne more imeti skladišče. Skladišče mora nastaviti borze vstopu ali Potrdilo o nakupu,
New Warehouse Name,Novo skladišče Ime,
New credit limit is less than current outstanding amount for the customer. Credit limit has to be atleast {0},Nova kreditna meja je nižja od trenutne neporavnani znesek za stranko. Kreditno linijo mora biti atleast {0},
New task,Nova naloga,
New {0} pricing rules are created,Izdelana so nova {0} pravila za določanje cen,
Newsletters,Glasila,
Newspaper Publishers,Newspaper Publishers,
Next,Naslednja,
Next Contact By cannot be same as the Lead Email Address,Naslednja Kontakt Po ne more biti enaka kot vodilni e-poštni naslov,
Next Contact Date cannot be in the past,Naslednja Stik datum ne more biti v preteklosti,
Next Steps,Naslednji koraki,
No Action,Brez akcije,
No Customers yet!,Ni še nobene stranke!,
No Data,Ni podatkov,
No Delivery Note selected for Customer {},Za kupca ni izbranega obvestila o dostavi {},
No Employee Found,Ni najdenega zaposlenega,
No Item with Barcode {0},Ne Postavka s črtno kodo {0},
No Item with Serial No {0},Ne Postavka s serijsko št {0},
No Items available for transfer,Ni razpoložljivih elementov za prenos,
No Items selected for transfer,Ni izbranih elementov za prenos,
No Items to pack,Ni prispevkov za pakiranje,
No Items with Bill of Materials to Manufacture,Ni Postavke z Bill materialov za Izdelava,
No Items with Bill of Materials.,Ni predmetov z gradivom.,
No Permission,Ne Dovoljenje,
No Remarks,Ni Opombe,
No Result to submit,Ni zadetka,
No Salary Structure assigned for Employee {0} on given date {1},Struktura plač ni dodeljena zaposlenemu {0} na določenem datumu {1},
No Staffing Plans found for this Designation,Za ta naziv ni bilo mogoče najti nobenega kadrovskega načrta,
No Student Groups created.,ustvaril nobene skupine študentov.,
No Students in,Ni Študenti,
No Tax Withholding data found for the current Fiscal Year.,"Ni podatkov o davčnem primanjkljaju, ugotovljenem za tekoče poslovno leto.",
No Work Orders created,Št delovnih nalogov ustvarjenih,
No accounting entries for the following warehouses,Ni vknjižbe za naslednjih skladiščih,
No active or default Salary Structure found for employee {0} for the given dates,"Ni aktivnega ali privzeti plač struktura, ugotovljena za zaposlenega {0} za datumoma",
No contacts with email IDs found.,Ni najdenih stikov z e-poštnimi ID-ji.,
No data for this period,Za ta čas ni podatkov,
No description given,Opis ni dana,
No employees for the mentioned criteria,Za omenjena merila ni zaposlenih,
No gain or loss in the exchange rate,Dobiček ali izguba v menjalnem tečaju ni,
No items listed,"Ni elementov, navedenih",
No items to be received are overdue,"Predmeti, ki jih želite prejeti, niso zapadli",
No material request created,Ni ustvarjeno nobeno materialno zahtevo,
No more updates,Nič več posodobitve,
No of Interactions,Število interakcij,
No of Shares,Število delnic,
No pending Material Requests found to link for the given items.,"Nobenih čakajočih materialnih zahtevkov, za katere je bilo ugotovljeno, da so povezani za določene predmete.",
No products found,Ni najdenih izdelkov,
No products found.,Ni izdelkov.,
No record found,Nobenega zapisa najdenih,
No records found in the Invoice table,Ni najdenih v tabeli računa zapisov,
No records found in the Payment table,Ni najdenih v tabeli plačil zapisov,
No replies from,Ni odgovorov,
No salary slip found to submit for the above selected criteria OR salary slip already submitted,"Za zgoraj navedena izbrana merila ILI plačilni list, ki je že bil predložen, ni bilo mogoče najti nobene plačilne liste",
No tasks,ni opravil,
No time sheets,Ni listami,
No values,Ni vrednosti,
No {0} found for Inter Company Transactions.,Št. {0} je bil najden za transakcije podjetja Inter.,
Non GST Inward Supplies,Vhodne potrebščine brez GST,
Non Profit,Non Profit,
Non Profit (beta),Neprofitna (beta),
Non-GST outward supplies,Zunanje zaloge brez GST,
Non-Group to Group,Non-Group skupini,
None,Nihče,
None of the items have any change in quantity or value.,Nobena od postavk imate kakršne koli spremembe v količini ali vrednosti.,
Nos,Nos,
Not Available,Ni na voljo,
Not Marked,ne Označeno,
Not Paid and Not Delivered,Ne plača in ne Delivered,
Not Permitted,Ni dovoljeno,
Not Started,Ni začelo,
Not active,Ni aktiven,
Not allow to set alternative item for the item {0},Ne dovolite nastavitve nadomestnega elementa za predmet {0},
Not allowed to update stock transactions older than {0},"Ni dovoljeno, da posodobite transakcije zalog starejši od {0}",
Not authorized to edit frozen Account {0},Ne smejo urejati zamrznjeni račun {0},
Not authroized since {0} exceeds limits,"Ne authroized saj je {0}, presega meje",
Not permitted for {0},Ni dovoljeno za {0},
"Not permitted, configure Lab Test Template as required","Ni dovoljeno, če je potrebno, konfigurirate preskusno različico Lab Labels",
Not permitted. Please disable the Service Unit Type,"Ni dovoljeno. Prosimo, onemogočite vrsto servisne enote",
Note: Due / Reference Date exceeds allowed customer credit days by {0} day(s),Opomba: Zaradi / Referenčni datum presega dovoljene kreditnih stranka dni s {0} dan (s),
Note: Item {0} entered multiple times,Opomba: Točka {0} vpisana večkrat,
Note: Payment Entry will not be created since 'Cash or Bank Account' was not specified,"Opomba: Začetek Plačilo se ne bodo ustvarili, saj &quot;gotovinski ali bančni račun&quot; ni bil podan",
Note: System will not check over-delivery and over-booking for Item {0} as quantity or amount is 0,Opomba: Sistem ne bo preveril čez povzetju in over-rezervacije za postavko {0} kot količina ali znesek je 0,
Note: There is not enough leave balance for Leave Type {0},Opomba: Ni dovolj bilanca dopust za dopust tipa {0},
Note: This Cost Center is a Group. Cannot make accounting entries against groups.,Opomba: Ta Stroški Center je skupina. Ne more vknjižbe proti skupinam.,
Note: {0},Opomba: {0},
Notes,Opombe,
Nothing is included in gross,Nič ni vključeno v bruto,
Nothing more to show.,Nič več pokazati.,
Nothing to change,Ničesar se ne spremeni,
Notice Period,Odpovedni rok,
Notify Customers via Email,Obvesti stranke po e-pošti,
Number,Številka,
Number of Depreciations Booked cannot be greater than Total Number of Depreciations,Število amortizacije naročene ne sme biti večja od skupnega št amortizacije,
Number of Interaction,Število interakcij,
Number of Order,Število reda,
"Number of new Account, it will be included in the account name as a prefix",Številka novega računa bo vključena v ime računa kot predpono,
"Number of new Cost Center, it will be included in the cost center name as a prefix",Število novih stroškovnih centrov bo vključeno v nabavno ime kot predpono,
Number of root accounts cannot be less than 4,Število korenskih računov ne sme biti manjše od 4,
Odometer,števec kilometrov,
Office Equipments,Pisarniška oprema,
Office Maintenance Expenses,Pisarniška Vzdrževanje Stroški,
Office Rent,Urad za najem,
On Hold,Na čakanju,
On Net Total,On Net Total,
One customer can be part of only single Loyalty Program.,Ena stranka je lahko del samo enega programa zvestobe.,
Online Auctions,Online Dražbe,
Only Leave Applications with status 'Approved' and 'Rejected' can be submitted,Pustite samo aplikacije s statusom &quot;Approved&quot; in &quot;Zavrnjeno&quot; se lahko predloži,
"Only the Student Applicant with the status ""Approved"" will be selected in the table below.",V spodnji tabeli bo izbran samo kandidat s statusom »Odobreno«.,
Only users with {0} role can register on Marketplace,V Marketplace se lahko registrirajo samo uporabniki z vlogo {0},
Open BOM {0},Odprti BOM {0},
Open Item {0},Odpri Artikel {0},
Open Notifications,Odprte Obvestila,
Open Orders,Odprta naročila,
Open a new ticket,Odprite novo karto,
Opening,Otvoritev,
Opening (Cr),Odprtino (Cr),
Opening (Dr),Odprtje (Dr),
Opening Accounting Balance,Začetna bilanca,
Opening Accumulated Depreciation,Odpiranje nabrano amortizacijo,
Opening Accumulated Depreciation must be less than equal to {0},Odpiranje nabrano amortizacijo sme biti manjša od enako {0},
Opening Balance,Odpiranje ravnotežja,
Opening Balance Equity,Otvoritev Balance Equity,
Opening Date and Closing Date should be within same Fiscal Year,Pričetek in rok bi moral biti v istem proračunskem letu,
Opening Date should be before Closing Date,Pričetek mora biti pred Zapiranje Datum,
Opening Entry Journal,Otvoritveni dnevnik,
Opening Invoice Creation Tool,Odpiranje orodja za ustvarjanje računov,
Opening Invoice Item,Odpiranje računa,
Opening Invoices,Odpiranje računov,
Opening Invoices Summary,Povzetek povzetka računov,
Opening Qty,Odpiranje Količina,
Opening Stock,Začetna zaloga,
Opening Stock Balance,Odpiranje Stock Balance,
Opening Value,Otvoritev Vrednost,
Opening {0} Invoice created,Odpiranje {0} Ustvarjen račun,
Operation,Delovanje,
Operation Time must be greater than 0 for Operation {0},"Delovanje Čas mora biti večja od 0, za obratovanje {0}",
"Operation {0} longer than any available working hours in workstation {1}, break down the operation into multiple operations","Operacija {0} dlje od vseh razpoložljivih delovnih ur v delovni postaji {1}, razčleniti operacijo na več operacij",
Operations,Operacije,
Operations cannot be left blank,Operacije se ne sme ostati prazno,
Opp Count,Opp Štetje,
Opp/Lead %,OPP / svinec%,
Opportunities,Priložnosti,
Opportunities by lead source,"Možnosti, ki jih ponujajo svinec",
Opportunity,Priložnost,
Opportunity Amount,Znesek priložnosti,
Optional Holiday List not set for leave period {0},Neobvezni seznam počitnic ni določen za obdobje dopusta {0},
"Optional. Sets company's default currency, if not specified.","Neobvezno. Nastavi privzeto valuto družbe, če ni določeno.",
Optional. This setting will be used to filter in various transactions.,Neobvezno. Ta nastavitev bo uporabljena za filtriranje v različnih poslih.,
Options,Možnosti,
Order Count,Da bi Štetje,
Order Entry,Vnos naročila,
Order Value,Vrednost naročila,
Order rescheduled for sync,Naročilo je prestavljeno za sinhronizacijo,
Order/Quot %,Naročilo / quot%,
Ordered,Naročeno,
Ordered Qty,Naročeno Kol,
"Ordered Qty: Quantity ordered for purchase, but not received.","Naročeno Količina: Količina naročena za nakup, vendar ni prejeta.",
Orders,Naročila,
Orders released for production.,Naročila sprosti za proizvodnjo.,
Organization,Organizacija,
Organization Name,Organization Name,
Other,Drugi,
Other Reports,Druga poročila,
"Other outward supplies(Nil rated,Exempted)","Druge zunanje dobave (ničelno, oproščeno)",
Others,Drugi,
Out Qty,Out Kol,
Out Value,iz Vrednost,
Out of Order,Ne deluje,
Outgoing,Odhodni,
Outstanding,Izjemna,
Outstanding Amount,Neporavnani znesek,
Outstanding Amt,Izjemna Amt,
Outstanding Cheques and Deposits to clear,Neporavnani čeki in depoziti želite počistiti,
Outstanding for {0} cannot be less than zero ({1}),Izjemna za {0} ne more biti manjša od nič ({1}),
Outward taxable supplies(zero rated),Dohodno obdavčljive dobave (ničelna ocena),
Overdue,Zapadle,
Overlap in scoring between {0} and {1},Prekrivanje v dosegu med {0} in {1},
Overlapping conditions found between:,Prekrivajoča pogoji najdemo med:,
Owner,Lastnik,
PAN,PAN,
POS,POS,
POS Profile,POS profila,
POS Profile is required to use Point-of-Sale,Profil POS je potreben za uporabo Point-of-Sale,
POS Profile required to make POS Entry,"POS Profil zahteva, da POS Entry",
POS Settings,POS nastavitve,
Packed quantity must equal quantity for Item {0} in row {1},Pakirana količina mora biti enaka količini za postavko {0} v vrstici {1},
Packing Slip,Pakiranje listek,
Packing Slip(s) cancelled,Dobavnico (e) odpovedan,
Paid,Plačan,
Paid Amount,Znesek Plačila,
Paid Amount cannot be greater than total negative outstanding amount {0},Plačani znesek ne sme biti večja od celotnega negativnega neplačanega zneska {0},
Paid amount + Write Off Amount can not be greater than Grand Total,Plačan znesek + odpis Znesek ne sme biti večja od Grand Skupaj,
Paid and Not Delivered,Plačana in ni podal,
Parameter,Parameter,
Parent Item {0} must not be a Stock Item,Parent Item {0} ne sme biti Stock Postavka,
Parents Teacher Meeting Attendance,Udeležba učiteljev na srečanju staršev,
Part-time,Krajši delovni čas,
Partially Depreciated,delno amortiziranih,
Partially Received,Delno prejeto,
Party,Zabava,
Party Name,Ime stranka,
Party Type,Vrsta Party,
Party Type and Party is mandatory for {0} account,Vrsta stranke in stranka je obvezna za račun {0},
Party Type is mandatory,Vrsta Party je obvezen,
Party is mandatory,Party je obvezen,
Password,Geslo,
Password policy for Salary Slips is not set,Pravilnik o geslu za plače ni nastavljen,
Past Due Date,Pretekli rok,
Patient,Bolnik,
Patient Appointment,Imenovanje pacienta,
Patient Encounter,Patient Encounter,
Patient not found,Bolnik ni najden,
Pay Remaining,Plačajte preostale,
Pay {0} {1},Plačajte {0} {1},
Payable,Plačljivo,
Payable Account,Plačljivo račun,
Payable Amount,Plačljivi znesek,
Payment,Plačilo,
Payment Cancelled. Please check your GoCardless Account for more details,Plačilo preklicano. Preverite svoj GoCardless račun za več podrobnosti,
Payment Confirmation,Potrdilo plačila,
Payment Date,Dan plačila,
Payment Days,Plačilni dnevi,
Payment Document,plačilo dokumentov,
Payment Due Date,Datum zapadlosti,
Payment Entries {0} are un-linked,Plačilni Navedbe {0} un povezane,
Payment Entry,Začetek plačilo,
Payment Entry already exists,Plačilo vnos že obstaja,
Payment Entry has been modified after you pulled it. Please pull it again.,"Začetek Plačilo je bil spremenjen, ko je potegnil. Prosimo, še enkrat vleči.",
Payment Entry is already created,Začetek Plačilo je že ustvarjena,
Payment Failed. Please check your GoCardless Account for more details,Plačilo ni uspelo. Preverite svoj GoCardless račun za več podrobnosti,
Payment Gateway,Plačilo Gateway,
"Payment Gateway Account not created, please create one manually.","Plačilo Gateway računa ni ustvaril, si ustvariti ročno.",
Payment Gateway Name,Ime plačilnega prehoda,
Payment Mode,Način Plačilo,
Payment Receipt Note,Prejem plačilnih Note,
Payment Request,Plačilni Nalog,
Payment Request for {0},Zahteva za plačilo za {0},
Payment Tems,Tems plačila,
Payment Term,Pogoji plačila,
Payment Terms,Plačilni pogoji,
Payment Terms Template,Predloga za plačilni pogoji,
Payment Terms based on conditions,Plačilni pogoji glede na pogoje,
Payment Type,Način plačila,
"Payment Type must be one of Receive, Pay and Internal Transfer","Plačilo Tip mora biti eden od Prejemanje, plačati in notranji prenos",
Payment against {0} {1} cannot be greater than Outstanding Amount {2},Plačilo pred {0} {1} ne sme biti večja od neporavnanega zneska {2},
Payment of {0} from {1} to {2},Plačilo {0} od {1} do {2},
Payment request {0} created,Zahtevek za plačilo {0} je bil ustvarjen,
Payments,Plačila,
Payroll,izplačane plače,
Payroll Number,Številka plače,
Payroll Payable,Plače plačljivo,
Payslip,Payslip,
Pending Activities,Čakanju Dejavnosti,
Pending Amount,Dokler Znesek,
Pending Leaves,Čakajoči listi,
Pending Qty,Pending Kol,
Pending Quantity,Količina v teku,
Pending Review,Dokler Pregled,
Pending activities for today,V čakanju na aktivnosti za danes,
Pension Funds,Pokojninski skladi,
Percentage Allocation should be equal to 100%,Odstotek dodelitve mora biti enaka 100%,
Perception Analysis,Analiza percepcije,
Period,Obdobje,
Period Closing Entry,Obdobje Closing Začetek,
Period Closing Voucher,Obdobje Closing bon,
Periodicity,Periodičnost,
Personal Details,Osebne podrobnosti,
Pharmaceutical,Pharmaceutical,
Pharmaceuticals,Farmacevtski izdelki,
Physician,Zdravnik,
Piecework,Akord,
Pincode,Kodi PIN,
Place Of Supply (State/UT),Kraj dobave (država / UT),
Place Order,Naročiti,
Plan Name,Ime načrta,
Plan for maintenance visits.,Načrt za vzdrževanje obiskov.,
Planned Qty,Načrtovano Kol,
"Planned Qty: Quantity, for which, Work Order has been raised, but is pending to be manufactured.","Količina načrtovanih: Količina, za katero je bil delovni nalog dvignjen, vendar ga bo treba izdelati.",
Planning,Načrtovanje,
Plants and Machineries,Rastline in stroje,
Please Set Supplier Group in Buying Settings.,V nastavitvah nakupa nastavite skupino dobaviteljev.,
Please add a Temporary Opening account in Chart of Accounts,"Prosimo, dodajte račun za začasno odpiranje v kontnem okvirju",
Please add the account to root level Company - ,Dodajte račun na korensko raven Podjetje -,
Please add the remaining benefits {0} to any of the existing component,"Prosimo, dodajte preostale ugodnosti {0} v katero koli obstoječo komponento",
Please check Multi Currency option to allow accounts with other currency,"Prosimo, preverite Multi Valuta možnost, da se omogoči račune pri drugi valuti",
Please click on 'Generate Schedule',"Prosimo, kliknite na &quot;ustvarjajo Seznamu&quot;",
Please click on 'Generate Schedule' to fetch Serial No added for Item {0},"Prosimo, kliknite na &quot;ustvarjajo Seznamu&quot; puščati Serijska št dodal za postavko {0}",
Please click on 'Generate Schedule' to get schedule,"Prosimo, kliknite na &quot;ustvarjajo Seznamu&quot;, da bi dobili razpored",
Please confirm once you have completed your training,"Potrdite, ko ste končali usposabljanje",
Please create purchase receipt or purchase invoice for the item {0},"Prosimo, ustvarite potrdilo o nakupu ali kupite račun za predmet {0}",
Please define grade for Threshold 0%,"Prosimo, določite stopnjo za praga 0%",
Please enable Applicable on Booking Actual Expenses,"Omogočite veljavne stroške, ki se uporabljajo pri rezervaciji",
Please enable Applicable on Purchase Order and Applicable on Booking Actual Expenses,"Prosimo, omogočite veljavno naročilo in veljavne stroške rezervacije",
Please enable default incoming account before creating Daily Work Summary Group,"Prosimo, omogočite privzeti dohodni račun, preden ustvarite skupino povzetkov dnevnega reda",
Please enable pop-ups,"Prosimo, omogočite pojavna okna",
Please enter 'Is Subcontracted' as Yes or No,"Prosimo, vpišite &quot;Je v podizvajanje&quot;, kot DA ali NE",
Please enter API Consumer Key,Vnesite uporabniški ključ API,
Please enter API Consumer Secret,Vnesite Potrošniško skrivnost API-ja,
Please enter Account for Change Amount,Prosim vnesite račun za znesek spremembe,
Please enter Approving Role or Approving User,Vnesite Odobritev vloge ali Potrditev uporabnika,
Please enter Cost Center,Vnesite stroškovni center,
Please enter Delivery Date,Vnesite datum dostave,
Please enter Employee Id of this sales person,Vnesite ID Employee te prodaje oseba,
Please enter Expense Account,Vnesite Expense račun,
Please enter Item Code to get Batch Number,Vnesite Koda priti Serija Število,
Please enter Item Code to get batch no,Vnesite Koda dobiti serijo no,
Please enter Item first,"Prosimo, da najprej vnesete artikel",
Please enter Maintaince Details first,"Prosimo, da najprej vnesete Maintaince Podrobnosti",
Please enter Planned Qty for Item {0} at row {1},Vnesite načrtovanih Količina za postavko {0} v vrstici {1},
Please enter Preferred Contact Email,Vnesite Želeni Kontakt Email,
Please enter Production Item first,"Prosimo, da najprej vnesete Production artikel",
Please enter Purchase Receipt first,"Prosimo, da najprej vnesete Potrdilo o nakupu",
Please enter Receipt Document,Vnesite Prejem dokumenta,
Please enter Reference date,Vnesite Referenčni datum,
Please enter Repayment Periods,Vnesite roki odplačevanja,
Please enter Reqd by Date,Vnesite Reqd po datumu,
Please enter Woocommerce Server URL,Vnesite URL strežnika Woocommerce,
Please enter Write Off Account,Vnesite račun za odpis,
Please enter atleast 1 invoice in the table,Vnesite atleast 1 račun v tabeli,
Please enter company first,"Prosimo, da najprej vnesete podjetje",
Please enter company name first,"Prosimo, da najprej vpišete ime podjetja",
Please enter default currency in Company Master,Vnesite privzeto valuto v podjetju Master,
Please enter message before sending,Vnesite sporočilo pred pošiljanjem,
Please enter parent cost center,Vnesite stroškovno mesto matično,
Please enter quantity for Item {0},Vnesite količino za postavko {0},
Please enter relieving date.,Vnesite lajšanje datum.,
Please enter repayment Amount,Vnesite odplačevanja Znesek,
Please enter valid Financial Year Start and End Dates,"Prosimo, vnesite veljaven proračunsko leto, datum začetka in konca",
Please enter valid email address,Vnesite veljaven e-poštni naslov,
Please enter {0} first,Vnesite {0} najprej,
Please fill in all the details to generate Assessment Result.,"Prosimo, da izpolnite vse podrobnosti, da ustvarite rezultat ocene.",
Please identify/create Account (Group) for type - {0},Opišite / ustvarite račun (skupino) za vrsto - {0},
Please identify/create Account (Ledger) for type - {0},Opišite / ustvarite račun (knjigo) za vrsto - {0},
Please login as another user to register on Marketplace,"Prijavite se kot drugi uporabnik, da se registrirate 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.,"Prosimo, preverite, ali ste prepričani, da želite izbrisati vse posle, za te družbe. Vaši matični podatki bodo ostali kot je. Ta ukrep ni mogoče razveljaviti.",
Please mention Basic and HRA component in Company,V podjetju navedite komponento Basic in HRA,
Please mention Round Off Account in Company,Navedite zaokrožijo račun v družbi,
Please mention Round Off Cost Center in Company,Navedite zaokrožijo stroškovno mesto v družbi,
Please mention no of visits required,Navedite ni obiskov zahtevanih,
Please mention the Lead Name in Lead {0},"Prosimo, navedite vodilno ime v vodniku {0}",
Please pull items from Delivery Note,Prosimo povlecite predmete iz dobavnice,
Please register the SIREN number in the company information file,"Prosimo, registrirajte številko SIREN v podatkovni datoteki podjetja",
Please remove this Invoice {0} from C-Form {1},"Prosimo, odstranite tej fakturi {0} od C-Form {1}",
Please save the patient first,Najprej shranite bolnika,
Please save the report again to rebuild or update,"Ponovno shranite poročilo, da obnovite ali posodobite",
"Please select Allocated Amount, Invoice Type and Invoice Number in atleast one row","Prosimo, izberite Dodeljeni znesek, fakture Vrsta in številka računa v atleast eno vrstico",
Please select Apply Discount On,"Prosimo, izberite Uporabi popust na",
Please select BOM against item {0},"Prosimo, izberite BOM proti elementu {0}",
Please select BOM for Item in Row {0},Izberite BOM za postavko v vrstici {0},
Please select BOM in BOM field for Item {0},"Prosimo, izberite BOM BOM v polju za postavko {0}",
Please select Category first,"Prosimo, izberite kategorijo najprej",
Please select Charge Type first,"Prosimo, izberite Charge Vrsta najprej",
Please select Company,"Prosimo, izberite Company",
Please select Company and Designation,Izberite podjetje in določitev,
Please select Company and Posting Date to getting entries,"Prosimo, izberite Podjetje in Datum objave, da vnesete vnose",
Please select Company first,"Prosimo, izberite Company najprej",
Please select Completion Date for Completed Asset Maintenance Log,"Prosimo, izberite Datum zaključka za zaključen dnevnik vzdrževanja sredstev",
Please select Completion Date for Completed Repair,Izberite datum zaključka za dokončano popravilo,
Please select Course,Izberite tečaj,
Please select Drug,Izberite Drogo,
Please select Employee,Izberite zaposleni,
Please select Existing Company for creating Chart of Accounts,Izberite obstoječo družbo za ustvarjanje kontnem načrtu,
Please select Healthcare Service,Izberite storitev zdravstvenega varstva,
"Please select Item where ""Is Stock Item"" is ""No"" and ""Is Sales Item"" is ""Yes"" and there is no other Product Bundle","Prosimo, izberite postavko, kjer &quot;Stock postavka je&quot; &quot;Ne&quot; in &quot;Je Sales Postavka&quot; je &quot;Yes&quot; in ni druge Bundle izdelka",
Please select Maintenance Status as Completed or remove Completion Date,Izberite stanje vzdrževanja kot dokončano ali odstranite datum zaključka,
Please select Party Type first,Izberite Party Vrsta najprej,
Please select Patient,Izberite Patient,
Please select Patient to get Lab Tests,"Prosimo, izberite Patient, da dobite laboratorijske teste",
Please select Posting Date before selecting Party,Izberite datum objave pred izbiro stranko,
Please select Posting Date first,"Prosimo, izberite datumom knjiženja najprej",
Please select Price List,Izberite Cenik,
Please select Program,Izberite Program,
Please select Qty against item {0},Izberite količino proti elementu {0},
Please select Sample Retention Warehouse in Stock Settings first,Najprej izberite skladišče za shranjevanje vzorcev v nastavitvah zalog,
Please select Start Date and End Date for Item {0},"Prosimo, izberite Start in končni datum za postavko {0}",
Please select Student Admission which is mandatory for the paid student applicant,"Prosimo, izberite Študentski Pristop, ki je obvezen za študenta, ki plača študent",
Please select a BOM,Izberite BOM,
Please select a Batch for Item {0}. Unable to find a single batch that fulfills this requirement,"Izberite Serija za postavko {0}. Ni mogoče, da bi našli eno serijo, ki izpolnjuje te zahteve",
Please select a Company,Prosimo izberite Company,
Please select a batch,Izberite serijo,
Please select a csv file,Izberite csv datoteko,
Please select a field to edit from numpad,Izberite polje za urejanje iz numpad,
Please select a table,Izberite tabelo,
Please select a valid Date,Izberite veljaven datum,
Please select a value for {0} quotation_to {1},"Prosimo, izberite vrednost za {0} quotation_to {1}",
Please select a warehouse,Izberite skladišče,
Please select at least one domain.,Izberite vsaj eno domeno.,
Please select correct account,"Prosimo, izberite ustrezen račun",
Please select date,Izberite datum,
Please select item code,"Prosimo, izberite postavko kodo",
Please select month and year,"Prosimo, izberite mesec in leto",
Please select prefix first,"Prosimo, izberite predpono najprej",
Please select the Company,Izberite podjetje,
Please select the Multiple Tier Program type for more than one collection rules.,"Prosimo, izberite vrsto programa z več tirnimi sistemi za več pravil za zbiranje.",
Please select the assessment group other than 'All Assessment Groups',"Izberite ocenjevalne skupine, razen &quot;vseh skupin za presojo&quot;",
Please select the document type first,"Prosimo, najprej izberite vrsto dokumenta",
Please select weekly off day,"Prosimo, izberite tedensko off dan",
Please select {0},"Prosimo, izberite {0}",
Please select {0} first,"Prosimo, izberite {0} najprej",
Please set 'Apply Additional Discount On',Prosim nastavite &quot;Uporabi dodatni popust na &#39;,
Please set 'Asset Depreciation Cost Center' in Company {0},Prosim nastavite &quot;Asset Center Amortizacija stroškov&quot; v družbi {0},
Please set 'Gain/Loss Account on Asset Disposal' in Company {0},Prosim nastavite &quot;dobiček / izguba račun pri odtujitvi sredstev&quot; v družbi {0},
Please set Account in Warehouse {0} or Default Inventory Account in Company {1},V računu Warehouse {0} ali Privzetem inventarju nastavite račun v podjetju {1},
Please set B2C Limit in GST Settings.,Nastavite omejitev B2C v nastavitvah GST.,
Please set Company,Nastavite Company,
Please set Company filter blank if Group By is 'Company',"Nastavite Podjetje filtriranje prazno, če skupina Z je &quot;Podjetje&quot;",
Please set Default Payroll Payable Account in Company {0},"Prosimo, nastavite privzetega izplačane plače je treba plačati račun v družbi {0}",
Please set Depreciation related Accounts in Asset Category {0} or Company {1},"Prosim, nastavite račune, povezane Amortizacija v sredstvih kategoriji {0} ali družbe {1}",
Please set Email Address,Nastavite e-poštni naslov,
Please set GST Accounts in GST Settings,Nastavite GST račune v nastavitvah GST,
Please set Hotel Room Rate on {},"Prosimo, nastavite hotelsko sobo na {",
Please set Number of Depreciations Booked,"Prosim, nastavite Število amortizacije Rezervirano",
Please set Unrealized Exchange Gain/Loss Account in Company {0},V podjetju nastavite neizkoriščen račun za dobiček / izgubo za Exchange {0},
Please set User ID field in an Employee record to set Employee Role,"Prosim, nastavite ID uporabnika polje v zapisu zaposlenih za določen Vloga zaposlenih",
Please set a default Holiday List for Employee {0} or Company {1},Nastavite privzeto Hiša List za zaposlenega {0} ali podjetja {1},
Please set account in Warehouse {0},Nastavite račun v Galeriji {0},
Please set an active menu for Restaurant {0},"Prosimo, nastavite aktivni meni za restavracijo {0}",
Please set associated account in Tax Withholding Category {0} against Company {1},"Prosimo, nastavite povezani račun v Kategorija davčne zavrnitve {0} proti podjetju {1}",
Please set at least one row in the Taxes and Charges Table,V tabelo davkov in dajatev nastavite vsaj eno vrstico,
Please set default Cash or Bank account in Mode of Payment {0},"Prosim, nastavite privzeto gotovinski ali bančni račun v načinu plačevanja {0}",
Please set default account in Salary Component {0},"Prosim, nastavite privzetega računa v plač komponento {0}",
Please set default customer in Restaurant Settings,Privzeto stran nastavite v nastavitvah restavracij,
Please set default template for Leave Approval Notification in HR Settings.,"Prosimo, nastavite privzeto predlogo za obvestilo o zavrnitvi odobritve v HR nastavitvah.",
Please set default template for Leave Status Notification in HR Settings.,"Prosimo, nastavite privzeto predlogo za obvestilo o opustitvi statusa v HR nastavitvah.",
Please set default {0} in Company {1},"Prosim, nastavite privzeto {0} v družbi {1}",
Please set filter based on Item or Warehouse,"Prosim, nastavite filter, ki temelji na postavki ali skladišče",
Please set leave policy for employee {0} in Employee / Grade record,"Prosimo, nastavite politiko dopusta zaposlenega {0} v zapisu zaposlenih / razreda",
Please set recurring after saving,"Prosim, nastavite ponavljajočih se po shranjevanju",
Please set the Company,Nastavite Company,
Please set the Customer Address,"Prosimo, nastavite naslov stranke",
Please set the Date Of Joining for employee {0},"Prosimo, da določi datum Vstop za zaposlenega {0}",
Please set the Default Cost Center in {0} company.,Center za privzete stroške nastavite v {0} podjetju.,
Please set the Email ID for the Student to send the Payment Request,"Prosimo, nastavite e-poštni ID za študenta, da pošljete zahtevek za plačilo",
Please set the Item Code first,Najprej nastavite kodo izdelka,
Please set the Payment Schedule,"Prosimo, nastavite plačilni načrt",
Please set the series to be used.,"Prosimo, nastavite serijo za uporabo.",
Please set {0} for address {1},"Prosimo, nastavite {0} za naslov {1}",
Please setup Students under Student Groups,"Prosimo, nastavite Študente v študentskih skupinah",
Please share your feedback to the training by clicking on 'Training Feedback' and then 'New',"Pošljite povratne informacije o usposabljanju, tako da kliknete »Povratne informacije o usposabljanju« in nato »Novo«,",
Please specify Company,"Prosimo, navedite Company",
Please specify Company to proceed,"Prosimo, navedite Company nadaljevati",
Please specify a valid 'From Case No.',"Prosimo, navedite veljaven &quot;Od zadevi št &#39;",
Please specify a valid Row ID for row {0} in table {1},Navedite veljavno Row ID za vrstico {0} v tabeli {1},
Please specify at least one attribute in the Attributes table,Prosimo navedite vsaj en atribut v tabeli Atributi,
Please specify currency in Company,"Prosimo, navedite valuto v družbi",
Please specify either Quantity or Valuation Rate or both,"Prosimo, navedite bodisi količina ali Ocenite vrednotenja ali oboje",
Please specify from/to range,"Prosimo, navedite iz / v razponu",
Please supply the specified items at the best possible rates,"Prosimo, da določene elemente na najboljših možnih cenah",
Please update your status for this training event,"Prosimo, posodobite svoj status za ta trening dogodek",
Please wait 3 days before resending the reminder.,Počakajte 3 dni pred ponovnim pošiljanjem opomnika.,
Point of Sale,Prodajno mesto,
Point-of-Sale,Prodajno mesto,
Point-of-Sale Profile,Point-of-Sale profila,
Portal,Portal,
Portal Settings,Portal Nastavitve,
Possible Supplier,Možni Dobavitelj,
Postal Expenses,Poštni stroški,
Posting Date,Napotitev Datum,
Posting Date cannot be future date,Napotitev datum ne more biti prihodnji datum,
Posting Time,Ura vnosa,
Posting date and posting time is mandatory,"Napotitev datum in čas objavljate, je obvezna",
Posting timestamp must be after {0},Napotitev žig mora biti po {0},
Potential opportunities for selling.,Potencialne možnosti za prodajo.,
Practitioner Schedule,Urnik zdravnikov,
Pre Sales,pre Sales,
Preference,Prednost,
Prescribed Procedures,Predpisani postopki,
Prescription,Predpis,
Prescription Dosage,Odmerjanje na recept,
Prescription Duration,Trajanje recepta,
Prescriptions,Predpisi,
Present,Present,
Prev,Prejšnja,
Preview,Predogled,
Preview Salary Slip,Predogled Plača listek,
Previous Financial Year is not closed,Prejšnja Proračunsko leto ni zaprt,
Price,Cena,
Price List,Cenik,
Price List Currency not selected,Cenik Valuta ni izbran,
Price List Rate,Cenik Rate,
Price List master.,Cenik gospodar.,
Price List must be applicable for Buying or Selling,Cenik mora biti primerno za nakup ali prodajo,
Price List {0} is disabled or does not exist,Cenik {0} je onemogočena ali pa ne obstaja,
Price or product discount slabs are required,Potrebne so plošče za ceno ali popust,
Pricing,Cenitev,
Pricing Rule,Cen Pravilo,
"Pricing Rule is first selected based on 'Apply On' field, which can be Item, Item Group or Brand.","Cen Pravilo je najprej treba izbrati glede na &quot;Uporabi On &#39;polju, ki je lahko točka, točka Group ali Brand.",
"Pricing Rule is made to overwrite Price List / define discount percentage, based on some criteria.","Cen Pravilo je narejen prepisati Cenik / določiti diskontno odstotek, na podlagi nekaterih kriterijev.",
Pricing Rule {0} is updated,Pravilo oblikovanja cen {0} je posodobljeno,
Pricing Rules are further filtered based on quantity.,Cenovne Pravila so dodatno filtriran temelji na količini.,
Primary Address Details,Osnovni podatki o naslovu,
Primary Contact Details,Primarni kontaktni podatki,
Principal Amount,Glavni znesek,
Print Format,Print Format,
Print IRS 1099 Forms,Natisni obrazci IRS 1099,
Print Report Card,Kartica za tiskanje poročila,
Print Settings,Nastavitve tiskanja,
Print and Stationery,Tiskanje in Pisalne,
Print settings updated in respective print format,nastavitve tiskanja posodabljajo v ustrezni obliki za tiskanje,
Print taxes with zero amount,Natisni davke z ničelnim zneskom,
Printing and Branding,Tiskanje in Branding,
Private Equity,Private Equity,
Privilege Leave,Privilege Zapusti,
Probation,Poskusno delo,
Probationary Period,Poskusna doba,
Procedure,Postopek,
Process Day Book Data,Obdelajte podatke o knjigi na dan,
Process Master Data,Obdelajte glavne podatke,
Processing Chart of Accounts and Parties,Obdelava kontnega plana in strani,
Processing Items and UOMs,Obdelava elementov in UOM-ov,
Processing Party Addresses,Naslovi obdelovalnih strank,
Processing Vouchers,Obdelava bonov,
Procurement,Javna naročila,
Produced Qty,Proizvedeno količino,
Product,Izdelek,
Product Bundle,Bundle izdelek,
Product Search,Iskanje,
Production,Proizvodnja,
Production Item,Proizvodnja Postavka,
Products,Izdelki,
Profit and Loss,Dobiček in izguba,
Profit for the year,Dobiček za leto,
Program,Program,
Program in the Fee Structure and Student Group {0} are different.,Program v strukturi pristojbin in študentski skupini {0} je drugačen.,
Program {0} does not exist.,Program {0} ne obstaja.,
Program: ,Program:,
Progress % for a task cannot be more than 100.,"Napredek% za nalogo, ne more biti več kot 100.",
Project Collaboration Invitation,Projekt Sodelovanje Vabilo,
Project Id,ID projekta,
Project Manager,Project Manager,
Project Name,Ime Projekta,
Project Start Date,Projekt Start Date,
Project Status,Stanje projekta,
Project Summary for {0},Povzetek projekta za {0},
Project Update.,Posodobitev projekta.,
Project Value,Project Value,
Project activity / task.,Projektna dejavnost / naloga.,
Project master.,Master projekt.,
Project-wise data is not available for Quotation,Podatki projekt pametno ni na voljo za ponudbo,
Projected,Predvidoma,
Projected Qty,Predvidena količina,
Projected Quantity Formula,Formula predvidene količine,
Projects,Projekti,
Property,Nepremičnine,
Property already added,Lastnost že dodana,
Proposal Writing,Predlog Pisanje,
Proposal/Price Quote,Cenik ponudbe / cen,
Prospecting,Raziskovanje,
Provisional Profit / Loss (Credit),Začasna dobiček / izguba (Credit),
Publications,Publikacije,
Publish Items on Website,Objavite elementov na spletni strani,
Published,Objavljeno,
Publishing,Založništvo,
Purchase,Nakup,
Purchase Amount,Znesek nakupa,
Purchase Date,Datum nakupa,
Purchase Invoice,Nakup Račun,
Purchase Invoice {0} is already submitted,Nakup Račun {0} je že predložila,
Purchase Manager,Nakup Manager,
Purchase Master Manager,Nakup Master Manager,
Purchase Order,Naročilnica,
Purchase Order Amount,Znesek naročila,
Purchase Order Amount(Company Currency),Znesek naročila (valuta podjetja),
Purchase Order Date,Datum naročila,
Purchase Order Items not received on time,Točke naročilnice niso bile prejete pravočasno,
Purchase Order number required for Item {0},Naročilnica zahtevanega števila za postavko {0},
Purchase Order to Payment,Nakup naročila do plačila,
Purchase Order {0} is not submitted,Naročilnica {0} ni predložila,
Purchase Orders are not allowed for {0} due to a scorecard standing of {1}.,Nakupna naročila niso dovoljena za {0} zaradi postavke ocene rezultatov {1}.,
Purchase Orders given to Suppliers.,Naročila dati dobaviteljev.,
Purchase Price List,Nakup Cenik,
Purchase Receipt,Potrdilo o nakupu,
Purchase Receipt {0} is not submitted,Potrdilo o nakupu {0} ni predložila,
Purchase Tax Template,Nakup Davčna Template,
Purchase User,Nakup Uporabnik,
Purchase orders help you plan and follow up on your purchases,Naročilnice vam pomaga načrtovati in spremljati svoje nakupe,
Purchasing,Purchasing,
Purpose must be one of {0},Cilj mora biti eden od {0},
Qty,Kol.,
Qty To Manufacture,Količina za izdelavo,
Qty Total,Količina skupaj,
Qty for {0},Količina za {0},
Qualification,Kvalifikacije,
Quality,Kakovost,
Quality Action,Kakovostna akcija,
Quality Goal.,Cilj kakovosti.,
Quality Inspection,Quality Inspection,
Quality Inspection: {0} is not submitted for the item: {1} in row {2},Pregled kakovosti: {0} za izdelek ni: {1} v vrsti {2},
Quality Management,Upravljanje kakovosti,
Quality Meeting,Kakovostno srečanje,
Quality Procedure,Postopek kakovosti,
Quality Procedure.,Postopek kakovosti.,
Quality Review,Pregled kakovosti,
Quantity,Količina,
Quantity for Item {0} must be less than {1},Količina za postavko {0} sme biti manjša od {1},
Quantity in row {0} ({1}) must be same as manufactured quantity {2},Količina v vrstici {0} ({1}) mora biti enaka kot je bila proizvedena količina {2},
Quantity must be less than or equal to {0},Količina mora biti manjša ali enaka {0},
Quantity must not be more than {0},Količina ne sme biti več kot {0},
Quantity required for Item {0} in row {1},"Količina, potrebna za postavko {0} v vrstici {1}",
Quantity should be greater than 0,Količina mora biti večja od 0,
Quantity to Make,Količina za izdelavo,
Quantity to Manufacture must be greater than 0.,Količina na Izdelava mora biti večja od 0.,
Quantity to Produce,Količina za proizvodnjo,
Quantity to Produce can not be less than Zero,Količina za proizvodnjo ne sme biti manjša od ničle,
Query Options,Možnosti poizvedbe,
Queued for replacing the BOM. It may take a few minutes.,Vrstni red za zamenjavo BOM. Traja lahko nekaj minut.,
Queued for updating latest price in all Bill of Materials. It may take a few minutes.,Vrstni red za posodobitev najnovejše cene v vseh gradivih. Traja lahko nekaj minut.,
Quick Journal Entry,Hitro Journal Entry,
Quot Count,quot Štetje,
Quot/Lead %,Quot / svinec%,
Quotation,Ponudba,
Quotation {0} is cancelled,Ponudba {0} je odpovedana,
Quotation {0} not of type {1},Ponudba {0} ni tipa {1},
Quotations,Ponudbe,
"Quotations are proposals, bids you have sent to your customers","Citati so predlogi, ponudbe, ki ste jih poslali svojim strankam",
Quotations received from Suppliers.,Prejete ponudbe,
Quotations: ,Ponudbe:,
Quotes to Leads or Customers.,Ponudbe za interesente ali stranke.,
RFQs are not allowed for {0} due to a scorecard standing of {1},RFQ-ji niso dovoljeni za {0} zaradi postavke ocene rezultatov {1},
Range,Razpon,
Rate,Stopnja,
Rate:,Oceniti:,
Rating,Ocena,
Raw Material,Surovina,
Raw Materials,Surovine,
Raw Materials cannot be blank.,Surovine ne more biti prazno.,
Re-open,Re-open,
Read blog,Preberite blog,
Read the ERPNext Manual,Preberite ERPNext navodila,
Reading Uploaded File,Branje naložene datoteke,
Real Estate,Nepremičnina,
Reason For Putting On Hold,Razlog za zaustavitev,
Reason for Hold,Razlog za zadrževanje,
Reason for hold: ,Razlog za zadržanje:,
Receipt,Prejem,
Receipt document must be submitted,Potrdilo dokument je treba predložiti,
Receivable,Terjatev,
Receivable Account,Terjatev račun,
Received,Prejetih,
Received On,Prejetih Na,
Received Quantity,Prejeta količina,
Received Stock Entries,Prejeti vpisi v zaloge,
Receiver List is empty. Please create Receiver List,"Sprejemnik Seznam je prazen. Prosimo, da ustvarite sprejemnik seznam",
Recipients,Prejemniki,
Reconcile,Uskladitev,
"Record of all communications of type email, phone, chat, visit, etc.","Evidenca vseh komunikacij tipa elektronski pošti, telefonu, klepet, obisk, itd",
Records,Zapisi,
Redirect URL,Preusmeritev URL,
Ref,Ref,
Ref Date,Ref Datum,
Reference,Sklicevanje,
Reference #{0} dated {1},Referenčna # {0} dne {1},
Reference Date,Referenčni datum,
Reference Doctype must be one of {0},Referenčna DOCTYPE mora biti eden od {0},
Reference Document,referenčni dokument,
Reference Document Type,Referenčni dokument Type,
Reference No & Reference Date is required for {0},Referenčna št &amp; Referenčni datum je potrebna za {0},
Reference No and Reference Date is mandatory for Bank transaction,Referenčna številka in referenčni datum je obvezna za banke transakcijo,
Reference No is mandatory if you entered Reference Date,"Referenčna številka je obvezna, če ste vnesli referenčni datum",
Reference No.,Referenčna št.,
Reference Number,Referenčna številka,
Reference Owner,referenčna lastnika,
Reference Type,Referenčna Type,
"Reference: {0}, Item Code: {1} and Customer: {2}",Referenca: {0} Oznaka: {1} in stranke: {2},
References,Reference,
Refresh Token,Osveži Token,
Region,Regija,
Register,Registriraj se,
Reject,Zavrni,
Rejected,Zavrnjeno,
Related,Podobni,
Relation with Guardian1,Povezava z Guardian1,
Relation with Guardian2,Povezava z skrbnika2,
Release Date,Datum izdaje,
Reload Linked Analysis,Ponovno naloži povezano analizo,
Remaining,preostala,
Remaining Balance,Ostati v ravnotežju,
Remarks,Opombe,
Reminder to update GSTIN Sent,Opomnik za posodobitev GSTIN Poslano,
Remove item if charges is not applicable to that item,"Odstranite element, če stroški ne nanaša na to postavko",
Removed items with no change in quantity or value.,Odstranjeni deli brez spremembe količine ali vrednosti.,
Reopen,Ponovno odpre,
Reorder Level,Preureditev Raven,
Reorder Qty,Preureditev Kol,
Repeat Customer Revenue,Ponovite Customer Prihodki,
Repeat Customers,Ponovite stranke,
Replace BOM and update latest price in all BOMs,Zamenjajte BOM in posodobite najnovejšo ceno v vseh BOM,
Replied,Odgovorjeno,
Replies,Odgovori,
Report,Poročilo,
Report Builder,Gradnik poročil,
Report Type,Poročilo Type,
Report Type is mandatory,Vrsta poročila je obvezna,
Reports,Poročila,
Reqd By Date,Reqd po Datum,
Reqd Qty,Reqd Qty,
Request for Quotation,Zahteva za ponudbo,
Request for Quotations,Zahteva za Citati,
Request for Raw Materials,Prošnja za Surove materiale,
Request for purchase.,Zaprosi za nakup.,
Request for quotation.,Zahteva za ponudbo.,
Requested Qty,Zahteval Kol,
"Requested Qty: Quantity requested for purchase, but not ordered.","Zahtevana količina: Zahtevana količina za nakup, vendar ni naročena.",
Requesting Site,"Spletno mesto, ki zaprosi",
Requesting payment against {0} {1} for amount {2},Zahteva plačilo pred {0} {1} za znesek {2},
Requestor,Prosilec,
Required On,Zahtevani Na,
Required Qty,Zahtevani Kol,
Required Quantity,Zahtevana količina,
Reschedule,Ponovni premik,
Research,Raziskave,
Research & Development,Raziskave in razvoj,
Researcher,Raziskovalec,
Resend Payment Email,Ponovno pošlji plačila Email,
Reserve Warehouse,Rezervno skladišče,
Reserved Qty,Rezervirano Kol,
Reserved Qty for Production,Rezervirano Količina za proizvodnjo,
Reserved Qty for Production: Raw materials quantity to make manufacturing items.,Količina pridržane za proizvodnjo: Količina surovin za izdelavo izdelkov.,
"Reserved Qty: Quantity ordered for sale, but not delivered.","Količina rezervirana: Količina, naročena za prodajo, vendar ni dobavljena.",
Reserved Warehouse is mandatory for Item {0} in Raw Materials supplied,Rezervirano skladišče je obvezno za postavko {0} v dobavljenih surovinah,
Reserved for manufacturing,Rezervirano za proizvodnjo,
Reserved for sale,Rezervirano za prodajo,
Reserved for sub contracting,Rezervirano za podizvajalce,
Resistant,Odporen,
Resolve error and upload again.,Odpravite napako in naložite znova.,
Responsibilities,Odgovornosti,
Rest Of The World,Ostali svet,
Restart Subscription,Ponovni zagon naročnine,
Restaurant,Restavracija,
Result Date,Datum oddaje,
Result already Submitted,Rezultat že oddan,
Resume,Nadaljuj,
Retail,Maloprodaja,
Retail & Wholesale,Trgovina na drobno in na debelo,
Retail Operations,Maloprodajne dejavnosti,
Retained Earnings,Preneseni čisti poslovni izid,
Retention Stock Entry,Vstop v zaloge,
Retention Stock Entry already created or Sample Quantity not provided,"Zaprta zaloga, ki je že bila ustvarjena, ali količina vzorca ni zagotovljena",
Return,Return,
Return / Credit Note,Nazaj / dobropis,
Return / Debit Note,Nazaj / opominu,
Returns,Vračila,
Reverse Journal Entry,Reverse Journal Entry,
Review Invitation Sent,Povabljeni vabilo,
Review and Action,Pregled in ukrepanje,
Role,Vloga,
Rooms Booked,Sobe Rezervirano,
Root Company,Root Company,
Root Type,Root Type,
Root Type is mandatory,Root Tip je obvezna,
Root cannot be edited.,Root ni mogoče urejati.,
Root cannot have a parent cost center,Root ne more imeti matična stroškovno mesto v,
Round Off,Zaokrožite,
Rounded Total,Zaokroženo skupaj,
Route,Route,
Row # {0}: ,Vrstica # {0}:,
Row # {0}: Batch No must be same as {1} {2},Vrstica # {0}: mora Serija Ne biti enaka kot {1} {2},
Row # {0}: Cannot return more than {1} for Item {2},Vrstica # {0}: ne more vrniti več kot {1} za postavko {2},
Row # {0}: Rate cannot be greater than the rate used in {1} {2},"Vrstica # {0}: stopnja ne more biti večji od stopnje, ki se uporablja pri {1} {2}",
Row # {0}: Serial No is mandatory,Vrstica # {0}: Zaporedna številka je obvezna,
Row # {0}: Serial No {1} does not match with {2} {3},Vrstica # {0}: Serijska št {1} ne ujema z {2} {3},
Row #{0} (Payment Table): Amount must be negative,Vrstica # {0} (Tabela plačil): Znesek mora biti negativen,
Row #{0} (Payment Table): Amount must be positive,Vrstica # {0} (Tabela plačil): Znesek mora biti pozitiven,
Row #{0}: Account {1} does not belong to company {2},Vrstica # {0}: Račun {1} ne pripada podjetju {2},
Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Vrstica # {0}: Razporejeni vrednosti ne sme biti večja od neplačanega zneska.,
"Row #{0}: Asset {1} cannot be submitted, it is already {2}","Row # {0}: Asset {1} ni mogoče predložiti, je že {2}",
Row #{0}: Cannot set Rate if amount is greater than billed amount for Item {1}.,"Vrstica # {0}: Ne morem nastaviti stopnje, če je znesek večji od zaračunanega zneska za predmet {1}.",
Row #{0}: Clearance date {1} cannot be before Cheque Date {2},Row # {0}: Datum Potrditev {1} ne more biti pred Ček Datum {2},
Row #{0}: Duplicate entry in References {1} {2},Vrstica # {0}: Duplikat vnos v Referenčni {1} {2},
Row #{0}: Expected Delivery Date cannot be before Purchase Order Date,Vrstica # {0}: Pričakovani datum dostave ne sme biti pred datumom naročila,
Row #{0}: Item added,Vrstica # {0}: element je dodan,
Row #{0}: Journal Entry {1} does not have account {2} or already matched against another voucher,Row # {0}: Journal Entry {1} nima računa {2} ali pa so že primerjali z drugo kupona,
Row #{0}: Not allowed to change Supplier as Purchase Order already exists,Vrstica # {0}: ni dovoljeno spreminjati Dobavitelj kot Naročilo že obstaja,
Row #{0}: Please set reorder quantity,Vrstica # {0}: Prosim nastavite naročniško količino,
Row #{0}: Please specify Serial No for Item {1},Vrstica # {0}: Navedite Zaporedna številka za postavko {1},
Row #{0}: Qty increased by 1,Vrstica # {0}: Število se je povečalo za 1,
Row #{0}: Rate must be same as {1}: {2} ({3} / {4}) ,Vrstica # {0}: Stopnja mora biti enaka kot {1}: {2} ({3} / {4}),
Row #{0}: Reference Document Type must be one of Expense Claim or Journal Entry,Vrstica # {0}: Referenčni dokument mora biti eden od zahtevkov za stroške ali vpisa v dnevnik,
"Row #{0}: Reference Document Type must be one of Purchase Order, Purchase Invoice or Journal Entry","Row # {0}: Reference Vrsta dokumenta mora biti eden od narocilo, Nakup računa ali Journal Entry",
Row #{0}: Rejected Qty can not be entered in Purchase Return,Vrstica # {0}: Zavrnjena Kol ne more biti vpisana v Nabava Nazaj,
Row #{0}: Rejected Warehouse is mandatory against rejected Item {1},Vrstica # {0}: zavrnitev Skladišče je obvezno proti zavrnil postavki {1},
Row #{0}: Reqd by Date cannot be before Transaction Date,Vrstica # {0}: Reqd po datumu ne more biti pred datumom transakcije,
Row #{0}: Set Supplier for item {1},Vrstica # {0}: Nastavite Dobavitelj za postavko {1},
Row #{0}: Status must be {1} for Invoice Discounting {2},Vrstica # {0}: za popust na računu mora biti stanje {1} {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","Vrstica # {0}: Serija {1} ima le {2} kol. Izberite drugo serijo, ki ima {3} kol na voljo ali razdeli vrstico v več vrstic, da poda / vprašanja iz različnih serij",
Row #{0}: Timings conflicts with row {1},Vrstica # {0}: čase v nasprotju z vrsto {1},
Row #{0}: {1} can not be negative for item {2},Vrstica # {0} {1} ne more biti negativna za element {2},
Row No {0}: Amount cannot be greater than Pending Amount against Expense Claim {1}. Pending Amount is {2},Vrstica št {0}: količina ne more biti večja od Dokler Znesek proti Expense zahtevka {1}. Dokler Znesek je {2},
Row {0} : Operation is required against the raw material item {1},Vrstica {0}: delovanje je potrebno proti elementu surovin {1},
Row {0}# Allocated amount {1} cannot be greater than unclaimed amount {2},"Vrstica {0} # Razdeljena količina {1} ne sme biti večja od količine, za katero je vložena zahtevka {2}",
Row {0}# Item {1} cannot be transferred more than {2} against Purchase Order {3},Vrstice {0} # Element {1} ni mogoče prenesti več kot {2} proti naročilnici {3},
Row {0}# Paid Amount cannot be greater than requested advance amount,Vrstica {0} # Plačan znesek ne sme biti večji od zahtevanega zneska predplačila,
Row {0}: Activity Type is mandatory.,Vrstica {0}: Vrsta dejavnosti je obvezna.,
Row {0}: Advance against Customer must be credit,Vrstica {0}: Advance proti naročniku mora biti kredit,
Row {0}: Advance against Supplier must be debit,Vrstica {0}: Advance zoper dobavitelja mora biti v breme,
Row {0}: Allocated amount {1} must be less than or equals to Payment Entry amount {2},"Vrstica {0}: Dodeljena količina {1}, mora biti manjša ali enaka plačila za vnos zneska {2}",
Row {0}: Allocated amount {1} must be less than or equals to invoice outstanding amount {2},"Vrstica {0}: Dodeljena količina {1}, mora biti manjša ali enaka zaračunati neodplačanega {2}",
Row {0}: An Reorder entry already exists for this warehouse {1},Vrstica {0}: Vpis Preureditev že obstaja za to skladišče {1},
Row {0}: Bill of Materials not found for the Item {1},Vrstica {0}: Kosovnica nismo našli v postavki {1},
Row {0}: Conversion Factor is mandatory,Vrstica {0}: Factor Pretvorba je obvezna,
Row {0}: Cost center is required for an item {1},Vrstica {0}: Za postavko je potreben stroškovni center {1},
Row {0}: Credit entry can not be linked with a {1},Vrstica {0}: Credit vnos ni mogoče povezati z {1},
Row {0}: Currency of the BOM #{1} should be equal to the selected currency {2},Vrstica {0}: valuta BOM # {1} mora biti enaka izbrani valuti {2},
Row {0}: Debit entry can not be linked with a {1},Vrstica {0}: debetna vnos ne more biti povezano z {1},
Row {0}: Depreciation Start Date is required,Vrstica {0}: začetni datum amortizacije je obvezen,
Row {0}: Enter location for the asset item {1},Vrstica {0}: vnesite lokacijo za postavko sredstva {1},
Row {0}: Exchange Rate is mandatory,Vrstica {0}: menjalni tečaj je obvezen,
Row {0}: Expected Value After Useful Life must be less than Gross Purchase Amount,Vrstica {0}: Pričakovana vrednost po uporabnem življenjskem obdobju mora biti manjša od bruto zneska nakupa,
Row {0}: From Time and To Time is mandatory.,Vrstica {0}: Od časa in do časa je obvezna.,
Row {0}: From Time and To Time of {1} is overlapping with {2},Vrstica {0}: V času in času {1} se prekrivajo z {2},
Row {0}: From time must be less than to time,Vrstica {0}: Od časa mora biti manj časa,
Row {0}: Hours value must be greater than zero.,Vrstica {0}: Ure vrednost mora biti večja od nič.,
Row {0}: Invalid reference {1},Vrstica {0}: Neveljavna referenčna {1},
Row {0}: Party / Account does not match with {1} / {2} in {3} {4},Vrstica {0}: Party / račun se ne ujema z {1} / {2} v {3} {4},
Row {0}: Party Type and Party is required for Receivable / Payable account {1},Vrstica {0}: Vrsta stranka in stranka je potrebna za terjatve / obveznosti račun {1},
Row {0}: Payment against Sales/Purchase Order should always be marked as advance,Vrstica {0}: morala Plačilo proti prodaja / narocilo vedno označen kot vnaprej,
Row {0}: Please check 'Is Advance' against Account {1} if this is an advance entry.,"Vrstica {0}: Prosimo, preverite &quot;Je Advance&quot; proti račun {1}, če je to predujem vnos.",
Row {0}: Please set at Tax Exemption Reason in Sales Taxes and Charges,"Vrstica {0}: Prosimo, nastavite Razlog oprostitve plačila davkov na promet in davkov",
Row {0}: Please set the Mode of Payment in Payment Schedule,Vrstica {0}: v plačilni shemi nastavite način plačila,
Row {0}: Please set the correct code on Mode of Payment {1},Vrstica {0}: nastavite pravilno kodo na način plačila {1},
Row {0}: Qty is mandatory,Vrstica {0}: Kol je obvezna,
Row {0}: Quality Inspection rejected for item {1},Vrstica {0}: pregled izdelka je zavrnjen za postavko {1},
Row {0}: UOM Conversion Factor is mandatory,Vrstica {0}: UOM Conversion Factor je obvezna,
Row {0}: select the workstation against the operation {1},Vrstica {0}: izberite delovno postajo proti operaciji {1},
Row {0}: {1} Serial numbers required for Item {2}. You have provided {3}.,"Vrstica {0}: {1} Serijske številke, potrebne za postavko {2}. Dali ste {3}.",
Row {0}: {1} must be greater than 0,Vrstica {0}: {1} mora biti večja od 0,
Row {0}: {1} {2} does not match with {3},Vrstica {0}: {1} {2} ne ujema s {3},
Row {0}:Start Date must be before End Date,Vrstica {0}: začetni datum mora biti pred končnim datumom,
Rows with duplicate due dates in other rows were found: {0},Vrstice s podvojenimi datumi v drugih vrsticah so bile najdene: {0},
Rules for adding shipping costs.,Pravila za dodajanje stroškov dostave.,
Rules for applying pricing and discount.,Pravila za uporabo cene in popust.,
S.O. No.,SO No.,
SGST Amount,SGST Znesek,
SO Qty,SO Kol,
Safety Stock,Varnostna zaloga,
Salary,Plača,
Salary Slip ID,Plača Slip ID,
Salary Slip of employee {0} already created for this period,Plača Slip delavca {0} že ustvarili za to obdobje,
Salary Slip of employee {0} already created for time sheet {1},Plača Slip delavca {0} že ustvarili za časa stanja {1},
Salary Slip submitted for period from {0} to {1},Plačilo za plačilo je oddano za obdobje od {0} do {1},
Salary Structure Assignment for Employee already exists,Struktura plače za zaposlene že obstaja,
Salary Structure Missing,Plača Struktura Missing,
Salary Structure must be submitted before submission of Tax Ememption Declaration,Strukturo plače je treba predložiti pred predložitvijo izjave o oprostitvi davka,
Salary Structure not found for employee {0} and date {1},Strukture plače za zaposlenega {0} in datum {1} ni mogoče najti,
Salary Structure should have flexible benefit component(s) to dispense benefit amount,"Struktura plače mora imeti prožne komponente (komponente), da bi odplačala znesek nadomestila",
"Salary already processed for period between {0} and {1}, Leave application period cannot be between this date range.","Plača je že pripravljena za obdobje med {0} in {1}, Pusti obdobje uporabe ne more biti med tem časovnem obdobju.",
Sales,Prodaja,
Sales Account,Prodajni račun,
Sales Expenses,Prodajna Stroški,
Sales Funnel,Prodaja toka,
Sales Invoice,Račun,
Sales Invoice {0} has already been submitted,Račun {0} je že bil predložen,
Sales Invoice {0} must be cancelled before cancelling this Sales Order,Račun {0} je potrebno preklicati pred preklicom tega prodajnega naročila,
Sales Manager,Vodja prodaje,
Sales Master Manager,Prodaja Master Manager,
Sales Order,Naročilo,
Sales Order Item,Artikel naročila,
Sales Order required for Item {0},Sales Order potreben za postavko {0},
Sales Order to Payment,Sales Order do plačila,
Sales Order {0} is not submitted,Naročilo {0} ni predloženo,
Sales Order {0} is not valid,Naročilo {0} ni veljavno,
Sales Order {0} is {1},Naročilo {0} je {1},
Sales Orders,Naročila Kupcev,
Sales Partner,Prodaja Partner,
Sales Pipeline,prodaja Pipeline,
Sales Price List,Prodaja Cenik,
Sales Return,Prodaja Return,
Sales Summary,Povzetek prodaje,
Sales Tax Template,Sales Tax Predloga,
Sales Team,Sales Team,
Sales User,Prodaja Uporabnik,
Sales and Returns,Prodaja in vrnitev,
Sales campaigns.,Prodajne akcije.,
Sales orders are not available for production,Prodajna naročila niso na voljo za proizvodnjo,
Salutation,Pozdrav,
Same Company is entered more than once,Ista družba je vpisana več kot enkrat,
Same item cannot be entered multiple times.,Isti element ni mogoče vnesti večkrat.,
Same supplier has been entered multiple times,Enako dobavitelj je bila vpisana večkrat,
Sample,Vzorec,
Sample Collection,Zbiranje vzorcev,
Sample quantity {0} cannot be more than received quantity {1},Količina vzorca {0} ne sme biti večja od prejete količine {1},
Sanctioned,Sankcionirano,
Sanctioned Amount,Sankcionirano Znesek,
Sanctioned Amount cannot be greater than Claim Amount in Row {0}.,Sankcionirano Znesek ne sme biti večja od škodnega Znesek v vrstici {0}.,
Sand,Pesek,
Saturday,Sobota,
Saved,Shranjena,
Saving {0},Shranjevanje {0},
Scan Barcode,Skeniranje črtne kode,
Schedule,Urnik,
Schedule Admission,Sprejem razporeda,
Schedule Course,urnik predmeta,
Schedule Date,Urnik Datum,
Schedule Discharge,Razrešnica razporeda,
Scheduled,Načrtovano,
Scheduled Upto,Načrtovani Upto,
"Schedules for {0} overlaps, do you want to proceed after skiping overlaped slots ?","Seznami za {0} se prekrivajo, ali želite nadaljevati, ko preskočite prekrivne reže?",
Score cannot be greater than Maximum Score,Rezultat ne sme biti večja od najvišjo oceno,
Score must be less than or equal to 5,Rezultat mora biti manjša od ali enaka 5,
Scorecards,Oglednice,
Scrapped,izločeni,
Search,Iskanje,
Search Results,Rezultati iskanja,
Search Sub Assemblies,Iskanje sklope,
"Search by item code, serial number, batch no or barcode","Iskanje po oznaki predmeta, serijski številki, številki serije ali črtno kodo",
"Seasonality for setting budgets, targets etc.","Sezonskost za nastavitev proračunov, cilji itd",
Secret Key,Secret Key,
Secretary,Sekretar,
Section Code,Koda oddelka,
Secured Loans,Secured Posojila,
Securities & Commodity Exchanges,Vrednostnih papirjev in blagovne borze,
Securities and Deposits,Vrednostne papirje in depozite,
See All Articles,Oglejte si vse članke,
See all open tickets,Oglejte si vse odprte vozovnice,
See past orders,Glej pretekla naročila,
See past quotations,Oglejte si pretekle navedke,
Select,Izberite,
Select Alternate Item,Izberite nadomestni element,
Select Attribute Values,Izberite vrednosti atributa,
Select BOM,Izberite BOM,
Select BOM and Qty for Production,Izberite BOM in Količina za proizvodnjo,
"Select BOM, Qty and For Warehouse","Izberite BOM, Qty in Za skladišče",
Select Batch,Izberite Serija,
Select Batch Numbers,Izberite številke Serija,
Select Brand...,Izberi znamko ...,
Select Company,Izberite podjetje,
Select Company...,Izberite Company ...,
Select Customer,Izberite stranko,
Select Days,Izberite Dnevi,
Select Default Supplier,Izberite Privzeta Dobavitelj,
Select DocType,Izberite DOCTYPE,
Select Fiscal Year...,Izberite poslovno leto ...,
Select Item (optional),Izberite postavko (neobvezno),
Select Items based on Delivery Date,Izberite elemente glede na datum dostave,
Select Items to Manufacture,Izberite artikel v Izdelava,
Select Loyalty Program,Izberite Program zvestobe,
Select Patient,Izberite Patient,
Select Possible Supplier,Izberite Možni Dobavitelj,
Select Property,Izberite Lastnost,
Select Quantity,Izberite Količina,
Select Serial Numbers,Izberite serijsko številko,
Select Target Warehouse,Izberite Target Skladišče,
Select Warehouse...,Izberite Skladišče ...,
Select an account to print in account currency,"Izberite račun, ki ga želite natisniti v valuti računa",
Select an employee to get the employee advance.,"Izberite zaposlenega, da zaposleni vnaprej napreduje.",
Select at least one value from each of the attributes.,Izberite vsaj eno vrednost iz vsakega od atributov.,
Select change amount account,znesek računa Izberite sprememba,
Select company first,Najprej izberite podjetje,
Select students manually for the Activity based Group,"Izberite študentov ročno za skupine dejavnosti, ki temelji",
Select the customer or supplier.,Izberite kupca ali dobavitelja.,
Select the nature of your business.,Izberite naravo vašega podjetja.,
Select the program first,Najprej izberite program,
Select to add Serial Number.,"Izberite, če želite dodati serijsko številko.",
Select your Domains,Izberite svoje domene,
Selected Price List should have buying and selling fields checked.,Izbrani cenik bi moral imeti preverjena polja nakupa in prodaje.,
Sell,Prodaja,
Selling,Prodaja,
Selling Amount,Prodajni Znesek,
Selling Price List,Prodajni cenik,
Selling Rate,Prodajna cena,
"Selling must be checked, if Applicable For is selected as {0}","Prodajanje je treba preveriti, če se uporablja za izbrana kot {0}",
Send Grant Review Email,Pošlji e-pošto za pregled e-pošte,
Send Now,Pošlji Zdaj,
Send SMS,Pošlji SMS,
Send mass SMS to your contacts,Pošlji množično SMS vaših stikov,
Sensitivity,Občutljivost,
Sent,Pošlje,
Serial No and Batch,Serijska številka in serije,
Serial No is mandatory for Item {0},Zaporedna številka je obvezna za postavko {0},
Serial No {0} does not belong to Batch {1},Serijska številka {0} ne sodi v paket {1},
Serial No {0} does not belong to Delivery Note {1},Serijska št {0} ne pripada dobavnica {1},
Serial No {0} does not belong to Item {1},Serijska št {0} ne pripada postavki {1},
Serial No {0} does not belong to Warehouse {1},Serijska št {0} ne pripada Warehouse {1},
Serial No {0} does not belong to any Warehouse,Serijska št {0} ne pripada nobeni Warehouse,
Serial No {0} does not exist,Serijska št {0} ne obstaja,
Serial No {0} has already been received,Serijska št {0} je že prejela,
Serial No {0} is under maintenance contract upto {1},Serijska št {0} je pod vzdrževalne pogodbe stanuje {1},
Serial No {0} is under warranty upto {1},Serijska št {0} je pod garancijo stanuje {1},
Serial No {0} not found,Serijska št {0} ni bilo mogoče najti,
Serial No {0} not in stock,Serijska št {0} ni na zalogi,
Serial No {0} quantity {1} cannot be a fraction,Serijska št {0} količina {1} ne more biti del,
Serial Nos Required for Serialized Item {0},Serijska št Zahtevano za zaporednimi postavki {0},
Serial Number: {0} is already referenced in Sales Invoice: {1},Serijska številka: {0} že naveden v prodajne fakture: {1},
Serial Numbers,Serijske številke,
Serial Numbers in row {0} does not match with Delivery Note,Številke v vrstici {0} se ne ujema z dobavnice,
Serial no {0} has been already returned,Serijski št. {0} je bil že vrnjen,
Serial number {0} entered more than once,Serijska številka {0} je začela več kot enkrat,
Serialized Inventory,Zaporednimi Inventory,
Series Updated,Zaporedje posodobljeno,
Series Updated Successfully,Zaporedje uspešno posodobljeno,
Series is mandatory,Serija je obvezna,
Series {0} already used in {1},Zaporedje {0} se že uporablja v {1},
Service,Storitev,
Service Expense,Service Expense,
Service Level Agreement,Sporazum o ravni storitev,
Service Level Agreement.,Sporazum o ravni storitev.,
Service Level.,Raven storitev.,
Service Stop Date cannot be after Service End Date,Datum zaustavitve storitve ne more biti po končnem datumu storitve,
Service Stop Date cannot be before Service Start Date,Datum zaustavitve storitve ne sme biti pred datumom začetka storitve,
Services,Storitve,
"Set Default Values like Company, Currency, Current Fiscal Year, etc.","Privzeta nastavitev Vrednote, kot so podjetja, valuta, tekočem proračunskem letu, itd",
Set Details,Nastavite podrobnosti,
Set New Release Date,Nastavite nov datum izdaje,
Set Project and all Tasks to status {0}?,Nastavite stanje Projekta in vseh opravil {0}?,
Set Status,Nastavi stanje,
Set Tax Rule for shopping cart,Nastavite Davčna pravilo za nakupovalno košarico,
Set as Closed,Nastavi kot zaprto,
Set as Completed,Nastavi kot dokončano,
Set as Default,Nastavi kot privzeto,
Set as Lost,Nastavi kot Lost,
Set as Open,Nastavi kot Odpri,
Set default inventory account for perpetual inventory,Privzeta nastavitev popis račun za stalne inventarizacije,
Set this if the customer is a Public Administration company.,"To nastavite, če je stranka podjetje javne uprave.",
Set {0} in asset category {1} or company {2},Nastavite {0} v kategoriji sredstev {1} ali podjetje {2},
"Setting Events to {0}, since the Employee attached to the below Sales Persons does not have a User ID{1}","Nastavitev dogodkov na {0}, saj je zaposlenih pritrjen na spodnji prodaje oseb nima uporabniško {1}",
Setting defaults,Nastavitev privzetih nastavitev,
Setting up Email,Postavitev Email,
Setting up Email Account,Nastavitev e-poštnega računa,
Setting up Employees,Postavitev Zaposleni,
Setting up Taxes,Postavitev Davki,
Setting up company,Ustanovitev podjetja,
Settings,Nastavitve,
"Settings for online shopping cart such as shipping rules, price list etc.","Nastavitve za spletni košarici, kot so predpisi v pomorskem prometu, cenik itd",
Settings for website homepage,Nastavitve za spletni strani,
Settings for website product listing,Nastavitve za seznam izdelkov na spletnem mestu,
Settled,Naseljeni,
Setup Gateway accounts.,Gateway račune.,
Setup SMS gateway settings,Nastavitve Setup SMS gateway,
Setup cheque dimensions for printing,Preverite nastavitve za dimenzije za tiskanje,
Setup default values for POS Invoices,Nastavitev privzetih vrednosti za račune POS,
Setup mode of POS (Online / Offline),Način nastavitve POS (Online / Offline),
Setup your Institute in ERPNext,Nastavite svoj inštitut v ERPNext,
Share Balance,Deljeno stanje,
Share Ledger,Delež knjige,
Share Management,Deljeno upravljanje,
Share Transfer,Prenos delnic,
Share Type,Vrsta delnice,
Shareholder,Delničar,
Ship To State,Pošiljanje v državo,
Shipments,Pošiljke,
Shipping,Dostava,
Shipping Address,naslov za pošiljanje,
"Shipping Address does not have country, which is required for this Shipping Rule","Naslov za dostavo nima države, ki je potrebna za to pravilo o pošiljanju",
Shipping rule only applicable for Buying,Pravilo o dostavi velja samo za nakup,
Shipping rule only applicable for Selling,Pravilo o dostavi velja samo za prodajo,
Shopify Supplier,Shopify dobavitelj,
Shopping Cart,Nakupovalni voziček,
Shopping Cart Settings,Nastavitve Košarica,
Short Name,Kratko ime,
Shortage Qty,Pomanjkanje Kol,
Show Completed,Prikaži končano,
Show Cumulative Amount,Prikaži skupni znesek,
Show Employee,Prikaži zaposlenega,
Show Open,Prikaži odprte,
Show Opening Entries,Prikaži uvodne vnose,
Show Payment Details,Prikaži podatke o plačilu,
Show Return Entries,Prikaži vnose za vračilo,
Show Salary Slip,Prikaži Plača listek,
Show Variant Attributes,Prikaži lastnosti različic,
Show Variants,Prikaži Variante,
Show closed,Prikaži zaprto,
Show exploded view,Pokaži eksplodiran pogled,
Show only POS,Prikaži samo POS,
Show unclosed fiscal year's P&L balances,Prikaži nezaprt poslovno leto je P &amp; L bilanc,
Show zero values,Prikaži ničelnimi vrednostmi,
Sick Leave,Bolniški dopust,
Silt,Silt,
Single Variant,Enotna varianta,
Single unit of an Item.,Enotni enota točke.,
"Skipping Leave Allocation for the following employees, as Leave Allocation records already exists against them. {0}","Preskočite dodelitev dodelitve za naslednje zaposlene, saj zanje obstajajo zapise o zapustitvi dodelitve. {0}",
"Skipping Salary Structure Assignment for the following employees, as Salary Structure Assignment records already exists against them. {0}","Preskok dodelitve strukture plače za naslednje zaposlene, saj za njih že obstajajo zapisi o dodelitvi strukture plače. {0}",
Slideshow,Slideshow,
Slots for {0} are not added to the schedule,Reže za {0} niso dodane v razpored,
Small,Majhno,
Soap & Detergent,Soap &amp; Detergent,
Software,Programska oprema,
Software Developer,Razvijalec programske opreme,
Softwares,Programska oprema,
Soil compositions do not add up to 100,Sestavine tal ne ustvarjajo do 100,
Sold,Prodano,
Some emails are invalid,Nekaj e-poštnih sporočil je neveljavno,
Some information is missing,Nekateri podatki manjkajo,
Something went wrong!,Nekaj je šlo narobe!,
"Sorry, Serial Nos cannot be merged","Oprostite, Serijska št ni mogoče združiti",
Source,Vir,
Source Name,Source Name,
Source Warehouse,Vir Skladišče,
Source and Target Location cannot be same,Izvorna in ciljna lokacija ne moreta biti enaka,
Source and target warehouse cannot be same for row {0},Vir in cilj skladišče ne more biti enaka za vrstico {0},
Source and target warehouse must be different,Vir in cilj skladišče mora biti drugačen,
Source of Funds (Liabilities),Vir sredstev (obveznosti),
Source warehouse is mandatory for row {0},Vir skladišče je obvezna za vrstico {0},
Specified BOM {0} does not exist for Item {1},Določeno BOM {0} ne obstaja za postavko {1},
Split,Split,
Split Batch,Split Serija,
Split Issue,Razdelitev izdaje,
Sports,Šport,
Staffing Plan {0} already exist for designation {1},Kadrovski načrt {0} že obstaja za oznako {1},
Standard,Standardni,
Standard Buying,Standardna nabavna,
Standard Selling,Standardna prodaja,
Standard contract terms for Sales or Purchase.,Standardni pogodbeni pogoji za prodajo ali nakup.,
Start Date,Datum začetka,
Start Date of Agreement can't be greater than or equal to End Date.,Začetni datum pogodbe ne sme biti večji ali enak končnemu datumu.,
Start Year,Začetek Leto,
"Start and end dates not in a valid Payroll Period, cannot calculate {0}","Začetni in končni datumi, ki niso v veljavnem obdobju plače, ne morejo izračunati {0}",
"Start and end dates not in a valid Payroll Period, cannot calculate {0}.","Začetni in končni datumi, ki niso v veljavnem plačilnem obdobju, ne morejo izračunati {0}.",
Start date should be less than end date for Item {0},Začetni datum mora biti manjša od končnega datuma za postavko {0},
Start date should be less than end date for task {0},Začetni datum mora biti krajši od končnega datuma za opravilo {0},
Start day is greater than end day in task '{0}',Začetni dan je večji od končnega dne pri nalogi &#39;{0}&#39;,
Start on,Začni,
State,Država,
State/UT Tax,Državni / davek na UT,
Statement of Account,Izkaz računa,
Status must be one of {0},Stanje mora biti eno od {0},
Stock,Zaloga,
Stock Adjustment,Prilagoditev zaloge,
Stock Analytics,Analiza zaloge,
Stock Assets,Zaloga Sredstva,
Stock Available,Stock Na voljo,
Stock Balance,Stock Balance,
Stock Entries already created for Work Order ,"Zaloge, ki so že bile ustvarjene za delovno nalogo",
Stock Entry,Stock Začetek,
Stock Entry {0} created,Stock Začetek {0} ustvaril,
Stock Entry {0} is not submitted,Stock Začetek {0} ni predložila,
Stock Expenses,Zaloga Stroški,
Stock In Hand,Zaloga v roki,
Stock Items,zalogi,
Stock Ledger,Stock Ledger,
Stock Ledger Entries and GL Entries are reposted for the selected Purchase Receipts,Zaloga Glavna knjiga Prijave in GL Vnosi se oglaša za izbrane Nakup Prejemki,
Stock Levels,Zaloga Ravni,
Stock Liabilities,Zaloga Obveznosti,
Stock Options,Delniških opcij,
Stock Qty,Stock Kol,
Stock Received But Not Billed,Prejete Stock Ampak ne zaračuna,
Stock Reports,Poročila o zalogi,
Stock Summary,Stock Povzetek,
Stock Transactions,Zaloga Transakcije,
Stock UOM,Stock UOM,
Stock Value,Stock Value,
Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},Stock ravnotežje Serija {0} bo postal negativen {1} za postavko {2} v skladišču {3},
Stock cannot be updated against Delivery Note {0},Stock ni mogoče posodobiti proti dobavnica {0},
Stock cannot be updated against Purchase Receipt {0},Stock ni mogoče posodobiti proti Nakup prejemu {0},
Stock cannot exist for Item {0} since has variants,"Stock ne more obstajati za postavko {0}, saj ima variant",
Stock transactions before {0} are frozen,Zaloga transakcije pred {0} so zamrznjeni,
Stop,Stop,
Stopped,Ustavljen,
"Stopped Work Order cannot be cancelled, Unstop it first to cancel","Prenehanja delovnega naročila ni mogoče preklicati, jo najprej izključite",
Stores,Trgovine,
Structures have been assigned successfully,Strukture so bile dodeljene uspešno,
Student,Študent,
Student Activity,študent dejavnost,
Student Address,študent Naslov,
Student Admissions,Študentski Sprejemi,
Student Attendance,študent Udeležba,
"Student Batches help you track attendance, assessments and fees for students","Študentski Paketi vam pomaga slediti sejnin, ocene in pristojbine za študente",
Student Email Address,Študent e-poštni naslov,
Student Email ID,Študent Email ID,
Student Group,Študentska skupina,
Student Group Strength,Študent Skupina moč,
Student Group is already updated.,Študent Skupina je že posodobljen.,
Student Group: ,Študentska skupina:,
Student ID,Student ID,
Student ID: ,Študentski ID:,
Student LMS Activity,Aktivnost študentskih učencev,
Student Mobile No.,Študent Mobile No.,
Student Name,Student Ime,
Student Name: ,Študentsko ime:,
Student Report Card,Student Report Card,
Student is already enrolled.,Študent je že vpisan.,
Student {0} - {1} appears Multiple times in row {2} & {3},Študent {0} - {1} pojavi večkrat v vrsti {2} {3},
Student {0} does not belong to group {1},Študent {0} ne pripada skupini {1},
Student {0} exist against student applicant {1},Študent {0} obstaja proti študentskega prijavitelja {1},
"Students are at the heart of the system, add all your students","Študenti so v središču sistema, dodamo vse svoje učence",
Sub Assemblies,Sklope,
Sub Type,Pod tip,
Sub-contracting,Podizvajalcem,
Subcontract,Podizvajalska pogodba,
Subject,Predmet,
Submit,Submit,
Submit Proof,Predložite dokazilo,
Submit Salary Slip,Predloži plačilni list,
Submit this Work Order for further processing.,Pošljite ta delovni nalog za nadaljnjo obdelavo.,
Submit this to create the Employee record,"Pošljite to, da ustvarite zapis zaposlenega",
Submitting Salary Slips...,Predložitev plakatov ...,
Subscription,Naročnina,
Subscription Management,Upravljanje naročnin,
Subscriptions,Naročnine,
Subtotal,Vmesni seštevek,
Successful,Uspešno,
Successfully Reconciled,Uspešno usklajeno,
Successfully Set Supplier,Uspešno nastavite dobavitelja,
Successfully created payment entries,Uspešno so ustvarili vnose v plačilo,
Successfully deleted all transactions related to this company!,Uspešno izbrisana vse transakcije v zvezi s to družbo!,
Sum of Scores of Assessment Criteria needs to be {0}.,Vsota ocen ocenjevalnih meril mora biti {0}.,
Sum of points for all goals should be 100. It is {0},Seštevek točk za vseh ciljev bi morala biti 100. To je {0},
Summary,Povzetek,
Summary for this month and pending activities,Povzetek za ta mesec in v teku dejavnosti,
Summary for this week and pending activities,Povzetek za ta teden in ki potekajo dejavnosti,
Sunday,Nedelja,
Suplier,Suplier,
Supplier,Dobavitelj,
Supplier Group,Skupina dobaviteljev,
Supplier Group master.,Poveljnik skupine dobaviteljev.,
Supplier Id,Dobavitelj Id,
Supplier Invoice Date cannot be greater than Posting Date,Datum dobavitelj na računu ne sme biti večja od Napotitev Datum,
Supplier Invoice No,Dobavitelj Račun Ne,
Supplier Invoice No exists in Purchase Invoice {0},Dobavitelj računa ni v računu o nakupu obstaja {0},
Supplier Name,Dobavitelj Name,
Supplier Part No,Šifra dela dobavitelj,
Supplier Quotation,Dobavitelj za predračun,
Supplier Scorecard,Scorecard dobavitelja,
Supplier Warehouse mandatory for sub-contracted Purchase Receipt,Dobavitelj Skladišče obvezno za podizvajalcev Potrdilo o nakupu,
Supplier database.,Dobavitelj baze podatkov.,
Supplier {0} not found in {1},Dobavitelj {0} ni bil najden v {1},
Supplier(s),Dobavitelj (-i),
Supplies made to UIN holders,Potrebščine za imetnike UIN,
Supplies made to Unregistered Persons,Potrebščine za neregistrirane osebe,
Suppliies made to Composition Taxable Persons,Dobave za sestave davčnih zavezancev,
Supply Type,Vrsta dobave,
Support,Podpora,
Support Analytics,Podpora Analytics,
Support Settings,Nastavitve podpora,
Support Tickets,Podporne vstopnice,
Support queries from customers.,Podpora poizvedbe strank.,
Susceptible,Občutljivo,
Sync has been temporarily disabled because maximum retries have been exceeded,"Sinhronizacija je bila začasno onemogočena, ker so bile prekoračene največje število ponovnih poskusov",
Syntax error in condition: {0},Sintaktična napaka v stanju: {0},
Syntax error in formula or condition: {0},Skladenjska napaka v formuli ali stanje: {0},
System Manager,System Manager,
TDS Rate %,TDS Stopnja%,
Tap items to add them here,"Dotaknite predmete, da jih dodate tukaj",
Target,Target,
Target ({}),Cilj ({}),
Target On,Ciljna Na,
Target Warehouse,Ciljna Skladišče,
Target warehouse is mandatory for row {0},Ciljna skladišče je obvezna za vrstico {0},
Task,Naloga,
Tasks,Naloge,
Tasks have been created for managing the {0} disease (on row {1}),Opravljene so bile naloge za upravljanje {0} bolezni (na vrstici {1}),
Tax,Davčna,
Tax Assets,Davčni Sredstva,
Tax Category,Davčna kategorija,
Tax Category for overriding tax rates.,Davčna kategorija za previsoke davčne stopnje.,
"Tax Category has been changed to ""Total"" because all the Items are non-stock items","Davčna kategorija se je spremenila v &quot;Skupaj&quot;, ker so vsi artikli, ki niso zalogi",
Tax ID,Davčna številka,
Tax Id: ,Davčna številka:,
Tax Rate,Davčna stopnja,
Tax Rule Conflicts with {0},Davčna Pravilo Konflikti z {0},
Tax Rule for transactions.,Davčna pravilo za transakcije.,
Tax Template is mandatory.,Davčna Predloga je obvezna.,
Tax Withholding rates to be applied on transactions.,"Stopnje obdavčitve davkov, ki se uporabljajo pri transakcijah.",
Tax template for buying transactions.,Davčna predloga za nabavne transakcije,
Tax template for item tax rates.,Predloga davka za davčne stopnje na postavke.,
Tax template for selling transactions.,Davčna predlogo za prodajne transakcije.,
Taxable Amount,Davčna osnova,
Taxes,Davki,
Team Updates,ekipa Posodobitve,
Technology,Tehnologija,
Telecommunications,Telekomunikacije,
Telephone Expenses,Telefonske Stroški,
Television,Televizija,
Template Name,Predloga Ime,
Template of terms or contract.,Predloga izrazov ali pogodbe.,
Templates of supplier scorecard criteria.,Predloge meril uspešnosti dobaviteljev.,
Templates of supplier scorecard variables.,Predloge spremenljivk rezultatov dobaviteljev.,
Templates of supplier standings.,Predloge dobaviteljevega položaja.,
Temporarily on Hold,Začasno zadržano,
Temporary,Začasna,
Temporary Accounts,Začasni računi,
Temporary Opening,Začasna Otvoritev,
Terms and Conditions,Pravila in pogoji,
Terms and Conditions Template,Pogoji Template,
Territory,Ozemlje,
Test,Testna,
Thank you,Hvala,
Thank you for your business!,Hvala za vaš posel!,
The 'From Package No.' field must neither be empty nor it's value less than 1.,&quot;Od paketa št.&quot; polje ne sme biti prazno niti je vrednost manjša od 1.,
The Brand,Brand,
The Item {0} cannot have Batch,Postavki {0} ne more imeti Batch,
The Loyalty Program isn't valid for the selected company,Program zvestobe ni veljaven za izbrano podjetje,
The Payment Term at row {0} is possibly a duplicate.,Izraz plačila v vrstici {0} je morda dvojnik.,
The Term End Date cannot be earlier than the Term Start Date. Please correct the dates and try again.,Izraz Končni datum ne more biti zgodnejši od datuma Term Start. Popravite datum in poskusite znova.,
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.,"Izraz Končni datum ne more biti najpozneje do leta End Datum študijskem letu, v katerem je izraz povezan (študijsko leto {}). Popravite datum in poskusite znova.",
The Term Start Date cannot be earlier than the Year Start Date of the Academic Year to which the term is linked (Academic Year {}). Please correct the dates and try again.,"Datum izraz začetka ne more biti zgodnejši od datuma Leto začetku študijskega leta, v katerem je izraz povezan (študijsko leto {}). Popravite datum in poskusite znova.",
The Year End Date cannot be earlier than the Year Start Date. Please correct the dates and try again.,Leto Končni datum ne more biti zgodnejši od datuma Leto Start. Popravite datum in poskusite znova.,
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.,"V tem zahtevku za plačilo je znesek {0} različen od izračunane vsote vseh plačilnih načrtov: {1}. Preden pošljete dokument, se prepričajte, da je to pravilno.",
The day(s) on which you are applying for leave are holidays. You need not apply for leave.,"Dan (s), na kateri se prijavljate za dopust, so prazniki. Vam ni treba zaprositi za dopust.",
The field From Shareholder cannot be blank,Polje Od delničarja ne more biti prazno,
The field To Shareholder cannot be blank,Polje Delničarju ne more biti prazno,
The fields From Shareholder and To Shareholder cannot be blank,Polja Od delničarja in delničarja ne morejo biti prazna,
The folio numbers are not matching,Folio številke se ne ujemajo,
The holiday on {0} is not between From Date and To Date,"Praznik na {0} ni med Od datuma, do sedaj",
The name of the institute for which you are setting up this system.,"Ime zavoda, za katerega vzpostavitev tega sistema.",
The name of your company for which you are setting up this system.,"Ime vašega podjetja, za katero ste vzpostavitvijo tega sistema.",
The number of shares and the share numbers are inconsistent,Število delnic in številke delnic so neskladne,
The payment gateway account in plan {0} is different from the payment gateway account in this payment request,Račun plačilnega prehoda v načrtu {0} se razlikuje od računa prehoda plačila v tej zahtevi za plačilo,
The selected BOMs are not for the same item,Izbrani BOMs niso na isti točki,
The selected item cannot have Batch,Izbrana postavka ne more imeti Batch,
The seller and the buyer cannot be the same,Prodajalec in kupec ne moreta biti isti,
The shareholder does not belong to this company,Delničar ne pripada tej družbi,
The shares already exist,Delnice že obstajajo,
The shares don't exist with the {0},Delnice ne obstajajo z {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","Naloga je bila vključena v ozadje. Če obstaja kakšna težava pri obdelavi v ozadju, bo sistem dodal komentar o napaki na tej usklajevanju zalog in se vrnil v fazo osnutka.",
"Then Pricing Rules are filtered out based on Customer, Customer Group, Territory, Supplier, Supplier Type, Campaign, Sales Partner etc.","Potem Označevanje cen Pravila se filtrirajo temeljijo na stranke, skupine kupcev, ozemlje, dobavitelja, dobavitelj Type, kampanje, prodajnemu partnerju itd",
"There are inconsistencies between the rate, no of shares and the amount calculated","Obstajajo neskladja med stopnjo, brez delnic in izračunanim zneskom",
There are more holidays than working days this month.,Obstaja več prazniki od delovnih dneh tega meseca.,
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 podlagi skupnih porabljenih sredstev je lahko več faktorjev zbiranja. Toda pretvorbeni faktor za odkup bo vedno enak za vse stopnje.,
There can only be 1 Account per Company in {0} {1},"Ne more biti samo 1 račun na podjetje, v {0} {1}",
"There can only be one Shipping Rule Condition with 0 or blank value for ""To Value""",Obstaja lahko samo en prevoz pravilo Pogoj z 0 ali prazno vrednost za &quot;ceniti&quot;,
There is no leave period in between {0} and {1},Obdobja dopusta ni med {0} in {1},
There is not enough leave balance for Leave Type {0},Ni dovolj bilanca dopust za dopust tipa {0},
There is nothing to edit.,Nič ni za urejanje.,
There isn't any item variant for the selected item,Za izbrani predmet ni nobene postavke,
"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.","Zdi se, da obstaja težava s strežniško GoCardless konfiguracijo. V primeru neuspeha ne skrbite, znesek bo povrnjen na vaš račun.",
There were errors creating Course Schedule,Prišlo je do napak pri urejanju tečaja tečaja,
There were errors.,Tam so bile napake.,
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,"Ta postavka je Predloga in je ni mogoče uporabiti v transakcijah. Atributi postavka bodo kopirali več kot v različicah, razen če je nastavljeno &quot;Ne Kopiraj«",
This Item is a Variant of {0} (Template).,Ta element je različica {0} (predloga).,
This Month's Summary,Povzetek tega meseca je,
This Week's Summary,Povzetek Ta teden je,
This action will stop future billing. Are you sure you want to cancel this subscription?,"To dejanje bo ustavilo prihodnje obračunavanje. Ali ste prepričani, da želite preklicati to naročnino?",
This covers all scorecards tied to this Setup,"To zajema vse kazalnike, povezane s tem Setup",
This document is over limit by {0} {1} for item {4}. Are you making another {3} against the same {2}?,"Ta dokument je nad mejo, ki jo {0} {1} za postavko {4}. Delaš drugo {3} zoper isto {2}?",
This is a root account and cannot be edited.,To je račun root in jih ni mogoče urejati.,
This is a root customer group and cannot be edited.,To je skupina koren stranke in jih ni mogoče urejati.,
This is a root department and cannot be edited.,To je korenski oddelek in ga ni mogoče urejati.,
This is a root healthcare service unit and cannot be edited.,To je korenska storitev zdravstvene oskrbe in je ni mogoče urejati.,
This is a root item group and cannot be edited.,"To je skupina, root element in ga ni mogoče urejati.",
This is a root sales person and cannot be edited.,To je koren prodaje oseba in jih ni mogoče urejati.,
This is a root supplier group and cannot be edited.,To je skupna skupina dobaviteljev in je ni mogoče urejati.,
This is a root territory and cannot be edited.,To je koren ozemlje in ga ni mogoče urejati.,
This is an example website auto-generated from ERPNext,To je primer spletne strani samodejno ustvari iz ERPNext,
This is based on logs against this Vehicle. See timeline below for details,Ta temelji na dnevnikih glede na ta vozila. Oglejte si časovnico spodaj za podrobnosti,
This is based on stock movement. See {0} for details,Ta temelji na gibanju zalog. Glej {0} za podrobnosti,
This is based on the Time Sheets created against this project,Ta temelji na časovnih preglednicah ustvarjenih pred tem projektu,
This is based on the attendance of this Employee,Ta temelji na prisotnosti tega zaposlenega,
This is based on the attendance of this Student,Ta temelji na prisotnosti tega Študent,
This is based on transactions against this Customer. See timeline below for details,Ta temelji na transakcijah zoper to stranko. Oglejte si časovnico spodaj za podrobnosti,
This is based on transactions against this Healthcare Practitioner.,To temelji na transakcijah proti temu zdravniku.,
This is based on transactions against this Patient. See timeline below for details,To temelji na transakcijah proti temu bolniku. Podrobnosti si oglejte spodaj,
This is based on transactions against this Sales Person. See timeline below for details,To temelji na transakcijah proti tej prodajni osebi. Podrobnosti si oglejte spodaj,
This is based on transactions against this Supplier. See timeline below for details,Ta temelji na transakcijah proti temu dobavitelju. Oglejte si časovnico spodaj za podrobnosti,
This will submit Salary Slips and create accrual Journal Entry. Do you want to proceed?,To bo poslalo plačne liste in ustvarilo časovni razpored poročanja. Želite nadaljevati?,
This {0} conflicts with {1} for {2} {3},Ta {0} ni v nasprotju s {1} za {2} {3},
Time Sheet for manufacturing.,Čas List za proizvodnjo.,
Time Tracking,sledenje čas,
"Time slot skiped, the slot {0} to {1} overlap exisiting slot {2} to {3}","Časovna reža je preskočena, reža {0} do {1} prekriva obstoječo režo {2} do {3}",
Time slots added,Dodane so časovne reže,
Time(in mins),Čas (v minutah),
Timer,Časovnik,
Timer exceeded the given hours.,Časovnik je presegel dane ure.,
Timesheet,Evidenca prisotnosti,
Timesheet for tasks.,Timesheet za naloge.,
Timesheet {0} is already completed or cancelled,"Timesheet {0}, je že končana ali preklicana",
Timesheets,Evidence prisotnosti,
"Timesheets help keep track of time, cost and billing for activites done by your team","Timesheets pomaga slediti časa, stroškov in zaračunavanje za aktivnostmi s svojo ekipo, podpisan",
Titles for print templates e.g. Proforma Invoice.,"Naslovi za tiskane predloge, npr predračunu.",
To,Za,
To Address 1,Naslov 1,
To Address 2,Na naslov 2,
To Bill,Billu,
To Date,Če želite Datum,
To Date cannot be before From Date,Do danes ne more biti pred od datuma,
To Date cannot be less than From Date,Datum ne sme biti krajši od datuma,
To Date must be greater than From Date,Do datuma mora biti večje od datuma,
To Date should be within the Fiscal Year. Assuming To Date = {0},"Do datuma mora biti v poslovnem letu. Ob predpostavki, da želite Datum = {0}",
To Datetime,Da datetime,
To Deliver,Dostaviti,
To Deliver and Bill,Dostaviti in Bill,
To Fiscal Year,V proračunsko leto,
To GSTIN,Za GSTIN,
To Party Name,Ime stranke,
To Pin Code,Za kodo,
To Place,Na mestu,
To Receive,Prejeti,
To Receive and Bill,Za prejemanje in Bill,
To State,Trditi,
To Warehouse,Za skladišča,
To create a Payment Request reference document is required,Če želite ustvariti zahtevek za plačilo je potrebno referenčni dokument,
To date can not be equal or less than from date,Do datuma ne more biti enako ali manj kot od datuma,
To date can not be less than from date,Do danes ne sme biti manj kot od datuma,
To date can not greater than employee's relieving date,Do danes ne more biti večji od datuma razrešitve zaposlenih,
"To filter based on Party, select Party Type first","Za filtriranje, ki temelji na stranke, da izberete Party Vnesite prvi",
"To get the best out of ERPNext, we recommend that you take some time and watch these help videos.","Da bi dobili najboljše iz ERPNext, vam priporočamo, da si vzamete nekaj časa in gledam te posnetke pomoč.",
"To include tax in row {0} in Item rate, taxes in rows {1} must also be included","Da vključujejo davek v vrstici {0} v stopnji Element, davki v vrsticah {1} je treba vključiti tudi",
To make Customer based incentive schemes.,Ustvariti spodbujevalne sheme s strani kupcev.,
"To merge, following properties must be same for both items","Za pripojitev, mora naslednje lastnosti biti enaka za oba predmetov",
"To not apply Pricing Rule in a particular transaction, all applicable Pricing Rules should be disabled.","Da ne uporabljajo Cenovno pravilo v posameznem poslu, bi morali vsi, ki se uporabljajo pravila za oblikovanje cen so onemogočeni.",
"To set this Fiscal Year as Default, click on 'Set as Default'","Če želite nastaviti to poslovno leto kot privzeto, kliknite na &quot;Set as Default&quot;",
To view logs of Loyalty Points assigned to a Customer.,"Če si želite ogledati dnevnike točk zvestobe, dodeljenih naročniku.",
To {0},Za {0},
To {0} | {1} {2},Za {0} | {1} {2},
Toggle Filters,Preklopite filtre,
Too many columns. Export the report and print it using a spreadsheet application.,Preveč stolpcev. Izvoziti poročilo in ga natisnete s pomočjo aplikacije za preglednice.,
Tools,Orodja,
Total (Credit),Skupaj (Credit),
Total (Without Tax),Skupaj (brez davka),
Total Absent,Skupaj Odsoten,
Total Achieved,Skupaj Doseženi,
Total Actual,Skupaj Actual,
Total Allocated Leaves,Skupna dodeljena lista,
Total Amount,Skupni znesek,
Total Amount Credited,Skupni znesek kredita,
Total Applicable Charges in Purchase Receipt Items table must be same as Total Taxes and Charges,Skupaj veljavnih cenah na Potrdilo o nakupu postavke tabele mora biti enaka kot Skupaj davkov in dajatev,
Total Budget,Skupni proračun,
Total Collected: {0},Skupno zbranih: {0},
Total Commission,Skupaj Komisija,
Total Contribution Amount: {0},Skupni znesek prispevka: {0},
Total Credit/ Debit Amount should be same as linked Journal Entry,Skupni znesek kredita / obresti mora biti enak kot povezan dnevnik,
Total Debit must be equal to Total Credit. The difference is {0},Skupaj obremenitve mora biti enaka celotnemu kreditnemu. Razlika je {0},
Total Deduction,Skupaj Odbitek,
Total Invoiced Amount,Skupaj Obračunani znesek,
Total Leaves,Skupaj listi,
Total Order Considered,Skupaj naročite Upoštevani,
Total Order Value,Skupna vrednost naročila,
Total Outgoing,Skupaj odhodni,
Total Outstanding,Skupaj izjemen,
Total Outstanding Amount,Skupni preostali znesek,
Total Outstanding: {0},Skupno izjemno: {0},
Total Paid Amount,Skupaj Plačan znesek,
Total Payment Amount in Payment Schedule must be equal to Grand / Rounded Total,Skupni znesek plačila v urniku plačil mora biti enak znesku zaokroženo / zaokroženo,
Total Payments,Skupna plačila,
Total Present,Skupaj Present,
Total Qty,Skupaj Kol,
Total Quantity,Skupna količina,
Total Revenue,Skupni prihodki,
Total Student,Skupaj študent,
Total Target,Skupaj Target,
Total Tax,Skupna davčna,
Total Taxable Amount,Skupaj obdavčljiv znesek,
Total Taxable Value,Skupna obdavčljiva vrednost,
Total Unpaid: {0},Skupaj neplačano: {0},
Total Variance,Skupne variance,
Total Weightage of all Assessment Criteria must be 100%,Skupaj weightage vseh ocenjevalnih meril mora biti 100%,
Total advance ({0}) against Order {1} cannot be greater than the Grand Total ({2}),Skupaj predplačilo ({0}) proti odredbi {1} ne more biti večja od Grand Total ({2}),
Total advance amount cannot be greater than total claimed amount,Skupni znesek vnaprej ne more biti večji od skupnega zahtevanega zneska,
Total advance amount cannot be greater than total sanctioned amount,Skupni znesek predplačila ne more biti večji od skupnega sankcioniranega zneska,
Total allocated leaves are more days than maximum allocation of {0} leave type for employee {1} in the period,Skupno dodeljeni listi so več dni kot največja dodelitev {0} tipa dopusta za zaposlenega {1} v obdobju,
Total allocated leaves are more than days in the period,Skupaj dodeljena listi so več kot dni v obdobju,
Total allocated percentage for sales team should be 100,Skupna dodeljena odstotek za prodajne ekipe mora biti 100,
Total cannot be zero,Skupaj ne more biti nič,
Total contribution percentage should be equal to 100,Skupni odstotek prispevka mora biti enak 100,
Total flexible benefit component amount {0} should not be less than max benefits {1},Skupni znesek komponente prožne ugodnosti {0} ne sme biti manjši od najvišjih ugodnosti {1},
Total hours: {0},Skupno število ur: {0},
Total leaves allocated is mandatory for Leave Type {0},Skupni dodeljeni listi so obvezni za tip zapustitve {0},
Total working hours should not be greater than max working hours {0},Skupaj delovni čas ne sme biti večja od max delovnih ur {0},
Total {0} ({1}),Skupno {0} ({1}),
"Total {0} for all items is zero, may be you should change 'Distribute Charges Based On'","Skupno {0} za vse postavke je nič, morda bi morali spremeniti &quot;Razdeli stroškov na osnovi&quot;",
Total(Amt),Skupaj (Amt),
Total(Qty),Skupaj (Kol),
Traceability,Sledljivost,
Traceback,Izslediti,
Track Leads by Lead Source.,Sledite navodilom po viru.,
Training,Usposabljanje,
Training Event,Dogodek usposabljanje,
Training Events,Dogodki za usposabljanje,
Training Feedback,Predlogi za usposabljanje,
Training Result,Rezultat usposabljanja,
Transaction,Posel,
Transaction Date,Transakcijski Datum,
Transaction Type,Vrsta transakcije,
Transaction currency must be same as Payment Gateway currency,Transakcijski valuta mora biti enaka kot vplačilo valuto,
Transaction not allowed against stopped Work Order {0},Transakcija ni dovoljena prekinjena Delovni nalog {0},
Transaction reference no {0} dated {1},Referenčna transakcija ni {0} dne {1},
Transactions,Transakcije,
Transactions can only be deleted by the creator of the Company,Transakcije se lahko izbriše le s ustvarjalca družbe,
Transfer,Prenos,
Transfer Material,Prenos Material,
Transfer Type,Vrsta prenosa,
Transfer an asset from one warehouse to another,Prenese sredstva iz enega skladišča v drugo,
Transfered,Prenese,
Transferred Quantity,Prenesena količina,
Transport Receipt Date,Datum prejema transporta,
Transport Receipt No,Prevozni list št,
Transportation,Prevoz,
Transporter ID,ID transporterja,
Transporter Name,Transporter Name,
Travel,Potovanja,
Travel Expenses,Potni stroški,
Tree Type,Tree Type,
Tree of Bill of Materials,Drevo Bill of Materials,
Tree of Item Groups.,Drevo skupin artiklov.,
Tree of Procedures,Drevo postopkov,
Tree of Quality Procedures.,Drevo kakovostnih postopkov.,
Tree of financial Cost Centers.,Drevo centrov finančnih stroškov.,
Tree of financial accounts.,Drevo finančnih računov.,
Treshold {0}% appears more than once,Praga {0}% pojavi več kot enkrat,
Trial Period End Date Cannot be before Trial Period Start Date,Datum konca poskusnega obdobja ne more biti pred začetkom začetnega poskusnega obdobja,
Trialling,Trialling,
Type of Business,Vrsta podjetja,
Types of activities for Time Logs,Vrste dejavnosti za Čas Dnevniki,
UOM,UOM,
UOM Conversion factor is required in row {0},Faktor UOM Pretvorba je potrebno v vrstici {0},
UOM coversion factor required for UOM: {0} in Item: {1},"UOM coversion dejavnik, potreben za UOM: {0} v postavki: {1}",
URL,URL,
Unable to find DocType {0},Datoteke DocType {0} ni mogoče najti,
Unable to find exchange rate for {0} to {1} for key date {2}. Please create a Currency Exchange record manually,Mogoče najti menjalni tečaj za {0} in {1} za ključ datumu {2}. Prosimo ustvariti zapis Valuta Exchange ročno,
Unable to find score starting at {0}. You need to have standing scores covering 0 to 100,"Rezultate ni mogoče najti od {0}. Imeti morate stoječe rezultate, ki pokrivajo od 0 do 100",
Unable to find variable: ,Ni mogoče najti spremenljivke:,
Unblock Invoice,Odblokiraj račun,
Uncheck all,Odznači vse,
Unclosed Fiscal Years Profit / Loss (Credit),Nezaprt proračunskih let dobiček / izguba (Credit),
Unit,Enota,
Unit of Measure,Merska enota,
Unit of Measure {0} has been entered more than once in Conversion Factor Table,Merska enota {0} je v pretvorbeni faktor tabeli vpisana več kot enkrat,
Unknown,Neznan,
Unpaid,Neplačan,
Unsecured Loans,Nezavarovana posojila,
Unsubscribe from this Email Digest,Odjaviti iz te Email Digest,
Unsubscribed,Odjavljeni,
Until,Do,
Unverified Webhook Data,Nepreverjeni podatki spletnega ure,
Update Account Name / Number,Posodobi ime računa / številka,
Update Account Number / Name,Posodobi številko računa / ime,
Update Cost,Posodobitev Stroški,
Update Items,Posodobi elemente,
Update Print Format,Update Print Format,
Update Response,Posodobi odgovor,
Update bank payment dates with journals.,Posodobite rok plačila banka s revijah.,
Update in progress. It might take a while.,Posodabljanje je v teku. Mogoče bo trajalo nekaj časa.,
Update rate as per last purchase,Hitrost posodobitve po zadnjem nakupu,
Update stock must be enable for the purchase invoice {0},Posodobitev zaloge mora biti omogočena za račun za nakup {0},
Updating Variants...,Posodobitev različic ...,
Upload your letter head and logo. (you can edit them later).,Naložite svoje pismo glavo in logotip. (lahko jih uredite kasneje).,
Upper Income,Zgornja Prihodki,
Use Sandbox,uporaba Sandbox,
Used Leaves,Uporabljeni listi,
User,Uporabnik,
User ID,Uporabniško ime,
User ID not set for Employee {0},ID uporabnika ni nastavljena za Employee {0},
User Remark,Uporabnik Pripomba,
User has not applied rule on the invoice {0},Uporabnik na računu ni uporabil pravila {0},
User {0} already exists,Uporabnik {0} že obstaja,
User {0} created,Uporabnik {0} je ustvaril,
User {0} does not exist,Uporabnik {0} ne obstaja,
User {0} doesn't have any default POS Profile. Check Default at Row {1} for this User.,Uporabnik {0} nima privzetega profila POS. Preverite privzeto na vrstici {1} za tega uporabnika.,
User {0} is already assigned to Employee {1},Uporabnik {0} je že dodeljen Employee {1},
User {0} is already assigned to Healthcare Practitioner {1},Uporabnik {0} je že dodeljen zdravstvenemu zdravniku {1},
Users,Uporabniki,
Utility Expenses,Pomožni Stroški,
Valid From Date must be lesser than Valid Upto Date.,Velja od datuma mora biti manjši od veljavnega datuma uveljavitve.,
Valid Till,Veljavno do,
Valid from and valid upto fields are mandatory for the cumulative,Veljavna in veljavna upto polja so obvezna za kumulativno,
Valid from date must be less than valid upto date,"Velja od datuma, ki mora biti manjši od veljavnega do datuma",
Valid till date cannot be before transaction date,Veljaven do datuma ne more biti pred datumom transakcije,
Validity,Veljavnost,
Validity period of this quotation has ended.,Obdobje veljavnosti te ponudbe se je končalo.,
Valuation Rate,Oceni Vrednotenje,
Valuation Rate is mandatory if Opening Stock entered,"Oceni Vrednotenje je obvezna, če je začel Odpiranje Stock",
Valuation type charges can not marked as Inclusive,Stroški Tip vrednotenje ni mogoče označiti kot Inclusive,
Value Or Qty,Vrednost ali Kol,
Value Proposition,Vrednostni predlog,
Value for Attribute {0} must be within the range of {1} to {2} in the increments of {3} for Item {4},Vrednost atributa {0} mora biti v razponu od {1} do {2} v korakih po {3} za postavko {4},
Value missing,Manjka vrednost,
Value must be between {0} and {1},Vrednost mora biti med {0} in {1},
"Values of exempt, nil rated and non-GST inward supplies","Vrednosti oproščenih, z ničelno vrednostjo in vhodnih dobav brez GST",
Variable,Spremenljivka,
Variance,Variance,
Variance ({}),Variance ({}),
Variant,Variant,
Variant Attributes,Atributi atributov,
Variant Based On cannot be changed,"Variante, ki temelji na, ni mogoče spremeniti",
Variant Details Report,Poročilo o variantah,
Variant creation has been queued.,Ustvarjanje variant je bilo v čakalni vrsti.,
Vehicle Expenses,Stroški vozil,
Vehicle No,Nobeno vozilo,
Vehicle Type,Vrsta vozila,
Vehicle/Bus Number,Vozila / Bus številka,
Venture Capital,Tveganega kapitala,
View Chart of Accounts,Oglejte si Chart of Accounts,
View Fees Records,Oglejte si zapisi o prispevkih,
View Form,Prikaži obrazec,
View Lab Tests,Oglejte si laboratorijske preiskave,
View Leads,Poglej ponudbe,
View Ledger,Ogled Ledger,
View Now,Oglejte si zdaj,
View a list of all the help videos,Oglejte si seznam vseh videoposnetkov pomočjo,
View in Cart,Poglej v košarico,
Visit report for maintenance call.,Obiščite poročilo za vzdrževalna klic.,
Visit the forums,Obiščite forume,
Vital Signs,Življenjski znaki,
Volunteer,Prostovoljka,
Volunteer Type information.,Informacije o prostovoljcih.,
Volunteer information.,Informacije o prostovoljcih.,
Voucher #,Voucher #,
Voucher No,Voucher ni,
Voucher Type,Bon Type,
WIP Warehouse,WIP skladišče,
Walk In,Vstopiti,
Warehouse can not be deleted as stock ledger entry exists for this warehouse.,"Skladišče ni mogoče črtati, saj obstaja vnos stock knjiga za to skladišče.",
Warehouse cannot be changed for Serial No.,Skladišče ni mogoče spremeniti za Serial No.,
Warehouse is mandatory,Skladišče je obvezna,
Warehouse is mandatory for stock Item {0} in row {1},Skladišče je obvezna za postavko {0} v vrstici {1},
Warehouse not found in the system,Skladišče ni mogoče najti v sistemu,
"Warehouse required at Row No {0}, please set default warehouse for the item {1} for the company {2}","Skladišče, potrebno na vrstico št. {0}, nastavite privzeto skladišče za predmet {1} za podjetje {2}",
Warehouse required for stock Item {0},Skladišče je potrebna za borzo postavki {0},
Warehouse {0} can not be deleted as quantity exists for Item {1},"Skladišče {0} ni mogoče izbrisati, kot obstaja količina za postavko {1}",
Warehouse {0} does not belong to company {1},Skladišče {0} ne pripada podjetju {1},
Warehouse {0} does not exist,Skladišče {0} ne obstaja,
"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šče {0} ni povezano z nobenim računom, navedite račun v evidenco skladišče ali nastavite privzeto inventarja račun v družbi {1}.",
Warehouses with child nodes cannot be converted to ledger,Skladišča z otrok vozlišča ni mogoče pretvoriti v knjigo terjatev,
Warehouses with existing transaction can not be converted to group.,Skladišča z obstoječim poslom ni mogoče pretvoriti v skupino.,
Warehouses with existing transaction can not be converted to ledger.,Skladišča z obstoječim poslom ni mogoče pretvoriti v knjigi.,
Warning,Opozorilo,
Warning: Another {0} # {1} exists against stock entry {2},Opozorilo: Drug {0} # {1} obstaja pred vstopom parka {2},
Warning: Invalid SSL certificate on attachment {0},Opozorilo: Neveljavno potrdilo SSL za pritrditev {0},
Warning: Invalid attachment {0},Opozorilo: Invalid Attachment {0},
Warning: Leave application contains following block dates,Opozorilo: Pustite prijava vsebuje naslednje datume blok,
Warning: Material Requested Qty is less than Minimum Order Qty,"Opozorilo: Material Zahtevana Količina je manj kot minimalna, da Kol",
Warning: Sales Order {0} already exists against Customer's Purchase Order {1},Opozorilo: Sales Order {0} že obstaja zoper naročnikovo narocilo {1},
Warning: System will not check overbilling since amount for Item {0} in {1} is zero,Opozorilo: Sistem ne bo preveril previsokih saj znesek za postavko {0} v {1} je nič,
Warranty,Garancija,
Warranty Claim,Garancija zahtevek,
Warranty Claim against Serial No.,Garancija zahtevek zoper Serial No.,
Website,Spletna stran,
Website Image should be a public file or website URL,Spletna stran Slika bi morala biti javna datoteka ali spletna stran URL,
Website Image {0} attached to Item {1} cannot be found,Spletna stran slike {0} pritrjena na postavki {1} ni mogoče najti,
Website Listing,Seznam spletnih mest,
Website Manager,Spletna stran Manager,
Website Settings,Spletna stran Nastavitve,
Wednesday,Sreda,
Week,teden,
Weekdays,Delovni dnevi,
Weekly,Tedenski,
"Weight is mentioned,\nPlease mention ""Weight UOM"" too","Teža je omenjeno, \ nProsim omenja &quot;Teža UOM&quot; preveč",
Welcome email sent,Dobrodošli email poslan,
Welcome to ERPNext,Dobrodošli na ERPNext,
What do you need help with?,Kaj potrebujete pomoč?,
What does it do?,Kaj to naredi?,
Where manufacturing operations are carried.,Kjer so proizvodni postopki.,
White,Bela,
Wire Transfer,Wire Transfer,
WooCommerce Products,Izdelki WooCommerce,
Work In Progress,Delo v teku,
Work Order,Delovni nalog,
Work Order already created for all items with BOM,Delovni nalog je že ustvarjen za vse elemente z BOM,
Work Order cannot be raised against a Item Template,Delovnega reda ni mogoče dvigniti glede na predlogo postavke,
Work Order has been {0},Delovni nalog je bil {0},
Work Order not created,Delovni nalog ni bil ustvarjen,
Work Order {0} must be cancelled before cancelling this Sales Order,Delovni nalog {0} morate preklicati pred preklicem tega prodajnega naloga,
Work Order {0} must be submitted,Delovni nalog {0} mora biti predložen,
Work Orders Created: {0},Ustvarjeni delovni nalogi: {0},
Work Summary for {0},Povzetek dela za {0},
Work-in-Progress Warehouse is required before Submit,Work-in-Progress Warehouse je pred potreben Submit,
Workflow,Workflow,
Working,Delovna,
Working Hours,Delovni čas,
Workstation,Workstation,
Workstation is closed on the following dates as per Holiday List: {0},Workstation je zaprt na naslednje datume kot na Holiday Seznam: {0},
Wrapping up,Zavijanje,
Wrong Password,Napačno geslo,
Year start date or end date is overlapping with {0}. To avoid please set company,"Leto datum začetka oziroma prenehanja se prekrivajo z {0}. Da bi se izognili prosim, da podjetje",
You are not authorized to add or update entries before {0},Nimate dovoljenja za dodajanje ali posodobitev vnose pred {0},
You are not authorized to approve leaves on Block Dates,Niste pooblaščeni za odobritev liste na Block termini,
You are not authorized to set Frozen value,Nimate dovoljenja za nastavitev Zamrznjena vrednost,
You are not present all day(s) between compensatory leave request days,Niste bili prisotni ves dan med zahtevki za nadomestni dopust,
You can not change rate if BOM mentioned agianst any item,"Vi stopnje ni mogoče spremeniti, če BOM omenjeno agianst vsako postavko",
You can not enter current voucher in 'Against Journal Entry' column,"Ne, ne more vstopiti trenutno bon v &quot;Proti listu vstopa&quot; stolpcu",
You can only have Plans with the same billing cycle in a Subscription,V naročnini lahko imate samo načrte z enakim obračunskim ciklom,
You can only redeem max {0} points in this order.,V tem vrstnem redu lahko uveljavljate največ {0} točk.,
You can only renew if your membership expires within 30 days,"Obnovite lahko le, če vaše članstvo poteče v 30 dneh",
You can only select a maximum of one option from the list of check boxes.,Iz seznama potrditvenih polj lahko izberete največ eno možnost.,
You can only submit Leave Encashment for a valid encashment amount,Leave Encashment lahko oddate samo za veljaven znesek obračuna,
You can't redeem Loyalty Points having more value than the Grand Total.,"Točke zvestobe ne morete izkoristiti, če imajo večjo vrednost kot Grand Total.",
You cannot credit and debit same account at the same time,"Ne, ne moreš kreditnih in debetnih isti račun ob istem času",
You cannot delete Fiscal Year {0}. Fiscal Year {0} is set as default in Global Settings,"Ne, ne moreš brisati poslovnega leta {0}. Poslovno leto {0} je privzet v globalnih nastavitvah",
You cannot delete Project Type 'External',Ne morete izbrisati vrste projekta &quot;Zunanji&quot;,
You cannot edit root node.,Rootnega vozlišča ne morete urejati.,
You cannot restart a Subscription that is not cancelled.,"Naročnino, ki ni preklican, ne morete znova zagnati.",
You don't have enought Loyalty Points to redeem,Za unovčevanje niste prejeli točk za zvestobo,
You have already assessed for the assessment criteria {}.,Ste že ocenili za ocenjevalnih meril {}.,
You have already selected items from {0} {1},Ste že izbrane postavke iz {0} {1},
You have been invited to collaborate on the project: {0},Ti so bili povabljeni k sodelovanju na projektu: {0},
You have entered duplicate items. Please rectify and try again.,"Vnesli ste podvojene elemente. Prosimo, popravite in poskusite znova.",
You need to be a user other than Administrator with System Manager and Item Manager roles to register on Marketplace.,"Če se želite registrirati v Marketplace, morate biti uporabnik, ki ni administrator, z vlogo Upravitelja sistema in Upravitelja elementov.",
You need to be a user with System Manager and Item Manager roles to add users to Marketplace.,"Če želite dodati uporabnike v Marketplace, morate biti uporabnik z vlogami upravitelja sistema in upravitelja elementov.",
You need to be a user with System Manager and Item Manager roles to register on Marketplace.,Za registracijo v Marketplace morate biti uporabnik z vlogami upravitelja sistemov in upravitelja elementov.,
You need to be logged in to access this page,Morate biti prijavljeni za dostop do te strani,
You need to enable Shopping Cart,Morate omogočiti Košarica,
You will lose records of previously generated invoices. Are you sure you want to restart this subscription?,"Izgubili boste zapise o že ustvarjenih računih. Ali ste prepričani, da želite znova zagnati to naročnino?",
Your Organization,Vaša organizacija,
Your cart is Empty,Vaš nakupovalni voziček je prazen,
Your email address...,Vaš email naslov...,
Your order is out for delivery!,Vaše naročilo je brezplačno!,
Your tickets,Vaše vstopnice,
ZIP Code,Poštna številka,
[Error],[Error],
[{0}](#Form/Item/{0}) is out of stock,[{0}] (# Form / Item / {0}) ni na zalogi,
`Freeze Stocks Older Than` should be smaller than %d days.,`Zamrzni zaloge starejše od` mora biti manjša od %d dni.,
based_on,temelji na,
cannot be greater than 100,ne more biti večja kot 100,
disabled user,onemogočena uporabnik,
"e.g. ""Build tools for builders""",npr &quot;Build orodja za gradbenike&quot;,
"e.g. ""Primary School"" or ""University""",npr &quot;Osnovna šola&quot; ali &quot;University&quot;,
"e.g. Bank, Cash, Credit Card","npr Bank, gotovini, Kreditna kartica",
hidden,Skrito,
modified,spremenjene,
old_parent,old_parent,
on,na,
{0} '{1}' is disabled,{0} {1} &quot;je onemogočena,
{0} '{1}' not in Fiscal Year {2},{0} {1} &quot;ni v proračunskem letu {2},
{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0} ({1}) ne more biti večja od načrtovane količine ({2}) v delovnem redu {3},
{0} - {1} is inactive student,{0} - {1} neaktiven študent,
{0} - {1} is not enrolled in the Batch {2},{0} - {1} ni vpisan v serijo {2},
{0} - {1} is not enrolled in the Course {2},{0} - {1} ni vpisan v smer {2},
{0} Budget for Account {1} against {2} {3} is {4}. It will exceed by {5},{0} proračun za račun {1} na {2} {3} je {4}. Bo prekoračen za {5},
{0} Digest,{0} Razlaga,
{0} Request for {1},{0} Zahteva za {1},
{0} Result submittted,{0} vloženo,
{0} Serial Numbers required for Item {1}. You have provided {2}.,{0} serijska(e) številka(e) zahtevana(e) za postavko {1}. Navedli ste {2}.,
{0} Student Groups created.,{0} skupine študentov ustvarjene,
{0} Students have been enrolled,{0} Študenti so bili vpisani,
{0} against Bill {1} dated {2},{0} za Račun {1} z dne {2},
{0} against Purchase Order {1},{0} za Naročilo {1},
{0} against Sales Invoice {1},{0} za Račun {1},
{0} against Sales Order {1},{0} za Naročilnico {1},
{0} already allocated for Employee {1} for period {2} to {3},{0} že dodeljeno za zaposlenega {1} za obdobje {2} do {3},
{0} applicable after {1} working days,{0} po {1} delovnih dneh,
{0} asset cannot be transferred,{0} sredstev ni mogoče prenesti,
{0} can not be negative,{0} ne more biti negativna,
{0} created,{0} ustvaril,
"{0} currently has a {1} Supplier Scorecard standing, and Purchase Orders to this supplier should be issued with caution.",{0} ima trenutno {1} oceno dobavitelja in naročila temu dobavitelju je treba izdajati s previdnostjo,
"{0} currently has a {1} Supplier Scorecard standing, and RFQs to this supplier should be issued with caution.",{0} ima trenutno {1} oceno dobavitelja in naročila temu dobavitelju je treba izdajati s previdnostjo,
{0} does not belong to Company {1},{0} ne pripada družbi {1},
{0} does not have a Healthcare Practitioner Schedule. Add it in Healthcare Practitioner master,{0} nima razporeda zdravniškega zdravnika. Dodajte ga v mojstrski zdravnik,
{0} entered twice in Item Tax,{0} dvakrat vpisano v davčni postavki,
{0} for {1},{0} za {1},
{0} has been submitted successfully,{0} je bilo uspešno poslano,
{0} has fee validity till {1},{0} ima veljavnost pristojbine {1},
{0} hours,{0} ur,
{0} in row {1},{0} v vrstici {1},
{0} is blocked so this transaction cannot proceed,"{0} je blokiran, da se ta transakcija ne more nadaljevati",
{0} is mandatory,{0} je obvezna,
{0} is mandatory for Item {1},{0} je obvezen za postavko {1},
{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2}.,{0} je obvezen. Mogoče zapis Menjalnega tečaja ni ustvarjen za {1} v {2}.,
{0} is not a stock Item,{0} ni zaloge artikla,
{0} is not a valid Batch Number for Item {1},{0} ni veljavna številka serije za postavko {1},
{0} is not added in the table,{0} ni dodan v tabeli,
{0} is not in Optional Holiday List,{0} ni na seznamu neobveznih praznikov,
{0} is not in a valid Payroll Period,{0} ni v veljavnem plačilnem obdobju,
{0} is now the default Fiscal Year. Please refresh your browser for the change to take effect.,"{0} je zdaj privzeto poslovno leto. Prosimo, osvežite brskalnik, da se sprememba uveljavi.",
{0} is on hold till {1},{0} je na čakanju do {1},
{0} item found.,{0} element je najden.,
{0} items found.,{0} najdenih elementov.,
{0} items in progress,{0} postavke v teku,
{0} items produced,{0} postavke proizvedene,
{0} must appear only once,{0} se morajo pojaviti le enkrat,
{0} must be negative in return document,{0} mora biti negativno na povratnem dokumentu,
{0} must be submitted,{0} je treba vložiti,
{0} not allowed to transact with {1}. Please change the Company.,"{0} ni dovoljeno posredovati z {1}. Prosimo, spremenite družbo.",
{0} not found for item {1},{0} ni najden za postavko {1},
{0} parameter is invalid,{0} Parameter ni veljaven,
{0} payment entries can not be filtered by {1},{0} vnosov plačil ni mogoče filtrirati s {1},
{0} should be a value between 0 and 100,{0} mora biti vrednost med 0 in 100,
{0} units of [{1}](#Form/Item/{1}) found in [{2}](#Form/Warehouse/{2}),{0} enot [{1}] (#Obrazec/Postavka/{1}) najden v [{2}] (#Obrazec/Skladišče/{2}),
{0} units of {1} needed in {2} on {3} {4} for {5} to complete this transaction.,{0} enot {1} potrebnih v {2} na {3} {4} za {5} za dokončanje te transakcije.,
{0} units of {1} needed in {2} to complete this transaction.,{0} enot {1} potrebnih v {2} za dokončanje te transakcije.,
{0} valid serial nos for Item {1},{0} veljavna serijska številka za postavko {1},
{0} variants created.,{0} ustvarjene različice.,
{0} {1} created,{0} {1} ustvarjeno,
{0} {1} does not exist,{0} {1} ne obstaja,
{0} {1} has been modified. Please refresh.,{0} {1} je bila spremenjena. Osvežite.,
{0} {1} has not been submitted so the action cannot be completed,"{0} {1} ni bila vložena, dejanje ne more biti dokončano",
"{0} {1} is associated with {2}, but Party Account is {3}","{0} {1} je povezan z {2}, vendar je Račun stranke {3}",
{0} {1} is cancelled or closed,{0} {1} je preklican ali končan,
{0} {1} is cancelled or stopped,{0} {1} je preklican ali ustavljen,
{0} {1} is cancelled so the action cannot be completed,"{0} {1} je preklican, dejanje ne more biti dokončano",
{0} {1} is closed,{0} {1} je zaprt,
{0} {1} is disabled,{0} {1} je onemogočeno,
{0} {1} is frozen,{0} {1} je zamrznjeno,
{0} {1} is fully billed,{0} {1} je v celoti zaračunano,
{0} {1} is not active,{0} {1} ni aktiven,
{0} {1} is not associated with {2} {3},{0} {1} ni povezan z {2} {3},
{0} {1} is not present in the parent company,{0} {1} ni v matični družbi,
{0} {1} is not submitted,{0} {1} ni vložen,
{0} {1} is {2},{0} {1} je {2},
{0} {1} must be submitted,{0} {1} je potrebno vložiti,
{0} {1} not in any active Fiscal Year.,{0} {1} ni v nobenem poslovnem letu,
{0} {1} status is {2},{0} {1} status {2},
{0} {1}: 'Profit and Loss' type account {2} not allowed in Opening Entry,"{0} {1}: ""Izkaz poslovnega izida"" tip računa {2} ni dovoljen v Otvoritvenem zapisu",
{0} {1}: Account {2} does not belong to Company {3},{0} {1}: račun {2} ne pripada družbi {3},
{0} {1}: Account {2} is inactive,{0} {1}: Račun {2} je neaktiven,
{0} {1}: Accounting Entry for {2} can only be made in currency: {3},{0} {1}: računovodski zapis za {2} se lahko zapiše le v valuti: {3},
{0} {1}: Cost Center is mandatory for Item {2},{0} {1}: Stroškovno mesto je zahtevano za postavko {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}: Stroškovno mesto je zahtevano za ""Izkaz poslovnega izida"" računa {2}. Nastavite privzeto stroškovno mesto za družbo.",
{0} {1}: Cost Center {2} does not belong to Company {3},{0} {1}: Stroškovno mesto {2} ne pripada družbi {3},
{0} {1}: Customer is required against Receivable account {2},{0} {1}: zahtevan je Naročnik za račun prejemkov {2},
{0} {1}: Either debit or credit amount is required for {2},{0} {1}: zahtevan je debetni ali kreditni znesek za {2},
{0} {1}: Supplier is required against Payable account {2},{0} {1}: zahtevan je Dobavitelj za račun izdatkov {2},
{0}% Billed,{0}% zaračunano,
{0}% Delivered,{0}% Dostavljeno,
"{0}: Employee email not found, hence email not sent","{0}: email zaposlenega ni mogoče najti, zato e-poštno sporočilo ni bilo poslano",
{0}: From {0} of type {1},{0}: Od {0} tipa {1},
{0}: From {1},{0}: Od {1},
{0}: {1} does not exists,{0}: {1} ne obstaja,
{0}: {1} not found in Invoice Details table,{0}: {1} ni mogoče najti v tabeli podrobnosti računov,
{} of {},{} od {},
Assigned To,Dodeljeno,
Chat,Klepet,
Completed By,Dokončano z,
Conditions,Pogoji,
County,County,
Day of Week,Dan v tednu,
"Dear System Manager,","Dragi System Manager,",
Default Value,Privzeta vrednost,
Email Group,Email Group,
Email Settings,Nastavitve e-pošte,
Email not sent to {0} (unsubscribed / disabled),Email ne pošlje na {0} (odjavili / onemogočeno),
Error Message,Obvestilo o napaki,
Fieldtype,Fieldtype,
Help Articles,Članki za pomoč,
ID,ID,
Images,slike,
Import,Uvoz,
Language,Jezik,
Likes,Likes,
Merge with existing,Združi z obstoječo,
Office,Pisarna,
Orientation,usmerjenost,
Parent,Parent,
Passive,Pasivna,
Payment Failed,plačilo ni uspelo,
Percent,Odstotek,
Permanent,Stalno,
Personal,Osebni,
Plant,Rastlina,
Post,Objavi,
Postal,Postal,
Postal Code,Poštna številka,
Previous,Prejšnja,
Provider,Ponudnik,
Read Only,Le za branje,
Recipient,Prejemnik,
Reviews,Ocene,
Sender,Sender,
Shop,Trgovina,
Subsidiary,Hčerinska družba,
There is some problem with the file url: {0},Obstaja nekaj problem z datoteko url: {0},
There were errors while sending email. Please try again.,Tam so bile napake pri pošiljanju e-pošte. Prosim poskusi znova.,
Values Changed,vrednosti Spremenjeno,
or,ali,
Ageing Range 4,Razpon staranja 4,
Allocated amount cannot be greater than unadjusted amount,Dodeljeni znesek ne sme biti večji od neprilagojenega zneska,
Allocated amount cannot be negative,Dodeljeni znesek ne more biti negativen,
"Difference Account must be a Asset/Liability type account, since this Stock Entry is an Opening Entry","Račun za razliko mora biti račun vrste sredstev / obveznosti, saj je ta vnos zaloga odprt",
Error in some rows,Napaka v nekaterih vrsticah,
Import Successful,Uvoz uspešen,
Please save first,Najprej shranite,
Price not found for item {0} in price list {1},Ni cene za izdelek {0} v ceniku {1},
Warehouse Type,Vrsta skladišča,
'Date' is required,&#39;Datum&#39; je obvezen,
Benefit,Ugodnost,
Budgets,Proračuni,
Bundle Qty,Število kosov,
Company GSTIN,Podjetje GSTIN,
Company field is required,Polje podjetja je obvezno,
Creating Dimensions...,Ustvarjanje dimenzij ...,
Duplicate entry against the item code {0} and manufacturer {1},Podvojen vnos s kodo izdelka {0} in proizvajalcem {1},
Invalid GSTIN! The input you've entered doesn't match the GSTIN format for UIN Holders or Non-Resident OIDAR Service Providers,Neveljaven GSTIN! Vneseni vnos ne ustreza formatu GSTIN za imetnike UIN ali nerezidentne ponudnike storitev OIDAR,
Invoice Grand Total,Račun za skupni znesek,
Last carbon check date cannot be a future date,Zadnji datum preverjanja emisij ogljika ne more biti prihodnji datum,
Make Stock Entry,Naredite vnos zalog,
Quality Feedback,Kakovostne povratne informacije,
Quality Feedback Template,Predloga za povratne informacije o kakovosti,
Rules for applying different promotional schemes.,Pravila za uporabo različnih promocijskih shem.,
Shift,Shift,
Show {0},Prikaži {0},
"Special Characters except '-', '#', '.', '/', '{{' and '}}' not allowed in naming series {0}","Posebni znaki, razen &quot;-&quot;, &quot;#&quot;, &quot;.&quot;, &quot;/&quot;, &quot;{{&quot; In &quot;}}&quot; v poimenovanju ni dovoljen {0}",
Target Details,Podrobnosti cilja,
{0} already has a Parent Procedure {1}.,{0} že ima nadrejeni postopek {1}.,
API,API,
Annual,Letno,
Approved,Odobreno,
Change,Spremeni,
Contact Email,Kontakt E-pošta,
Export Type,Izvozna vrsta,
From Date,Od datuma,
Group By,Skupina avtorja,
Importing {0} of {1},Uvoz {0} od {1},
Invalid URL,Neveljaven URL,
Landscape,Pokrajina,
Last Sync On,Zadnja sinhronizacija je vključena,
Naming Series,Poimenovanje zaporedja,
No data to export,Ni podatkov za izvoz,
Portrait,Portret,
Print Heading,Glava postavk,
Scheduler Inactive,Planer neaktiven,
Scheduler is inactive. Cannot import data.,Planer je neaktiven. Podatkov ni mogoče uvoziti.,
Show Document,Prikaži dokument,
Show Traceback,Pokaži sled,
Video,Video,
Webhook Secret,Spletna skrivnost,
% Of Grand Total,% Od skupne vsote,
'employee_field_value' and 'timestamp' are required.,Zahtevana sta &#39;Employ_field_value&#39; in &#39;timetamp&#39;.,
<b>Company</b> is a mandatory filter.,<b>Podjetje</b> je obvezen filter.,
<b>From Date</b> is a mandatory filter.,<b>From Date</b> je obvezen filter.,
<b>From Time</b> cannot be later than <b>To Time</b> for {0},<b>{Time od {~ asa</b> ne more biti pozneje kot <b>Do ~.</b>,
<b>To Date</b> is a mandatory filter.,<b>Do</b> danes je obvezen filter.,
A new appointment has been created for you with {0},Za vas je bil ustvarjen nov sestanek z {0},
Account Value,Vrednost računa,
Account is mandatory to get payment entries,Za vnos plačil je obvezen račun,
Account is not set for the dashboard chart {0},Za grafikon nadzorne plošče račun ni nastavljen {0},
Account {0} does not belong to company {1},Račun {0} ne pripada družbi {1},
Account {0} does not exists in the dashboard chart {1},Račun {0} ne obstaja v 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 Delo v teku in ga vnos v časopis ne more posodobiti,
Account: {0} is not permitted under Payment Entry,Račun: {0} ni dovoljen pri vnosu plačila,
Accounting Dimension <b>{0}</b> is required for 'Balance Sheet' account {1}.,Za račun &quot;Bilanca stanja&quot; {1} je potrebna računovodska razsežnost <b>{0</b> }.,
Accounting Dimension <b>{0}</b> is required for 'Profit and Loss' account {1}.,Za račun „Dobiček in izguba“ {1} je potrebna računovodska razsežnost <b>{0</b> }.,
Accounting Masters,Mojstri računovodstva,
Accounting Period overlaps with {0},Računovodsko obdobje se prekriva z {0},
Activity,Dejavnost,
Add / Manage Email Accounts.,Dodaj / Upravljanje e-poštnih računov.,
Add Child,Dodaj Child,
Add Loan Security,Dodaj varnost posojila,
Add Multiple,Dodaj več,
Add Participants,Dodaj udeležence,
Add to Featured Item,Dodaj med predstavljene izdelke,
Add your review,Dodajte svoje mnenje,
Add/Edit Coupon Conditions,Dodaj / uredite pogoje kupona,
Added to Featured Items,Dodano med predstavljenimi predmeti,
Added {0} ({1}),Dodana {0} ({1}),
Address Line 1,Naslov Line 1,
Addresses,Naslovi,
Admission End Date should be greater than Admission Start Date.,Končni datum sprejema bi moral biti večji od začetnega datuma sprejema.,
Against Loan,Proti posojilom,
Against Loan:,Proti posojilu:,
All,Vse,
All bank transactions have been created,Vse bančne transakcije so bile ustvarjene,
All the depreciations has been booked,Vse amortizacije so bile knjižene,
Allocation Expired!,Dodelitev je potekla!,
Allow Resetting Service Level Agreement from Support Settings.,Dovoli ponastavitev sporazuma o ravni storitve iz nastavitev podpore.,
Amount of {0} is required for Loan closure,Za zaprtje posojila je potreben znesek {0},
Amount paid cannot be zero,Plačani znesek ne sme biti nič,
Applied Coupon Code,Uporabljena koda kupona,
Apply Coupon Code,Uporabi kodo kupona,
Appointment Booking,Rezervacija termina,
"As there are existing transactions against item {0}, you can not change the value of {1}","Kot že obstajajo transakcije proti zapisu {0}, ki jih ne more spremeniti vrednosti {1}",
Asset Id,ID premoženja,
Asset Value,Vrednost sredstev,
Asset Value Adjustment cannot be posted before Asset's purchase date <b>{0}</b>.,Prilagoditve vrednosti sredstev ni mogoče objaviti pred datumom nakupa premoženja <b>{0}</b> .,
Asset {0} does not belongs to the custodian {1},Sredstvo {0} ne pripada skrbniku {1},
Asset {0} does not belongs to the location {1},Sredstvo {0} ne pripada lokaciji {1},
At least one of the Applicable Modules should be selected,Izbrati je treba vsaj enega izmed uporabnih modulov,
Atleast one asset has to be selected.,Izbrati je treba najmanj eno sredstvo.,
Attendance Marked,Število udeležencev,
Attendance has been marked as per employee check-ins,Udeležba je označena kot pri prijavah zaposlenih,
Authentication Failed,Preverjanje ni uspelo,
Automatic Reconciliation,Samodejna uskladitev,
Available For Use Date,Na voljo za uporabo,
Available Stock,Na zalogi,
"Available quantity is {0}, you need {1}","Količina na voljo je {0}, potrebujete {1}",
BOM 1,BOM 1,
BOM 2,BOM 2,
BOM Comparison Tool,Orodje za primerjavo BOM,
BOM recursion: {0} cannot be child of {1},BOM rekurzija: {0} ne more biti otrok od {1},
BOM recursion: {0} cannot be parent or child of {1},BOM rekurzija: {0} ne sme biti starš ali otrok od {1},
Back to Home,Nazaj domov,
Back to Messages,Nazaj na sporočila,
Bank Data mapper doesn't exist,Bančni podatkovni zemljevid ne obstaja,
Bank Details,Bančne podrobnosti,
Bank account '{0}' has been synchronized,Bančni račun &quot;{0}&quot; je bil sinhroniziran,
Bank account {0} already exists and could not be created again,Bančni račun {0} že obstaja in ga ni več mogoče ustvariti,
Bank accounts added,Dodani so bančni računi,
Batch no is required for batched item {0},Za serijsko postavko {0} ni potrebna nobena serija,
Billing Date,Datum obračuna,
Billing Interval Count cannot be less than 1,Interval števila računov ne sme biti manjši od 1,
Blue,Modra,
Book,Knjiga,
Book Appointment,Sestanek knjige,
Brand,Brand,
Browse,Brskanje,
Call Connected,Klic je povezan,
Call Disconnected,Klic prekinjen,
Call Missed,Pokliči klic,
Call Summary,Povzetek klicev,
Call Summary Saved,Povzetek klica je shranjen,
Cancelled,Prekinjeno,
Cannot Calculate Arrival Time as Driver Address is Missing.,"Časa prihoda ni mogoče izračunati, ker manjka naslov gonilnika.",
Cannot Optimize Route as Driver Address is Missing.,"Ne morem optimizirati poti, ker manjka naslov gonilnika.",
Cannot complete task {0} as its dependant task {1} are not ccompleted / cancelled.,"Naloge ni mogoče dokončati {0}, ker njegova odvisna naloga {1} ni dokončana / preklicana.",
Cannot create loan until application is approved,"Posojila ni mogoče ustvariti, dokler aplikacija ni odobrena",
Cannot find a matching Item. Please select some other value for {0}.,"Ne morete najti ujemanja artikel. Prosimo, izberite kakšno drugo vrednost za {0}.",
"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set allowance in Accounts Settings","Za postavko {0} v vrstici {1} več kot {2} ni mogoče preplačati. Če želite dovoliti preplačilo, nastavite dovoljenje v nastavitvah računov",
"Capacity Planning Error, planned start time can not be same as end time","Napaka pri načrtovanju zmogljivosti, načrtovani začetni čas ne more biti enak končnemu času",
Categories,Kategorije,
Changes in {0},Spremembe v {0},
Chart,Graf,
Choose a corresponding payment,Izberite ustrezno plačilo,
Click on the link below to verify your email and confirm the appointment,"Kliknite spodnjo povezavo, da preverite svoj e-poštni naslov in potrdite sestanek",
Close,Zapri,
Communication,Sporočilo,
Compact Item Print,Compact Točka Print,
Company,Podjetje,
Company of asset {0} and purchase document {1} doesn't matches.,Družba sredstva {0} in nakupni dokument {1} se ne ujema.,
Compare BOMs for changes in Raw Materials and Operations,Primerjajte BOM za spremembe v surovinah in postopkih,
Compare List function takes on list arguments,Funkcija Primerjanje seznama prevzame argumente seznama,
Complete,Končaj,
Completed,Končano,
Completed Quantity,Končana količina,
Connect your Exotel Account to ERPNext and track call logs,Povežite svoj račun Exotel z ERPNext in spremljajte dnevnike klicev,
Connect your bank accounts to ERPNext,Povežite svoje bančne račune z ERPNext,
Contact Seller,Kontaktiraj prodajalca,
Continue,Naprej,
Cost Center: {0} does not exist,Mestno mesto: {0} ne obstaja,
Couldn't Set Service Level Agreement {0}.,Dogovora o ravni storitve ni bilo mogoče nastaviti {0}.,
Country,Država,
Country Code in File does not match with country code set up in the system,"Koda države v datoteki se ne ujema s kodo države, nastavljeno v sistemu",
Create New Contact,Ustvari nov stik,
Create New Lead,Ustvari nov potencial,
Create Pick List,Ustvari seznam izbirnikov,
Create Quality Inspection for Item {0},Ustvari pregled kakovosti za predmet {0},
Creating Accounts...,Ustvarjanje računov ...,
Creating bank entries...,Ustvarjanje bančnih vnosov ...,
Credit limit is already defined for the Company {0},Kreditni limit je za podjetje že določen {0},
Ctrl + Enter to submit,Ctrl + Enter za oddajo,
Ctrl+Enter to submit,Ctrl + Enter za pošiljanje,
Currency,Valuta,
Current Status,Trenutni status,
Customer PO,Stranka PO,
Customize,Prilagajanje,
Daily,Dnevno,
Date,Datum,
Date Range,Časovno obdobje,
Date of Birth cannot be greater than Joining Date.,Datum rojstva ne sme biti večji od datuma pridružitve.,
Dear,Dragi,
Default,Privzeto,
Define coupon codes.,Določite kode kuponov.,
Delayed Days,Zakasnjeni dnevi,
Delete,Izbriši,
Delivered Quantity,Oddana količina,
Delivery Notes,Opombe o dostavi,
Depreciated Amount,Znesek amortizacije,
Description,Opis,
Designation,Imenovanje,
Difference Value,Vrednost razlike,
Dimension Filter,Dimenzijski filter,
Disabled,Onemogočeno,
Disbursement and Repayment,Izplačilo in vračilo,
Distance cannot be greater than 4000 kms,Razdalja ne sme biti večja od 4000 km,
Do you want to submit the material request,Ali želite oddati materialno zahtevo,
Doctype,DocType,
Document {0} successfully uncleared,Dokument {0} uspešno izbrisan,
Download Template,Prenesi predlogo,
Dr,Dr,
Due Date,Datum zapadlosti,
Duplicate,Podvajati,
Duplicate Project with Tasks,Podvojen projekt z nalogami,
Duplicate project has been created,Ustvaril se je dvojnik projekta,
E-Way Bill JSON can only be generated from a submitted document,E-Way Bill JSON lahko ustvarite samo iz predloženega dokumenta,
E-Way Bill JSON can only be generated from submitted document,E-Way Bill JSON je mogoče ustvariti samo iz predloženega dokumenta,
E-Way Bill JSON cannot be generated for Sales Return as of now,Računa za e-način JSON od zdaj ni mogoče ustvariti za vračilo prodaje,
ERPNext could not find any matching payment entry,ERPNext ni mogel najti nobenega ustreznega vnosa za plačilo,
Earliest Age,Najstarejša starost,
Edit Details,Uredite podrobnosti,
Edit Profile,Uredi profil,
Either GST Transporter ID or Vehicle No is required if Mode of Transport is Road,"Če je način prevoza cestni, GST Transporter ID ali vozilo ne potrebujeta",
Email,E-naslov,
Email Campaigns,E-poštne oglaševalske akcije,
Employee ID is linked with another instructor,ID zaposlenega je povezan z drugim inštruktorjem,
Employee Tax and Benefits,Davek na zaposlene in ugodnosti,
Employee is required while issuing Asset {0},Zaposleni je pri izdaji sredstev potreben {0},
Employee {0} does not belongs to the company {1},Zaposleni {0} ne spada v podjetje {1},
Enable Auto Re-Order,Omogoči samodejno ponovno naročilo,
End Date of Agreement can't be less than today.,Končni datum sporazuma ne sme biti krajši kot danes.,
End Time,Končni čas,
Energy Point Leaderboard,Tabela energetskih točk,
Enter API key in Google Settings.,V Googlove nastavitve vnesite ključ API.,
Enter Supplier,Vnesite dobavitelja,
Enter Value,Vnesite vrednost,
Entity Type,Tip subjekta,
Error,Napaka,
Error in Exotel incoming call,Napaka pri dohodnem klicu Exotel,
Error: {0} is mandatory field,Napaka: {0} je obvezno polje,
Event Link,Povezava dogodka,
Exception occurred while reconciling {0},Med usklajevanjem {0} je prišlo do izjeme.,
Expected and Discharge dates cannot be less than Admission Schedule date,Predvideni in razrešeni datumi ne smejo biti krajši od datuma sprejema,
Expire Allocation,Poteče dodelitev,
Expired,Potekel,
Export,Izvoz,
Export not allowed. You need {0} role to export.,Izvoz ni dovoljeno. Morate {0} vlogo izvoz.,
Failed to add Domain,Domene ni bilo mogoče dodati,
Fetch Items from Warehouse,Pridobivanje izdelkov iz skladišča,
Fetching...,Pridobivanje ...,
Field,field,
File Manager,Upravitelj datotek,
Filters,Filtri,
Finding linked payments,Iskanje povezanih plačil,
Fleet Management,Fleet management,
Following fields are mandatory to create address:,Naslednja polja so obvezna za ustvarjanje naslova:,
For Month,Za mesec,
"For item {0} at row {1}, count of serial numbers does not match with the picked quantity",Za postavko {0} v vrstici {1} se število serijskih številk ne ujema z izbrano količino,
For operation {0}: Quantity ({1}) can not be greter than pending quantity({2}),Za delovanje {0}: Količina ({1}) ne more biti večja od čakajoče količine ({2}),
For quantity {0} should not be greater than work order quantity {1},Za količino {0} ne sme biti večja od količine delovnega naloga {1},
Free item not set in the pricing rule {0},Prosti artikel ni nastavljen s pravilom o cenah {0},
From Date and To Date are Mandatory,Od datuma in do datuma so obvezni,
From employee is required while receiving Asset {0} to a target location,Od prejemnika sredstev je potreben med prejemom sredstev {0} na ciljno lokacijo,
Fuel Expense,Odhodki za gorivo,
Future Payment Amount,Prihodnji znesek plačila,
Future Payment Ref,Prihodnje plačilo Ref,
Future Payments,Prihodnja plačila,
GST HSN Code does not exist for one or more items,Koda GST HSN ne obstaja za enega ali več elementov,
Generate E-Way Bill JSON,Ustvari e-Way Bill JSON,
Get Items,Pridobi Artikle,
Get Outstanding Documents,Pridobite izjemne dokumente,
Goal,Cilj,
Greater Than Amount,Večji od zneska,
Green,Green,
Group,Skupina,
Group By Customer,Skupina po stranki,
Group By Supplier,Skupina po dobavitelju,
Group Node,Skupina Node,
Group Warehouses cannot be used in transactions. Please change the value of {0},"Skupinskih skladišč ni mogoče uporabiti pri transakcijah. Prosimo, spremenite vrednost {0}",
Help,Pomoč,
Help Article,Članek za pomoč,
"Helps you keep tracks of Contracts based on Supplier, Customer and Employee","Pomaga pri sledenju pogodb na podlagi dobavitelja, kupca in zaposlenega",
Helps you manage appointments with your leads,Pomaga pri upravljanju sestankov s strankami,
Home,Domov,
IBAN is not valid,IBAN ni veljaven,
Import Data from CSV / Excel files.,Uvozite podatke iz datotek CSV / Excel.,
In Progress,V delu,
Incoming call from {0},Dohodni klic od {0},
Incorrect Warehouse,Nepravilna skladišča,
Intermediate,vmesna,
Invalid Barcode. There is no Item attached to this barcode.,Neveljavna črtna koda. Na tej črtni kodi ni nobenega predmeta.,
Invalid credentials,Neveljavne poverilnice,
Invite as User,Povabi kot uporabnik,
Issue Priority.,Prednostna izdaja.,
Issue Type.,Vrsta izdaje,
"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.","Zdi se, da obstaja težava s strežniško konfiguracijo črtne kode. V primeru neuspeha bo znesek povrnjen na vaš račun.",
Item Reported,Element je prijavljen,
Item listing removed,Seznam elementov je odstranjen,
Item quantity can not be zero,Količina artikla ne more biti nič,
Item taxes updated,Davki na postavke so posodobljeni,
Item {0}: {1} qty produced. ,Postavka {0}: {1} proizvedeno.,
Joining Date can not be greater than Leaving Date,Datum pridružitve ne sme biti večji od datuma zapustitve,
Lab Test Item {0} already exist,Predmet laboratorijskega testa {0} že obstaja,
Last Issue,Zadnja izdaja,
Latest Age,Najnovejša doba,
Leave application is linked with leave allocations {0}. Leave application cannot be set as leave without pay,Prošnja za dopust je povezana z dodelitvijo dopusta {0}. Zapustitve vloge ni mogoče nastaviti kot dopust brez plačila,
Leaves Taken,Odvzeti listi,
Less Than Amount,Manj kot znesek,
Liabilities,Obveznosti,
Loading...,Nalaganje ...,
Loan Amount exceeds maximum loan amount of {0} as per proposed securities,Znesek posojila presega najvišji znesek posojila {0} glede na predlagane vrednostne papirje,
Loan Applications from customers and employees.,Prošnje za posojilo strank in zaposlenih.,
Loan Disbursement,Izplačilo posojila,
Loan Processes,Posojilni procesi,
Loan Security,Varnost posojila,
Loan Security Pledge,Zaloga za posojilo,
Loan Security Pledge Created : {0},Izdelano jamstvo za posojilo: {0},
Loan Security Price,Cena zavarovanja posojila,
Loan Security Price overlapping with {0},"Cena zavarovanja posojila, ki se prekriva z {0}",
Loan Security Unpledge,Varnost posojila ni dovoljena,
Loan Security Value,Vrednost zavarovanja posojila,
Loan Type for interest and penalty rates,Vrsta posojila za obresti in kazenske stopnje,
Loan amount cannot be greater than {0},Znesek posojila ne sme biti večji od {0},
Loan is mandatory,Posojilo je obvezno,
Loans,Posojila,
Loans provided to customers and employees.,Krediti strankam in zaposlenim.,
Location,Kraj,
Log Type is required for check-ins falling in the shift: {0}.,Vrsta dnevnika je potrebna za prijave pri padcu: {0}.,
Looks like someone sent you to an incomplete URL. Please ask them to look into it.,"Izgleda, da nekdo pošlje na nepopolno URL. Prosite, da pogled na to.",
Make Journal Entry,Naredite vnos Dnevnika,
Make Purchase Invoice,Naredite račun za nakup,
Manufactured,Izdelano,
Mark Work From Home,Označi delo od doma,
Master,Master,
Max strength cannot be less than zero.,Največja moč ne sme biti nižja od nič.,
Maximum attempts for this quiz reached!,Največje število poskusov tega kviza!,
Message,Sporočilo,
Missing Values Required,Manjkajoče vrednosti Obvezno,
Mobile No,Mobile No,
Mobile Number,Mobilna številka,
Month,Mesec,
Name,Name,
Near you,Blizu vas,
Net Profit/Loss,Čisti dobiček / izguba,
New Expense,Nov strošek,
New Invoice,Nov račun,
New Payment,Novo plačilo,
New release date should be in the future,Nov datum izida bi moral biti v prihodnosti,
Newsletter,Glasilo,
No Account matched these filters: {},Noben račun se ni ujemal s temi filtri: {},
No Employee found for the given employee field value. '{}': {},Za določeno vrednost polja zaposlenega ni bilo najdenega zaposlenega. &#39;{}&#39;: {},
No Leaves Allocated to Employee: {0} for Leave Type: {1},No Leaves dodeli zaposlenemu: {0} za vrsto dopusta: {1},
No communication found.,Sporočila ni mogoče najti.,
No correct answer is set for {0},Za {0} ni nastavljen pravilen odgovor,
No description,brez opisa,
No issue has been raised by the caller.,Pozivatelj ni postavil nobenega vprašanja.,
No items to publish,Ni predmetov za objavo,
No outstanding invoices found,Neplačanih računov ni bilo mogoče najti,
No outstanding invoices found for the {0} {1} which qualify the filters you have specified.,"Za {0} {1} ni mogoče najti neporavnanih računov, ki izpolnjujejo filtre, ki ste jih določili.",
No outstanding invoices require exchange rate revaluation,Nobena neporavnana faktura ne zahteva prevrednotenja tečaja,
No reviews yet,Še ni mnenja,
No views yet,Še ni ogledov,
Non stock items,Izdelki brez zalog,
Not Allowed,Ni dovoljeno,
Not allowed to create accounting dimension for {0},Ni dovoljeno ustvariti računovodske razsežnosti za {0},
Not permitted. Please disable the Lab Test Template,Ni dovoljeno. Onemogočite predlogo za preskus laboratorija,
Note,Zapisek,
Notes: ,Opombe:,
On Converting Opportunity,O pretvorbi priložnosti,
On Purchase Order Submission,Ob oddaji naročilnice,
On Sales Order Submission,Ob oddaji prodajnega naročila,
On Task Completion,Ob zaključku naloge,
On {0} Creation,Ob {0} Ustvarjanje,
Only .csv and .xlsx files are supported currently,Trenutno so podprte samo datoteke .csv in .xlsx,
Only expired allocation can be cancelled,Prekliče se lahko le dodelitev s potekom veljavnosti,
Only users with the {0} role can create backdated leave applications,Samo uporabniki z vlogo {0} lahko ustvarijo zaostale programe za dopust,
Open,Odprto,
Open Contact,Odprite stik,
Open Lead,Odprto vodi,
Opening and Closing,Odpiranje in zapiranje,
Operating Cost as per Work Order / BOM,Obratovalni stroški po delovnih nalogah / BOM,
Order Amount,Znesek naročila,
Page {0} of {1},Stran {0} od {1},
Paid amount cannot be less than {0},Plačani znesek ne sme biti manjši od {0},
Parent Company must be a group company,Matična družba mora biti skupinska družba,
Passing Score value should be between 0 and 100,Vrednost prenosa ocene mora biti med 0 in 100,
Password policy cannot contain spaces or simultaneous hyphens. The format will be restructured automatically,Pravilnik o geslu ne sme vsebovati presledkov ali istočasnih vezajev. Oblika se samodejno prestrukturira,
Patient History,Zgodovina bolnikov,
Pause,Pavza,
Pay,Plačajte,
Payment Document Type,Vrsta plačilnega dokumenta,
Payment Name,Ime plačila,
Penalty Amount,Kazenski znesek,
Pending,V teku,
Performance,Izvedba,
Period based On,Obdobje na podlagi,
Perpetual inventory required for the company {0} to view this report.,Za ogled tega poročila je potreben stalni zalog podjetja {0}.,
Phone,Telefon,
Pick List,Izberi seznam,
Plaid authentication error,Napačna avtentikacija,
Plaid public token error,Napaka v javnem žetonu,
Plaid transactions sync error,Napaka sinhronizacije transakcij v plaidu,
Please check the error log for details about the import errors,Preverite dnevnik napak za podrobnosti o napakah pri uvozu,
Please create <b>DATEV Settings</b> for Company <b>{}</b>.,Ustvarite <b>nastavitve DATEV</b> za podjetje <b>{}</b> .,
Please create adjustment Journal Entry for amount {0} ,Ustvarite prilagoditev Vnos dnevnika za znesek {0},
Please do not create more than 500 items at a time,Ne ustvarite več kot 500 elementov hkrati,
Please enter <b>Difference Account</b> or set default <b>Stock Adjustment Account</b> for company {0},Vnesite <b>račun za razliko</b> ali nastavite privzeti <b>račun</b> za <b>prilagoditev zalog</b> za podjetje {0},
Please enter GSTIN and state for the Company Address {0},Vnesite GSTIN in navedite naslov podjetja {0},
Please enter Item Code to get item taxes,"Vnesite kodo izdelka, da dobite davek na izdelke",
Please enter Warehouse and Date,Vnesite skladišče in datum,
Please enter the designation,Vnesite oznako,
Please login as a Marketplace User to edit this item.,"Prosimo, prijavite se kot uporabnik tržnice, če želite urediti ta element.",
Please login as a Marketplace User to report this item.,"Prijavite se kot uporabnik tržnice, če želite prijaviti ta element.",
Please select <b>Template Type</b> to download template,Izberite <b>vrsto predloge</b> za prenos predloge,
Please select Applicant Type first,Najprej izberite vrsto prosilca,
Please select Customer first,Najprej izberite stranko,
Please select Item Code first,Najprej izberite kodo predmeta,
Please select Loan Type for company {0},Izberite vrsto posojila za podjetje {0},
Please select a Delivery Note,Izberite dobavnico,
Please select a Sales Person for item: {0},Izberite prodajno osebo za izdelek: {0},
Please select another payment method. Stripe does not support transactions in currency '{0}',"Izberite drug način plačila. Stripe ne podpira transakcije v valuti, &quot;{0}&quot;",
Please select the customer.,Izberite stranko.,
Please set a Supplier against the Items to be considered in the Purchase Order.,"Prosimo, nastavite dobavitelja proti izdelkom, ki bodo upoštevani v naročilu.",
Please set account heads in GST Settings for Compnay {0},Nastavite glave računa v nastavitvah GST za podjetje {0},
Please set an email id for the Lead {0},"Prosimo, nastavite e-poštni naslov za vodilni {0}",
Please set default UOM in Stock Settings,V nastavitvah zalog nastavite privzeti UOM,
Please set filter based on Item or Warehouse due to a large amount of entries.,"Prosimo, nastavite filter na podlagi predmeta ali skladišča zaradi velike količine vnosov.",
Please set up the Campaign Schedule in the Campaign {0},"Prosimo, nastavite razpored akcije v kampanji {0}",
Please set valid GSTIN No. in Company Address for company {0},V naslovu podjetja nastavite veljavno številko GSTIN {0},
Please set {0},Nastavite {0},customer
Please setup a default bank account for company {0},Nastavite privzeti bančni račun za podjetje {0},
Please specify,"Prosimo, navedite",
Please specify a {0},Navedite {0},lead
Pledge Status,Stanje zastave,
Pledge Time,Čas zastave,
Printing,Tiskanje,
Priority,Prednost,
Priority has been changed to {0}.,Prednost je spremenjena na {0}.,
Priority {0} has been repeated.,Prednost {0} se je ponovila.,
Processing XML Files,Obdelava datotek XML,
Profitability,Donosnost,
Project,Projekt,
Proposed Pledges are mandatory for secured Loans,Predlagane zastave so obvezne za zavarovana posojila,
Provide the academic year and set the starting and ending date.,Navedite študijsko leto in določite datum začetka in konca.,
Public token is missing for this bank,Za to banko manjka javni žeton,
Publish,Objavi,
Publish 1 Item,Objavite 1 kos,
Publish Items,Objavite predmete,
Publish More Items,Objavite več predmetov,
Publish Your First Items,Objavite svoje prve izdelke,
Publish {0} Items,Objavite {0} Artikle,
Published Items,Objavljeni predmeti,
Purchase Invoice cannot be made against an existing asset {0},Računa za nakup ni mogoče predložiti proti obstoječemu sredstvu {0},
Purchase Invoices,Nakup računov,
Purchase Orders,Naročila,
Purchase Receipt doesn't have any Item for which Retain Sample is enabled.,"Potrdilo o nakupu nima nobenega predmeta, za katerega bi bil omogočen Retain Sample.",
Purchase Return,nakup Return,
Qty of Finished Goods Item,Količina izdelka končnega blaga,
Qty or Amount is mandatroy for loan security,Količina ali znesek je mandatroy za zavarovanje posojila,
Quality Inspection required for Item {0} to submit,"Inšpekcijski pregled kakovosti, potreben za pošiljanje predmeta {0}",
Quantity to Manufacture,Količina za izdelavo,
Quantity to Manufacture can not be zero for the operation {0},Količina za izdelavo ne more biti nič pri operaciji {0},
Quarterly,Četrtletno,
Queued,V čakalni vrsti,
Quick Entry,Quick Entry,
Quiz {0} does not exist,Kviz {0} ne obstaja,
Quotation Amount,Znesek ponudbe,
Rate or Discount is required for the price discount.,Za popust na ceno je potreben popust ali popust.,
Reason,Razlog,
Reconcile Entries,Usklajevanje vnosov,
Reconcile this account,Poravnajte ta račun,
Reconciled,Pomirjen,
Recruitment,Zaposlovanje,
Red,Red,
Refreshing,Osvežujoč,
Release date must be in the future,Datum izdaje mora biti v prihodnosti,
Relieving Date must be greater than or equal to Date of Joining,Datum razrešitve mora biti večji ali enak datumu pridružitve,
Rename,Preimenovanje,
Rename Not Allowed,Preimenovanje ni dovoljeno,
Repayment Method is mandatory for term loans,Način vračila je obvezen za posojila,
Repayment Start Date is mandatory for term loans,Datum začetka poplačila je obvezen za posojila,
Report Item,Postavka poročila,
Report this Item,Prijavite to postavko,
Reserved Qty for Subcontract: Raw materials quantity to make subcontracted items.,Količina za naročila podizvajalcev: Količina surovin za izdelavo podizvajalcev.,
Reset,Ponastavi,
Reset Service Level Agreement,Ponastavi sporazum o ravni storitev,
Resetting Service Level Agreement.,Ponastavitev sporazuma o ravni storitev.,
Return amount cannot be greater unclaimed amount,Povratni znesek ne more biti večji od zahtevanega zneska,
Review,Pregled,
Room,soba,
Room Type,Tip sobe,
Row # ,Vrstica #,
Row #{0}: Accepted Warehouse and Supplier Warehouse cannot be same,Vrstica # {0}: Sprejeta skladišča in skladišča dobaviteljev ne morejo biti enaka,
Row #{0}: Cannot delete item {1} which has already been billed.,"Vrstica # {0}: Elementa {1}, ki je že bil zaračunan, ni mogoče izbrisati.",
Row #{0}: Cannot delete item {1} which has already been delivered,"Vrstica # {0}: Ni mogoče izbrisati predmeta {1}, ki je že bil dostavljen",
Row #{0}: Cannot delete item {1} which has already been received,"Vrstica # {0}: Elementa {1}, ki je že prejet, ni mogoče izbrisati",
Row #{0}: Cannot delete item {1} which has work order assigned to it.,"Vrstica # {0}: Elementa {1}, ki mu je dodeljen delovni nalog, ni mogoče izbrisati.",
Row #{0}: Cannot delete item {1} which is assigned to customer's purchase order.,"Vrstica # {0}: izdelka ni mogoče izbrisati {1}, ki je dodeljen naročilu stranke.",
Row #{0}: Cannot select Supplier Warehouse while suppling raw materials to subcontractor,"Vrstica # {0}: Ni mogoče izbrati skladišča dobaviteljev, medtem ko surovine dobavlja podizvajalcem",
Row #{0}: Cost Center {1} does not belong to company {2},Vrstica # {0}: stroškovno središče {1} ne pripada podjetju {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}.,Vrstica # {0}: Postopek {1} ni končan za {2} količino končnih izdelkov v delovnem naročilu {3}. Posodobite stanje delovanja s Job Card {4}.,
Row #{0}: Payment document is required to complete the transaction,Vrstica # {0}: Za dokončanje transakcije je potreben plačilni dokument,
Row #{0}: Serial No {1} does not belong to Batch {2},Vrstica # {0}: Serijska št. {1} ne spada v serijo {2},
Row #{0}: Service End Date cannot be before Invoice Posting Date,Vrstica # {0}: Končni datum storitve ne sme biti pred datumom objave računa,
Row #{0}: Service Start Date cannot be greater than Service End Date,Vrstica # {0}: datum začetka storitve ne sme biti večji od končnega datuma storitve,
Row #{0}: Service Start and End Date is required for deferred accounting,Vrstica # {0}: datum začetka in konca storitve je potreben za odloženo računovodstvo,
Row {0}: Invalid Item Tax Template for item {1},Vrstica {0}: neveljavna predloga za davek na artikel {1},
Row {0}: Quantity not available for {4} in warehouse {1} at posting time of the entry ({2} {3}),Vrstica {0}: Količina ni na voljo za {4} v skladišču {1} ob času objave vnosa ({2} {3}),
Row {0}: user has not applied the rule {1} on the item {2},Vrstica {0}: uporabnik ni uporabil pravila {1} za element {2},
Row {0}:Sibling Date of Birth cannot be greater than today.,Vrstica {0}: datum rojstva brata ne more biti večji kot danes.,
Row({0}): {1} is already discounted in {2},Vrstica ({0}): {1} je že znižana v {2},
Rows Added in {0},Vrstice dodane v {0},
Rows Removed in {0},Vrstice so odstranjene v {0},
Sanctioned Amount limit crossed for {0} {1},Omejena dovoljena količina presežena za {0} {1},
Sanctioned Loan Amount already exists for {0} against company {1},Doseženi znesek posojila že obstaja za {0} proti podjetju {1},
Save,Shrani,
Save Item,Shrani element,
Saved Items,Shranjeni predmeti,
Search Items ...,Elementi iskanja ...,
Search for a payment,Poiščite plačilo,
Search for anything ...,Poiščite karkoli ...,
Search results for,Rezultati iskanja,
Select All,Izberi vse,
Select Difference Account,Izberite račun za razlike,
Select a Default Priority.,Izberite privzeto prioriteto.,
Select a company,Izberite podjetje,
Select finance book for the item {0} at row {1},Izberite knjigo financ za postavko {0} v vrstici {1},
Select only one Priority as Default.,Za privzeto izberite samo eno prednostno nalogo.,
Seller Information,Podatki prodajalca,
Send,Pošlji,
Send a message,Poslati sporočilo,
Sending,Pošiljanje,
Sends Mails to lead or contact based on a Campaign schedule,Pošlje sporočila za vodenje ali vzpostavitev stika na podlagi razporeda akcij,
Serial Number Created,Ustvarjena serijska številka,
Serial Numbers Created,Ustvarjene serijske številke,
Serial no(s) required for serialized item {0},Za serijsko postavko {0} niso potrebni serijski številki,
Series,Zaporedje,
Server Error,Napaka strežnika,
Service Level Agreement has been changed to {0}.,Pogodba o ravni storitve je spremenjena na {0}.,
Service Level Agreement was reset.,Sporazum o ravni storitev je bil ponastavljen.,
Service Level Agreement with Entity Type {0} and Entity {1} already exists.,Pogodba o ravni storitve s tipom entitete {0} in entiteto {1} že obstaja.,
Set,Set,
Set Meta Tags,Nastavite Meta oznake,
Set {0} in company {1},Nastavite {0} v podjetju {1},
Setup,Nastavitve,
Setup Wizard,Setup Wizard,
Shift Management,Shift Management,
Show Future Payments,Prikažite bodoča plačila,
Show Linked Delivery Notes,Pokaži povezane dobavnice,
Show Sales Person,Pokaži prodajno osebo,
Show Stock Ageing Data,Prikaži podatke o staranju zalog,
Show Warehouse-wise Stock,Pokaži skladišče,
Size,Velikost,
Something went wrong while evaluating the quiz.,Pri ocenjevanju kviza je šlo nekaj narobe.,
Sr,sr,
Start,Začetek,
Start Date cannot be before the current date,Datum začetka ne sme biti pred trenutnim datumom,
Start Time,Začetni čas,
Status,Stanje,
Status must be Cancelled or Completed,Status mora biti preklican ali dokončan,
Stock Balance Report,Poročilo o stanju zalog,
Stock Entry has been already created against this Pick List,Vpis zalog je že ustvarjen na tem seznamu izbir,
Stock Ledger ID,ID knjige zalog,
Stock Value ({0}) and Account Balance ({1}) are out of sync for account {2} and it's linked warehouses.,Vrednost zalog ({0}) in stanje na računu ({1}) nista sinhronizirana za račun {2} in je povezana skladišča.,
Stores - {0},Trgovine - {0},
Student with email {0} does not exist,Študent z e-pošto {0} ne obstaja,
Submit Review,Pošljite pregled,
Submitted,Predložen,
Supplier Addresses And Contacts,Dobavitelj Naslovi,
Synchronize this account,Sinhronizirajte ta račun,
Tag,Oznaka,
Target Location is required while receiving Asset {0} from an employee,Med prejemom sredstev {0} od zaposlenega je potrebna ciljna lokacija,
Target Location is required while transferring Asset {0},Med prenosom sredstev {0} je potrebna ciljna lokacija.,
Target Location or To Employee is required while receiving Asset {0},Med prejemom premoženja je potrebna ciljna lokacija ali zaposlenemu {0},
Task's {0} End Date cannot be after Project's End Date.,Končni datum naloge {0} ne more biti po končnem datumu projekta.,
Task's {0} Start Date cannot be after Project's End Date.,Začetni datum naloge {0} Ne more biti po končnem datumu projekta.,
Tax Account not specified for Shopify Tax {0},Davčni račun ni določen za Shopify Tax {0},
Tax Total,Davek skupaj,
Template,Predloga,
The Campaign '{0}' already exists for the {1} '{2}',Kampanja &#39;{0}&#39; že obstaja za {1} &#39;{2}&#39;,
The difference between from time and To Time must be a multiple of Appointment,Razlika med časom in časom mora biti imenovanje večkratna,
The field Asset Account cannot be blank,Polje Račun sredstva ne sme biti prazno,
The field Equity/Liability Account cannot be blank,Polje Lastniški račun / račun obveznosti ne sme biti prazno,
The following serial numbers were created: <br><br> {0},Izdelane so bile naslednje serijske številke: <br><br> {0},
The parent account {0} does not exists in the uploaded template,Nadrejeni račun {0} ne obstaja v naloženi predlogi,
The question cannot be duplicate,Vprašanje ni mogoče podvojiti,
The selected payment entry should be linked with a creditor bank transaction,Izbrani vnos plačila mora biti povezan s transakcijo banke upnika,
The selected payment entry should be linked with a debtor bank transaction,Izbrani vnos plačila mora biti povezan s bančno transakcijo dolžnika,
The total allocated amount ({0}) is greated than the paid amount ({1}).,Skupni dodeljeni znesek ({0}) je podmazan od plačanega zneska ({1}).,
There are no vacancies under staffing plan {0},V kadrovskem načrtu ni prostih mest {0},
This Service Level Agreement is specific to Customer {0},Ta pogodba o ravni storitev je značilna za stranko {0},
This action will unlink this account from any external service integrating ERPNext with your bank accounts. It cannot be undone. Are you certain ?,"S tem dejanjem boste povezali ta račun s katero koli zunanjo storitvijo, ki povezuje ERPNext z vašimi bančnimi računi. Ni mogoče razveljaviti. Ste prepričani?",
This bank account is already synchronized,Ta bančni račun je že sinhroniziran,
This bank transaction is already fully reconciled,Ta bančna transakcija je že v celoti usklajena,
This employee already has a log with the same timestamp.{0},Ta zaposleni že ima dnevnik z istim časovnim žigom. {0},
This page keeps track of items you want to buy from sellers.,"Ta stran spremlja predmete, ki jih želite kupiti pri prodajalcih.",
This page keeps track of your items in which buyers have showed some interest.,"Ta stran spremlja vaše izdelke, za katere so kupci pokazali nekaj zanimanja.",
Thursday,Četrtek,
Timing,Časovna omejitev,
Title,Naziv,
"To allow over billing, update ""Over Billing Allowance"" in Accounts Settings or the Item.","Če želite omogočiti preveč zaračunavanja, posodobite »Nadomestitev za obračunavanje« v nastavitvah računov ali postavke.",
"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.","Če želite dovoliti prejem / dostavo, posodobite &quot;Over Prejem / Dovoljenje za dostavo&quot; v nastavitvah zaloge ali pošiljko.",
To date needs to be before from date,Do danes mora biti pred datumom,
Total,Skupaj,
Total Early Exits,Skupni zgodnji izhodi,
Total Late Entries,Skupni pozni vpisi,
Total Payment Request amount cannot be greater than {0} amount,Skupni znesek zahtevka za plačilo ne sme biti večji od {0} zneska,
Total payments amount can't be greater than {},Skupni znesek plačil ne sme biti večji od {},
Totals,Pri zaokrožanju,
Training Event:,Trening dogodek:,
Transactions already retreived from the statement,Transakcije so že umaknjene iz izpisa,
Transfer Material to Supplier,Prenos Material za dobavitelja,
Transport Receipt No and Date are mandatory for your chosen Mode of Transport,Številka in datum prevoza sta za izbrani način prevoza obvezna,
Tuesday,Torek,
Type,Tip,
Unable to find Salary Component {0},Ni mogoče najti komponente plače {0},
Unable to find the time slot in the next {0} days for the operation {1}.,Časa v naslednjih {0} dneh za operacijo {1} ni mogoče najti.,
Unable to update remote activity,Oddaljene dejavnosti ni mogoče posodobiti,
Unknown Caller,Neznani klicatelj,
Unlink external integrations,Prekini povezavo zunanjih integracij,
Unmarked Attendance for days,Neoznačena udeležba dni,
Unpublish Item,Razveljavi element,
Unreconciled,Neusklajeno,
Unsupported GST Category for E-Way Bill JSON generation,Nepodprta kategorija GST za E-Way Bill JSON generacije,
Update,Update,
Update Details,Posodobite podrobnosti,
Update Taxes for Items,Posodobite davke za izdelke,
"Upload a bank statement, link or reconcile a bank account","Naložite bančni izpisek, povežite ali uskladite bančni račun",
Upload a statement,Naložite izjavo,
Use a name that is different from previous project name,"Uporabite ime, ki se razlikuje od imena prejšnjega projekta",
User {0} is disabled,Uporabnik {0} je onemogočena,
Users and Permissions,Uporabniki in dovoljenja,
Vacancies cannot be lower than the current openings,Prosta delovna mesta ne smejo biti nižja od trenutnih,
Valid From Time must be lesser than Valid Upto Time.,"Velja od časa, mora biti krajši od veljavnega Upto časa.",
Valuation Rate required for Item {0} at row {1},"Stopnja vrednotenja, potrebna za postavko {0} v vrstici {1}",
Values Out Of Sync,Vrednosti niso sinhronizirane,
Vehicle Type is required if Mode of Transport is Road,"Vrsta vozila je potrebna, če je način prevoza cestni",
Vendor Name,Ime prodajalca,
Verify Email,preveri email,
View,Poglej,
View all issues from {0},Oglejte si vse težave od {0},
View call log,Ogled dnevnika klicev,
Warehouse,Skladišče,
Warehouse not found against the account {0},Skladišča ni bilo mogoče najti v računu {0},
Welcome to {0},Dobrodošli {0},
Why do think this Item should be removed?,"Zakaj mislite, da je treba ta izdelek odstraniti?",
Work Order {0}: Job Card not found for the operation {1},Delovni nalog {0}: službene izkaznice ni mogoče najti za operacijo {1},
Workday {0} has been repeated.,Delovni dan {0} se je ponovil.,
XML Files Processed,Obdelane datoteke XML,
Year,Leto,
Yearly,Letni,
You,Vi,
You are not allowed to enroll for this course,Nimate dovoljenja za vpis na ta tečaj,
You are not enrolled in program {0},Niste vpisani v program {0},
You can Feature upto 8 items.,Predstavite lahko do 8 elementov.,
You can also copy-paste this link in your browser,"Lahko tudi kopirate, prilepite to povezavo v vašem brskalniku",
You can publish upto 200 items.,Objavite lahko do 200 elementov.,
You have to enable auto re-order in Stock Settings to maintain re-order levels.,Za vzdrževanje ravni ponovnega naročila morate v nastavitvah zalog omogočiti samodejno ponovno naročilo.,
You must be a registered supplier to generate e-Way Bill,Za generiranje e-poti morate biti registrirani dobavitelj,
You need to login as a Marketplace User before you can add any reviews.,"Preden lahko dodate ocene, se morate prijaviti kot uporabnik tržnice.",
Your Featured Items,Vaši predstavljeni predmeti,
Your Items,Predmeti,
Your Profile,Tvoj profil,
Your rating:,Vaša ocena:,
and,in,
e-Way Bill already exists for this document,Ta dokument že obstaja,
woocommerce - {0},woocommerce - {0},
{0} Coupon used are {1}. Allowed quantity is exhausted,{0} Uporabljeni kuponi so {1}. Dovoljena količina je izčrpana,
{0} Name,{0} Ime,
{0} Operations: {1},{0} Operacije: {1},
{0} bank transaction(s) created,{0} ustvarili bančne transakcije,
{0} bank transaction(s) created and {1} errors,{0} nastale bančne transakcije in {1} napake,
{0} can not be greater than {1},{0} ne sme biti večji od {1},
{0} conversations,{0} pogovori,
{0} is not a company bank account,{0} ni bančni račun podjetja,
{0} is not a group node. Please select a group node as parent cost center,{0} ni vozlišče skupine. Izberite vozlišče skupine kot matično stroškovno mesto,
{0} is not the default supplier for any items.,{0} ni privzeti dobavitelj za nobene izdelke.,
{0} is required,{0} je zahtevano,
{0}: {1} must be less than {2},{0}: {1} mora biti manjši od {2},
{} is an invalid Attendance Status.,{} je neveljaven status udeležbe.,
{} is required to generate E-Way Bill JSON,{} je potreben za izdelavo e-Way Bill JSON,
"Invalid lost reason {0}, please create a new lost reason","Neveljaven izgubljeni razlog {0}, ustvarite nov izgubljeni razlog",
Profit This Year,Dobiček letos,
Total Expense,Skupni odhodki,
Total Expense This Year,Letos skupni odhodki,
Total Income,Skupni dohodek,
Total Income This Year,Skupni dohodek v tem letu,
Barcode,Črtna koda,
Bold,Drzno,
Center,Center,
Clear,Jasno,
Comment,Komentar,
Comments,Komentarji,
DocType,DocType,
Download,Prenesi,
Left,Levo,
Link,Povezava,
New,Novo,
Not Found,Ni najdeno,
Print,Natisni,
Reference Name,Referenčno ime,
Refresh,Osveži,
Success,Uspeh,
Time,Čas,
Value,Vrednost,
Actual,Dejansko,
Add to Cart,Dodaj v voziček,
Days Since Last Order,Dnevi od zadnjega naročila,
In Stock,Na zalogi,
Loan Amount is mandatory,Znesek posojila je obvezen,
Mode Of Payment,Način plačila,
No students Found,Študentov ni mogoče najti,
Not in Stock,Ni na zalogi,
Please select a Customer,Izberite kupca,
Printed On,Tiskano na,
Received From,Prejela od,
Sales Person,Prodajalec,
To date cannot be before From date,Do danes ne more biti pred od datuma,
Write Off,Odpisati,
{0} Created,Ustvarjeno je {0},
Email Id,E-pošta ID,
No,Ne,
Reference Doctype,Referenčna DOCTYPE,
User Id,Uporabniško ime,
Yes,Da,
Actual ,Actual,
Add to cart,Dodaj v voziček,
Budget,Proračun,
Chart of Accounts,Kontni načrt,
Customer database.,Podatkovna baza strank.,
Days Since Last order,Dni od zadnjega naročila,
Download as JSON,Prenesite kot JSON,
End date can not be less than start date,Datum konca ne sme biti krajši od začetnega datuma,
For Default Supplier (Optional),Za privzeto dobavitelja (neobvezno),
From date cannot be greater than To date,Od datuma ne more biti večje od datuma,
Group by,Skupina avtorja,
In stock,Na zalogi,
Item name,Ime predmeta,
Loan amount is mandatory,Znesek posojila je obvezen,
Minimum Qty,Najmanjša količina,
More details,Več podrobnosti,
Nature of Supplies,Narava potrebščin,
No Items found.,Ni najdenih elementov.,
No employee found,Najdenih ni delavec,
No students found,Najdeno študenti,
Not in stock,Ni na zalogi,
Not permitted,Ni dovoljeno,
Open Issues ,Odprta vprašanja,
Open Projects ,Odprti projekti,
Open To Do ,Odpri storiti,
Operation Id,Operacija ID,
Partially ordered,delno Ž,
Please select company first,"Prosimo, izberite Company najprej",
Please select patient,Izberite Patient,
Printed On ,Natisnjeno dne,
Projected qty,Predvidoma Kol,
Sales person,Prodaja oseba,
Serial No {0} Created,Serijska št {0} ustvaril,
Source Location is required for the Asset {0},Izvorna lokacija je potrebna za sredstvo {0},
Tax Id,Davčna številka,
To Time,Time,
To date cannot be before from date,Do danes ni mogoče pred datumom,
Total Taxable value,Skupna davčna vrednost,
Upcoming Calendar Events ,Prihajajoči Koledar dogodkov,
Value or Qty,Vrednost ali Kol,
Variance ,Varianca,
Variant of,Varianta,
Write off,Odpisati,
hours,Ur,
received from,Prejela od,
to,Če želite,
Cards,Karte,
Percentage,Odstotek,
Failed to setup defaults for country {0}. Please contact support@erpnext.com,Nastavitve privzetih nastavitev za državo {0} ni bilo mogoče. Obrnite se na support@erpnext.com,
Row #{0}: Item {1} is not a Serialized/Batched Item. It cannot have a Serial No/Batch No against it.,Vrstica # {0}: Postavka {1} ni serializiran / združeni element. Proti njej ne more biti serijske številke / serije serije.,
Please set {0},"Prosim, nastavite {0}",
Please set {0},Nastavite {0},supplier
Draft,Osnutek,"docstatus,=,0"
Cancelled,Prekinjeno,"docstatus,=,2"
Please setup Instructor Naming System in Education > Education Settings,Nastavite sistem poimenovanja inštruktorjev v izobraževanju&gt; Nastavitve za izobraževanje,
Please set Naming Series for {0} via Setup > Settings > Naming Series,"Prosimo, nastavite Naming Series za {0} z nastavitvijo&gt; Settings&gt; Naming Series",
UOM Conversion factor ({0} -> {1}) not found for item: {2},Faktor pretvorbe UOM ({0} -&gt; {1}) za izdelek ni najden: {2},
Item Code > Item Group > Brand,Koda izdelka&gt; Skupina izdelkov&gt; Blagovna znamka,
Customer > Customer Group > Territory,Stranka&gt; Skupina kupcev&gt; Ozemlje,
Supplier > Supplier Type,Dobavitelj&gt; Vrsta dobavitelja,
Please setup Employee Naming System in Human Resource > HR Settings,"Prosimo, nastavite sistem poimenovanja zaposlenih v kadrovskem sektorju&gt; Nastavitve človeških virov",
Please setup numbering series for Attendance via Setup > Numbering Series,Nastavite serijsko številčenje za udeležbo prek Setup&gt; Setup Numbering Series,
The value of {0} differs between Items {1} and {2},Vrednost {0} se razlikuje med postavkama {1} in {2},
Auto Fetch,Samodejni prenos,
Fetch Serial Numbers based on FIFO,Pridobi serijske številke na podlagi FIFO,
"Outward taxable supplies(other than zero rated, nil rated and exempted)","Zunanje obdavčljive dobave (razen ničelne, nične in oproščene)",
"To allow different rates, disable the {0} checkbox in {1}.","Če želite omogočiti različne stopnje, onemogočite {0} potrditveno polje v {1}.",
Current Odometer Value should be greater than Last Odometer Value {0},Trenutna vrednost števca kilometrov mora biti večja od vrednosti zadnjega števca kilometrov {0},
No additional expenses has been added,Dodatni stroški niso bili dodani,
Asset{} {assets_link} created for {},Sredstvo {} {assets_link} ustvarjeno za {},
Row {}: Asset Naming Series is mandatory for the auto creation for item {},Vrstica {}: Serija poimenovanja sredstev je obvezna za samodejno ustvarjanje elementa {},
Assets not created for {0}. You will have to create asset manually.,"Sredstva, ki niso ustvarjena za {0}. Sredstvo boste morali ustvariti roč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 knjigovodske vnose v valuti {2} za podjetje {3}. Izberite račun za terjatve ali plačila z valuto {2}.,
Invalid Account,Neveljaven račun,
Purchase Order Required,Naročilnica obvezno,
Purchase Receipt Required,Potrdilo o nakupu Obvezno,
Account Missing,Manjka račun,
Requested,Zahteval,
Partially Paid,Delno plačano,
Invalid Account Currency,Neveljavna valuta računa,
"Row {0}: The item {1}, quantity must be positive number","Vrstica {0}: postavka {1}, količina mora biti pozitivno število",
"Please set {0} for Batched Item {1}, which is used to set {2} on Submit.","Nastavite {0} za paketni element {1}, ki se uporablja za nastavitev {2} na Pošlji.",
Expiry Date Mandatory,Datum izteka Obvezen,
Variant Item,Varianta izdelka,
BOM 1 {0} and BOM 2 {1} should not be same,BOM 1 {0} in BOM 2 {1} ne smeta biti enaki,
Note: Item {0} added multiple times,Opomba: Element {0} je bil večkrat dodan,
YouTube,YouTube,
Vimeo,Vimeo,
Publish Date,Datum objave,
Duration,Trajanje,
Advanced Settings,Napredne nastavitve,
Path,Pot,
Components,komponente,
Verified By,Verified by,
Invalid naming series (. missing) for {0},Neveljavna serija poimenovanj (. Manjka) za {0},
Filter Based On,Filter temelji na,
Reqd by date,Zahtevano po datumu,
Manufacturer Part Number <b>{0}</b> is invalid,Številka dela proizvajalca <b>{0}</b> je neveljavna,
Invalid Part Number,Neveljavna številka dela,
Select atleast one Social Media from Share on.,Izberite vsaj eno družabno omrežje iz možnosti Skupna raba naprej.,
Invalid Scheduled Time,Neveljaven načrtovani čas,
Length Must be less than 280.,Dolžina Mora biti manjša od 280.,
Error while POSTING {0},Napaka pri OBJAVI {0},
"Session not valid, Do you want to login?",Seja ni veljavna. Ali se želite prijaviti?,
Session Active,Seja aktivna,
Session Not Active. Save doc to login.,Seja ni aktivna. Shranite dokument za prijavo.,
Error! Failed to get request token.,Napaka! Žetona zahteve ni bilo mogoče dobiti.,
Invalid {0} or {1},Neveljaven {0} ali {1},
Error! Failed to get access token.,Napaka! Dostop do žetona ni uspel.,
Invalid Consumer Key or Consumer Secret Key,Neveljaven potrošniški ključ ali tajni ključ potrošnika,
Your Session will be expire in ,Vaša seja bo potekla leta,
 days.,dnevi.,
Session is expired. Save doc to login.,Seja je potekla. Shranite dokument za prijavo.,
Error While Uploading Image,Napaka pri nalaganju slike,
You Didn't have permission to access this API,Nimate dovoljenja za dostop do tega API-ja,
Valid Upto date cannot be before Valid From date,Veljavno do datuma ne more biti pred datumom Veljavno od,
Valid From date not in Fiscal Year {0},"Velja od datuma, ki ni v proračunskem letu {0}",
Valid Upto date not in Fiscal Year {0},"Veljavno do datuma, ki ni v proračunskem letu {0}",
Group Roll No,Skupinski zvitek št,
Maintain Same Rate Throughout Sales Cycle,Ohraniti enako stopnja skozi celoten cikel prodaje,
"Row {1}: Quantity ({0}) cannot be a fraction. To allow this, disable '{2}' in UOM {3}.","Vrstica {1}: Količina ({0}) ne sme biti ulomek. Če želite to omogočiti, onemogočite »{2}« v UOM {3}.",
Must be Whole Number,Mora biti celo število,
Please setup Razorpay Plan ID,Nastavite ID načrta Razorpay,
Contact Creation Failed,Ustvarjanje stika ni uspelo,
{0} already exists for employee {1} and period {2},{0} že obstaja za zaposlenega {1} in obdobje {2},
Leaves Allocated,Listi dodeljeni,
Leaves Expired,Listi potečejo,
Leave Without Pay does not match with approved {} records,Dopust brez plačila se ne ujema z odobrenimi zapisi {},
Income Tax Slab not set in Salary Structure Assignment: {0},Plošča za dohodek ni nastavljena pri dodelitvi strukture plače: {0},
Income Tax Slab: {0} is disabled,Plošča z dohodnino: {0} je onemogočena,
Income Tax Slab must be effective on or before Payroll Period Start Date: {0},Plošča za davek od dohodka mora veljati na začetni datum obdobja izplačil ali pred tem: {0},
No leave record found for employee {0} on {1},Zaposlenega {0} dne {1} ni mogoče najti evidence o dopustu,
Row {0}: {1} is required in the expenses table to book an expense claim.,Vrstica {0}: {1} je v tabeli stroškov potrebna za knjiženje zahtevka za stroške.,
Set the default account for the {0} {1},Nastavite privzeti račun za {0} {1},
(Half Day),(Poldnevni),
Income Tax Slab,Plošča za dohodnino,
Row #{0}: Cannot set amount or formula for Salary Component {1} with Variable Based On Taxable Salary,Vrstica št. {0}: ni mogoče nastaviti zneska ali formule za komponento plače {1} s spremenljivko na podlagi obdavčljive plače,
Row #{}: {} of {} should be {}. Please modify the account or select a different account.,Vrstica št. {}: {} Od {} mora biti {}. Spremenite račun ali izberite drugega.,
Row #{}: Please asign task to a member.,"Vrstica {{}: Prosimo, dodelite nalogo članu.",
Process Failed,Proces ni uspel,
Tally Migration Error,Napaka pri selitvi Tally,
Please set Warehouse in Woocommerce Settings,"Prosimo, nastavite Warehouse v nastavitvah Woocommerce",
Row {0}: Delivery Warehouse ({1}) and Customer Warehouse ({2}) can not be same,Vrstica {0}: Skladišče za dostavo ({1}) in Skladišče strank ({2}) ne moreta biti enaka,
Row {0}: Due Date in the Payment Terms table cannot be before Posting Date,Vrstica {0}: Datum zapadlosti v tabeli Plačilni pogoji ne sme biti pred datumom knjiženja,
Cannot find {} for item {}. Please set the same in Item Master or Stock Settings.,"Elementa {} za element {} ni mogoče najti. Prosimo, nastavite enako v poglavju Postavke ali Nastavitve zalog.",
Row #{0}: The batch {1} has already expired.,Vrstica št. {0}: serija {1} je že potekla.,
Start Year and End Year are mandatory,Začetno in končno leto sta obvezna,
GL Entry,GL Začetek,
Cannot allocate more than {0} against payment term {1},Ne morem dodeliti več kot {0} glede na rok plačila {1},
The root account {0} must be a group,Koreninski račun {0} mora biti skupina,
Shipping rule not applicable for country {0} in Shipping Address,Pravilo pošiljanja ne velja za državo {0} v naslovu pošiljanja,
Get Payments from,Pridobite plačila pri,
Set Shipping Address or Billing Address,Nastavite naslov za pošiljanje ali naslov za izstavitev računa,
Consultation Setup,Nastavitev posvetovanja,
Fee Validity,Veljavnost pristojbine,
Laboratory Setup,Laboratorijska postavitev,
Dosage Form,Odmerni obrazec,
Records and History,Zapisi in zgodovina,
Patient Medical Record,Zdravniški zapis bolnika,
Rehabilitation,Rehabilitacija,
Exercise Type,Vrsta vadbe,
Exercise Difficulty Level,Težavnost vadbe,
Therapy Type,Vrsta terapije,
Therapy Plan,Načrt terapije,
Therapy Session,Seja terapije,
Motor Assessment Scale,Lestvica za oceno motorja,
[Important] [ERPNext] Auto Reorder Errors,[Pomembno] [ERPNext] Napake samodejnega preurejanja,
"Regards,","S spoštovanjem,",
The following {0} were created: {1},Ustvarjeni so bili naslednji {0}: {1},
Work Orders,Delovni nalogi,
The {0} {1} created sucessfully,{0} {1} je bil uspešno ustvarjen,
Work Order cannot be created for following reason: <br> {0},Delovnega naloga ni mogoče ustvariti iz naslednjega razloga:<br> {0},
Add items in the Item Locations table,Dodajte elemente v tabelo Lokacije elementov,
Update Current Stock,Posodobi trenutno zalogo,
"{0} Retain Sample is based on batch, please check Has Batch No to retain sample of item","{0} Zadrži vzorec temelji na seriji. Označite Has Batch No., da zadržite vzorec izdelka",
Empty,Prazno,
Currently no stock available in any warehouse,Trenutno v nobenem skladišču ni na voljo zaloge,
BOM Qty,BOM Količina,
Time logs are required for {0} {1},Za {0} {1} so potrebni časovni dnevniki,
Total Completed Qty,Skupaj opravljeno Količina,
Qty to Manufacture,Količina za izdelavo,
Repay From Salary can be selected only for term loans,Povračilo s plače lahko izberete samo za ročna posojila,
No valid Loan Security Price found for {0},Za {0} ni bila najdena veljavna cena zavarovanja posojila,
Loan Account and Payment Account cannot be same,Posojilni račun in plačilni račun ne moreta biti enaka,
Loan Security Pledge can only be created for secured loans,Obljubo zavarovanja posojila je mogoče ustvariti samo za zavarovana posojila,
Social Media Campaigns,Kampanje za družabne medije,
From Date can not be greater than To Date,Od datuma ne sme biti daljši od datuma,
Please set a Customer linked to the Patient,"Nastavite stranko, ki je povezana s pacientom",
Customer Not Found,Stranke ni mogoče najti,
Please Configure Clinical Procedure Consumable Item in ,"Prosimo, nastavite potrošni izdelek za klinični postopek v",
Missing Configuration,Manjkajoča konfiguracija,
Out Patient Consulting Charge Item,Out Patient Consulting Charge Item,
Inpatient Visit Charge Item,Bolniška obtočna obrestna točka,
OP Consulting Charge,OP Consulting Charge,
Inpatient Visit Charge,Bolnišnični obisk na obisku,
Appointment Status,Status imenovanja,
Test: ,Preizkus:,
Collection Details: ,Podrobnosti zbirke:,
{0} out of {1},{0} od {1},
Select Therapy Type,Izberite vrsto terapije,
{0} sessions completed,Končano {0} sej,
{0} session completed,{0} seja končana,
 out of {0},od {0},
Therapy Sessions,Terapijske seje,
Add Exercise Step,Dodajte korak vadbe,
Edit Exercise Step,Uredi korak vaje,
Patient Appointments,Imenovanja pacientov,
Item with Item Code {0} already exists,Element s kodo elementa {0} že obstaja,
Registration Fee cannot be negative or zero,Kotizacija ne sme biti negativna ali nič,
Configure a service Item for {0},Konfigurirajte element storitve za {0},
Temperature: ,Temperatura:,
Pulse: ,Utrip:,
Respiratory Rate: ,Hitrost dihanja:,
BP: ,BP:,
BMI: ,ITM:,
Note: ,Opomba:,
Check Availability,Preveri razpoložljivost,
Please select Patient first,Najprej izberite Pacient,
Please select a Mode of Payment first,Najprej izberite način plačila,
Please set the Paid Amount first,Najprej nastavite plačani znesek,
Not Therapies Prescribed,Niso predpisane terapije,
There are no Therapies prescribed for Patient {0},Za bolnika niso predpisane nobene terapije {0},
Appointment date and Healthcare Practitioner are Mandatory,Datum imenovanja in zdravstveni delavec sta obvezna,
No Prescribed Procedures found for the selected Patient,Za izbranega pacienta ni bilo mogoče najti predpisanih postopkov,
Please select a Patient first,Najprej izberite bolnika,
There are no procedure prescribed for ,Za to ni predpisanega postopka,
Prescribed Therapies,Predpisane terapije,
Appointment overlaps with ,Imenovanje se prekriva z,
{0} has appointment scheduled with {1} at {2} having {3} minute(s) duration.,"Oseba {0} ima sestanek z {1} ob {2}, ki traja {3} minut.",
Appointments Overlapping,Imenovanja Prekrivanje,
Consulting Charges: {0},Stroški svetovanja: {0},
Appointment Cancelled. Please review and cancel the invoice {0},Imenovanje preklicano. Preglejte in prekličite račun {0},
Appointment Cancelled.,Imenovanje preklicano.,
Fee Validity {0} updated.,Veljavnost provizije {0} je posodobljena.,
Practitioner Schedule Not Found,Urnika zdravnika ni mogoče najti,
{0} is on a Half day Leave on {1},{0} je na poldnevnem dopustu dne {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} nima seznama zdravstvenih delavcev. Dodajte ga v zdravstveni delavec,
Healthcare Service Units,Enote zdravstvenega varstva,
Complete and Consume,Izpolnite in porabite,
Complete {0} and Consume Stock?,Izpolnite {0} in porabite zaloge?,
Complete {0}?,Dokončati {0}?,
Stock quantity to start the Procedure is not available in the Warehouse {0}. Do you want to record a Stock Entry?,Količina zalog za začetek postopka ni na voljo v skladišču {0}. Ali želite posneti vnos zalog?,
{0} as on {1},{0} kot {1},
Clinical Procedure ({0}):,Klinični postopek ({0}):,
Please set Customer in Patient {0},Nastavite stranko za pacienta {0},
Item {0} is not active,Element {0} ni aktiven,
Therapy Plan {0} created successfully.,Načrt terapije {0} je bil uspešno ustvarjen.,
Symptoms: ,Simptomi:,
No Symptoms,Brez simptomov,
Diagnosis: ,Diagnoza:,
No Diagnosis,Brez diagnoze,
Drug(s) Prescribed.,Predpisana zdravila.,
Test(s) Prescribed.,Preskusi Predpisani.,
Procedure(s) Prescribed.,Predpisani postopki.,
Counts Completed: {0},Štetja dokončana: {0},
Patient Assessment,Ocena bolnika,
Assessments,Ocene,
Heads (or groups) against which Accounting Entries are made and balances are maintained.,Glave (ali skupine) po katerih so narejene vknjižbe in se ohranjajo bilance.,
Account Name,Ime računa,
Inter Company Account,Inter Company račun,
Parent Account,Matični račun,
Setting Account Type helps in selecting this Account in transactions.,Nastavitev vrste računa pomaga pri izbiri računa v transakcijah.,
Chargeable,Obračuna,
Rate at which this tax is applied,"Hitrost, s katero se ta davek",
Frozen,Frozen,
"If the account is frozen, entries are allowed to restricted users.","Če je račun zamrznjen, so vpisi dovoljeni omejenim uporabnikom.",
Balance must be,Ravnotežju mora biti,
Lft,Lft,
Rgt,Rgt,
Old Parent,Stara Parent,
Include in gross,Vključi v bruto,
Auditor,Revizor,
Accounting Dimension,Računovodska razsežnost,
Dimension Name,Ime razsežnosti,
Dimension Defaults,Privzete dimenzije,
Accounting Dimension Detail,Podrobnosti o dimenzijah računovodstva,
Default Dimension,Privzeta razsežnost,
Mandatory For Balance Sheet,Obvezno za bilanco stanja,
Mandatory For Profit and Loss Account,Obvezno za račun dobička in izgube,
Accounting Period,Obračunsko obdobje,
Period Name,Ime obdobja,
Closed Documents,Zaprti dokumenti,
Accounts Settings,Računi Nastavitve,
Settings for Accounts,Nastavitve za račune,
Make Accounting Entry For Every Stock Movement,Naredite vknjižba Za vsako borzno gibanje,
Users with this role are allowed to set frozen accounts and create / modify accounting entries against frozen accounts,Uporabniki s to vlogo dovoljeno postaviti na zamrznjene račune in ustvariti / spreminjanje vknjižbe zoper zamrznjenih računih,
Determine Address Tax Category From,Določite kategorijo naslova davka od,
Over Billing Allowance (%),Nadomestilo za obračun (%),
Credit Controller,Credit Controller,
Check Supplier Invoice Number Uniqueness,Preverite Dobavitelj Številka računa Edinstvenost,
Make Payment via Journal Entry,Naredite plačilo preko Journal Entry,
Unlink Payment on Cancellation of Invoice,Prekinitev povezave med Plačilo na Izbris računa,
Book Asset Depreciation Entry Automatically,Knjiga sredstev Amortizacija Začetek samodejno,
Automatically Add Taxes and Charges from Item Tax Template,Samodejno dodajte davke in dajatve iz predloge za davek na postavke,
Automatically Fetch Payment Terms,Samodejno prejmite plačilne pogoje,
Show Payment Schedule in Print,Prikaži čas plačila v tisku,
Currency Exchange Settings,Nastavitve menjave valut,
Allow Stale Exchange Rates,Dovoli tečajne menjalne tečaje,
Stale Days,Stale dni,
Report Settings,Poročanje nastavitev,
Use Custom Cash Flow Format,Uporabite obliko prilagojenega denarnega toka,
Allowed To Transact With,Dovoljeno transakcijo z,
SWIFT number,Številka SWIFT,
Branch Code,Koda podružnice,
Address and Contact,Naslov in Stik,
Address HTML,Naslov HTML,
Contact HTML,Kontakt HTML,
Data Import Configuration,Konfiguracija uvoza podatkov,
Bank Transaction Mapping,Kartiranje bančnih transakcij,
Plaid Access Token,Plaid Access Token,
Company Account,Račun podjetja,
Account Subtype,Podtip računa,
Is Default Account,Ali je privzeti račun,
Is Company Account,Je račun podjetja,
Party Details,Podrobnosti o zabavi,
Account Details,podrobnosti računa,
IBAN,IBAN,
Bank Account No,Bančni račun št,
Integration Details,Podrobnosti integracije,
Integration ID,ID integracije,
Last Integration Date,Zadnji datum vključitve,
Change this date manually to setup the next synchronization start date,"Ročno spremenite ta datum, da nastavite naslednji datum začetka sinhronizacije",
Mask,Maska,
Bank Account Subtype,Podvrsta bančnega računa,
Bank Account Type,Vrsta bančnega računa,
Bank Guarantee,Bančna garancija,
Bank Guarantee Type,Vrsta bančne garancije,
Receiving,Prejemanje,
Providing,Zagotavljanje,
Reference Document Name,Referenčno ime dokumenta,
Validity in Days,Veljavnost v dnevih,
Bank Account Info,Informacije o bančnem računu,
Clauses and Conditions,Klavzule in pogoji,
Other Details,Druge podrobnosti,
Bank Guarantee Number,Bančna garancija Število,
Name of Beneficiary,Ime upravičenca,
Margin Money,Denar od razlike,
Charges Incurred,"Stroški, nastali",
Fixed Deposit Number,Fiksna številka depozita,
Account Currency,Valuta računa,
Select the Bank Account to reconcile.,Izberite bančni račun za uskladitev.,
Include Reconciled Entries,Vključi usklajene vnose,
Get Payment Entries,Dobili plačila Entries,
Payment Entries,Plačilni vnosi,
Update Clearance Date,Posodobitev Potrditev Datum,
Bank Reconciliation Detail,Banka Sprava Detail,
Cheque Number,Ček Število,
Cheque Date,Ček Datum,
Statement Header Mapping,Kartiranje glave izjave,
Statement Headers,Glave izjave,
Transaction Data Mapping,Kartiranje podatkov o transakcijah,
Mapped Items,Kartirani elementi,
Bank Statement Settings Item,Postavka postavke bančne postavke,
Mapped Header,Mapped Header,
Bank Header,Glava banke,
Bank Statement Transaction Entry,Vnos transakcijskega poročila banke,
Bank Transaction Entries,Vnosi transakcij banke,
New Transactions,Nove transakcije,
Match Transaction to Invoices,Ujemanje transakcije z računi,
Create New Payment/Journal Entry,Ustvari novo plačilo / vnos v dnevnik,
Submit/Reconcile Payments,Pošljite / uskladite plačila,
Matching Invoices,Ujemanje računov,
Payment Invoice Items,Točke plačilne fakture,
Reconciled Transactions,Usklajene transakcije,
Bank Statement Transaction Invoice Item,Postavka računa za transakcijo banke,
Payment Description,Opis plačila,
Invoice Date,Datum računa,
invoice,račun,
Bank Statement Transaction Payment Item,Postavka plačilne transakcije za bančno izjavo,
outstanding_amount,izstopajoč_števek,
Payment Reference,Sklicevanje na plačilo,
Bank Statement Transaction Settings Item,Postavka postavk transakcije za bankovce,
Bank Data,Podatki banke,
Mapped Data Type,Tip mapiranih podatkov,
Mapped Data,Mapirani podatki,
Bank Transaction,Bančna transakcija,
ACC-BTN-.YYYY.-,ACC-BTN-.YYYY.-,
Transaction ID,Transaction ID,
Unallocated Amount,nerazporejena Znesek,
Field in Bank Transaction,Polje v bančni transakciji,
Column in Bank File,Stolpec v bančni datoteki,
Bank Transaction Payments,Bančna transakcijska plačila,
Control Action,Kontrolni ukrep,
Applicable on Material Request,Velja za materialno zahtevo,
Action if Annual Budget Exceeded on MR,"Ukrep, če je letni proračun presegel MR",
Warn,Opozori,
Ignore,Prezri,
Action if Accumulated Monthly Budget Exceeded on MR,"Ukrep, če je skupni mesečni proračun presegel MR",
Applicable on Purchase Order,Velja za nakupno naročilo,
Action if Annual Budget Exceeded on PO,"Ukrep, če je letni proračun presegel PO",
Action if Accumulated Monthly Budget Exceeded on PO,"Ukrep, če je bil akumuliran mesečni proračun prekoračen na PO",
Applicable on booking actual expenses,Veljavno pri rezervaciji dejanskih stroškov,
Action if Annual Budget Exceeded on Actual,"Ukrep, če je letni proračun presegel dejansko",
Action if Accumulated Monthly Budget Exceeded on Actual,"Ukrep, če je bil akumulirani mesečni proračun presežen na dejanski",
Budget Accounts,Proračun računi,
Budget Account,proračun računa,
Budget Amount,proračun Znesek,
C-Form,C-Form,
ACC-CF-.YYYY.-,ACC-CF-.GGGG.-,
C-Form No,C-forma,
Received Date,Prejela Datum,
Quarter,Quarter,
I,jaz,
II,II,
III,III,
IV,IV,
C-Form Invoice Detail,C-Form Račun Detail,
Invoice No,Račun št,
Cash Flow Mapper,Mapper za denarni tok,
Section Name,Ime oddelka,
Section Header,Naslov glave,
Section Leader,Oddelek Leader,
e.g Adjustments for:,npr. prilagoditve za:,
Section Subtotal,Vmesni del vsote,
Section Footer,Noga odseka,
Position,Položaj,
Cash Flow Mapping,Kartiranje denarnih tokov,
Select Maximum Of 1,Izberite največ 1,
Is Finance Cost,Je strošek financiranja,
Is Working Capital,Je delovni kapital,
Is Finance Cost Adjustment,Je prilagoditev stroškov financiranja,
Is Income Tax Liability,Je obveznost dohodnine,
Is Income Tax Expense,Ali je prihodek od davka na dohodek,
Cash Flow Mapping Accounts,Računovodski pregledi denarnih tokov,
account,Račun,
Cash Flow Mapping Template,Predloga za preslikavo denarnega toka,
Cash Flow Mapping Template Details,Podrobnosti o predlogi za kartiranje denarnega toka,
POS-CLO-,POS-CLO-,
Custody,Skrbništvo,
Net Amount,Neto znesek,
Cashier Closing Payments,Blizna plačila,
Chart of Accounts Importer,Kontni načrt Uvoznik,
Import Chart of Accounts from a csv file,Uvoz računov iz datoteke csv,
Attach custom Chart of Accounts file,Priložite datoteko računa računa po meri,
Chart Preview,Predogled grafikona,
Chart Tree,Drevesno lestvico,
Cheque Print Template,Ček Print Predloga,
Has Print Format,Ima format tiskanja,
Primary Settings,primarni Nastavitve,
Cheque Size,Ček Velikost,
Regular,redno,
Starting position from top edge,Začetni položaj od zgornjega roba,
Cheque Width,Ček Širina,
Cheque Height,Ček Višina,
Scanned Cheque,skeniranih Ček,
Is Account Payable,Je računa plačljivo,
Distance from top edge,Oddaljenost od zgornjega roba,
Distance from left edge,Oddaljenost od levega roba,
Message to show,Sporočilo za prikaz,
Date Settings,Datum Nastavitve,
Starting location from left edge,Izhajajoč lokacijo od levega roba,
Payer Settings,Nastavitve plačnik,
Width of amount in word,Širina zneska z besedo,
Line spacing for amount in words,Razmik med vrsticami za znesek z besedami,
Amount In Figure,Znesek v sliki,
Signatory Position,podpisnik Položaj,
Closed Document,Zaprti dokument,
Track separate Income and Expense for product verticals or divisions.,Sledi ločeno prihodki in odhodki za vertikal proizvodov ali delitve.,
Cost Center Name,Stalo Ime Center,
Parent Cost Center,Parent Center Stroški,
lft,LFT,
rgt,RGT,
Coupon Code,Koda kupona,
Coupon Name,Ime kupona,
"e.g. ""Summer Holiday 2019 Offer 20""",npr. &quot;Poletne počitnice 2019 ponudba 20&quot;,
Coupon Type,Vrsta kupona,
Promotional,Promocijska,
Gift Card,Darilne kartice,
unique e.g. SAVE20  To be used to get discount,edinstven npr. SAVE20 Uporabiti za popust,
Validity and Usage,Veljavnost in uporaba,
Valid From,Velja od,
Valid Upto,Velja do,
Maximum Use,Največja uporaba,
Used,Rabljeni,
Coupon Description,Opis kupona,
Discounted Invoice,Popustni račun,
Debit to,V breme,
Exchange Rate Revaluation,Prevrednotenje deviznega tečaja,
Get Entries,Get Entries,
Exchange Rate Revaluation Account,Račun prevrednotenja deviznih tečajev,
Total Gain/Loss,Skupni dobiček / izguba,
Balance In Account Currency,Stanje v valuti računa,
Current Exchange Rate,Trenutni menjalni tečaj,
Balance In Base Currency,Stanje v osnovni valuti,
New Exchange Rate,Nov tečaj,
New Balance In Base Currency,Nova bilanca v osnovni valuti,
Gain/Loss,Dobiček / izguba,
**Fiscal Year** represents a Financial Year. All accounting entries and other major transactions are tracked against **Fiscal Year**.,**Poslovno leto** predstavlja knjigovodsko leto. Vse vknjižbe in druge transakcije so povezane s **poslovnim letom**.,
Year Name,Leto Name,
"For e.g. 2012, 2012-13","Za primer leta 2012, 2012-13",
Year Start Date,Leto Start Date,
Year End Date,Leto End Date,
Companies,Podjetja,
Auto Created,Samodejno ustvarjeno,
Stock User,Stock Uporabnik,
Fiscal Year Company,Fiskalna Leto Company,
Debit Amount,Debetni Znesek,
Credit Amount,Credit Znesek,
Debit Amount in Account Currency,Debetno Znesek v Valuta računa,
Credit Amount in Account Currency,Credit Znesek v Valuta računa,
Voucher Detail No,Bon Detail Ne,
Is Opening,Je Odpiranje,
Is Advance,Je Advance,
To Rename,Če želite preimenovati,
GST Account,GST račun,
CGST Account,Račun CGST,
SGST Account,Račun SGST,
IGST Account,Račun IGST,
CESS Account,CESS račun,
Loan Start Date,Datum začetka posojila,
Loan Period (Days),Obdobje posojila (dnevi),
Loan End Date,Končni datum posojila,
Bank Charges,Bančni stroški,
Short Term Loan Account,Kratkoročni posojilni račun,
Bank Charges Account,Račun za bančne stroške,
Accounts Receivable Credit Account,Kreditni račun terjatev,
Accounts Receivable Discounted Account,Račun s terjatvami s popustom,
Accounts Receivable Unpaid Account,Neplačani račun,
Item Tax Template,Predloga davčne predloge,
Tax Rates,Davčne stopnje,
Item Tax Template Detail,Podrobnosti predloge o predlogi za davek,
Entry Type,Začetek Type,
Inter Company Journal Entry,Inter Entry Journal Entry,
Bank Entry,Banka Začetek,
Cash Entry,Cash Začetek,
Credit Card Entry,Začetek Credit Card,
Contra Entry,Contra Začetek,
Excise Entry,Trošarina Začetek,
Write Off Entry,Napišite Off Entry,
Opening Entry,Otvoritev Začetek,
ACC-JV-.YYYY.-,ACC-JV-.YYYY.-,
Accounting Entries,Vknjižbe,
Total Debit,Skupaj Debetna,
Total Credit,Skupaj Credit,
Difference (Dr - Cr),Razlika (Dr - Cr),
Make Difference Entry,Naredite vnos Razlike,
Total Amount Currency,Skupni znesek Valuta,
Total Amount in Words,Skupni znesek z besedo,
Remark,Pripomba,
Paid Loan,Plačano posojilo,
Inter Company Journal Entry Reference,Referenčni opis vmesnika podjetja,
Write Off Based On,Odpisuje temelji na,
Get Outstanding Invoices,Pridobite neplačanih računov,
Write Off Amount,Odpis zneska,
Printing Settings,Nastavitve tiskanja,
Pay To / Recd From,Pay / Recd Od,
Payment Order,Plačilni nalog,
Subscription Section,Naročniška sekcija,
Journal Entry Account,Journal Entry račun,
Account Balance,Stanje na računu,
Party Balance,Balance Party,
Accounting Dimensions,Računovodske razsežnosti,
If Income or Expense,Če prihodek ali odhodek,
Exchange Rate,Menjalni tečaj,
Debit in Company Currency,Debetno v podjetju valuti,
Credit in Company Currency,Kredit v valuti podjetja,
Payroll Entry,Vnos plače,
Employee Advance,Napredek zaposlenih,
Reference Due Date,Referenčni datum roka,
Loyalty Program Tier,Stopnja programa zvestobe,
Redeem Against,Odkup proti,
Expiry Date,Rok uporabnosti,
Loyalty Point Entry Redemption,Odkup vstopnice točke zvestobe,
Redemption Date,Datum odkupa,
Redeemed Points,Uveljavljene točke,
Loyalty Program Name,Ime programa zvestobe,
Loyalty Program Type,Vrsta programa zvestobe,
Single Tier Program,Program enotnega razreda,
Multiple Tier Program,Večstranski program,
Customer Territory,Teritorija kupca,
Auto Opt In (For all customers),Auto Opt In (za vse stranke),
Collection Tier,Zbirni list,
Collection Rules,Pravila za zbiranje,
Redemption,Odkup,
Conversion Factor,Faktor pretvorbe,
1 Loyalty Points = How much base currency?,1 Točke za zvestobe = Koliko osnovna valuta?,
Expiry Duration (in days),Trajanje veljavnosti (v dnevih),
Help Section,Oddelek za pomoč,
Loyalty Program Help,Pomoč programa zvestobe,
Loyalty Program Collection,Zbirka programa zvestobe,
Tier Name,Ime razreda,
Minimum Total Spent,Minimalno skupno porabljeno,
Collection Factor (=1 LP),Zbirni faktor (= 1 LP),
For how much spent = 1 Loyalty Point,Za koliko je bila porabljena = 1 Točka zvestobe,
Mode of Payment Account,Način plačilnega računa,
Default Account,Privzeti račun,
Default account will be automatically updated in POS Invoice when this mode is selected.,"Privzet račun se samodejno posodablja v računu POS, ko je ta način izbran.",
**Monthly Distribution** helps you distribute the Budget/Target across months if you have seasonality in your business.,"**Mesečna razporeditev** vam pomaga razporejati proračun/cilje po mesecih, če imate sezonskost v vaši dejavnosti.",
Distribution Name,Porazdelitev Name,
Name of the Monthly Distribution,Ime mesečnim izplačilom,
Monthly Distribution Percentages,Mesečni Distribucijski Odstotki,
Monthly Distribution Percentage,Mesečni Distribution Odstotek,
Percentage Allocation,Odstotek dodelitve,
Create Missing Party,Ustvari manjkajočo stranko,
Create missing customer or supplier.,Ustvari manjkajočo stranko ali dobavitelja.,
Opening Invoice Creation Tool Item,Element orodja za ustvarjanje odprtega računa,
Temporary Opening Account,Začasni odpiranje računa,
Party Account,Račun Party,
Type of Payment,Vrsta plačila,
ACC-PAY-.YYYY.-,ACC-PAY-.YYYY.-,
Receive,Prejeti,
Internal Transfer,Interni prenos,
Payment Order Status,Stanje plačilnega naloga,
Payment Ordered,Plačilo je naročeno,
Payment From / To,Plačilo Od / Do,
Company Bank Account,Bančni račun podjetja,
Party Bank Account,Bančni račun stranke,
Account Paid From,Račun se plača iz,
Account Paid To,Račun Izplača,
Paid Amount (Company Currency),Plačan znesek (družba Valuta),
Received Amount,prejela znesek,
Received Amount (Company Currency),Prejela znesek (družba Valuta),
Get Outstanding Invoice,Pridobite neporavnane račune,
Payment References,Plačilni Reference,
Writeoff,Odpisati,
Total Allocated Amount,Skupaj Dodeljena Znesek,
Total Allocated Amount (Company Currency),Skupaj Dodeljena Znesek (družba Valuta),
Set Exchange Gain / Loss,Set Exchange dobiček / izguba,
Difference Amount (Company Currency),Razlika Znesek (družba Valuta),
Write Off Difference Amount,Napišite Off Razlika Znesek,
Deductions or Loss,Odbitki ali izguba,
Payment Deductions or Loss,Plačilni Odbitki ali izguba,
Cheque/Reference Date,Ček / Referenčni datum,
Payment Entry Deduction,Plačilo Začetek odštevanja,
Payment Entry Reference,Plačilo Začetek Reference,
Allocated,Razporejeni,
Payment Gateway Account,Plačilo Gateway račun,
Payment Account,Plačilo računa,
Default Payment Request Message,Privzeto Sporočilo Plačilnega Naloga,
PMO-,PMO-,
Payment Order Type,Vrsta plačilnega naloga,
Payment Order Reference,Referenca za plačilni nalog,
Bank Account Details,Podatki o bančnem računu,
Payment Reconciliation,Uskladitev plačil,
Receivable / Payable Account,Terjatve / plačljivo račun,
Bank / Cash Account,Banka / Gotovinski račun,
From Invoice Date,Od Datum računa,
To Invoice Date,Če želite Datum računa,
Minimum Invoice Amount,Minimalna Znesek računa,
Maximum Invoice Amount,Največja Znesek računa,
System will fetch all the entries if limit value is zero.,"Sistem bo dobil vse vnose, če je mejna vrednost enaka nič.",
Get Unreconciled Entries,Pridobite neusklajene vnose,
Unreconciled Payment Details,Unreconciled Plačilni Podrobnosti,
Invoice/Journal Entry Details,Račun / Journal Entry Podrobnosti,
Payment Reconciliation Invoice,Plačilo Sprava Račun,
Invoice Number,Številka računa,
Payment Reconciliation Payment,Plačilo Sprava Plačilo,
Reference Row,referenčna Row,
Allocated amount,Dodeljen znesek,
Payment Request Type,Vrsta zahtevka za plačilo,
Outward,Zunaj,
Inward,V notranjost,
ACC-PRQ-.YYYY.-,ACC-PRQ-.YYYY.-,
Transaction Details,Podrobnosti transakcije,
Amount in customer's currency,Znesek v valuti stranke,
Is a Subscription,Je naročnina,
Transaction Currency,transakcija Valuta,
Subscription Plans,Naročni načrti,
SWIFT Number,SWIFT številka,
Recipient Message And Payment Details,Prejemnik sporočila in način plačila,
Make Sales Invoice,Naredi račun,
Mute Email,Mute Email,
payment_url,payment_url,
Payment Gateway Details,Plačilo Gateway Podrobnosti,
Payment Schedule,Urnik plačila,
Invoice Portion,Delež računa,
Payment Amount,Znesek Plačila,
Payment Term Name,Ime izraza za plačilo,
Due Date Based On,Datum na podlagi datuma,
Day(s) after invoice date,Dan (dan) po datumu računa,
Day(s) after the end of the invoice month,Dan (e) po koncu računa na mesec,
Month(s) after the end of the invoice month,Mesec (i) po koncu meseca računa,
Credit Days,Kreditni dnevi,
Credit Months,Kreditni meseci,
Allocate Payment Based On Payment Terms,Dodelite plačilo na podlagi plačilnih pogojev,
"If this checkbox is checked, paid amount will be splitted and allocated as per the amounts in payment schedule against each payment term","Če je to potrditveno polje označeno, se plačani znesek razdeli in dodeli glede na zneske v urniku plačil glede na vsak rok plačila",
Payment Terms Template Detail,Podrobnosti o predlogi za plačila,
Closing Fiscal Year,Zapiranje poslovno leto,
Closing Account Head,Zapiranje računa Head,
"The account head under Liability or Equity, in which Profit/Loss will be booked","Glava račun v odgovornosti ali kapitala, v katerem se bo dobiček / izguba rezervirana",
POS Customer Group,POS Group stranke,
POS Field,POS polje,
POS Item Group,POS Element Group,
Company Address,Naslov podjetja,
Update Stock,Posodobi zalogo,
Ignore Pricing Rule,Ignoriraj pravilo Cenitve,
Applicable for Users,Uporabno za uporabnike,
Sales Invoice Payment,Plačilo prodaja Račun,
Item Groups,postavka Skupine,
Only show Items from these Item Groups,Prikažite samo izdelke iz teh skupin predmetov,
Customer Groups,Skupine strank,
Only show Customer of these Customer Groups,Pokaži samo kupcem teh skupin kupcev,
Write Off Account,Odpišite račun,
Write Off Cost Center,Napišite Off stroškovni center,
Account for Change Amount,Račun za znesek spremembe,
Taxes and Charges,Davki in dajatve,
Apply Discount On,Uporabi popust na,
POS Profile User,POS profil uporabnika,
Apply On,Nanesite na,
Price or Product Discount,Cena ali popust na izdelke,
Apply Rule On Item Code,Uporabi pravilo za kodo predmeta,
Apply Rule On Item Group,Uporabi pravilo za skupino izdelkov,
Apply Rule On Brand,Uporabi pravilo o blagovni znamki,
Mixed Conditions,Mešani pogoji,
Conditions will be applied on all the selected items combined. ,Pogoji bodo uporabljeni za vse izbrane izdelke skupaj.,
Is Cumulative,Je kumulativno,
Coupon Code Based,Na osnovi kode kupona,
Discount on Other Item,Popust na drugi artikel,
Apply Rule On Other,Uporabi pravilo o drugem,
Party Information,Informacije o zabavi,
Quantity and Amount,Količina in količina,
Min Qty,Min Kol,
Max Qty,Max Kol,
Min Amt,Min Amt,
Max Amt,Max Amt,
Period Settings,Nastavitve obdobja,
Margin,Razlika,
Margin Type,Margin Type,
Margin Rate or Amount,Razlika v stopnji ali količini,
Price Discount Scheme,Shema popustov na cene,
Rate or Discount,Stopnja ali popust,
Discount Percentage,Popust Odstotek,
Discount Amount,Popust Količina,
For Price List,Za cenik,
Product Discount Scheme,Shema popustov na izdelke,
Same Item,Isti element,
Free Item,Brezplačni artikel,
Threshold for Suggestion,Prag za predlog,
System will notify to increase or decrease quantity or amount ,Sistem bo obvestil o povečanju ali zmanjšanju količine ali količine,
"Higher the number, higher the priority","Višja kot je številka, višja je prioriteta",
Apply Multiple Pricing Rules,Uporabite pravila več cen,
Apply Discount on Rate,Uporabite popust na ceno,
Validate Applied Rule,Preverjanje veljavnega pravila,
Rule Description,Opis pravila,
Pricing Rule Help,Cen Pravilo Pomoč,
Promotional Scheme Id,ID promocijske sheme,
Promotional Scheme,Promocijska shema,
Pricing Rule Brand,Blagovna znamka,
Pricing Rule Detail,Podrobnosti o cenah,
Child Docname,Docname otroka,
Rule Applied,Uporabljeno pravilo,
Pricing Rule Item Code,Koda predmeta pravila o cenah,
Pricing Rule Item Group,Skupina izdelkov s predpisi o cenah,
Price Discount Slabs,Plošče s popustom na cene,
Promotional Scheme Price Discount,Popust na ceno promocijske sheme,
Product Discount Slabs,Plošče s popustom na izdelke,
Promotional Scheme Product Discount,Popust na izdelke promocijske sheme,
Min Amount,Minimalni znesek,
Max Amount,Max znesek,
Discount Type,Vrsta popusta,
ACC-PINV-.YYYY.-,ACC-PINV-.LLLL.-,
Tax Withholding Category,Kategorija pobiranja davkov,
Edit Posting Date and Time,Uredi datum in uro vnosa,
Is Paid,je plačano,
Is Return (Debit Note),Je povračilo (obvestilo o obremenitvi),
Apply Tax Withholding Amount,Znesek davčnega odbitka,
Accounting Dimensions ,Računovodske dimenzije,
Supplier Invoice Details,Dobavitelj Podrobnosti računa,
Supplier Invoice Date,Dobavitelj Datum računa,
Return Against Purchase Invoice,Vrni proti Račun za nakup,
Select Supplier Address,Izberite Dobavitelj naslov,
Contact Person,Kontaktna oseba,
Select Shipping Address,Izbira naslova za dostavo,
Currency and Price List,Gotovina in Cenik,
Price List Currency,Cenik Valuta,
Price List Exchange Rate,Cenik Exchange Rate,
Set Accepted Warehouse,Nastavite Sprejeto skladišče,
Rejected Warehouse,Zavrnjeno Skladišče,
Warehouse where you are maintaining stock of rejected items,"Skladišče, kjer ste vzdrževanje zalog zavrnjenih predmetov",
Raw Materials Supplied,"Surovin, dobavljenih",
Supplier Warehouse,Dobavitelj Skladišče,
Pricing Rules,Pravila cen,
Supplied Items,Priložena Items,
Total (Company Currency),Skupaj (družba Valuta),
Net Total (Company Currency),Net Total (družba Valuta),
Total Net Weight,Skupna neto teža,
Shipping Rule,Pravilo za dostavo,
Purchase Taxes and Charges Template,Nakup davki in dajatve Template,
Purchase Taxes and Charges,Nakup davki in dajatve,
Tax Breakup,davčna Breakup,
Taxes and Charges Calculation,Davki in dajatve Izračun,
Taxes and Charges Added (Company Currency),Davki in dajatve na dodano vrednost (Company Valuta),
Taxes and Charges Deducted (Company Currency),Davki in dajatve Odbitek (družba Valuta),
Total Taxes and Charges (Company Currency),Skupaj davki in dajatve (Company valuti),
Taxes and Charges Added,Davki in dajatve Dodano,
Taxes and Charges Deducted,Davki in dajatve Odbitek,
Total Taxes and Charges,Skupaj davki in dajatve,
Additional Discount,Dodatni popust,
Apply Additional Discount On,Uporabi dodatni popust na,
Additional Discount Amount (Company Currency),Dodatni popust Znesek (Valuta Company),
Additional Discount Percentage,Dodatni odstotek popusta,
Additional Discount Amount,Dodatni znesek popusta,
Grand Total (Company Currency),Grand Total (družba Valuta),
Rounding Adjustment (Company Currency),Prilagajanje zaokroževanja (valuta podjetja),
Rounded Total (Company Currency),Zaokrožena Skupaj (Company Valuta),
In Words (Company Currency),V besedi (družba Valuta),
Rounding Adjustment,Prilagajanje zaokroževanja,
In Words,V besedi,
Total Advance,Skupaj predplačila,
Disable Rounded Total,Onemogoči zaokroževanje,
Cash/Bank Account,Gotovina / bančni račun,
Write Off Amount (Company Currency),Napišite enkratni znesek (družba Valuta),
Set Advances and Allocate (FIFO),Nastavi predujme in dodelitev (FIFO),
Get Advances Paid,Get plačanih predplačil,
Advances,Predplačila,
Terms,Pogoji,
Terms and Conditions1,Pogoji in razmer1,
Group same items,Skupina Iste vsebine,
Print Language,Jezik tiskanja,
"Once set, this invoice will be on hold till the set date","Ko je nastavljen, bo ta račun zadržan do določenega datuma",
Credit To,Kredit,
Party Account Currency,Party Valuta računa,
Against Expense Account,Proti Expense račun,
Inter Company Invoice Reference,Sklic na račun družbe,
Is Internal Supplier,Je notranji dobavitelj,
Start date of current invoice's period,Datum začetka obdobja sedanje faktura je,
End date of current invoice's period,Končni datum obdobja tekočega faktura je,
Update Auto Repeat Reference,Posodobi samodejno ponavljanje referenc,
Purchase Invoice Advance,Nakup računa Advance,
Purchase Invoice Item,Nakup računa item,
Quantity and Rate,Količina in stopnja,
Received Qty,Prejela Kol,
Accepted Qty,Sprejeto Količina,
Rejected Qty,zavrnjen Kol,
UOM Conversion Factor,UOM Conversion Factor,
Discount on Price List Rate (%),Popust na ceno iz cenika Stopnja (%),
Price List Rate (Company Currency),Cenik Rate (družba Valuta),
Rate ,Stopnja,
Rate (Company Currency),Stopnja (Valuta podjetja),
Amount (Company Currency),Znesek (družba Valuta),
Is Free Item,Je brezplačen izdelek,
Net Rate,Net Rate,
Net Rate (Company Currency),Net Rate (družba Valuta),
Net Amount (Company Currency),Neto znesek (družba Valuta),
Item Tax Amount Included in Value,Znesek davka na postavke je vključen v vrednost,
Landed Cost Voucher Amount,Pristali Stroški bon Znesek,
Raw Materials Supplied Cost,"Surovin, dobavljenih Stroški",
Accepted Warehouse,Accepted Skladišče,
Serial No,Zaporedna številka,
Rejected Serial No,Zavrnjeno Zaporedna številka,
Expense Head,Expense Head,
Is Fixed Asset,Je osnovno sredstvo,
Asset Location,Lokacija sredstva,
Deferred Expense,Odloženi stroški,
Deferred Expense Account,Odloženi račun za stroške,
Service Stop Date,Datum zaustavitve storitve,
Enable Deferred Expense,Omogoči odloženi strošek,
Service Start Date,Datum začetka storitve,
Service End Date,Datum konca storitve,
Allow Zero Valuation Rate,Dovoli ničelni stopnji vrednotenja,
Item Tax Rate,Postavka Davčna stopnja,
Tax detail table fetched from item master as a string and stored in this field.\nUsed for Taxes and Charges,Davčna podrobnosti tabela nerealne iz postavke mojstra kot vrvico in shranjena na tem področju. Uporablja se za davki in dajatve,
Purchase Order Item,Naročilnica item,
Purchase Receipt Detail,Podrobnosti o potrdilu o nakupu,
Item Weight Details,Element Teža Podrobnosti,
Weight Per Unit,Teža na enoto,
Total Weight,Totalna teža,
Weight UOM,Teža UOM,
Page Break,Page Break,
Consider Tax or Charge for,Razmislite davek ali dajatev za,
Valuation and Total,Vrednotenje in Total,
Valuation,Vrednotenje,
Add or Deduct,Dodajte ali odštejemo,
Deduct,Odbitka,
On Previous Row Amount,Na prejšnje vrstice Znesek,
On Previous Row Total,Na prejšnje vrstice Skupaj,
On Item Quantity,Na Količina izdelka,
Reference Row #,Referenčna Row #,
Is this Tax included in Basic Rate?,Je to DDV vključen v osnovni stopnji?,
"If checked, the tax amount will be considered as already included in the Print Rate / Print Amount","Če je omogočeno, se bo štela za znesek davka, kot je že vključena v Print Oceni / Print Znesek",
Account Head,Račun Head,
Tax Amount After Discount Amount,Davčna Znesek Po Popust Znesek,
Item Wise Tax Detail ,Podrobnosti o davku na modro postavko,
"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.","Standardna davčna predlogo, ki se lahko uporablja za vse nakupnih poslov. To predlogo lahko vsebuje seznam davčnih glavami in tudi drugih odhodkov glavah, kot so &quot;Shipping&quot;, &quot;zavarovanje&quot;, &quot;Ravnanje&quot; itd #### Opomba davčno stopnjo, ki jo določite tu bo standard davčna stopnja za vse ** Točke * *. Če obstajajo ** Items **, ki imajo različne stopnje, ki jih je treba dodati v ** Element davku ** miza v ** Element ** mojstra. #### Opis Stolpci 1. Vrsta Izračun: - To je lahko na ** Net Total ** (to je vsota osnovnega zneska). - ** Na prejšnje vrstice Total / Znesek ** (za kumulativnih davkov ali dajatev). Če izberete to možnost, bo davek treba uporabiti kot odstotek prejšnje vrstice (davčne tabele) znesek ali skupaj. - ** Dejanska ** (kot je omenjeno). 2. Račun Head: The knjiga račun, pod katerimi se bodo rezervirana ta davek 3. stroškovni center: Če davek / pristojbina je prihodek (kot ladijski promet) ali odhodek je treba rezervirana proti centru stroškov. 4. Opis: Opis davka (bo, da se natisne v faktur / narekovajev). 5. stopnja: Davčna stopnja. 6. Znesek: Davčna znesek. 7. Skupaj: Kumulativno do te točke. 8. Vnesite Row: Če je na osnovi &quot;Prejšnji Row Total&quot; lahko izberete številko vrstice, ki bo sprejet kot osnova za ta izračun (privzeta je prejšnja vrstica). 9. Razmislite davek ali dajatev za: V tem razdelku lahko določite, če je davek / pristojbina le za vrednotenje (ni del skupaj) ali samo za skupno (ne dodajajo vrednost za postavko), ali pa oboje. 10. Dodajte ali odštejemo: Ali želite dodati ali odbiti davek.",
Salary Component Account,Plača Komponenta račun,
Default Bank / Cash account will be automatically updated in Salary Journal Entry when this mode is selected.,"Privzeti Bank / Cash račun bo samodejno posodobljen plač Journal Entry, ko je izbrana ta način.",
ACC-SINV-.YYYY.-,ACC-SINV-.YYYY.-,
Include Payment (POS),Vključujejo plačilo (POS),
Offline POS Name,Offline POS Ime,
Is Return (Credit Note),Je donos (kreditna opomba),
Return Against Sales Invoice,Vrni proti prodajne fakture,
Update Billed Amount in Sales Order,Posodobi obračunani znesek v prodajnem nalogu,
Customer PO Details,Podrobnosti kupca PO,
Customer's Purchase Order,Stranke Naročilo,
Customer's Purchase Order Date,Stranke Naročilo Datum,
Customer Address,Naslov stranke,
Shipping Address Name,Naslov dostave,
Company Address Name,Naslov podjetja Ime,
Rate at which Customer Currency is converted to customer's base currency,"Stopnjo, po kateri je naročnik Valuta pretvori v osnovni valuti kupca",
Rate at which Price list currency is converted to customer's base currency,"Obrestna mera, po kateri Cenik valuti se pretvorijo v osn stranke",
Set Source Warehouse,Nastavite Source Warehouse,
Packing List,Seznam pakiranja,
Packed Items,Pakirane Items,
Product Bundle Help,Izdelek Bundle Pomoč,
Time Sheet List,Časovnica,
Time Sheets,čas listi,
Total Billing Amount,Skupni znesek plačevanja,
Sales Taxes and Charges Template,Prodajne Davki in dajatve predloge,
Sales Taxes and Charges,Prodajne Davki in dajatve,
Loyalty Points Redemption,Odkupi točk zvestobe,
Redeem Loyalty Points,Izkoristite točke zvestobe,
Redemption Account,Račun odkupa,
Redemption Cost Center,Center za odkupne stroške,
In Words will be visible once you save the Sales Invoice.,"V besedi bo viden, ko boste prihranili prodajni fakturi.",
Allocate Advances Automatically (FIFO),Avtomatsko dodeljevanje napredka (FIFO),
Get Advances Received,Get prejeti predujmi,
Base Change Amount (Company Currency),Osnovna Sprememba Znesek (družba Valuta),
Write Off Outstanding Amount,Napišite Off neporavnanega zneska,
Terms and Conditions Details,Pogoji in Podrobnosti,
Is Internal Customer,Je notranja stranka,
Is Discounted,Se zniža,
Unpaid and Discounted,Neplačano in znižano,
Overdue and Discounted,Prepozno in znižano,
Accounting Details,Računovodstvo Podrobnosti,
Debit To,Bremenitev,
Is Opening Entry,Je vstopna odprtina,
C-Form Applicable,"C-obliki, ki velja",
Commission Rate (%),Komisija Stopnja (%),
Sales Team1,Prodaja TEAM1,
Against Income Account,Proti dohodkov,
Sales Invoice Advance,Predplačila,
Advance amount,Advance Znesek,
Sales Invoice Item,Artikel na računu,
Customer's Item Code,Koda artikla stranke,
Brand Name,Blagovna znamka,
Qty as per Stock UOM,Kol. kot na UOM,
Discount and Margin,Popust in Margin,
Rate With Margin,Oceni z mejo,
Discount (%) on Price List Rate with Margin,Popust (%) na Cena iz cenika Oceni z mejo,
Rate With Margin (Company Currency),Stopnja z maržo (valuta podjetja),
Delivered By Supplier,Delivered dobavitelj,
Deferred Revenue,Odloženi prihodki,
Deferred Revenue Account,Odloženi prihodki,
Enable Deferred Revenue,Omogočite odloženi prihodek,
Stock Details,Stock Podrobnosti,
Customer Warehouse (Optional),Skladišče stranka (po želji),
Available Batch Qty at Warehouse,Dostopno Serija Količina na Warehouse,
Available Qty at Warehouse,Na voljo Količina na Warehouse,
Delivery Note Item,Dostava Opomba Postavka,
Base Amount (Company Currency),Osnovna Znesek (družba Valuta),
Sales Invoice Timesheet,Prodaja Račun Timesheet,
Time Sheet,čas Sheet,
Billing Hours,zaračunavanje storitev ure,
Timesheet Detail,timesheet Podrobnosti,
Tax Amount After Discount Amount (Company Currency),Davčna Znesek Po Popust Znesek (družba Valuta),
Item Wise Tax Detail,Postavka Wise Davčna Detail,
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.","Standardna davčna predlogo, ki se lahko uporablja za vse prodajne transakcije. To predlogo lahko vsebuje seznam davčnih glavami in tudi druge glave strošek / dohodki, kot so &quot;Shipping&quot;, &quot;zavarovanje&quot;, &quot;Ravnanje&quot; itd #### Opomba davčno stopnjo, ki jo določite tu bo standard davčna stopnja za vse ** Postavke **. Če obstajajo ** Items **, ki imajo različne stopnje, ki jih je treba dodati v ** Element davku ** miza v ** Element ** mojstra. #### Opis Stolpci 1. Vrsta Izračun: - To je lahko na ** Net Total ** (to je vsota osnovnega zneska). - ** Na prejšnje vrstice Total / Znesek ** (za kumulativnih davkov ali dajatev). Če izberete to možnost, bo davek treba uporabiti kot odstotek prejšnje vrstice (davčne tabele) znesek ali skupaj. - ** Dejanska ** (kot je omenjeno). 2. Račun Head: The knjiga račun, pod katerimi se bodo rezervirana ta davek 3. stroškovni center: Če davek / pristojbina je prihodek (kot ladijski promet) ali odhodek je treba rezervirana proti centru stroškov. 4. Opis: Opis davka (bo, da se natisne v faktur / narekovajev). 5. stopnja: Davčna stopnja. 6. Znesek: Davčna znesek. 7. Skupaj: Kumulativno do te točke. 8. Vnesite Row: Če je na osnovi &quot;Prejšnji Row Total&quot; lahko izberete številko vrstice, ki bo sprejet kot osnova za ta izračun (privzeta je prejšnja vrstica). 9. Ali je to DDV vključen v osnovni stopnji ?: Če preverite to, to pomeni, da ta davek ne bo prikazan pod tabelo postavk, vendar bodo vključeni v osnovne stopnje v svoji glavni element tabele. To je uporabno, kadar želite dati ravno ceno (vključno z vsemi davki) ceno za kupce.",
* Will be calculated in the transaction.,* Bo izračunano v transakciji.,
From No,Od št,
To No,Na št,
Is Company,Je podjetje,
Current State,Trenutno stanje,
Purchased,Nakup,
From Shareholder,Od delničarja,
From Folio No,Iz Folio No,
To Shareholder,Za delničarja,
To Folio No,V Folio št,
Equity/Liability Account,Račun kapitala / obveznost,
Asset Account,Račun sredstev,
(including),(vključno),
ACC-SH-.YYYY.-,ACC-SH-.YYYY.-,
Folio no.,Folio št.,
Address and Contacts,Naslov in kontakti,
Contact List,Seznam kontaktov,
Hidden list maintaining the list of contacts linked to Shareholder,"Skrit seznam, ki vodi seznam kontaktov, povezanih z delničarjem",
Specify conditions to calculate shipping amount,Navedite pogoje za izračun zneska ladijskega,
Shipping Rule Label,Oznaka dostavnega pravila,
example: Next Day Shipping,Primer: Next Day Shipping,
Shipping Rule Type,Vrsta pravilnika o dostavi,
Shipping Account,Dostava račun,
Calculate Based On,Izračun temelji na,
Fixed,Popravljeno,
Net Weight,Neto teža,
Shipping Amount,Znesek Dostave,
Shipping Rule Conditions,Pogoji dostavnega pravila,
Restrict to Countries,Omeji na države,
Valid for Countries,Velja za države,
Shipping Rule Condition,Pogoj dostavnega pravila,
A condition for a Shipping Rule,Pogoj za Pravilo pošiljanja,
From Value,Od vrednosti,
To Value,Do vrednosti,
Shipping Rule Country,Država dostavnega pravila,
Subscription Period,Obdobje naročnine,
Subscription Start Date,Začetni datum naročnine,
Cancelation Date,Datum preklica,
Trial Period Start Date,Začetni datum poskusnega obdobja,
Trial Period End Date,Končni datum poskusnega obdobja,
Current Invoice Start Date,Začetni datum trenutnega računa,
Current Invoice End Date,Trenutni datum zaključka računa,
Days Until Due,Dnevi do dneva,
Number of days that the subscriber has to pay invoices generated by this subscription,"Število dni, v katerem mora naročnik plačati račune, ki jih ustvari ta naročnina",
Cancel At End Of Period,Prekliči ob koncu obdobja,
Generate Invoice At Beginning Of Period,Ustvarite račun na začetku obdobja,
Plans,Načrti,
Discounts,Popusti,
Additional DIscount Percentage,Dodatni popust Odstotek,
Additional DIscount Amount,Dodatni popust Količina,
Subscription Invoice,Naročniški račun,
Subscription Plan,Naročni načrt,
Cost,Cena,
Billing Interval,Interval zaračunavanja,
Billing Interval Count,Številka obračunavanja,
"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","Število intervalov za intervalno polje, npr. Če je interval &quot;Dnevi&quot; in časovni interval obračunavanja 3, bodo računi ustvarjeni vsakih 3 dni",
Payment Plan,Plačilni načrt,
Subscription Plan Detail,Podrobnosti o naročniškem načrtu,
Plan,Načrt,
Subscription Settings,Nastavitve naročnine,
Grace Period,Grace Period,
Number of days after invoice date has elapsed before canceling subscription or marking subscription as unpaid,Število dni po datumu računa je preteklo pred preklicem naročnine ali označitve naročnine kot neplačano,
Prorate,Prorate,
Tax Rule,Davčna Pravilo,
Tax Type,Davčna Type,
Use for Shopping Cart,Uporabite za Košarica,
Billing City,Zaračunavanje Mesto,
Billing County,County obračun,
Billing State,Država za zaračunavanje,
Billing Zipcode,Poštna številka,
Billing Country,Zaračunavanje Država,
Shipping City,Dostava Mesto,
Shipping County,Dostava County,
Shipping State,Dostava država,
Shipping Zipcode,Poštna številka pošiljanja,
Shipping Country,Dostava Država,
Tax Withholding Account,Davčni odtegljaj,
Tax Withholding Rates,Davčne odtegljaje,
Rates,Cene,
Tax Withholding Rate,Davčna stopnja zadržanja,
Single Transaction Threshold,Enotni transakcijski prag,
Cumulative Transaction Threshold,Skupni prag transakcij,
Agriculture Analysis Criteria,Kriteriji za analizo kmetijstva,
Linked Doctype,Povezani Doctype,
Water Analysis,Analiza vode,
Soil Analysis,Analiza tal,
Plant Analysis,Analiza rastlin,
Fertilizer,Gnojilo,
Soil Texture,Tekstura za tla,
Weather,Vreme,
Agriculture Manager,Kmetijski vodja,
Agriculture User,Kmetijski uporabnik,
Agriculture Task,Kmetijska naloga,
Task Name,Ime naloga,
Start Day,Začni dan,
End Day,Konec dneva,
Holiday Management,Upravljanje praznikov,
Ignore holidays,Prezri praznike,
Previous Business Day,Prejšnji delovni dan,
Next Business Day,Naslednji delovni dan,
Urgent,Nujna,
Crop,Pridelek,
Crop Name,Ime pridelka,
Scientific Name,Znanstveno ime,
"You can define all the tasks which need to carried out for this crop here. The day field is used to mention the day on which the task needs to be carried out, 1 being the 1st day, etc.. ","Določite lahko vse naloge, ki jih je treba izvesti za ta pridelek tukaj. Dansko polje se uporablja za navedbo dneva, ko je naloga treba opraviti, 1 je 1. dan itd.",
Crop Spacing,Razmik rastlin,
Crop Spacing UOM,UOM razmika rastlin,
Row Spacing,Razmik vrstic,
Row Spacing UOM,Razmik vrstic UOM,
Perennial,Trajen,
Biennial,Bienale,
Planting UOM,Sajenje UOM,
Planting Area,Območje sajenja,
Yield UOM,Donosnost UOM,
Materials Required,Potrebni materiali,
Produced Items,Proizvedeni elementi,
Produce,Produkt,
Byproducts,Stranski produkti,
Linked Location,Povezana lokacija,
A link to all the Locations in which the Crop is growing,"Povezava do vseh lokacij, v katerih se pridelek prideluje",
This will be day 1 of the crop cycle,To bo dan 1 ciklusa poljščin,
ISO 8601 standard,ISO 8601 standard,
Cycle Type,Vrsta cikla,
Less than a year,Manj kot eno leto,
The minimum length between each plant in the field for optimum growth,Najmanjša dolžina med posameznimi rastlinami na polju za optimalno rast,
The minimum distance between rows of plants for optimum growth,Najmanjša razdalja med vrstami rastlin za optimalno rast,
Detected Diseases,Detektirane bolezni,
List of diseases detected on the field. When selected it'll automatically add a list of tasks to deal with the disease ,"Seznam bolezni, odkritih na terenu. Ko je izbran, bo samodejno dodal seznam nalog, ki se ukvarjajo z boleznijo",
Detected Disease,Detektirana bolezen,
LInked Analysis,LInked analiza,
Disease,Bolezen,
Tasks Created,Ustvarjene naloge,
Common Name,Pogosto ime,
Treatment Task,Naloga zdravljenja,
Treatment Period,Obdobje zdravljenja,
Fertilizer Name,Ime gnojila,
Density (if liquid),Gostota (če je tekoča),
Fertilizer Contents,Vsebina gnojil,
Fertilizer Content,Vsebina gnojil,
Linked Plant Analysis,Analiza povezanih naprav,
Linked Soil Analysis,Povezana analiza tal,
Linked Soil Texture,Povezana tla teksture,
Collection Datetime,Zbirka Datetime,
Laboratory Testing Datetime,Laboratorijsko testiranje Datetime,
Result Datetime,Result Datetime,
Plant Analysis Criterias,Kriteriji za analizo rastlin,
Plant Analysis Criteria,Kriteriji za analizo rastlin,
Minimum Permissible Value,Najmanjša dovoljena vrednost,
Maximum Permissible Value,Najvišja dovoljena vrednost,
Ca/K,Ca / K,
Ca/Mg,Ca / Mg,
Mg/K,Mg / K,
(Ca+Mg)/K,(Ca+Mg)/K,
Ca/(K+Ca+Mg),Ca / (K + Ca + Mg),
Soil Analysis Criterias,Kriteriji za analizo tal,
Soil Analysis Criteria,Kriteriji za analizo tal,
Soil Type,Vrsta tal,
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 Sestava (%),
Sand Composition (%),Sestava peska (%),
Silt Composition (%),Siltova sestava (%),
Ternary Plot,Ternary plot,
Soil Texture Criteria,Kriteriji za teksturo tal,
Type of Sample,Vrsta vzorca,
Container,Zabojnik,
Origin,Izvor,
Collection Temperature ,Zbirna temperatura,
Storage Temperature,Temperatura shranjevanja,
Appearance,Videz,
Person Responsible,Odgovorna oseba,
Water Analysis Criteria,Kriteriji za analizo vode,
Weather Parameter,Vremenski parameter,
ACC-ASS-.YYYY.-,ACC-ASS-.YYYY.-,
Asset Owner,Lastnik sredstev,
Asset Owner Company,Družba z lastniki sredstev,
Custodian,Skrbnik,
Disposal Date,odstranjevanje Datum,
Journal Entry for Scrap,Journal Entry za pretep,
Available-for-use Date,"Datum, ki je na voljo za uporabo",
Calculate Depreciation,Izračunajte amortizacijo,
Allow Monthly Depreciation,Dovoli mesečno amortizacijo,
Number of Depreciations Booked,Število amortizacije Rezervirano,
Finance Books,Finance Knjige,
Straight Line,Ravna črta,
Double Declining Balance,Double Upadanje Balance,
Manual,Ročno,
Value After Depreciation,Vrednost po amortizaciji,
Total Number of Depreciations,Skupno število amortizacije,
Frequency of Depreciation (Months),Pogostost amortizacijo (meseci),
Next Depreciation Date,Naslednja Amortizacija Datum,
Depreciation Schedule,Amortizacija Razpored,
Depreciation Schedules,Amortizacija Urniki,
Insurance details,Podrobnosti o zavarovanju,
Policy number,Številka politike,
Insurer,Zavarovatelj,
Insured value,Zavarovana vrednost,
Insurance Start Date,Začetni datum zavarovanja,
Insurance End Date,Končni datum zavarovanja,
Comprehensive Insurance,Celovito zavarovanje,
Maintenance Required,Potrebno vzdrževanje,
Check if Asset requires Preventive Maintenance or Calibration,"Preverite, ali sredstva potrebujejo preventivno vzdrževanje ali kalibracijo",
Booked Fixed Asset,Rezervirano osnovno sredstvo,
Purchase Receipt Amount,Znesek kupnine,
Default Finance Book,Privzeta finančna knjiga,
Quality Manager,Quality Manager,
Asset Category Name,Sredstvo Kategorija Ime,
Depreciation Options,Možnosti amortizacije,
Enable Capital Work in Progress Accounting,Omogoči kapitalsko delo v računovodstvu v teku,
Finance Book Detail,Finance Book Detail,
Asset Category Account,Sredstvo Kategorija račun,
Fixed Asset Account,Fiksna račun premoženja,
Accumulated Depreciation Account,Bilančni Amortizacija račun,
Depreciation Expense Account,Amortizacija račun,
Capital Work In Progress Account,Vloga za kapitalsko delo v teku,
Asset Finance Book,Knjiga o premoženju,
Written Down Value,Zapisana vrednost,
Expected Value After Useful Life,Pričakovana vrednost Po Koristne življenja,
Rate of Depreciation,Stopnja amortizacije,
In Percentage,V odstotkih,
Maintenance Team,Vzdrževalna ekipa,
Maintenance Manager Name,Ime upravitelja vzdrževanja,
Maintenance Tasks,Vzdrževalna opravila,
Manufacturing User,Proizvodnja Uporabnik,
Asset Maintenance Log,Dnevnik o vzdrževanju sredstev,
ACC-AML-.YYYY.-,ACC-AML-YYYY-,
Maintenance Type,Vzdrževanje Tip,
Maintenance Status,Status vzdrževanje,
Planned,Načrtovano,
Has Certificate ,Ima potrdilo,
Certificate,Potrdilo,
Actions performed,Izvedeni ukrepi,
Asset Maintenance Task,Naloga vzdrževanja sredstev,
Maintenance Task,Vzdrževalna naloga,
Preventive Maintenance,Preventivno vzdrževanje,
Calibration,Praznovanje,
2 Yearly,pred 2 letoma,
Certificate Required,Zahtevano potrdilo,
Assign to Name,Dodeli imenu,
Next Due Date,Naslednji datum roka,
Last Completion Date,Zadnji datum zaključka,
Asset Maintenance Team,Ekipa za vzdrževanje sredstev,
Maintenance Team Name,Ime ekipe za vzdrževanje,
Maintenance Team Members,Člani vzdrževalne ekipe,
Purpose,Namen,
Stock Manager,Stock Manager,
Asset Movement Item,Postavka gibanja sredstev,
Source Location,Izvorna lokacija,
From Employee,Od zaposlenega,
Target Location,Ciljna lokacija,
To Employee,Za zaposlene,
Asset Repair,Popravilo sredstev,
ACC-ASR-.YYYY.-,ACC-ASR-.YYYY.-,
Failure Date,Datum odpovedi,
Assign To Name,Dodeli imenu,
Repair Status,Stanje popravila,
Error Description,Opis napake,
Downtime,Odmore,
Repair Cost,Stroški popravila,
Manufacturing Manager,Upravnik proizvodnje,
Current Asset Value,Trenutna vrednost sredstev,
New Asset Value,Nova vrednost sredstev,
Make Depreciation Entry,Naj Amortizacija Začetek,
Finance Book Id,Id knjižne knjige,
Location Name,Ime lokacije,
Parent Location,Lokacija matere,
Is Container,Je kontejner,
Check if it is a hydroponic unit,"Preverite, ali gre za hidroponično enoto",
Location Details,Podrobnosti o lokaciji,
Latitude,Zemljepisna širina,
Longitude,Dolžina,
Area,Območje,
Area UOM,Področje UOM,
Tree Details,drevo Podrobnosti,
Maintenance Team Member,Član vzdrževalne ekipe,
Team Member,Član ekipe,
Maintenance Role,Vzdrževalna vloga,
Buying Settings,Nastavitve nabave,
Settings for Buying Module,Nastavitve za modul nabava,
Supplier Naming By,Dobavitelj Imenovanje Z,
Default Supplier Group,Privzeta dobaviteljska skupina,
Default Buying Price List,Privzet nabavni cenik,
Backflush Raw Materials of Subcontract Based On,Backflush surovine podizvajalske pogodbe na podlagi,
Material Transferred for Subcontract,Preneseni material za podizvajalsko pogodbo,
Over Transfer Allowance (%),Nadomestilo za prerazporeditev (%),
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.,"Odstotek, ki ga lahko prenesete več glede na naročeno količino. Na primer: Če ste naročili 100 enot. in vaš dodatek znaša 10%, potem vam je dovoljeno prenašati 110 enot.",
PUR-ORD-.YYYY.-,PUR-ORD-YYYY-,
Get Items from Open Material Requests,Dobili predmetov iz Odpri Material Prošnje,
Fetch items based on Default Supplier.,Izvlecite izdelke na podlagi privzetega dobavitelja.,
Required By,Zahtevani Z,
Order Confirmation No,Potrditev št,
Order Confirmation Date,Datum potrditve naročila,
Customer Mobile No,Stranka Mobile No,
Customer Contact Email,Customer Contact Email,
Set Target Warehouse,Nastavite ciljno skladišče,
Sets 'Warehouse' in each row of the Items table.,Nastavi &#39;Skladišče&#39; v vsaki vrstici tabele Predmeti.,
Supply Raw Materials,Oskrba z Surovine,
Purchase Order Pricing Rule,Pravilo o cenah naročil,
Set Reserve Warehouse,Nastavite rezervno skladišče,
In Words will be visible once you save the Purchase Order.,"V besedi bo viden, ko boste prihranili naročilnico.",
Advance Paid,Advance Paid,
Tracking,Sledenje,
% Billed,% zaračunano,
% Received,% Prejeto,
Ref SQ,Ref SQ,
Inter Company Order Reference,Referenčna številka internih naročil,
Supplier Part Number,Dobavitelj Številka dela,
Billed Amt,Bremenjenega Amt,
Warehouse and Reference,Skladišče in Reference,
To be delivered to customer,Ki jih je treba dostaviti kupcu,
Material Request Item,Material Zahteva Postavka,
Supplier Quotation Item,Dobavitelj Kotacija Postavka,
Against Blanket Order,Proti odeji red,
Blanket Order,Blanket naročilo,
Blanket Order Rate,Stopnja poravnave,
Returned Qty,Vrnjeno Kol,
Purchase Order Item Supplied,Nakup Sklep Postavka Priložena,
BOM Detail No,BOM Detail Ne,
Stock Uom,Stock UOM,
Raw Material Item Code,Raw Material Oznaka,
Supplied Qty,Priložena Kol,
Purchase Receipt Item Supplied,Potrdilo o nakupu Postavka Priložena,
Current Stock,Trenutna zaloga,
PUR-RFQ-.YYYY.-,PUR-RFQ-.YYYY.-,
For individual supplier,Za posameznega dobavitelja,
Link to Material Requests,Povezava do zahtev za material,
Message for Supplier,Sporočilo za dobavitelja,
Request for Quotation Item,Zahteva za ponudbo točki,
Required Date,Zahtevani Datum,
Request for Quotation Supplier,Zahteva za ponudbo dobavitelja,
Send Email,Pošlji e-pošto,
Quote Status,Citiraj stanje,
Download PDF,Prenos PDF,
Supplier of Goods or Services.,Dobavitelj blaga ali storitev.,
Name and Type,Ime in Type,
SUP-.YYYY.-,SUP-.YYYY.-,
Default Bank Account,Privzeti bančni račun,
Is Transporter,Je transporter,
Represents Company,Predstavlja podjetje,
Supplier Type,Dobavitelj Type,
Allow Purchase Invoice Creation Without Purchase Order,Dovoli ustvarjanje računa za nakup brez naročilnice,
Allow Purchase Invoice Creation Without Purchase Receipt,Dovoli ustvarjanje računa za nakup brez potrdila o nakupu,
Warn RFQs,Opozori RFQs,
Warn POs,Opozori PO,
Prevent RFQs,Preprečite RFQ-je,
Prevent POs,Preprečevanje PO,
Billing Currency,Zaračunavanje Valuta,
Default Payment Terms Template,Predloga za privzete plačilne pogoje,
Block Supplier,Blokiraj dobavitelja,
Hold Type,Tip držite,
Leave blank if the Supplier is blocked indefinitely,"Pustite prazno, če je dobavitelj blokiran za nedoločen čas",
Default Payable Accounts,Privzete plačuje računov,
Mention if non-standard payable account,Omemba če nestandardni plača račun,
Default Tax Withholding Config,Podnapisani davčni odtegljaj,
Supplier Details,Dobavitelj Podrobnosti,
Statutory info and other general information about your Supplier,Statutarna info in druge splošne informacije o vašem dobavitelju,
PUR-SQTN-.YYYY.-,PUR-SQTN-.GGGG.-,
Supplier Address,Dobavitelj Naslov,
Link to material requests,Povezava na materialne zahteve,
Rounding Adjustment (Company Currency,Prilagajanje zaokroževanja (Valuta podjetja,
Auto Repeat Section,Samodejni del ponovitve,
Is Subcontracted,Je v podizvajanje,
Lead Time in days,Lead time v dnevih,
Supplier Score,Ocen dobavitelja,
Indicator Color,Barva indikatorja,
Evaluation Period,Ocenjevalno obdobje,
Per Week,Tedensko,
Per Month,Na mesec,
Per Year,Letno,
Scoring Setup,Nastavitev točkovanja,
Weighting Function,Tehtalna funkcija,
"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","Uporabljate lahko spremenljivke Scorecard, kot tudi: {total_score} (skupna ocena iz tega obdobja), {period_number} (število obdobij do današnjega dne)",
Scoring Standings,Točkovno točkovanje,
Criteria Setup,Nastavitev meril,
Load All Criteria,Naložite vsa merila,
Scoring Criteria,Kriteriji točkovanja,
Scorecard Actions,Akcije kazalnikov,
Warn for new Request for Quotations,Opozori na novo zahtevo za citate,
Warn for new Purchase Orders,Opozori na nova naročila,
Notify Supplier,Obvesti dobavitelja,
Notify Employee,Obvesti delavca,
Supplier Scorecard Criteria,Merila ocenjevalnih meril za dobavitelje,
Criteria Name,Ime merila,
Max Score,Najvišji rezultat,
Criteria Formula,Kriterijska formula,
Criteria Weight,Teža meril,
Supplier Scorecard Period,Period ocenjevanja dobaviteljev,
PU-SSP-.YYYY.-,PU-SSP-YYYY.-,
Period Score,Obdobje obdobja,
Calculations,Izračuni,
Criteria,Merila,
Variables,Spremenljivke,
Supplier Scorecard Setup,Nastavitev kazalčevega kazalnika,
Supplier Scorecard Scoring Criteria,Merila ocenjevanja rezultatov ocenjevanja dobavitelja,
Score,ocena,
Supplier Scorecard Scoring Standing,Ocenjevalno ocenjevalno točko dobavitelja,
Standing Name,Stalno ime,
Purple,Vijolična,
Yellow,Rumena,
Orange,Oranžna,
Min Grade,Min razred,
Max Grade,Max razred,
Warn Purchase Orders,Opozori na naročila za nakup,
Prevent Purchase Orders,Preprečevanje nakupnih naročil,
Employee ,Zaposleni,
Supplier Scorecard Scoring Variable,Dobavitelj Scorecard Scoring Spremenljivka,
Variable Name,Ime spremenljivke,
Parameter Name,Ime parametra,
Supplier Scorecard Standing,Stalni ocenjevalni list dobavitelja,
Notify Other,Obvesti drugo,
Supplier Scorecard Variable,Spremenljivka Scorecard spremenljivke,
Call Log,Seznam klicev,
Received By,Prejeto od,
Caller Information,Podatki o klicalcu,
Contact Name,Kontaktno ime,
Lead ,Svinec,
Lead Name,Ime ponudbe,
Ringing,Zvonjenje,
Missed,Zgrešen,
Call Duration in seconds,Trajanje klica v sekundah,
Recording URL,Snemalni URL,
Communication Medium,Sporočilo Medium,
Communication Medium Type,Komunikacija Srednja vrsta,
Voice,Glas,
Catch All,Ujemite vse,
"If there is no assigned timeslot, then communication will be handled by this group","Če ni določenega časovnega razporeda, bo komunikacija upravljala ta skupina",
Timeslots,Časopisi,
Communication Medium Timeslot,Srednja časovna komunikacija,
Employee Group,Skupina zaposlenih,
Appointment,Imenovanje,
Scheduled Time,Časovni načrt,
Unverified,Nepreverjeno,
Customer Details,Podrobnosti strank,
Phone Number,Telefonska številka,
Skype ID,Skype ID,
Linked Documents,Povezani dokumenti,
Appointment With,Sestanek s,
Calendar Event,Koledarski dogodek,
Appointment Booking Settings,Nastavitve rezervacije termina,
Enable Appointment Scheduling,Omogoči razpored sestankov,
Agent Details,Podrobnosti o agentu,
Availability Of Slots,Razpoložljivost slotov,
Number of Concurrent Appointments,Število sočasnih sestankov,
Agents,Agenti,
Appointment Details,Podrobnosti o sestanku,
Appointment Duration (In Minutes),Trajanje sestanka (v minutah),
Notify Via Email,Obvestite preko e-pošte,
Notify customer and agent via email on the day of the appointment.,Na dan sestanka obvestite stranko in zastopnika po e-pošti.,
Number of days appointments can be booked in advance,Število terminov je mogoče rezervirati vnaprej,
Success Settings,Nastavitve uspeha,
Success Redirect URL,URL za preusmeritev uspeha,
"Leave blank for home.\nThis is relative to site URL, for example ""about"" will redirect to ""https://yoursitename.com/about""","Pustite prazno doma. To je glede na URL spletnega mesta, na primer &quot;približno&quot; bo preusmerjeno na &quot;https://yoursitename.com/about&quot;",
Appointment Booking Slots,Slots za rezervacijo termina,
Day Of Week,Dan v tednu,
From Time ,Od časa,
Campaign Email Schedule,Načrt e-poštnih sporočil kampanje,
Send After (days),Pošlji po (dnevih),
Signed,Podpisano,
Party User,Stranski uporabnik,
Unsigned,Brez podpore,
Fulfilment Status,Status izpolnjevanja,
N/A,N / A,
Unfulfilled,Neizpolnjeno,
Partially Fulfilled,Delno izpolnjeno,
Fulfilled,Izpolnjeno,
Lapsed,Neodločeno,
Contract Period,Pogodbeno obdobje,
Signee Details,Podrobnosti o označevanju,
Signee,Signee,
Signed On,Podpisano,
Contract Details,Podrobnosti pogodbe,
Contract Template,Predloga pogodbe,
Contract Terms,Pogoji pogodbe,
Fulfilment Details,Podrobnosti o izpolnjevanju,
Requires Fulfilment,Zahteva izpolnjevanje,
Fulfilment Deadline,Rok izpolnjevanja,
Fulfilment Terms,Izpolnjevanje pogojev,
Contract Fulfilment Checklist,Kontrolni seznam izpolnjevanja pogodb,
Requirement,Zahteva,
Contract Terms and Conditions,Pogoji pogodbe,
Fulfilment Terms and Conditions,Izpolnjevanje pogojev,
Contract Template Fulfilment Terms,Pogoji izpolnjevanja pogodbenih pogojev,
Email Campaign,E-poštna akcija,
Email Campaign For ,E-poštna akcija za,
Lead is an Organization,Svinec je organizacija,
CRM-LEAD-.YYYY.-,CRM-LEAD-.YYYY.-,
Person Name,Ime oseba,
Lost Quotation,Izgubljeno Kotacija,
Interested,Zanima,
Converted,Pretvorjena,
Do Not Contact,Ne Pišite,
From Customer,Od kupca,
Campaign Name,Ime kampanje,
Follow Up,Nadaljuj,
Next Contact By,Naslednja Kontakt Z,
Next Contact Date,Naslednja Stik Datum,
Ends On,Konča se naprej,
Address & Contact,Naslov in kontakt,
Mobile No.,Mobilni No.,
Lead Type,Tip ponudbe,
Channel Partner,Channel Partner,
Consultant,Svetovalec,
Market Segment,Tržni segment,
Industry,Industrija,
Request Type,Zahteva Type,
Product Enquiry,Povpraševanje izdelek,
Request for Information,Zahteva za informacije,
Suggestions,Predlogi,
Blog Subscriber,Blog Subscriber,
LinkedIn Settings,Nastavitve LinkedIn,
Company ID,ID podjetja,
OAuth Credentials,Poverilnice OAuth,
Consumer Key,Potrošniški ključ,
Consumer Secret,Potrošniška skrivnost,
User Details,Podrobnosti o uporabniku,
Person URN,Oseba URN,
Session Status,Stanje seje,
Lost Reason Detail,Podrobnosti o izgubljenih razlogih,
Opportunity Lost Reason,Priložnost izgubljen razlog,
Potential Sales Deal,Potencialni Sales Deal,
CRM-OPP-.YYYY.-,CRM-OPP-YYYY.-,
Opportunity From,Priložnost Od,
Customer / Lead Name,Stranka / Ime ponudbe,
Opportunity Type,Priložnost Type,
Converted By,Pretvoril,
Sales Stage,Prodajna faza,
Lost Reason,Razlog za izgubljeno,
Expected Closing Date,Pričakovani datum zaključka,
To Discuss,Razpravljati,
With Items,Z Items,
Probability (%),Verjetnost (%),
Contact Info,Kontaktni podatki,
Customer / Lead Address,Stranka / Naslov ponudbe,
Contact Mobile No,Kontaktna mobilna številka,
Enter name of campaign if source of enquiry is campaign,"Vnesite ime oglaševalske akcije, če je vir preiskovalne akcije",
Opportunity Date,Priložnost Datum,
Opportunity Item,Priložnost Postavka,
Basic Rate,Osnovni tečaj,
Stage Name,Ime stadiona,
Social Media Post,Social Social Post,
Post Status,Stanje objave,
Posted,Objavljeno,
Share On,Delite naprej,
Twitter,Twitter,
LinkedIn,LinkedIn,
Twitter Post Id,ID objave na Twitterju,
LinkedIn Post Id,LinkedIn Post Id,
Tweet,Tweet,
Twitter Settings,Nastavitve Twitterja,
API Secret Key,Skrivni ključ API,
Term Name,izraz Ime,
Term Start Date,Izraz Datum začetka,
Term End Date,Izraz Končni datum,
Academics User,akademiki Uporabnik,
Academic Year Name,Ime študijsko leto,
Article,Člen,
LMS User,Uporabnik LMS,
Assessment Criteria Group,Skupina Merila ocenjevanja,
Assessment Group Name,Ime skupine ocena,
Parent Assessment Group,Skupina Ocena Parent,
Assessment Name,Ime ocena,
Grading Scale,Ocenjevalna lestvica,
Examiner,Examiner,
Examiner Name,Ime Examiner,
Supervisor,nadzornik,
Supervisor Name,Ime nadzornik,
Evaluate,Ocenite,
Maximum Assessment Score,Najvišja ocena Ocena,
Assessment Plan Criteria,Merila načrt ocenjevanja,
Maximum Score,Najvišja ocena,
Result,Rezultat,
Total Score,Skupni rezultat,
Grade,razred,
Assessment Result Detail,Ocena Rezultat Podrobnosti,
Assessment Result Tool,Ocena Rezultat orodje,
Result HTML,rezultat HTML,
Content Activity,Vsebinska aktivnost,
Last Activity ,Zadnja aktivnost,
Content Question,Vsebinsko vprašanje,
Question Link,Povezava z vprašanji,
Course Name,Ime predmeta,
Topics,Teme,
Hero Image,Slika junaka,
Default Grading Scale,Privzeti Ocenjevalna lestvica,
Education Manager,Vodja izobraževanja,
Course Activity,Dejavnost tečaja,
Course Enrollment,Vpis na tečaj,
Activity Date,Datum aktivnosti,
Course Assessment Criteria,Merila ocenjevanja tečaj,
Weightage,Weightage,
Course Content,Vsebina predmeta,
Quiz,Kviz,
Program Enrollment,Program Vpis,
Enrollment Date,Datum včlanitve,
Instructor Name,inštruktor Ime,
EDU-CSH-.YYYY.-,EDU-CSH-YYYY-,
Course Scheduling Tool,Tečajno orodje za planiranje,
Course Start Date,Datum začetka predmeta,
To TIme,Time,
Course End Date,Seveda Končni datum,
Course Topic,Tema predmeta,
Topic,tema,
Topic Name,Ime temo,
Education Settings,Nastavitve izobraževanja,
Current Academic Year,Trenutni študijsko leto,
Current Academic Term,Trenutni Academic Term,
Attendance Freeze Date,Udeležba Freeze Datum,
Validate Batch for Students in Student Group,Potrdite Batch za študente v študentskih skupine,
"For Batch based Student Group, the Student Batch will be validated for every Student from the Program Enrollment.",Za Študentske skupine temelji Serija bo študent Serija biti potrjena za vse učence od programa vpis.,
Validate Enrolled Course for Students in Student Group,Potrdite vpisanih tečaj za študente v študentskih skupine,
"For Course based Student Group, the Course will be validated for every Student from the enrolled Courses in Program Enrollment.","Za Študentske skupine temelji igrišče, bo tečaj se potrdi za vsakega študenta od vpisanih Tečaji v programu vpis.",
Make Academic Term Mandatory,Naredite akademski izraz obvezen,
"If enabled, field Academic Term will be Mandatory in Program Enrollment Tool.","Če je omogočeno, bo polje Academic Term Obvezno v orodju za vpisovanje programov.",
Skip User creation for new Student,Preskoči ustvarjanje uporabnika za novega študenta,
"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.","Privzeto se za vsakega novega študenta ustvari nov uporabnik. Če je omogočeno, ob ustvarjanju novega študenta ne bo ustvarjen nov uporabnik.",
Instructor Records to be created by,"Zapise za inštruktorje, ki jih bo ustvaril",
Employee Number,Število zaposlenih,
Fee Category,Fee Kategorija,
Fee Component,Fee Component,
Fees Category,pristojbine Kategorija,
Fee Schedule,Razpored Fee,
Fee Structure,Fee Struktura,
EDU-FSH-.YYYY.-,EDU-FSH-.YYYY.-,
Fee Creation Status,Status ustvarjanja provizije,
In Process,V postopku,
Send Payment Request Email,Pošlji e-pošto za plačilni zahtevek,
Student Category,študent kategorije,
Fee Breakup for each student,Povračilo stroškov za vsakega študenta,
Total Amount per Student,Skupni znesek na študenta,
Institution,ustanova,
Fee Schedule Program,Program urnika,
Student Batch,študent serije,
Total Students,Skupaj študenti,
Fee Schedule Student Group,Skupina študijskih ur,
EDU-FST-.YYYY.-,EDU-FST-.LLLL.-,
EDU-FEE-.YYYY.-,EDU-FEE-.YYYY.-,
Include Payment,Vključi plačilo,
Send Payment Request,Pošiljanje zahtevka za plačilo,
Student Details,Podrobnosti študenta,
Student Email,Student Email,
Grading Scale Name,Ocenjevalna lestvica Ime,
Grading Scale Intervals,Ocenjevalna lestvica intervali,
Intervals,intervali,
Grading Scale Interval,Ocenjevalna lestvica Interval,
Grade Code,razred Code,
Threshold,prag,
Grade Description,razred Opis,
Guardian,Guardian,
Guardian Name,Ime Guardian,
Alternate Number,namestnik Število,
Occupation,poklic,
Work Address,Delovni naslov,
Guardian Of ,Guardian Of,
Students,študenti,
Guardian Interests,Guardian Zanima,
Guardian Interest,Guardian Obresti,
Interest,Obresti,
Guardian Student,Guardian Študent,
EDU-INS-.YYYY.-,EDU-INS-.YYYY.-,
Instructor Log,Dnevnik inštruktorja,
Other details,Drugi podatki,
Option,Možnost,
Is Correct,Je pravilen,
Program Name,Ime programa,
Program Abbreviation,Kratica programa,
Courses,Tečaji,
Is Published,Je objavljeno,
Allow Self Enroll,Dovoli samovpis,
Is Featured,Je predstavljeno,
Intro Video,Intro video,
Program Course,Tečaj programa,
School House,šola House,
Boarding Student,Boarding Študent,
Check this if the Student is residing at the Institute's Hostel.,"Označite to, če je študent s stalnim prebivališčem v Hostel inštituta.",
Walking,Hoditi,
Institute's Bus,Inštitutski avtobus,
Public Transport,Javni prevoz,
Self-Driving Vehicle,Self-Vožnja vozil,
Pick/Drop by Guardian,Pick / znižala za Guardian,
Enrolled courses,vpisani tečaji,
Program Enrollment Course,Program Vpis tečaj,
Program Enrollment Fee,Program Vpis Fee,
Program Enrollment Tool,Program Vpis orodje,
Get Students From,Dobili študenti iz,
Student Applicant,študent Prijavitelj,
Get Students,Get Študenti,
Enrollment Details,Podrobnosti o vpisu,
New Program,Nov program,
New Student Batch,Nova študentska serija,
Enroll Students,včlanite Študenti,
New Academic Year,Novo študijsko leto,
New Academic Term,Novi akademski izraz,
Program Enrollment Tool Student,Program Vpis Orodje Student,
Student Batch Name,Student Serija Ime,
Program Fee,Cena programa,
Question,Vprašanje,
Single Correct Answer,Enotni pravilen odgovor,
Multiple Correct Answer,Več pravilnih odgovorov,
Quiz Configuration,Konfiguracija kviza,
Passing Score,Prehodna ocena,
Score out of 100,Rezultat od 100,
Max Attempts,Največji poskusi,
Enter 0 to waive limit,Vnesite 0 za omejitev omejitve,
Grading Basis,Osnove za ocenjevanje,
Latest Highest Score,Zadnji najvišji rezultat,
Latest Attempt,Najnovejši poskus,
Quiz Activity,Dejavnost kviza,
Enrollment,Vpis,
Pass,Prehod,
Quiz Question,Vprašanje za kviz,
Quiz Result,Rezultat kviza,
Selected Option,Izbrana možnost,
Correct,Pravilno,
Wrong,Napačno,
Room Name,soba Ime,
Room Number,Številka sobe,
Seating Capacity,Število sedežev,
House Name,Naslov,
EDU-STU-.YYYY.-,EDU-STU-.YYYY.-,
Student Mobile Number,Študent mobilno številko,
Joining Date,Vstop Datum,
Blood Group,Blood Group,
A+,A +,
A-,A-,
B+,B +,
B-,B-,
O+,O +,
O-,O-,
AB+,AB +,
AB-,AB-,
Nationality,državljanstvo,
Home Address,Domači naslov,
Guardian Details,Guardian Podrobnosti,
Guardians,skrbniki,
Sibling Details,sorodstvena Podrobnosti,
Siblings,Bratje in sestre,
Exit,Izhod,
Date of Leaving,Datum Leaving,
Leaving Certificate Number,Leaving Certificate Število,
Reason For Leaving,Razlog za odhod,
Student Admission,študent Sprejem,
Admission Start Date,Vstop Datum začetka,
Admission End Date,Sprejem Končni datum,
Publish on website,Objavi na spletni strani,
Eligibility and Details,Upravičenost in podrobnosti,
Student Admission Program,Program sprejema študentov,
Minimum Age,Najnižja starost,
Maximum Age,Najvišja starost,
Application Fee,Fee uporaba,
Naming Series (for Student Applicant),Poimenovanje Series (za Student prijavitelja),
LMS Only,Samo LMS,
EDU-APP-.YYYY.-,EDU-APP-YYYY-,
Application Status,Status uporaba,
Application Date,uporaba Datum,
Student Attendance Tool,Študent Udeležba orodje,
Group Based On,Skupina temelji na,
Students HTML,študenti HTML,
Group Based on,"Skupina, ki temelji na",
Student Group Name,Ime študent Group,
Max Strength,Max moč,
Set 0 for no limit,Nastavite 0 za brez omejitev,
Instructors,inštruktorji,
Student Group Creation Tool,Študent orodje za oblikovanje skupine,
Leave blank if you make students groups per year,"Pustite prazno, če bi študenti skupin na leto",
Get Courses,Get Tečaji,
Separate course based Group for every Batch,Ločeno Group s sedežem tečaj za vsako serijo,
Leave unchecked if you don't want to consider batch while making course based groups. ,"Pustite neoznačeno, če ne želite, da razmisli serije, hkrati pa seveda temelji skupin.",
Student Group Creation Tool Course,Orodje za oblikovanje študent Group tečaj,
Course Code,Koda predmeta,
Student Group Instructor,Inštruktor Študent Skupina,
Student Group Student,Študentska skupina Študent,
Group Roll Number,Skupina Roll Število,
Student Guardian,študent Guardian,
Relation,Razmerje,
Mother,mati,
Father,oče,
Student Language,študent jezik,
Student Leave Application,Študent Zapusti Uporaba,
Mark as Present,Označi kot Trenutno,
Student Log,študent Log,
Academic,akademski,
Achievement,dosežek,
Student Report Generation Tool,Orodje za generiranje študentskega poročila,
Include All Assessment Group,Vključi vse ocenjevalne skupine,
Show Marks,Pokaži oznake,
Add letterhead,Dodaj pisemsko glavo,
Print Section,Oddelek za tiskanje,
Total Parents Teacher Meeting,Skupaj učiteljski sestanek staršev,
Attended by Parents,Obiskujejo starši,
Assessment Terms,Pogoji ocenjevanja,
Student Sibling,študent Sorodstvena,
Studying in Same Institute,Študij v istem inštitutu,
NO,ŠT,
YES,DA,
Student Siblings,Študentski Bratje in sestre,
Topic Content,Vsebina teme,
Amazon MWS Settings,Amazonske nastavitve MWS,
ERPNext Integrations,Integracije ERPNext,
Enable Amazon,Omogoči Amazon,
MWS Credentials,MVS poverilnice,
Seller ID,ID prodajalca,
AWS Access Key ID,AWS Access Key ID,
MWS Auth Token,MWS Auth Token,
Market Place ID,ID tržne točke,
AE,AE,
AU,AU,
BR,BR,
CA,CA,
CN,CN,
DE,DE,
ES,ES,
FR,FR,
IN,IN,
JP,JP,
IT,IT,
MX,mx,
UK,Velika Britanija,
US,ZDA,
Customer Type,Vrsta stranke,
Market Place Account Group,Skupina računov na trgu,
After Date,Po datumu,
Amazon will synch data updated after this date,"Amazon bo sinhroniziral podatke, posodobljene po tem datumu",
Sync Taxes and Charges,Sinhronizacija davkov in dajatev,
Get financial breakup of Taxes and charges data by Amazon ,"Get finančno razčlenitev davkov in zaračunavanje podatkov, ki jih Amazon",
Sync Products,Izdelki za sinhronizacijo,
Always sync your products from Amazon MWS before synching the Orders details,Pred sinhronizacijo podrobnosti o naročilih vedno sinhronizirajte izdelke z Amazon MWS,
Sync Orders,Naročila za sinhronizacijo,
Click this button to pull your Sales Order data from Amazon MWS.,"Kliknite ta gumb, da povlečete podatke o prodajnem naročilu iz Amazon MWS.",
Enable Scheduled Sync,Omogočite načrtovano sinhronizacijo,
Check this to enable a scheduled Daily synchronization routine via scheduler,"Preverite to, da omogočite načrtovano dnevno sinhronizacijo prek načrtovalca",
Max Retry Limit,Najvišja poskusna omejitev,
Exotel Settings,Nastavitve Exotela,
Account SID,SID računa,
API Token,API žeton,
GoCardless Mandate,GoCardless mandat,
Mandate,Mandat,
GoCardless Customer,GoCardless stranka,
GoCardless Settings,GoCardless nastavitve,
Webhooks Secret,Webhooks Secret,
Plaid Settings,Nastavitve Plaid,
Synchronize all accounts every hour,Vsako uro sinhronizirajte vse račune,
Plaid Client ID,Plaid ID stranke,
Plaid Secret,Plaid Secret,
Plaid Environment,Plaid okolje,
sandbox,peskovnik,
development,razvoj,
production,proizvodnjo,
QuickBooks Migrator,QuickBooks migrator,
Application Settings,Nastavitve aplikacije,
Token Endpoint,Končna točka žetona,
Scope,Področje uporabe,
Authorization Settings,Nastavitve avtorizacije,
Authorization Endpoint,Končna točka avtorizacije,
Authorization URL,URL avtorizacije,
Quickbooks Company ID,ID podjetja Quickbooks,
Company Settings,Nastavitve podjetja,
Default Shipping Account,Privzeti ladijski račun,
Default Warehouse,Privzeto Skladišče,
Default Cost Center,Privzet Stroškovni Center,
Undeposited Funds Account,Račun nedefiniranih skladov,
Shopify Log,Nakup dnevnika,
Request Data,Zahtevajte podatke,
Shopify Settings,Nakup nastavitev,
status html,status html,
Enable Shopify,Omogoči Shopify,
App Type,Vrsta aplikacije,
Last Sync Datetime,Last Sync Datetime,
Shop URL,URL trgovine,
eg: frappe.myshopify.com,npr .: frappe.myshopify.com,
Shared secret,Skupna skrivnost,
Webhooks Details,Podrobnosti o spletnih urah,
Webhooks,Webhooks,
Customer Settings,Nastavitve stranke,
Default Customer,Privzeta stranka,
Customer Group will set to selected group while syncing customers from Shopify,"Skupina strank bo nastavila na izbrano skupino, medtem ko bo sinhronizirala stranke s spletnim mestom Shopify",
For Company,Za podjetje,
Cash Account will used for Sales Invoice creation,Gotovinski račun se bo uporabil za ustvarjanje prodajne fakture,
Update Price from Shopify To ERPNext Price List,Posodobitev cene od Shopify na ERPNext Cenik,
Default Warehouse to to create Sales Order and Delivery Note,Privzeta skladišče za ustvarjanje prodajnega naročila in dostave,
Sales Order Series,Serija prodajnih naročil,
Import Delivery Notes from Shopify on Shipment,Uvozne opombe za dostavo iz Shopify na pošiljko,
Delivery Note Series,Serija opombe o dostavi,
Import Sales Invoice from Shopify if Payment is marked,"Uvozite račun za prodajo iz Shopify, če je plačilo označeno",
Sales Invoice Series,Serija prodajnih računov,
Shopify Tax Account,Nakup davčnega računa,
Shopify Tax/Shipping Title,Kupujte naslov davka / odpremo,
ERPNext Account,ERPNext račun,
Shopify Webhook Detail,Nakup podrobnosti nakupa,
Webhook ID,ID spletnega koda,
Tally Migration,Tally Migration,
Master Data,Glavni podatki,
"Data exported from Tally that consists of the Chart of Accounts, Customers, Suppliers, Addresses, Items and UOMs","Podatki, izvoženi iz podjetja Tally, ki jih sestavljajo kontni načrt, kupci, dobavitelji, naslovi, predmeti in UOM",
Is Master Data Processed,Ali so glavni podatki obdelani,
Is Master Data Imported,Ali so uvoženi glavni podatki,
Tally Creditors Account,Račun upnikov Tally,
Creditors Account set in Tally,Račun upnikov nastavljen v Tally,
Tally Debtors Account,Račun dolžnikov Tally,
Debtors Account set in Tally,Račun dolžnikov nastavljen v Tally,
Tally Company,Tally Company,
Company Name as per Imported Tally Data,Ime podjetja po uvoženih podatkih o seštevkih,
Default UOM,Privzeti UOM,
UOM in case unspecified in imported data,"UOM v primeru, da v uvoženih podatkih ni določeno",
ERPNext Company,Podjetje ERPNext,
Your Company set in ERPNext,Vaše podjetje nastavljeno v ERPNext,
Processed Files,Obdelane datoteke,
Parties,Pogodbenice,
UOMs,UOMs,
Vouchers,Vavčerji,
Round Off Account,Zaokrožijo račun,
Day Book Data,Podatki o dnevnih knjigah,
Day Book Data exported from Tally that consists of all historic transactions,"Podatki dnevne knjige, izvoženi iz podjetja Tally, ki vključujejo vse pretekle transakcije",
Is Day Book Data Processed,Ali so podatki o dnevnikih obdelani,
Is Day Book Data Imported,Ali so uvoženi podatki o dnevnikih,
Woocommerce Settings,Nastavitve Woocommerce,
Enable Sync,Omogoči sinhronizacijo,
Woocommerce Server URL,URL strežnika Woocommerce,
Secret,Skrivnost,
API consumer key,API-ključ potrošnika,
API consumer secret,API potrošnikov skrivnost,
Tax Account,Davčni račun,
Freight and Forwarding Account,Tovorni in posredniški račun,
Creation User,Uporabnik ustvarjanja,
"The user that will be used to create Customers, Items and Sales Orders. This user should have the relevant permissions.","Uporabnik, ki bo uporabljen za ustvarjanje kupcev, izdelkov in prodajnih naročil. Ta uporabnik mora imeti ustrezna dovoljenja.",
"This warehouse will be used to create Sales Orders. The fallback warehouse is ""Stores"".",To skladišče bo uporabljeno za izdelavo prodajnih naročil. Rezervno skladišče so &quot;Trgovine&quot;.,
"The fallback series is ""SO-WOO-"".",Nadomestna serija je &quot;SO-WOO-&quot;.,
This company will be used to create Sales Orders.,To podjetje bo uporabljeno za ustvarjanje prodajnih naročil.,
Delivery After (Days),Dostava po (dneh),
This is the default offset (days) for the Delivery Date in Sales Orders. The fallback offset is 7 days from the order placement date.,To je privzeti odmik (dni) za datum dostave v prodajnih nalogah. Nadomestilo nadomestitve je 7 dni od datuma oddaje naročila.,
"This is the default UOM used for items and Sales orders. The fallback UOM is ""Nos"".","To je privzeti UOM, ki se uporablja za predmete in prodajna naročila. Rezervni UOM je &quot;št.&quot;",
Endpoints,Končne točke,
Endpoint,Končna točka,
Antibiotic Name,Ime antibiotika,
Healthcare Administrator,Skrbnik zdravstva,
Laboratory User,Laboratorijski uporabnik,
Is Inpatient,Je bolnišnična,
Default Duration (In Minutes),Privzeto trajanje (v minutah),
Body Part,Del telesa,
Body Part Link,Povezava dela telesa,
HLC-CPR-.YYYY.-,HLC-CPR-.GGGG.-,
Procedure Template,Predloga postopka,
Procedure Prescription,Postopek Predpis,
Service Unit,Servisna enota,
Consumables,Potrošni material,
Consume Stock,Porabi zalogo,
Invoice Consumables Separately,Potrošni material za račune ločeno,
Consumption Invoiced,Poraba zaračunana,
Consumable Total Amount,Potrošni celotni znesek,
Consumption Details,Podrobnosti o porabi,
Nursing User,Uporabnik zdravstvene nege,
Clinical Procedure Item,Postavka kliničnega postopka,
Invoice Separately as Consumables,Račun ločeno kot potrošni material,
Transfer Qty,Prenos količine,
Actual Qty (at source/target),Dejanska Količina (pri viru / cilju),
Is Billable,Je zaračunljiv,
Allow Stock Consumption,Dovolite porabo zalog,
Sample UOM,Vzorec UOM,
Collection Details,Podrobnosti o zbirki,
Change In Item,Spremeni element,
Codification Table,Tabela kodifikacije,
Complaints,Pritožbe,
Dosage Strength,Odmerek,
Strength,Moč,
Drug Prescription,Predpis o drogah,
Drug Name / Description,Ime / opis zdravila,
Dosage,Odmerjanje,
Dosage by Time Interval,Odmerjanje po časovnem intervalu,
Interval,Interval,
Interval UOM,Interval UOM,
Hour,Ura,
Update Schedule,Posodobi urnik,
Exercise,Vadba,
Difficulty Level,Težavnost,
Counts Target,Šteje tarča,
Counts Completed,Štetja dokončana,
Assistance Level,Raven pomoči,
Active Assist,Aktivna asistenca,
Exercise Name,Ime vadbe,
Body Parts,Deli telesa,
Exercise Instructions,Navodila za vadbo,
Exercise Video,Video za vajo,
Exercise Steps,Koraki za vadbo,
Steps,Koraki,
Steps Table,Tabela korakov,
Exercise Type Step,Korak vrste vadbe,
Max number of visit,Največje število obiska,
Visited yet,Obiskal še,
Reference Appointments,Referenčni sestanki,
Valid till,Veljavno do,
Fee Validity Reference,Referenca veljavnosti provizije,
Basic Details,Osnovne podrobnosti,
HLC-PRAC-.YYYY.-,FHP-PRAC-.LLLL.-,
Mobile,Mobile,
Phone (R),Telefon (R),
Phone (Office),Telefon (Office),
Employee and User Details,Podrobnosti o zaposlenem in uporabniku,
Hospital,Bolnišnica,
Appointments,Imenovanja,
Practitioner Schedules,Urniki zdravnikov,
Charges,Dajatve,
Out Patient Consulting Charge,Strošek svetovanja za pacienta,
Default Currency,Privzeta valuta,
Healthcare Schedule Time Slot,Časovni razpored zdravstvenega varstva,
Parent Service Unit,Enota starševske službe,
Service Unit Type,Vrsta enote storitev,
Allow Appointments,Dovoli imenovanja,
Allow Overlap,Dovoli prekrivanje,
Inpatient Occupancy,Bolnišnično zasedbo,
Occupancy Status,Status zasedenosti,
Vacant,Prazen,
Occupied,Zasedeno,
Item Details,Podrobni podatki,
UOM Conversion in Hours,Pretvorba UOM v urah,
Rate / UOM,Oceni / UOM,
Change in Item,Spremeni v postavki,
Out Patient Settings,Out Patient Settings,
Patient Name By,Ime bolnika z,
Patient Name,Ime bolnika,
Link Customer to Patient,Povežite stranko s pacientom,
"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.","Če je označeno, bo stranka ustvarjena, mapirana na Patient. Pacientovi računi bodo ustvarjeni proti tej Stranki. Med ustvarjanjem bolnika lahko izberete tudi obstoječo stranko.",
Default Medical Code Standard,Privzeti standard za medicinsko kodo,
Collect Fee for Patient Registration,Zberi pristojbino za registracijo pacientov,
Checking this will create new Patients with a Disabled status by default and will only be enabled after invoicing the Registration Fee.,"Če to potrdite, bodo privzeto ustvarjeni novi bolniki s statusom invalida, ki bodo omogočeni šele po izstavitvi računa za registracijo.",
Registration Fee,Kotizacija,
Automate Appointment Invoicing,Avtomatizirajte izdajanje računov,
Manage Appointment Invoice submit and cancel automatically for Patient Encounter,Upravljanje s pripisom Imetnik samodejno predloži in samodejno prekliče za srečanje bolnikov,
Enable Free Follow-ups,Omogočite brezplačne nadaljnje ukrepe,
Number of Patient Encounters in Valid Days,Število srečanj bolnikov v veljavnih dneh,
The number of free follow ups (Patient Encounters in valid days) allowed,Dovoljeno število brezplačnih nadaljnjih pregledov (srečanja bolnikov v veljavnih dneh),
Valid Number of Days,Veljavno število dni,
Time period (Valid number of days) for free consultations,Časovno obdobje (veljavno število dni) za brezplačna posvetovanja,
Default Healthcare Service Items,Privzeti predmeti zdravstvenih storitev,
"You can configure default Items for billing consultation charges, procedure consumption items and inpatient visits","Konfigurirate lahko privzete postavke za zaračunavanje stroškov posvetovanja, postavke porabe postopkov in bolnišnične obiske",
Clinical Procedure Consumable Item,Klinični postopek Potrošni element,
Default Accounts,Privzeti računi,
Default income accounts to be used if not set in Healthcare Practitioner to book Appointment charges.,"Računovodski izkazi za neplačane zneske, ki se uporabljajo, če zdravnik ni določil za knjiženje pristojbin za imenovanja.",
Default receivable accounts to be used to book Appointment charges.,"Privzeti računi terjatev, ki se bodo uporabljali za knjiženje stroškov imenovanja.",
Out Patient SMS Alerts,Out Patient SMS Opozorila,
Patient Registration,Registracija pacientov,
Registration Message,Registracija sporočilo,
Confirmation Message,Potrditveno sporočilo,
Avoid Confirmation,Izogibajte se potrditvi,
Do not confirm if appointment is created for the same day,"Ne potrdite, če je sestanek ustvarjen za isti dan",
Appointment Reminder,Opomnik o imenovanju,
Reminder Message,Opomnik,
Remind Before,Opomni pred,
Laboratory Settings,Laboratorijske nastavitve,
Create Lab Test(s) on Sales Invoice Submission,Ustvarite laboratorijske teste za oddajo računa za prodajo,
Checking this will create Lab Test(s) specified in the Sales Invoice on submission.,"Če to preverite, boste ob oddaji ustvarili laboratorijske teste, navedene v prodajnem računu.",
Create Sample Collection document for Lab Test,Ustvarite dokument z zbirko vzorcev za laboratorijski test,
Checking this will create a Sample Collection document  every time you create a Lab Test,"Če to preverite, boste vsakič, ko ustvarite laboratorijski test, ustvarili dokument z zbirko vzorcev",
Employee name and designation in print,Ime in oznaka zaposlenega v tiskani obliki,
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.,"Potrdite to, če želite, da se ime in ime zaposlenega, povezanega z uporabnikom, ki predloži dokument, natisne v poročilu o laboratorijskih preizkusih.",
Do not print or email Lab Tests without Approval,Brez odobritve ne tiskajte ali pošiljajte laboratorijskih testov po e-pošti,
Checking this will restrict printing and emailing of Lab Test documents unless they have the status as Approved.,"Če to preverite, boste omejili tiskanje in pošiljanje dokumentov laboratorijskih testov po e-pošti, razen če imajo status Odobreno.",
Custom Signature in Print,Podpis po meri v tisku,
Laboratory SMS Alerts,Laboratorijske opozorila SMS,
Result Printed Message,Rezultat Natisnjeno sporočilo,
Result Emailed Message,Rezultat po e-pošti,
Check In,Prijava,
Check Out,Preveri,
HLC-INP-.YYYY.-,HLC-INP-.LLLL.-,
A Positive,Pozitiven,
A Negative,Negativno,
AB Positive,AB pozitivno,
AB Negative,AB negativno,
B Positive,B Pozitivni,
B Negative,B Negativno,
O Positive,O Pozitivno,
O Negative,O Negativno,
Date of birth,Datum rojstva,
Admission Scheduled,Vstop je načrtovan,
Discharge Scheduled,Razrešnica načrtovana,
Discharged,Razrešeno,
Admission Schedule Date,Datum vstopnice,
Admitted Datetime,Sprejeto Datetime,
Expected Discharge,Pričakovano odvajanje,
Discharge Date,Datum odvajanja,
Lab Prescription,Laboratorijski recept,
Lab Test Name,Ime laboratorijskega testa,
Test Created,Ustvarjeno testiranje,
Submitted Date,Datum predložitve,
Approved Date,Odobren datum,
Sample ID,Vzorec ID,
Lab Technician,Laboratorijski tehnik,
Report Preference,Prednost poročila,
Test Name,Ime preskusa,
Test Template,Preskusna predloga,
Test Group,Testna skupina,
Custom Result,Rezultat po meri,
LabTest Approver,Odobritev LabTest,
Add Test,Dodaj test,
Normal Range,Normalni obseg,
Result Format,Format zapisa,
Single,Samski,
Compound,Spojina,
Descriptive,Opisno,
Grouped,Združeno,
No Result,Ne Rezultat,
This value is updated in the Default Sales Price List.,Ta vrednost se posodablja na seznamu Privzeta prodajna cena.,
Lab Routine,Lab Routine,
Result Value,Vrednost rezultata,
Require Result Value,Zahtevajte vrednost rezultata,
Normal Test Template,Običajna preskusna predloga,
Patient Demographics,Demografija pacienta,
HLC-PAT-.YYYY.-,HLC-PAT-.GGGG.-,
Middle Name (optional),Srednje ime (neobvezno),
Inpatient Status,Bolnišnično stanje,
"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.","Če je v nastavitvah zdravstvenega varstva označena možnost »Poveži stranko s pacientom« in obstoječa stranka ni izbrana, bo za tega pacienta ustvarjena stranka za beleženje transakcij v modulu Računi.",
Personal and Social History,Osebna in socialna zgodovina,
Marital Status,Zakonski stan,
Married,Poročen,
Divorced,Ločen,
Widow,Vdova,
Patient Relation,Pacientovo razmerje,
"Allergies, Medical and Surgical History","Alergije, medicinska in kirurška zgodovina",
Allergies,Alergije,
Medication,Zdravila,
Medical History,Zdravstvena zgodovina,
Surgical History,Kirurška zgodovina,
Risk Factors,Dejavniki tveganja,
Occupational Hazards and Environmental Factors,Poklicne nevarnosti in dejavniki okolja,
Other Risk Factors,Drugi dejavniki tveganja,
Patient Details,Podrobnosti bolnika,
Additional information regarding the patient,Dodatne informacije o bolniku,
HLC-APP-.YYYY.-,HLC-APP-.LLLL.-,
Patient Age,Pacientova doba,
Get Prescribed Clinical Procedures,Pridobite predpisane klinične postopke,
Therapy,Terapija,
Get Prescribed Therapies,Pridobite predpisane terapije,
Appointment Datetime,Imenovanje Datum in čas,
Duration (In Minutes),Trajanje (v minutah),
Reference Sales Invoice,Referenčni prodajni račun,
More Info,Več informacij,
Referring Practitioner,Referenčni zdravnik,
Reminded,Opomniti,
HLC-PA-.YYYY.-,HLC-PA-.LLLL.-,
Assessment Template,Predloga ocenjevanja,
Assessment Datetime,Datum in čas ocene,
Assessment Description,Opis ocene,
Assessment Sheet,Ocenjevalni list,
Total Score Obtained,Skupna pridobljena ocena,
Scale Min,Lestvica Min,
Scale Max,Lestvica Max,
Patient Assessment Detail,Podrobnosti o oceni bolnika,
Assessment Parameter,Parameter ocenjevanja,
Patient Assessment Parameter,Parameter ocene bolnika,
Patient Assessment Sheet,Pregled bolnika,
Patient Assessment Template,Predloga za oceno bolnika,
Assessment Parameters,Ocenjevalni parametri,
Parameters,Parametri,
Assessment Scale,Ocenjevalna lestvica,
Scale Minimum,Lestvica Minimum,
Scale Maximum,Scale Maximum,
HLC-ENC-.YYYY.-,HLC-ENC-.GGGG.-,
Encounter Date,Datum srečanja,
Encounter Time,Čas srečanja,
Encounter Impression,Ujemanje prikaza,
Symptoms,Simptomi,
In print,V tisku,
Medical Coding,Zdravniško kodiranje,
Procedures,Postopki,
Therapies,Terapije,
Review Details,Pregled podrobnosti,
Patient Encounter Diagnosis,Diagnoza srečanja pacientov,
Patient Encounter Symptom,Simptom pacientovega srečanja,
HLC-PMR-.YYYY.-,HLC-PMR-YYYY.-,
Attach Medical Record,Priložite zdravstveni karton,
Reference DocType,Referenčni DocType,
Spouse,Zakonec,
Family,Družina,
Schedule Details,Podrobnosti urnika,
Schedule Name,Ime seznama,
Time Slots,Časovne reže,
Practitioner Service Unit Schedule,Urnik službe zdravnika,
Procedure Name,Ime postopka,
Appointment Booked,Imenovanje rezervirano,
Procedure Created,Ustvarjen postopek,
HLC-SC-.YYYY.-,HLC-SC-.YYYY.-,
Collected By,Zbrane z,
Particulars,Podrobnosti,
Result Component,Komponenta rezultata,
HLC-THP-.YYYY.-,HLC-THP-.LLLL.-,
Therapy Plan Details,Podrobnosti načrta terapije,
Total Sessions,Skupno število sej,
Total Sessions Completed,Skupno število zaključenih sej,
Therapy Plan Detail,Podrobnosti načrta terapije,
No of Sessions,Število sej,
Sessions Completed,Seje zaključene,
Tele,Tele,
Exercises,Vaje,
Therapy For,Terapija za,
Add Exercises,Dodajte vaje,
Body Temperature,Temperatura telesa,
Presence of a fever (temp &gt; 38.5 °C/101.3 °F or sustained temp &gt; 38 °C/100.4 °F),"Prisotnost vročine (temp&gt; 38,5 ° C / 101,3 ° F ali trajne temp&gt; 38 ° C / 100,4 ° F)",
Heart Rate / Pulse,Srčni utrip / pulz,
Adults' pulse rate is anywhere between 50 and 80 beats per minute.,Srčni utrip odraslih je med 50 in 80 utripov na minuto.,
Respiratory rate,Stopnja dihanja,
Normal reference range for an adult is 16–20 breaths/minute (RCP 2012),Normalno referenčno območje za odraslo osebo je 16-20 vdihov / minut (RCP 2012),
Tongue,Jezik,
Coated,Prevlečen,
Very Coated,Zelo prevlečen,
Normal,Normalno,
Furry,Furry,
Cuts,Kosi,
Abdomen,Trebuh,
Bloated,Napihnjen,
Fluid,Tekočina,
Constipated,Zaprta,
Reflexes,Refleksi,
Hyper,Hyper,
Very Hyper,Zelo Hyper,
One Sided,Enostransko,
Blood Pressure (systolic),Krvni tlak (sistolični),
Blood Pressure (diastolic),Krvni tlak (diastolični),
Blood Pressure,Krvni pritisk,
"Normal resting blood pressure in an adult is approximately 120 mmHg systolic, and 80 mmHg diastolic, abbreviated ""120/80 mmHg""","Normalni krvni tlak pri odraslih je približno 120 mmHg sistoličnega in 80 mmHg diastoličnega, okrajšanega &quot;120/80 mmHg&quot;",
Nutrition Values,Prehranske vrednosti,
Height (In Meter),Višina (v metrih),
Weight (In Kilogram),Teža (v kilogramih),
BMI,ITM,
Hotel Room,Hotelska soba,
Hotel Room Type,Tip sobe hotela,
Capacity,Zmogljivost,
Extra Bed Capacity,Zmogljivost dodatnega ležišča,
Hotel Manager,Hotel Manager,
Hotel Room Amenity,Hotelska ugodnost,
Billable,Plačljivo,
Hotel Room Package,Paket za hotelske sobe,
Amenities,Amenities,
Hotel Room Pricing,Cene hotelske sobe,
Hotel Room Pricing Item,Postavka hotelske sobe,
Hotel Room Pricing Package,Paket hotelskih cen,
Hotel Room Reservation,Rezervacija hotelske sobe,
Guest Name,Ime gosta,
Late Checkin,Pozno preverjanje,
Booked,Rezervirano,
Hotel Reservation User,Uporabnik rezervacije hotela,
Hotel Room Reservation Item,Rezervacija za hotelsko sobo,
Hotel Settings,Hotelske nastavitve,
Default Taxes and Charges,Privzete Davki in dajatve,
Default Invoice Naming Series,Privzeto imenovanje računov,
Additional Salary,Dodatna plača,
HR,Človeški viri,
HR-ADS-.YY.-.MM.-,HR-ADS-.YY .-. MM.-,
Salary Component,plača Component,
Overwrite Salary Structure Amount,Znesek nadomestila plače prepišite,
Deduct Full Tax on Selected Payroll Date,Odšteti polni davek na izbrani datum plače,
Payroll Date,Datum plačila,
Date on which this component is applied,"Datum, ko je ta komponenta uporabljena",
Salary Slip,Plača listek,
Salary Component Type,Vrsta plačne komponente,
HR User,Uporabnik človeških virov,
Appointment Letter,Pismo o imenovanju,
Job Applicant,Job Predlagatelj,
Applicant Name,Predlagatelj Ime,
Appointment Date,Datum imenovanja,
Appointment Letter Template,Predloga pisma o imenovanju,
Body,Telo,
Closing Notes,Zaključne opombe,
Appointment Letter content,Vsebina pisma o vsebini,
Appraisal,Cenitev,
HR-APR-.YY.-.MM.,HR-APR-.YY.-.MM.,
Appraisal Template,Cenitev Predloga,
For Employee Name,Za imena zaposlenih,
Goals,Cilji,
Total Score (Out of 5),Skupna ocena (od 5),
"Any other remarks, noteworthy effort that should go in the records.","Kakršne koli druge pripombe, omembe vredna napora, da bi moral iti v evidencah.",
Appraisal Goal,Cenitev cilj,
Key Responsibility Area,Key Odgovornost Area,
Weightage (%),Weightage (%),
Score (0-5),Ocena (0-5),
Score Earned,Rezultat Zaslužili,
Appraisal Template Title,Cenitev Predloga Naslov,
Appraisal Template Goal,Cenitev Predloga cilj,
KRA,KRA,
Key Performance Area,Key Uspešnost Area,
HR-ATT-.YYYY.-,HR-ATT-.YYYY.-,
On Leave,Na dopustu,
Work From Home,Delo z doma,
Leave Application,Zapusti Application,
Attendance Date,Udeležba Datum,
Attendance Request,Zahteva za udeležbo,
Late Entry,Počasen vpis,
Early Exit,Zgodnji izhod,
Half Day Date,Poldnevni datum,
On Duty,Na dolžnosti,
Explanation,Pojasnilo,
Compensatory Leave Request,Zahtevek za kompenzacijski odhod,
Leave Allocation,Pustite Dodelitev,
Worked On Holiday,Delal na počitnicah,
Work From Date,Delo od datuma,
Work End Date,Datum zaključka dela,
Email Sent To,E-poštno sporočilo poslano na,
Select Users,Izberite Uporabniki,
Send Emails At,Pošlji e-pošte na,
Reminder,Opomnik,
Daily Work Summary Group User,Uporabnik dnevnega dela Povzetek dela,
email,E-naslov,
Parent Department,Oddelek za starše,
Leave Block List,Pustite Block List,
Days for which Holidays are blocked for this department.,"Dni, za katere so Holidays blokirana za ta oddelek.",
Leave Approver,Pustite odobritelju,
Expense Approver,Expense odobritelj,
Department Approver,Odobreni oddelek,
Approver,Odobritelj,
Required Skills,Zahtevane veščine,
Skills,Spretnosti,
Designation Skill,Naziv spretnosti,
Skill,Spretnost,
Driver,Voznik,
HR-DRI-.YYYY.-,HR-DRI-.YYYY.-,
Suspended,Suspendirano,
Transporter,Transporter,
Applicable for external driver,Velja za zunanjega voznika,
Cellphone Number,številka mobilnega telefona,
License Details,Podrobnosti o licenci,
License Number,Številka licence,
Issuing Date,Datum izdaje,
Driving License Categories,Kategorije vozniških dovoljenj,
Driving License Category,Kategorija vozniškega dovoljenja,
Fleet Manager,Fleet Manager,
Driver licence class,Razred vozniških dovoljenj,
HR-EMP-,HR-EMP-,
Employment Type,Vrsta zaposlovanje,
Emergency Contact,Zasilna Kontakt,
Emergency Contact Name,Ime stika za nujne primere,
Emergency Phone,Zasilna Telefon,
ERPNext User,Uporabnik ERPNext,
"System User (login) ID. If set, it will become default for all HR forms.","Sistem uporabniku (login) ID. Če je nastavljeno, bo postala privzeta za vse oblike HR.",
Create User Permission,Ustvarite dovoljenje za uporabnika,
This will restrict user access to other employee records,To bo uporabniku omejilo dostop do drugih zapisov zaposlenih,
Joining Details,Povezovanje Podrobnosti,
Offer Date,Ponudba Datum,
Confirmation Date,Datum potrditve,
Contract End Date,Naročilo End Date,
Notice (days),Obvestilo (dni),
Date Of Retirement,Datum upokojitve,
Department and Grade,Oddelek in razred,
Reports to,Poročila,
Attendance and Leave Details,Podrobnosti o udeležbi in odhodih,
Leave Policy,Leave Policy,
Attendance Device ID (Biometric/RF tag ID),ID naprave za udeležbo (ID biometrične / RF oznake),
Applicable Holiday List,Velja Holiday Seznam,
Default Shift,Privzeti premik,
Salary Details,Podrobnosti o plačah,
Salary Mode,Način plače,
Bank A/C No.,Bank A / C No.,
Health Insurance,Zdravstveno zavarovanje,
Health Insurance Provider,Ponudnik zdravstvenega zavarovanja,
Health Insurance No,Zdravstveno zavarovanje št,
Prefered Email,Prednostna pošta,
Personal Email,Osebna Email,
Permanent Address Is,Stalni naslov je,
Rented,Najemu,
Owned,Lasti,
Permanent Address,stalni naslov,
Prefered Contact Email,Prednostna Kontaktni e-naslov,
Company Email,Družba E-pošta,
Provide Email Address registered in company,Navedite e-poštni naslov je registriran v podjetju,
Current Address Is,Trenutni Naslov je,
Current Address,Trenutni naslov,
Personal Bio,Osebni Bio,
Bio / Cover Letter,Bio / Cover Letter,
Short biography for website and other publications.,Kratka biografija za spletne strani in drugih publikacij.,
Passport Number,Številka potnega lista,
Date of Issue,Datum izdaje,
Place of Issue,Kraj izdaje,
Widowed,Ovdovela,
Family Background,Družina Ozadje,
"Here you can maintain family details like name and occupation of parent, spouse and children","Tukaj lahko hranite družinske podrobnosti, kot so ime in poklic staršev, zakonca in otrok",
Health Details,Podrobnosti zdravja,
"Here you can maintain height, weight, allergies, medical concerns etc","Tukaj lahko hranite višino, težo, alergije, zdravstvene pomisleke in podobno",
Educational Qualification,Izobraževalni Kvalifikacije,
Previous Work Experience,Prejšnja Delovne izkušnje,
External Work History,Zunanji Delo Zgodovina,
History In Company,Zgodovina v družbi,
Internal Work History,Notranji Delo Zgodovina,
Resignation Letter Date,Odstop pismo Datum,
Relieving Date,Lajšanje Datum,
Reason for Leaving,Razlog za odhod,
Leave Encashed?,Dopusta unovčijo?,
Encashment Date,Vnovčevanje Datum,
New Workplace,Novo delovno mesto,
HR-EAD-.YYYY.-,HR-EAD-.LLLL.-,
Returned Amount,Vrnjeni znesek,
Claimed,Zahtevana,
Advance Account,Predplačniški račun,
Employee Attendance Tool,Zaposleni Udeležba Tool,
Unmarked Attendance,neoznačena in postrežbo,
Employees HTML,zaposleni HTML,
Marked Attendance,Zabeležena Udeležba,
Marked Attendance HTML,Zabeležena Udeležba HTML,
Employee Benefit Application,Application Employee Benefit,
Max Benefits (Yearly),Maksimalne ugodnosti (letno),
Remaining Benefits (Yearly),Preostale koristi (letno),
Payroll Period,Obdobje plačevanja,
Benefits Applied,"Prednosti, ki se uporabljajo",
Dispensed Amount (Pro-rated),Razdeljeni znesek (Pro-rated),
Employee Benefit Application Detail,Podrobnosti o uporabi programa za zaposlene,
Earning Component,Zmagovalna komponenta,
Pay Against Benefit Claim,Neupravičeno plačilo,
Max Benefit Amount,Max Benefit znesek,
Employee Benefit Claim,Zahtevek za zaposlene,
Claim Date,Datum zahtevka,
Benefit Type and Amount,Vrsta in znesek ugodnosti,
Claim Benefit For,Claim Benefit For,
Max Amount Eligible,Najvišji znesek je primeren,
Expense Proof,Dokazilo o stroških,
Employee Boarding Activity,Aktivnost vkrcanja zaposlenih,
Activity Name,Ime dejavnosti,
Task Weight,naloga Teža,
Required for Employee Creation,Potreben za ustvarjanje zaposlenih,
Applicable in the case of Employee Onboarding,Velja za zaposlene na vozilu,
Employee Checkin,Zaposleni Checkin,
Log Type,Vrsta dnevnika,
OUT,ZUNAJ,
Location / Device ID,Lokacija / ID naprave,
Skip Auto Attendance,Preskočite samodejno udeležbo,
Shift Start,Shift Start,
Shift End,Shift End,
Shift Actual Start,Dejanski začetek premika,
Shift Actual End,Dejanski konec premika,
Employee Education,Izobraževanje delavec,
School/University,Šola / univerza,
Graduate,Maturirati,
Post Graduate,Post Graduate,
Under Graduate,Pod Graduate,
Year of Passing,"Leto, ki poteka",
Class / Percentage,Razred / Odstotek,
Major/Optional Subjects,Glavni / Izbirni predmeti,
Employee External Work History,Delavec Zunanji Delo Zgodovina,
Total Experience,Skupaj Izkušnje,
Default Leave Policy,Privzeti pravilnik o zapustitvi,
Default Salary Structure,Privzeta plačna struktura,
Employee Group Table,Tabela skupin zaposlenih,
ERPNext User ID,ID uporabnika ERPNext,
Employee Health Insurance,Zdravstveno zavarovanje zaposlenih,
Health Insurance Name,Ime zdravstvenega zavarovanja,
Employee Incentive,Spodbujanje zaposlenih,
Incentive Amount,Spodbujevalni znesek,
Employee Internal Work History,Zaposleni Notranji Delo Zgodovina,
Employee Onboarding,Zaposleni na vozilu,
Notify users by email,Uporabnike obvestite po e-pošti,
Employee Onboarding Template,Predloga za vknjiževanje zaposlenih,
Activities,Dejavnosti,
Employee Onboarding Activity,Aktivnost vkrcanja zaposlenih,
Employee Other Income,Drugi dohodki zaposlenih,
Employee Promotion,Promocija zaposlenih,
Promotion Date,Datum promocije,
Employee Promotion Details,Podrobnosti o napredovanju zaposlenih,
Employee Promotion Detail,Podrobnosti o napredovanju zaposlenih,
Employee Property History,Zgodovina lastnine zaposlenih,
Employee Separation,Razdelitev zaposlenih,
Employee Separation Template,Predloga za ločevanje zaposlenih,
Exit Interview Summary,Izhod iz povzetka intervjujev,
Employee Skill,Spretnost zaposlenih,
Proficiency,Strokovnost,
Evaluation Date,Datum ocenjevanja,
Employee Skill Map,Zemljevid spretnosti zaposlenih,
Employee Skills,Spretnosti zaposlenih,
Trainings,Treningi,
Employee Tax Exemption Category,Kategorija oprostitve plačila davka za zaposlene,
Max Exemption Amount,Najvišji znesek oprostitve,
Employee Tax Exemption Declaration,Izjava o davčni oprostitvi za zaposlene,
Declarations,Izjave,
Total Declared Amount,Skupni prijavljeni znesek,
Total Exemption Amount,Skupni znesek oprostitve,
Employee Tax Exemption Declaration Category,Kategorija izjave o oprostitvi davka na zaposlene,
Exemption Sub Category,Podskupina za izvzetje,
Exemption Category,Kategorija izvzetja,
Maximum Exempted Amount,Najvišja oproščena količina,
Declared Amount,Deklarirani znesek,
Employee Tax Exemption Proof Submission,Predložitev dokazila o oprostitvi davka na zaposlene,
Submission Date,Datum oddaje,
Tax Exemption Proofs,Dokazi o davčni oprostitvi,
Total Actual Amount,Skupni dejanski znesek,
Employee Tax Exemption Proof Submission Detail,Dodatek o predložitvi dokazila o oprostitvi davka na zaposlene,
Maximum Exemption Amount,Najvišji znesek oprostitve,
Type of Proof,Vrsta dokazila,
Actual Amount,Dejanski znesek,
Employee Tax Exemption Sub Category,Podrazdelek za davčne oprostitve za zaposlene,
Tax Exemption Category,Kategorija davčne oprostitve,
Employee Training,Usposabljanje zaposlenih,
Training Date,Datum usposabljanja,
Employee Transfer,Prenos zaposlenih,
Transfer Date,Datum prenosa,
Employee Transfer Details,Podrobnosti o prenosu zaposlenih,
Employee Transfer Detail,Podrobnosti o prenosu zaposlencev,
Re-allocate Leaves,Ponovno dodelite listi,
Create New Employee Id,Ustvari ID novega zaposlenega,
New Employee ID,Novo zaposlitveno ime,
Employee Transfer Property,Lastnina za prenos zaposlencev,
HR-EXP-.YYYY.-,HR-EXP-YYYY-,
Expense Taxes and Charges,Davek na dajatve in dajatve,
Total Sanctioned Amount,Skupaj sankcionirano Znesek,
Total Advance Amount,Skupni znesek vnaprej,
Total Claimed Amount,Skupaj zahtevani znesek,
Total Amount Reimbursed,"Skupnega zneska, povrnjenega",
Vehicle Log,vozilo Log,
Employees Email Id,Zaposleni Email Id,
More Details,Več podrobnosti,
Expense Claim Account,Expense Zahtevek računa,
Expense Claim Advance,Advance Claim Advance,
Unclaimed amount,Nezahteven znesek,
Expense Claim Detail,Expense Zahtevek Detail,
Expense Date,Expense Datum,
Expense Claim Type,Expense Zahtevek Type,
Holiday List Name,Naziv seznama praznikov,
Total Holidays,Skupaj prazniki,
Add Weekly Holidays,Dodaj tedenske počitnice,
Weekly Off,Tedenski Off,
Add to Holidays,Dodaj v praznike,
Holidays,Prazniki,
Clear Table,Počisti tabelo,
HR Settings,Nastavitve človeških virov,
Employee Settings,Nastavitve zaposlenih,
Retirement Age,upokojitvena starost,
Enter retirement age in years,Vnesite upokojitveno starost v letih,
Stop Birthday Reminders,Stop Birthday opomniki,
Expense Approver Mandatory In Expense Claim,Odobritev stroškov je obvezna v zahtevi za odhodke,
Payroll Settings,Nastavitve plače,
Leave,Pustite,
Max working hours against Timesheet,Max delovne ure pred Timesheet,
Include holidays in Total no. of Working Days,Vključi počitnice v Total no. delovnih dni,
"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Če je označeno, Total no. delovnih dni bo vključeval praznike, in to se bo zmanjšala vrednost plač dan na",
"If checked, hides and disables Rounded Total field in Salary Slips","Če je označeno, se v plačah zakriva in onemogoči polje Zaokroženo skupno",
The fraction of daily wages to be paid for half-day attendance,"Del dnevnih plač, ki se izplača za poldnevno udeležbo",
Email Salary Slip to Employee,Email Plača Slip na zaposlenega,
Emails salary slip to employee based on preferred email selected in Employee,"E-pošta plačilni list na zaposlenega, ki temelji na prednostni e-pošti izbrani na zaposlenega",
Encrypt Salary Slips in Emails,Šifrirajte plačne spodrsljaje v e-pošti,
"The salary slip emailed to the employee will be password protected, the password will be generated based on the password policy.","Potrdilo o plači, poslano zaposlenemu, bo zaščiteno z geslom, geslo bo ustvarjeno na podlagi pravilnika o geslu.",
Password Policy,Politika gesla,
<b>Example:</b> SAL-{first_name}-{date_of_birth.year} <br>This will generate a password like SAL-Jane-1972,"<b>Primer:</b> SAL- {first_name} - {datum_of_birth.year} <br> To bo ustvarilo geslo, kot je SAL-Jane-1972",
Leave Settings,Pustite nastavitve,
Leave Approval Notification Template,Zapusti predlogo za odobritev odobritve,
Leave Status Notification Template,Zapusti predlogo o statusu obvestila,
Role Allowed to Create Backdated Leave Application,Vloga dovoljena za ustvarjanje programa za nazaj,
Leave Approver Mandatory In Leave Application,Pustite odobritev obvezno v odjavi,
Show Leaves Of All Department Members In Calendar,Prikaži liste vseh članov oddelka v koledarju,
Auto Leave Encashment,Samodejno zapustite enkaš,
Hiring Settings,Nastavitve najema,
Check Vacancies On Job Offer Creation,Preverite prosta delovna mesta pri ustvarjanju ponudbe delovnih mest,
Identification Document Type,Vrsta identifikacijskega dokumenta,
Effective from,Učinkovito od,
Allow Tax Exemption,Dovoli oprostitev davka,
"If enabled, Tax Exemption Declaration will be considered for income tax calculation.","Če je omogočena, bo za izračun davka od dohodka upoštevana izjava o oprostitvi davka.",
Standard Tax Exemption Amount,Standardni znesek oprostitve davka,
Taxable Salary Slabs,Obdavčljive pločevine,
Taxes and Charges on Income Tax,Davki in davki od dohodka,
Other Taxes and Charges,Drugi davki in dajatve,
Income Tax Slab Other Charges,Druge dajatve za davek od dohodka,
Min Taxable Income,Minimalni obdavčljivi dohodek,
Max Taxable Income,Največji obdavčljivi dohodek,
Applicant for a Job,Kandidat za službo,
Accepted,Sprejeto,
Job Opening,Job Otvoritev,
Cover Letter,Cover Letter,
Resume Attachment,Nadaljuj Attachment,
Job Applicant Source,Vir prijavitelja zaposlitve,
Applicant Email Address,E-poštni naslov prosilca,
Awaiting Response,Čakanje na odgovor,
Job Offer Terms,Pogoji ponudb za delo,
Select Terms and Conditions,Izberite Pogoji,
Printing Details,Tiskanje Podrobnosti,
Job Offer Term,Job Offer Term,
Offer Term,Ponudba Term,
Value / Description,Vrednost / Opis,
Description of a Job Opening,Opis službo Otvoritev,
Job Title,Job Naslov,
Staffing Plan,Načrt zaposlovanja,
Planned number of Positions,Predvideno število pozicij,
"Job profile, qualifications required etc.","Profil delovnega mesta, potrebna usposobljenost itd",
HR-LAL-.YYYY.-,HR-LAL-YYYY-,
Allocation,Dodelitev,
New Leaves Allocated,Nove Listi Dodeljena,
Add unused leaves from previous allocations,Dodaj neuporabljene liste iz prejšnjih dodelitev,
Unused leaves,Neizkoriščene listi,
Total Leaves Allocated,Skupaj Listi Dodeljena,
Total Leaves Encashed,Skupaj na listi,
Leave Period,Pustite obdobje,
Carry Forwarded Leaves,Carry Posredovano Leaves,
Apply / Approve Leaves,Uporabi / Odobri Leaves,
HR-LAP-.YYYY.-,HR-LAP-.GGGG.-,
Leave Balance Before Application,Pustite Stanje pred uporabo,
Total Leave Days,Skupaj dni dopusta,
Leave Approver Name,Pustite odobritelju Name,
Follow via Email,Sledite preko e-maila,
Block Holidays on important days.,Blokiranje Počitnice na pomembnih dni.,
Leave Block List Name,Pustite Ime Block List,
Applies to Company,Velja za podjetja,
"If not checked, the list will have to be added to each Department where it has to be applied.","Če ni izbrana, bo seznam je treba dodati, da vsak oddelek, kjer je treba uporabiti.",
Block Days,Block dnevi,
Stop users from making Leave Applications on following days.,Stop uporabnike iz česar dopusta aplikacij na naslednjih dneh.,
Leave Block List Dates,Pustite Block List termini,
Allow Users,Dovoli uporabnike,
Allow the following users to approve Leave Applications for block days.,"Pustimo, da se naslednji uporabniki za odobritev dopusta Aplikacije za blok dni.",
Leave Block List Allowed,Pustite Block Seznam Dovoljeno,
Leave Block List Allow,Pustite Block List Dovoli,
Allow User,Dovoli Uporabnik,
Leave Block List Date,Pustite Block List Datum,
Block Date,Block Datum,
Leave Control Panel,Pustite Nadzorna plošča,
Select Employees,Izberite Zaposleni,
Employment Type (optional),Vrsta zaposlitve (neobvezno),
Branch (optional),Podružnica (neobvezno),
Department (optional),Oddelek (neobvezno),
Designation (optional),Oznaka (neobvezno),
Employee Grade (optional),Stopnja zaposlenega (neobvezno),
Employee (optional),Zaposleni (neobvezno),
Allocate Leaves,Dodelite liste,
Carry Forward,Carry Forward,
Please select Carry Forward if you also want to include previous fiscal year's balance leaves to this fiscal year,"Prosimo, izberite Carry Forward, če želite vključiti tudi v preteklem poslovnem letu je bilanca prepušča tem fiskalnem letu",
New Leaves Allocated (In Days),Nove Listi Dodeljena (v dnevih),
Allocate,Dodeli,
Leave Balance,Pusti ravnovesje,
Encashable days,Priloženi dnevi,
Encashment Amount,Znesek nakladanja,
Leave Ledger Entry,Pustite vpis v knjigo,
Transaction Name,Ime transakcije,
Is Carry Forward,Se Carry Forward,
Is Expired,Isteklo,
Is Leave Without Pay,Se Leave brez plačila,
Holiday List for Optional Leave,Seznam počitnic za izbirni dopust,
Leave Allocations,Pustite dodelitve,
Leave Policy Details,Pustite podrobnosti pravilnika,
Leave Policy Detail,Pustite podrobnosti o politiki,
Annual Allocation,Letno dodeljevanje,
Leave Type Name,Pustite Tip Ime,
Max Leaves Allowed,Dovoljeno je maksimalno dovoljeno odstopanje,
Applicable After (Working Days),Velja za (delovne dni),
Maximum Continuous Days Applicable,Najvišji neprekinjeni dnevi veljajo,
Is Optional Leave,Neobvezno pusti,
Allow Negative Balance,Dovoli negativni saldo,
Include holidays within leaves as leaves,Vključite počitnice v listih kot listja,
Is Compensatory,Je nadomestilo,
Maximum Carry Forwarded Leaves,Največje dovoljene sprednje liste,
Expire Carry Forwarded Leaves (Days),Pretekle rokavice (dnevi),
Calculated in days,Izračunano v dneh,
Encashment,Pritrditev,
Allow Encashment,Dovoli Encashment,
Encashment Threshold Days,Dnevi praga obkroževanja,
Earned Leave,Zasluženi dopust,
Is Earned Leave,Je zasluženo zapustiti,
Earned Leave Frequency,Pogostost oddanih dopustov,
Rounding,Zaokroževanje,
Payroll Employee Detail,Detajl zaposlenih zaposlenih,
Payroll Frequency,izplačane Frequency,
Fortnightly,vsakih štirinajst dni,
Bimonthly,vsaka dva meseca,
Employees,zaposleni,
Number Of Employees,Število zaposlenih,
Employee Details,Podrobnosti o zaposlenih,
Validate Attendance,Potrjevanje prisotnosti,
Salary Slip Based on Timesheet,Plača Slip Na Timesheet,
Select Payroll Period,Izberite izplačane Obdobje,
Deduct Tax For Unclaimed Employee Benefits,Davek od odbitka za neupravičene zaslužke zaposlenih,
Deduct Tax For Unsubmitted Tax Exemption Proof,Davek od odbitka za neosnovan dokaz o davčni oprostitvi,
Select Payment Account to make Bank Entry,"Izberite Plačilo računa, da bo Bank Entry",
Salary Slips Created,Ustvarjene plačne liste,
Salary Slips Submitted,Poslane plačljive plače,
Payroll Periods,Obdobja plačevanja,
Payroll Period Date,Datum roka plačila,
Purpose of Travel,Namen potovanja,
Retention Bonus,Zadrževalni bonus,
Bonus Payment Date,Datum plačila bonusa,
Bonus Amount,Bonus znesek,
Abbr,Abbr,
Depends on Payment Days,Odvisno od plačilnih dni,
Is Tax Applicable,Ali je davčni zavezanec,
Variable Based On Taxable Salary,Spremenljivka na podlagi obdavčljive plače,
Exempted from Income Tax,Oproščen davka od dohodka,
Round to the Nearest Integer,Zaokrožite do najbližjega celega števila,
Statistical Component,Statistični Komponenta,
"If selected, the value specified or calculated in this component will not contribute to the earnings or deductions. However, it's value can be referenced by other components that can be added or deducted. ","Če je izbrana, je vrednost navedena ali izračunana pri tem delu ne bo prispevalo k zaslužka ali odbitkov. Kljub temu, da je vrednost se lahko sklicujejo na druge sestavne dele, ki se lahko dodajo ali odbitih.",
Do Not Include in Total,Ne vključi v skupno,
Flexible Benefits,Fleksibilne prednosti,
Is Flexible Benefit,Je fleksibilna korist,
Max Benefit Amount (Yearly),Znesek maksimalnega zneska (letno),
Only Tax Impact (Cannot Claim But Part of Taxable Income),"Samo davčni vpliv (ne moremo trditi, ampak del obdavčljivega dohodka)",
Create Separate Payment Entry Against Benefit Claim,Ustvarite ločen plačilni vpis pred škodnim zahtevkom,
Condition and Formula,Pogoj in formula,
Amount based on formula,"Znesek, ki temelji na formuli",
Formula,Formula,
Salary Detail,plača Podrobnosti,
Component,Komponenta,
Do not include in total,Ne vključite v celoti,
Default Amount,Privzeti znesek,
Additional Amount,Dodatni znesek,
Tax on flexible benefit,Davek na prožne koristi,
Tax on additional salary,Davek na dodatno plačo,
Salary Structure,Struktura Plače,
Working Days,Delovni dnevi,
Salary Slip Timesheet,Plača Slip Timesheet,
Total Working Hours,Skupaj Delovni čas,
Hour Rate,Urna postavka,
Bank Account No.,Št. bančnega računa,
Earning & Deduction,Zaslužek &amp; Odbitek,
Earnings,Zaslužek,
Deductions,Odbitki,
Loan repayment,Odplačilo posojila,
Employee Loan,zaposlenih Loan,
Total Principal Amount,Skupni glavni znesek,
Total Interest Amount,Skupni znesek obresti,
Total Loan Repayment,Skupaj posojila Povračilo,
net pay info,net info plačilo,
Gross Pay - Total Deduction - Loan Repayment,Bruto plača - Skupaj Odbitek - Posojilo Povračilo,
Total in words,Skupaj z besedami,
Net Pay (in words) will be visible once you save the Salary Slip.,"Neto Pay (z besedami), bo viden, ko boste shranite plačilnega lista.",
Salary Component for timesheet based payroll.,"Plača Komponenta za Timesheet na izplačane plače, ki temelji.",
Leave Encashment Amount Per Day,Pustite znesek obrokov na dan,
Max Benefits (Amount),Maksimalne ugodnosti (znesek),
Salary breakup based on Earning and Deduction.,Plača razpadu temelji na zaslužek in odbitka.,
Total Earning,Skupaj zaslužka,
Salary Structure Assignment,Dodelitev strukture plač,
Shift Assignment,Shift Assignment,
Shift Type,Vrsta premika,
Shift Request,Zahteva za premik,
Enable Auto Attendance,Omogoči samodejno udeležbo,
Mark attendance based on 'Employee Checkin' for Employees assigned to this shift.,"Označite udeležbo na podlagi „Checkee Employee Checkin“ za zaposlene, dodeljene tej izmeni.",
Auto Attendance Settings,Nastavitve samodejne udeležbe,
Determine Check-in and Check-out,Določite prijavo in odjavo,
Alternating entries as IN and OUT during the same shift,Med istim premikom se izmenični vnosi kot IN in OUT,
Strictly based on Log Type in Employee Checkin,Strogo temelji na vrsti dnevnika v Checkin zaposlenem,
Working Hours Calculation Based On,Izračun delovnega časa na podlagi,
First Check-in and Last Check-out,Prva prijava in Zadnja odjava,
Every Valid Check-in and Check-out,Vsaka veljavna prijava in odjava,
Begin check-in before shift start time (in minutes),Začnite prijavo pred začetkom izmene (v minutah),
The time before the shift start time during which Employee Check-in is considered for attendance.,"Čas pred začetkom izmene, v katerem se šteje prijava zaposlenih za udeležbo.",
Allow check-out after shift end time (in minutes),Dovoli odjavo po končanem času izmene (v minutah),
Time after the end of shift during which check-out is considered for attendance.,"Čas po koncu izmene, med katero se šteje odjava za udeležbo.",
Working Hours Threshold for Half Day,Mejna vrednost delovnega časa za pol dneva,
Working hours below which Half Day is marked. (Zero to disable),"Delovni čas, pod katerim je označen pol dneva. (Nič, da onemogoči)",
Working Hours Threshold for Absent,Mejna vrednost delovnega časa za odsotne,
Working hours below which Absent is marked. (Zero to disable),"Delovni čas, pod katerim je odsoten. (Nič, da onemogoči)",
Process Attendance After,Obiskanost procesa po,
Attendance will be marked automatically only after this date.,Udeležba bo označena samodejno šele po tem datumu.,
Last Sync of Checkin,Zadnja sinhronizacija Checkin,
Last Known Successful Sync of Employee Checkin. Reset this only if you are sure that all Logs are synced from all the locations. Please don't modify this if you are unsure.,"Zadnja znana uspešna sinhronizacija zaposlenega Checkin. To ponastavite le, če ste prepričani, da so vsi Dnevniki sinhronizirani z vseh lokacij. Če niste prepričani, tega ne spreminjajte.",
Grace Period Settings For Auto Attendance,Nastavitve časovnega obdobja za samodejno udeležbo,
Enable Entry Grace Period,Omogoči časovno obdobje vnosa,
Late Entry Grace Period,Obdobje poznega vstopa,
The time after the shift start time when check-in is considered as late (in minutes).,"Čas po začetnem času premika, ko se prijava šteje za pozno (v minutah).",
Enable Exit Grace Period,Omogoči obdobje izstopa milosti,
Early Exit Grace Period,Predčasno izstopno milostno obdobje,
The time before the shift end time when check-out is considered as early (in minutes).,"Čas pred zaključkom izmene, ko se odjava šteje kot zgodnji (v minutah).",
Skill Name,Ime spretnosti,
Staffing Plan Details,Podrobnosti o kadrovskem načrtu,
Staffing Plan Detail,Podrobnosti o kadrovskem načrtu,
Total Estimated Budget,Skupni predvideni proračun,
Vacancies,Prosta delovna mesta,
Estimated Cost Per Position,Ocenjeni strošek na pozicijo,
Total Estimated Cost,Skupni predvideni stroški,
Current Count,Trenutna števila,
Current Openings,Aktualne odprtine,
Number Of Positions,Število položajev,
Taxable Salary Slab,Obdavčljive plače,
From Amount,Od zneska,
To Amount,Za znesek,
Percent Deduction,Odstotek odbitka,
Training Program,Program usposabljanja,
Event Status,Status dogodek,
Has Certificate,Ima certifikat,
Seminar,seminar,
Theory,teorija,
Workshop,Delavnica,
Conference,Konferenca,
Exam,Izpit,
Internet,internet,
Self-Study,Samo-študija,
Advance,Napredovanje,
Trainer Name,Ime Trainer,
Trainer Email,Trainer Email,
Attendees,udeleženci,
Employee Emails,Emails za zaposlene,
Training Event Employee,Dogodek usposabljanje zaposlenih,
Invited,povabljen,
Feedback Submitted,povratne informacije Objavil,
Optional,Neobvezno,
Training Result Employee,Usposabljanje Rezultat zaposlenih,
Travel Itinerary,Načrt potovanja,
Travel From,Potovanje iz,
Travel To,Potovati v,
Mode of Travel,Način potovanja,
Flight,Polet,
Train,Vlak,
Taxi,Taxi,
Rented Car,Najem avtomobila,
Meal Preference,Prednost hrane,
Vegetarian,Vegetarijansko,
Non-Vegetarian,Ne-vegetarijanska,
Gluten Free,Brez glutena,
Non Diary,Ne Dnevnik,
Travel Advance Required,Zahtevano potovanje,
Departure Datetime,Odhod Datetime,
Arrival Datetime,Prihod Datetime,
Lodging Required,Potrebna namestitev,
Preferred Area for Lodging,Prednostno območje za vložitev,
Check-in Date,Datum prihoda,
Check-out Date,Datum odhoda,
Travel Request,Zahteva za potovanje,
Travel Type,Vrsta potovanja,
Domestic,Domači,
International,Mednarodni,
Travel Funding,Financiranje potovanj,
Require Full Funding,Zahtevati polno financiranje,
Fully Sponsored,Popolnoma sponzorirani,
"Partially Sponsored, Require Partial Funding","Delno sponzorirana, zahteva delno financiranje",
Copy of Invitation/Announcement,Kopija vabila / obvestila,
"Details of Sponsor (Name, Location)","Podrobnosti o sponzorju (ime, lokacija)",
Identification Document Number,Številka identifikacijskega dokumenta,
Any other details,Kakšne druge podrobnosti,
Costing Details,Podrobnosti o stroških,
Costing,Stanejo,
Event Details,Podrobnosti dogodka,
Name of Organizer,Ime organizatorja,
Address of Organizer,Naslov organizatorja,
Travel Request Costing,Potni stroški,
Expense Type,Vrsta izdatkov,
Sponsored Amount,Sponzorirani znesek,
Funded Amount,"Znesek, ki ga financira",
Upload Attendance,Naloži Udeležba,
Attendance From Date,Udeležba Od datuma,
Attendance To Date,Udeležba na tekočem,
Get Template,Get predlogo,
Import Attendance,Uvoz Udeležba,
Upload HTML,Naloži HTML,
Vehicle,vozila,
License Plate,Registrska tablica,
Odometer Value (Last),Vrednost števca (Zadnja),
Acquisition Date,Pridobitev Datum,
Chassis No,podvozje ni,
Vehicle Value,Vrednost vozila,
Insurance Details,Zavarovanje Podrobnosti,
Insurance Company,Zavarovalnica,
Policy No,Pravilnik št,
Additional Details,Dodatne podrobnosti,
Fuel Type,Vrsta goriva,
Petrol,Petrol,
Diesel,Diesel,
Natural Gas,Zemeljski plin,
Electric,električni,
Fuel UOM,gorivo UOM,
Last Carbon Check,Zadnja Carbon Check,
Wheels,kolesa,
Doors,vrata,
HR-VLOG-.YYYY.-,HR-VLOG-.YYYY.-,
Odometer Reading,Stanje kilometrov,
Current Odometer value ,Trenutna vrednost odometra,
last Odometer Value ,zadnja vrednost odometra,
Refuelling Details,Oskrba z gorivom Podrobnosti,
Invoice Ref,Ref na računu,
Service Details,storitev Podrobnosti,
Service Detail,Service Podrobnosti,
Vehicle Service,servis vozila,
Service Item,Service Element,
Brake Oil,Zavorna olja,
Brake Pad,Brake Pad,
Clutch Plate,sklopka Plate,
Engine Oil,Motorno olje,
Oil Change,Menjava olja,
Inspection,Pregled,
Mileage,Kilometrina,
Hub Tracked Item,Hub Gosenica Postavka,
Hub Node,Vozliščna točka,
Image List,Seznam slik,
Item Manager,Element Manager,
Hub User,Uporabnik Hub,
Hub Password,Hub geslo,
Hub Users,Uporabniki vozlišča,
Marketplace Settings,Nastavitve tržnice,
Disable Marketplace,Onemogoči trg,
Marketplace URL (to hide and update label),URL tržišča (za skrivanje in posodobitev oznake),
Registered,Registrirani,
Sync in Progress,Sinhronizacija v toku,
Hub Seller Name,Ime prodajalca vozlišča,
Custom Data,Podatki po meri,
Member,Član,
Partially Disbursed,delno črpanju,
Loan Closure Requested,Zahtevano je zaprtje posojila,
Repay From Salary,Poplačilo iz Plača,
Loan Details,posojilo Podrobnosti,
Loan Type,posojilo Vrsta,
Loan Amount,Znesek posojila,
Is Secured Loan,Je zavarovana posojila,
Rate of Interest (%) / Year,Obrestna mera (%) / leto,
Disbursement Date,izplačilo Datum,
Disbursed Amount,Izplačana znesek,
Is Term Loan,Je Term Posojilo,
Repayment Method,Povračilo Metoda,
Repay Fixed Amount per Period,Povrne fiksni znesek na obdobje,
Repay Over Number of Periods,Odplačilo Over število obdobij,
Repayment Period in Months,Vračilo Čas v mesecih,
Monthly Repayment Amount,Mesečni Povračilo Znesek,
Repayment Start Date,Datum začetka odplačevanja,
Loan Security Details,Podrobnosti o posojilu,
Maximum Loan Value,Najvišja vrednost posojila,
Account Info,Informacije o računu,
Loan Account,Kreditni račun,
Interest Income Account,Prihodki od obresti račun,
Penalty Income Account,Račun dohodkov,
Repayment Schedule,Povračilo Urnik,
Total Payable Amount,Skupaj plačljivo Znesek,
Total Principal Paid,Skupna plačana glavnica,
Total Interest Payable,Skupaj Obresti plačljivo,
Total Amount Paid,Skupni znesek plačan,
Loan Manager,Vodja posojil,
Loan Info,posojilo Info,
Rate of Interest,Obrestna mera,
Proposed Pledges,Predlagane obljube,
Maximum Loan Amount,Največja Znesek posojila,
Repayment Info,Povračilo Info,
Total Payable Interest,Skupaj plačljivo Obresti,
Against Loan ,Proti Posojilu,
Loan Interest Accrual,Porazdelitev posojil,
Amounts,Zneski,
Pending Principal Amount,Nerešeni glavni znesek,
Payable Principal Amount,Plačljiva glavnica,
Paid Principal Amount,Plačani znesek glavnice,
Paid Interest Amount,Znesek plačanih obresti,
Process Loan Interest Accrual,Proračun za obresti za posojila,
Repayment Schedule Name,Ime razporeda odplačevanja,
Regular Payment,Redno plačilo,
Loan Closure,Zaprtje posojila,
Payment Details,Podatki o plačilu,
Interest Payable,Obresti za plačilo,
Amount Paid,Plačani znesek,
Principal Amount Paid,Plačani glavni znesek,
Repayment Details,Podrobnosti o odplačilu,
Loan Repayment Detail,Podrobnosti o odplačilu posojila,
Loan Security Name,Varnostno ime posojila,
Unit Of Measure,Merska enota,
Loan Security Code,Kodeks za posojilo,
Loan Security Type,Vrsta zavarovanja posojila,
Haircut %,Odbitki%,
Loan  Details,Podrobnosti o posojilu,
Unpledged,Neodključeno,
Pledged,Založeno,
Partially Pledged,Delno zastavljeno,
Securities,Vrednostni papirji,
Total Security Value,Skupna vrednost varnosti,
Loan Security Shortfall,Pomanjkanje varnosti posojila,
Loan ,Posojilo,
Shortfall Time,Čas pomanjkanja,
America/New_York,Amerika / New_York,
Shortfall Amount,Znesek primanjkljaja,
Security Value ,Vrednost varnosti,
Process Loan Security Shortfall,Pomanjkanje varnosti posojila,
Loan To Value Ratio,Razmerje med posojilom in vrednostjo,
Unpledge Time,Čas odstranjevanja,
Loan Name,posojilo Ime,
Rate of Interest (%) Yearly,Obrestna mera (%) Letna,
Penalty Interest Rate (%) Per Day,Kazenska obrestna mera (%) na dan,
Penalty Interest Rate is levied on the pending interest amount on a daily basis in case of delayed repayment ,V primeru zamude pri odplačilu se dnevno plačuje obrestna mera za odmerjene obresti,
Grace Period in Days,Milostno obdobje v dnevih,
No. of days from due date until which penalty won't be charged in case of delay in loan repayment,"Število dni od datuma zapadlosti, do katerega kazen ne bo zaračunana v primeru zamude pri odplačilu posojila",
Pledge,Obljuba,
Post Haircut Amount,Količina odbitka po pošti,
Process Type,Vrsta procesa,
Update Time,Čas posodobitve,
Proposed Pledge,Predlagana zastava,
Total Payment,Skupaj plačila,
Balance Loan Amount,Bilanca Znesek posojila,
Is Accrued,Je zapadlo v plačilo,
Salary Slip Loan,Posojilo za plačilo,
Loan Repayment Entry,Vnos vračila posojila,
Sanctioned Loan Amount,Doseženi znesek posojila,
Sanctioned Amount Limit,Omejena omejitev zneska,
Unpledge,Odveči,
Haircut,Pričeska,
MAT-MSH-.YYYY.-,MAT-MSH-YYYY.-,
Generate Schedule,Ustvarjajo Urnik,
Schedules,Urniki,
Maintenance Schedule Detail,Vzdrževanje Urnik Detail,
Scheduled Date,Načrtovano Datum,
Actual Date,Dejanski datum,
Maintenance Schedule Item,Vzdrževanje Urnik Postavka,
Random,Naključen,
No of Visits,Število obiskov,
MAT-MVS-.YYYY.-,MAT-MVS-.LLLL.-,
Maintenance Date,Vzdrževanje Datum,
Maintenance Time,Vzdrževanje čas,
Completion Status,Zaključek Status,
Partially Completed,Delno Dopolnil,
Fully Completed,V celoti končana,
Unscheduled,Nenačrtovana,
Breakdown,Zlomiti se,
Purposes,Nameni,
Customer Feedback,Customer Feedback,
Maintenance Visit Purpose,Vzdrževanje Obiščite Namen,
Work Done,Delo končano,
Against Document No,Proti dokument št,
Against Document Detail No,Proti Podrobnosti dokumenta št,
MFG-BLR-.YYYY.-,MFG-BLR-.YYYY.-,
Order Type,Tip naročila,
Blanket Order Item,Blanket naročilo,
Ordered Quantity,Naročeno Količina,
Item to be manufactured or repacked,"Postavka, ki se proizvaja ali prepakirana",
Quantity of item obtained after manufacturing / repacking from given quantities of raw materials,Količina postavke pridobljeno po proizvodnji / prepakiranja iz danih količin surovin,
Set rate of sub-assembly item based on BOM,Nastavite količino predmeta sestavljanja na podlagi BOM,
Allow Alternative Item,Dovoli alternativni element,
Item UOM,Postavka UOM,
Conversion Rate,Stopnja konverzije,
Rate Of Materials Based On,Oceni materialov na osnovi,
With Operations,Pri poslovanju,
Manage cost of operations,Upravljati stroške poslovanja,
Transfer Material Against,Prenesite gradivo proti,
Routing,Usmerjanje,
Materials,Materiali,
Quality Inspection Required,Potreben je pregled kakovosti,
Quality Inspection Template,Obrazec za pregled kakovosti,
Scrap,Odpadno,
Scrap Items,ostanki Točke,
Operating Cost,Obratovalni stroški,
Raw Material Cost,Stroški surovin,
Scrap Material Cost,Stroški odpadnega materiala,
Operating Cost (Company Currency),Obratovalni stroški (družba Valuta),
Raw Material Cost (Company Currency),Stroški surovin (valuta podjetja),
Scrap Material Cost(Company Currency),Odpadni material Stroški (družba Valuta),
Total Cost,Skupni stroški,
Total Cost (Company Currency),Skupni stroški (valuta podjetja),
Materials Required (Exploded),Potreben materiali (eksplodirala),
Exploded Items,Eksplodirani predmeti,
Show in Website,Pokaži na spletnem mestu,
Item Image (if not slideshow),Postavka Image (če ne slideshow),
Thumbnail,Thumbnail,
Website Specifications,Spletna Specifikacije,
Show Items,prikaži Točke,
Show Operations,prikaži Operations,
Website Description,Spletna stran Opis,
BOM Explosion Item,BOM Eksplozija Postavka,
Qty Consumed Per Unit,Količina porabljene na enoto,
Include Item In Manufacturing,Vključi izdelek v proizvodnjo,
BOM Item,BOM Postavka,
Item operation,Operacija elementa,
Rate & Amount,Stopnja in znesek,
Basic Rate (Company Currency),Basic Rate (družba Valuta),
Scrap %,Ostanki%,
Original Item,Izvirna postavka,
BOM Operation,BOM Delovanje,
Operation Time ,Čas delovanja,
In minutes,V nekaj minutah,
Batch Size,Velikost serije,
Base Hour Rate(Company Currency),Osnovna urni tečaj (družba Valuta),
Operating Cost(Company Currency),Obratovalni stroški (družba Valuta),
BOM Scrap Item,BOM Odpadno Item,
Basic Amount (Company Currency),Osnovni znesek (družba Valuta),
BOM Update Tool,Orodje za posodobitev 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.","Zamenjajte določeno BOM v vseh drugih BOM, kjer se uporablja. Zamenjal bo staro povezavo BOM, posodobiti stroške in obnovil tabelo &quot;BOM eksplozijsko blago&quot; v skladu z novim BOM. Prav tako posodablja najnovejšo ceno v vseh BOM.",
Replace BOM,Zamenjajte BOM,
Current BOM,Trenutni BOM,
The BOM which will be replaced,BOM ki bo nadomestila,
The new BOM after replacement,Novi BOM po zamenjavi,
Replace,Zamenjaj,
Update latest price in all BOMs,Posodobi najnovejšo ceno v vseh BOM,
BOM Website Item,BOM Spletna stran Element,
BOM Website Operation,BOM Spletna stran Operacija,
Operation Time,Operacija čas,
PO-JOB.#####,PO-JOB. #####,
Timing Detail,Časovno podrobnost,
Time Logs,Čas Dnevniki,
Total Time in Mins,Skupni čas v min,
Operation ID,ID operacije,
Transferred Qty,Prenese Kol,
Job Started,Začelo se je delo,
Started Time,Začeti čas,
Current Time,Trenutni čas,
Job Card Item,Postavka Job Card,
Job Card Time Log,Dnevni dnevnik delovne kartice,
Time In Mins,Čas v minutah,
Completed Qty,Končano število,
Manufacturing Settings,Proizvodne Nastavitve,
Raw Materials Consumption,Poraba surovin,
Allow Multiple Material Consumption,Dovoli večkratno porabo materiala,
Backflush Raw Materials Based On,"Backflush Surovine, ki temelji na",
Material Transferred for Manufacture,Material Preneseno za Izdelava,
Capacity Planning,Načrtovanje zmogljivosti,
Disable Capacity Planning,Onemogoči načrtovanje zmogljivosti,
Allow Overtime,Dovoli Nadurno delo,
Allow Production on Holidays,Dovoli Proizvodnja na počitnicah,
Capacity Planning For (Days),Kapaciteta Načrtovanje Za (dnevi),
Default Warehouses for Production,Privzeta skladišča za proizvodnjo,
Default Work In Progress Warehouse,Privzeto Delo v skladišču napredku,
Default Finished Goods Warehouse,Privzete Končano Blago Skladišče,
Default Scrap Warehouse,Privzeta skladišča odpadkov,
Overproduction Percentage For Sales Order,Odstotek prekomerne proizvodnje za prodajno naročilo,
Overproduction Percentage For Work Order,Odstotek prekomerne proizvodnje za delovni red,
Other Settings,druge nastavitve,
Update BOM Cost Automatically,Posodobi BOM stroškov samodejno,
Material Request Plan Item,Postavka načrta materialne zahteve,
Material Request Type,Material Zahteva Type,
Material Issue,Material Issue,
Customer Provided,Stranka,
Minimum Order Quantity,Najmanjša količina naročila,
Default Workstation,Privzeto Workstation,
Production Plan,Načrt proizvodnje,
MFG-PP-.YYYY.-,MFG-PP-YYYY.-,
Get Items From,Pridobi artikle iz,
Get Sales Orders,Pridobite prodajnih nalogov,
Material Request Detail,Materialna zahteva Podrobnosti,
Get Material Request,Get Zahteva material,
Material Requests,Material Zahteve,
Get Items For Work Order,Pridobite predmete za delovni red,
Material Request Planning,Načrtovanje materialnih zahtev,
Include Non Stock Items,Vključite elemente brez zaloge,
Include Subcontracted Items,Vključite predmete s podizvajalci,
Ignore Existing Projected Quantity,Ignorirajte obstoječo predvideno količino,
"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>.","Če želite izvedeti več o predvideni količini, <a href=""https://erpnext.com/docs/user/manual/en/stock/projected-quantity"" style=""text-decoration: underline;"" target=""_blank"">kliknite tukaj</a> .",
Download Required Materials,Prenesite potrebna gradiva,
Get Raw Materials For Production,Pridobite surovine za proizvodnjo,
Total Planned Qty,Skupno načrtovano število,
Total Produced Qty,Skupno število proizvedenih količin,
Material Requested,Zahtevani material,
Production Plan Item,Proizvodni načrt Postavka,
Make Work Order for Sub Assembly Items,Naredite delovni nalog za predmete pod montažo,
"If enabled, system will create the work order for the exploded items against which BOM is available.","Če je omogočeno, bo sistem ustvaril delovni nalog za eksplodirane predmete, proti katerim je BOM na voljo.",
Planned Start Date,Načrtovani datum začetka,
Quantity and Description,Količina in opis,
material_request_item,material_request_item,
Product Bundle Item,Izdelek Bundle Postavka,
Production Plan Material Request,Proizvodnja Zahteva načrt Material,
Production Plan Sales Order,Proizvodni načrt Sales Order,
Sales Order Date,Datum Naročila Kupca,
Routing Name,Ime poti,
MFG-WO-.YYYY.-,MFG-WO-.YYYY.-,
Item To Manufacture,Postavka za izdelavo,
Material Transferred for Manufacturing,Material Preneseno za Manufacturing,
Manufactured Qty,Izdelano Kol.,
Use Multi-Level BOM,Uporabite Multi-Level BOM,
Plan material for sub-assemblies,Plan material za sklope,
Skip Material Transfer to WIP Warehouse,Preskočite prenos materiala v skladišče WIP,
Check if material transfer entry is not required,"Preverite, ali je vpis prenosa materiala ni potrebno",
Backflush Raw Materials From Work-in-Progress Warehouse,"Backflush surovine iz skladišča, ki dela v teku",
Update Consumed Material Cost In Project,Posodobiti porabljene stroške materiala v projektu,
Warehouses,Skladišča,
This is a location where raw materials are available.,"To je mesto, kjer so na voljo surovine.",
Work-in-Progress Warehouse,Work-in-Progress Warehouse,
This is a location where operations are executed.,"To je mesto, kjer se izvajajo operacije.",
This is a location where final product stored.,Na tem mestu je shranjen končni izdelek.,
Scrap Warehouse,ostanki Skladišče,
This is a location where scraped materials are stored.,"To je mesto, kjer se hranijo razrezani materiali.",
Required Items,Zahtevani Točke,
Actual Start Date,Dejanski datum začetka,
Planned End Date,Načrtovan End Date,
Actual End Date,Dejanski končni datum,
Operation Cost,Delovanje Stroški,
Planned Operating Cost,Načrtovana operacijski stroškov,
Actual Operating Cost,Dejanski operacijski stroškov,
Additional Operating Cost,Dodatne operacijski stroškov,
Total Operating Cost,Skupni operativni stroški,
Manufacture against Material Request,Izdelava proti Material zahtevo,
Work Order Item,Postavka delovnega naloga,
Available Qty at Source Warehouse,Na voljo Količina na Vir Warehouse,
Available Qty at WIP Warehouse,Na voljo Količina na WIP Warehouse,
Work Order Operation,Delovni nalog,
Operation Description,Operacija Opis,
Operation completed for how many finished goods?,"Operacija zaključena, za koliko končnih izdelkov?",
Work in Progress,Delo v teku,
Estimated Time and Cost,Predvideni čas in stroški,
Planned Start Time,Načrtovano Start Time,
Planned End Time,Načrtovano Končni čas,
in Minutes,V minutah,
Actual Time and Cost,Dejanski čas in stroški,
Actual Start Time,Actual Start Time,
Actual End Time,Dejanski Končni čas,
Updated via 'Time Log',Posodobljeno preko &quot;Čas Logu&quot;,
Actual Operation Time,Dejanska Operacija čas,
in Minutes\nUpdated via 'Time Log',v minutah Posodobljeno preko &quot;Čas Logu&quot;,
(Hour Rate / 60) * Actual Operation Time,(Urna postavka / 60) * Dejanski  čas operacije,
Workstation Name,Workstation Name,
Production Capacity,Proizvodna zmogljivost,
Operating Costs,Obratovalni stroški,
Electricity Cost,Stroški električne energije,
per hour,na uro,
Consumable Cost,Potrošni stroški,
Rent Cost,Najem Stroški,
Wages,Plače,
Wages per hour,Plače na uro,
Net Hour Rate,Neto urna postavka,
Workstation Working Hour,Workstation delovno uro,
Certification Application,Certifikacijska aplikacija,
Name of Applicant,Ime prosilca,
Certification Status,Certifikacijski status,
Yet to appear,Še vedno pa se pojavi,
Certified,Certified,
Not Certified,Ni potrjeno,
USD,ameriški dolar,
INR,INR,
Certified Consultant,Certified Consultant,
Name of Consultant,Ime svetovalca,
Certification Validity,Veljavnost certifikata,
Discuss ID,Pogovorite se o ID-ju,
GitHub ID,GitHub ID,
Non Profit Manager,Neprofitni menedžer,
Chapter Head,Poglavje glave,
Meetup Embed HTML,Meetup Vstavi HTML,
chapters/chapter_name\nleave blank automatically set after saving chapter.,poglavja / poglavje_name pustite samodejno nastaviti prazno po shranjevanju poglavja.,
Chapter Members,Članice poglavja,
Members,Člani,
Chapter Member,Član poslanke,
Website URL,Spletna stran URL,
Leave Reason,Pustite razlog,
Donor Name,Ime donatorja,
Donor Type,Vrsta donatorja,
Withdrawn,umaknjena,
Grant Application Details ,Podrobnosti o aplikaciji za dodelitev sredstev,
Grant Description,Grant Opis,
Requested Amount,Zahtevani znesek,
Has any past Grant Record,Ima dodeljen zapis,
Show on Website,Prikaži na spletni strani,
Assessment  Mark (Out of 10),Ocenjevalna oznaka (od 10),
Assessment  Manager,Ocenjevalec,
Email Notification Sent,Poslano obvestilo o e-pošti,
NPO-MEM-.YYYY.-,NPO-MEM-.GGGG.-,
Membership Expiry Date,Datum prenehanja članstva,
Razorpay Details,Podrobnosti o Razorpay,
Subscription ID,ID naročnine,
Customer ID,identifikacijska številka stranke,
Subscription Activated,Naročnina aktivirana,
Subscription Start ,Začetek naročnine,
Subscription End,Konec naročnine,
Non Profit Member,Neprofitni član,
Membership Status,Status članstva,
Member Since,Član od,
Payment ID,ID plačila,
Membership Settings,Nastavitve članstva,
Enable RazorPay For Memberships,Omogočite RazorPay za članstva,
RazorPay Settings,Nastavitve RazorPay,
Billing Cycle,Obračunski cikel,
Billing Frequency,Pogostost zaračunavanja,
"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.","Število obračunskih ciklov, za katere je treba stranki zaračunati. Če kupec na primer kupi enoletno članstvo, ki ga je treba mesečno obračunavati, mora biti ta vrednost 12.",
Razorpay Plan ID,ID načrta Razorpay,
Volunteer Name,Ime prostovoljca,
Volunteer Type,Volunteer Type,
Availability and Skills,Razpoložljivost in spretnosti,
Availability,Razpoložljivost,
Weekends,Vikendi,
Availability Timeslot,Razpoložljivost Timeslot,
Morning,Jutro,
Afternoon,Popoldne,
Evening,Večer,
Anytime,Kadarkoli,
Volunteer Skills,Prostovoljne spretnosti,
Volunteer Skill,Sposobnost prostovoljcev,
Homepage,Domača stran,
Hero Section Based On,Oddelek za heroje,
Homepage Section,Oddelek za domačo stran,
Hero Section,Oddelek za junake,
Tag Line,tag Line,
Company Tagline for website homepage,Podjetje Slogan za domačo stran spletnega mesta,
Company Description for website homepage,Podjetje Opis za domačo stran spletnega mesta,
Homepage Slideshow,Diaprojekcija domače strani,
"URL for ""All Products""",URL za »Vsi izdelki«,
Products to be shown on website homepage,"Proizvodi, ki se prikaže na spletni strani",
Homepage Featured Product,Domača stran izbranega izdelka,
route,poti,
Section Based On,Oddelek temelji na,
Section Cards,Karte oddelka,
Number of Columns,Število stolpcev,
Number of columns for this section. 3 cards will be shown per row if you select 3 columns.,"Število stolpcev za ta razdelek. Če izberete 3 stolpce, bodo v vsaki vrstici prikazane 3 kartice.",
Section HTML,Odsek HTML,
Use this field to render any custom HTML in the section.,"To polje uporabite v polju, če želite prikazati poljuben HTML po meri.",
Section Order,Odredba oddelka,
"Order in which sections should appear. 0 is first, 1 is second and so on.","Vrstni red, v katerem morajo biti razdelki. 0 je prvo, 1 je drugo in tako naprej.",
Homepage Section Card,Kartica oddelka za domačo stran,
Subtitle,Podnaslov,
Products Settings,Nastavitve izdelki,
Home Page is Products,Domača stran je izdelki,
"If checked, the Home page will be the default Item Group for the website","Če je omogočeno, bo Naslovna stran je skupina privzeta točka za spletno stran",
Show Availability Status,Prikaži stanje razpoložljivosti,
Product Page,Stran izdelka,
Products per Page,Izdelki na stran,
Enable Field Filters,Omogoči filtre polja,
Item Fields,Polja predmeta,
Enable Attribute Filters,Omogoči filtre atributov,
Attributes,Atributi,
Hide Variants,Skrij variante,
Website Attribute,Atributi spletnega mesta,
Attribute,Lastnost,
Website Filter Field,Polje filtra spletnega mesta,
Activity Cost,Stroški dejavnost,
Billing Rate,Zaračunavanje Rate,
Costing Rate,Stanejo Rate,
title,naslov,
Projects User,Projekti Uporabnik,
Default Costing Rate,Privzeto Costing Rate,
Default Billing Rate,Privzeto Oceni plačevanja,
Dependent Task,Odvisna Task,
Project Type,Projekt Type,
% Complete Method,% končano,
Task Completion,naloga Zaključek,
Task Progress,naloga Progress,
% Completed,% končano,
From Template,S predloge,
Project will be accessible on the website to these users,Projekt bo na voljo na spletni strani teh uporabnikov,
Copied From,Kopirano iz,
Start and End Dates,Začetni in končni datum,
Actual Time in Hours (via Timesheet),Dejanski čas (v urah),
Costing and Billing,Obračunavanje stroškov in plačevanja,
Total Costing Amount (via Timesheet),Skupni znesek stroškov (prek časopisov),
Total Expense Claim (via Expense Claim),Total Expense zahtevek (preko Expense zahtevkov),
Total Purchase Cost (via Purchase Invoice),Skupaj Nakup Cost (via računu o nakupu),
Total Sales Amount (via Sales Order),Skupni znesek prodaje (preko prodajnega naloga),
Total Billable Amount (via Timesheet),Skupni znesek zneska (prek časopisov),
Total Billed Amount (via Sales Invoice),Skupni fakturirani znesek (prek prodajnih računov),
Total Consumed Material Cost (via Stock Entry),Skupni stroški porabljenega materiala (preko zaloge na borzi),
Gross Margin,Gross Margin,
Gross Margin %,Gross Margin%,
Monitor Progress,Spremljajte napredek,
Collect Progress,Zberite napredek,
Frequency To Collect Progress,Frekvenca za zbiranje napredka,
Twice Daily,Dvakrat dnevno,
First Email,Prva e-pošta,
Second Email,Druga e-pošta,
Time to send,Čas za pošiljanje,
Day to Send,Dan za pošiljanje,
Message will be sent to the users to get their status on the Project,"Uporabnikom bo poslano sporočilo, da dobijo svoj status v projektu",
Projects Manager,Projekti Manager,
Project Template,Predloga projekta,
Project Template Task,Naloga predloge projekta,
Begin On (Days),Začetek dneva (dnevi),
Duration (Days),Trajanje (dnevi),
Project Update,Posodobitev projekta,
Project User,projekt Uporabnik,
View attachments,Ogled prilog,
Projects Settings,Nastavitve projektov,
Ignore Workstation Time Overlap,Prezri čas prekrivanja delovne postaje,
Ignore User Time Overlap,Prezreti preklop uporabniškega časa,
Ignore Employee Time Overlap,Prezri čas prekrivanja zaposlenih,
Weight,Teža,
Parent Task,Naloga staršev,
Timeline,Časovnica,
Expected Time (in hours),Pričakovani čas (v urah),
% Progress,% napredka,
Is Milestone,je Milestone,
Task Description,Opis naloge,
Dependencies,Odvisnosti,
Dependent Tasks,Odvisne naloge,
Depends on Tasks,Odvisno od Opravila,
Actual Start Date (via Timesheet),Dejanski začetni datum (preko Čas lista),
Actual Time in Hours (via Timesheet),Dejanski čas (v urah),
Actual End Date (via Timesheet),Dejanski končni datum (preko Čas lista),
Total Expense Claim (via Expense Claim),Total Expense zahtevek (preko Expense zahtevka),
Review Date,Pregled Datum,
Closing Date,Zapiranje Datum,
Task Depends On,Naloga je odvisna od,
Task Type,Vrsta naloge,
TS-.YYYY.-,TS-.LLLL.-,
Employee Detail,Podrobnosti zaposleni,
Billing Details,Podrobnosti o obračunavanju,
Total Billable Hours,Skupaj plačljivih ur,
Total Billed Hours,Skupaj Obračunane ure,
Total Costing Amount,Skupaj Stanejo Znesek,
Total Billable Amount,Skupaj Odgovorni Znesek,
Total Billed Amount,Skupaj zaračunano Znesek,
% Amount Billed,% Zaračunani znesek,
Hrs,Ur,
Costing Amount,Stanejo Znesek,
Corrective/Preventive,Korektivno / preventivno,
Corrective,Popravek,
Preventive,Preventivno,
Resolution,Ločljivost,
Resolutions,Ločljivosti,
Quality Action Resolution,Kakovostna ločljivost ukrepov,
Quality Feedback Parameter,Parameter kakovostne povratne informacije,
Quality Feedback Template Parameter,Parameter predloge kakovosti povratne informacije,
Quality Goal,Cilj kakovosti,
Monitoring Frequency,Spremljanje pogostosti,
Weekday,Delovni dan,
Objectives,Cilji,
Quality Goal Objective,Cilj Kakovostni cilj,
Objective,Cilj,
Agenda,Dnevni red,
Minutes,Minute,
Quality Meeting Agenda,Agenda o kakovostnem srečanju,
Quality Meeting Minutes,Zapisniki o kakovostnem sestanku,
Minute,Minute,
Parent Procedure,Starševski postopek,
Processes,Procesi,
Quality Procedure Process,Postopek kakovosti postopka,
Process Description,Opis postopka,
Link existing Quality Procedure.,Povezati obstoječi postopek kakovosti.,
Additional Information,Dodatne informacije,
Quality Review Objective,Cilj pregleda kakovosti,
DATEV Settings,Nastavitve DATEV,
Regional,regionalno,
Consultant ID,ID svetovalca,
GST HSN Code,DDV HSN koda,
HSN Code,Tarifna številka,
GST Settings,GST Nastavitve,
GST Summary,DDV Povzetek,
GSTIN Email Sent On,"GSTIN e-pošti,",
GST Accounts,GST računi,
B2C Limit,Omejitev B2C,
Set Invoice Value for B2C. B2CL and B2CS calculated based on this invoice value.,"Nastavite vrednost računa za B2C. B2CL in B2CS, izračunano na podlagi te fakture.",
GSTR 3B Report,Poročilo GSTR 3B,
January,Januarja,
February,Februarja,
March,Marec,
April,April,
May,Maj,
June,Junij,
July,Julija,
August,Avgusta,
September,Septembra,
October,Oktober,
November,Novembra,
December,December,
JSON Output,Izhod JSON,
Invoices with no Place Of Supply,Računi brez kraja dobave,
Import Supplier Invoice,Uvozi račun dobavitelja,
Invoice Series,Serija računov,
Upload XML Invoices,Naložite račune XML,
Zip File,Zip datoteka,
Import Invoices,Uvozi račune,
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.,"Ko dodate datoteko zip, kliknite gumb Uvozi račune. Vse napake, povezane z obdelavo, bodo prikazane v dnevniku napak.",
Lower Deduction Certificate,Spodnje potrdilo o odbitku,
Certificate Details,Podrobnosti potrdila,
194A,194A,
194C,194C,
194D,194D,
194H,194H,
194I,194I,
194J,194J,
194LA,194LA,
194LBB,194LBB,
194LBC,194LBC,
Certificate No,Potrdilo št,
Deductee Details,Podrobnosti o odbitku,
PAN No,PAN št,
Validity Details,Podrobnosti o veljavnosti,
Rate Of TDS As Per Certificate,Stopnja TDS na potrdilo,
Certificate Limit,Omejitev certifikata,
Invoice Series Prefix,Predpisi serije računov,
Active Menu,Aktivni meni,
Restaurant Menu,Restavracija Meni,
Price List (Auto created),Cenik (samodejno ustvarjen),
Restaurant Manager,Upravitelj restavracij,
Restaurant Menu Item,Restavracija Menu Item,
Restaurant Order Entry,Vnos naročila restavracij,
Restaurant Table,Restavracija Tabela,
Click Enter To Add,Kliknite Enter za dodajanje,
Last Sales Invoice,Zadnji račun za prodajo,
Current Order,Trenutni naročilo,
Restaurant Order Entry Item,Vnos naročila restavracije,
Served,Servirano,
Restaurant Reservation,Rezervacija restavracij,
Waitlisted,Waitlisted,
No Show,Ni predstave,
No of People,Število ljudi,
Reservation Time,Čas rezervacije,
Reservation End Time,Končni čas rezervacije,
No of Seats,Število sedežev,
Minimum Seating,Najmanjše število sedežev,
"Keep Track of Sales Campaigns. Keep track of Leads, Quotations, Sales Order etc from Campaigns to gauge Return on Investment. ","Spremljajte prodajnih akcij. Spremljajte Interesenti, citatov, Sales Order itd iz akcije, da bi ocenili donosnost naložbe.",
SAL-CAM-.YYYY.-,SAL-CAM-.LLLL.-,
Campaign Schedules,Časovni razpored akcij,
Buyer of Goods and Services.,Kupec blaga in storitev.,
CUST-.YYYY.-,CUST-.YYYY.-,
Default Company Bank Account,Privzeti bančni račun podjetja,
From Lead,Iz ponudbe,
Account Manager,Upravitelj računa,
Allow Sales Invoice Creation Without Sales Order,Dovoli ustvarjanje prodajnega računa brez prodajnega naloga,
Allow Sales Invoice Creation Without Delivery Note,Dovoli ustvarjanje prodajnega računa brez dobavnice,
Default Price List,Privzeto Cenik,
Primary Address and Contact Detail,Osnovni naslov in kontaktni podatki,
"Select, to make the customer searchable with these fields","Izberite, da bo stranka s temi področji omogočila iskanje",
Customer Primary Contact,Primarni kontakt s strankami,
"Reselect, if the chosen contact is edited after save","Ponovno izbere, če je izbrani stik po urejanju urejen",
Customer Primary Address,Primarni naslov stranke,
"Reselect, if the chosen address is edited after save","Ponovno izberite, če je izbrani naslov urejen po shranjevanju",
Primary Address,Primarni naslov,
Mention if non-standard receivable account,Omemba če nestandardno terjatve račun,
Credit Limit and Payment Terms,Kreditno omejitev in plačilni pogoji,
Additional information regarding the customer.,Dodatne informacije o kupcu.,
Sales Partner and Commission,Prodaja Partner in Komisija,
Commission Rate,Komisija Rate,
Sales Team Details,Sales Team Podrobnosti,
Customer POS id,ID kupca POS,
Customer Credit Limit,Omejitev kupca,
Bypass Credit Limit Check at Sales Order,Obvezno preverjanje kreditne omejitve pri prodajni nalogi,
Industry Type,Industrija Type,
MAT-INS-.YYYY.-,MAT-INS-.LLLL.-,
Installation Date,Datum vgradnje,
Installation Time,Namestitev čas,
Installation Note Item,Namestitev Opomba Postavka,
Installed Qty,Nameščen Kol,
Lead Source,Vir ponudbe,
Period Start Date,Datum začetka obdobja,
Period End Date,Datum konca obdobja,
Cashier,Blagajnik,
Difference,Razlika,
Modes of Payment,Načini plačila,
Linked Invoices,Povezani računi,
POS Closing Voucher Details,Podrobnosti POS pridržka,
Collected Amount,Zbrani znesek,
Expected Amount,Pričakovani znesek,
POS Closing Voucher Invoices,POS računi z zaprtimi računi,
Quantity of Items,Količina izdelkov,
"Aggregate group of **Items** into another **Item**. This is useful if you are bundling a certain **Items** into a package and you maintain stock of the packed **Items** and not the aggregate **Item**. \n\nThe package **Item** will have ""Is Stock Item"" as ""No"" and ""Is Sales Item"" as ""Yes"".\n\nFor Example: If you are selling Laptops and Backpacks separately and have a special price if the customer buys both, then the Laptop + Backpack will be a new Product Bundle Item.\n\nNote: BOM = Bill of Materials","Agregat skupina ** Items ** v drugo ** postavki **. To je uporabno, če ste združevanje neka ** Items ** v paketu in jo vzdrževati zalogo pakiranih ** Items ** in ne agregat ** item **. Paket ** Item ** bodo imeli &quot;Je Stock Postavka&quot; kot &quot;ne&quot; in &quot;Je Sales Item&quot;, kot je &quot;Yes&quot;. Na primer: Če prodajate Prenosniki in nahrbtniki ločeno in imajo posebno ceno, če kupec kupi tako, potem bo Laptop + nahrbtnik nov Bundle Izdelek točka. Opomba: BOM = Bill of Materials",
Parent Item,Parent Item,
List items that form the package.,"Seznam predmetov, ki tvorijo paket.",
SAL-QTN-.YYYY.-,SAL-QTN-YYYY-,
Quotation To,Ponudba za,
Rate at which customer's currency is converted to company's base currency,"Obrestna mera, po kateri kupec je valuti, se pretvori v osnovni valuti družbe",
Rate at which Price list currency is converted to company's base currency,"Obrestna mera, po kateri Cenik valuti, se pretvori v osnovni valuti družbe",
Additional Discount and Coupon Code,Dodatna koda popusta in kupona,
Referral Sales Partner,Referral Sales Partner,
In Words will be visible once you save the Quotation.,"V besedi bo viden, ko boste prihranili citata.",
Term Details,Izraz Podrobnosti,
Quotation Item,Postavka ponudbe,
Against Doctype,Proti DOCTYPE,
Against Docname,Proti Docname,
Additional Notes,Dodatne opombe,
SAL-ORD-.YYYY.-,SAL-ORD-.YYYY.-,
Skip Delivery Note,Preskočite dobavnico,
In Words will be visible once you save the Sales Order.,"V besedi bo viden, ko boste shranite Sales Order.",
Track this Sales Order against any Project,Sledi tej Sales Order proti kateri koli projekt,
Billing and Delivery Status,Zaračunavanje in Delivery Status,
Not Delivered,Ne Delivered,
Fully Delivered,Popolnoma Delivered,
Partly Delivered,Delno Delivered,
Not Applicable,Se ne uporablja,
%  Delivered,% Dostavljeno,
% of materials delivered against this Sales Order,% materiala dobavljeno po tej naročilnici,
% of materials billed against this Sales Order,% materiala zaračunano po tej naročilnici,
Not Billed,Ne zaračunavajo,
Fully Billed,Popolnoma zaračunavajo,
Partly Billed,Delno zaračunavajo,
Ensure Delivery Based on Produced Serial No,Zagotovite dostavo na podlagi izdelane serijske številke,
Supplier delivers to Customer,Dobavitelj zagotavlja naročniku,
Delivery Warehouse,Dostava Skladišče,
Planned Quantity,Načrtovana Količina,
For Production,Za proizvodnjo,
Work Order Qty,Količina naročila dela,
Produced Quantity,Proizvedena količina,
Used for Production Plan,Uporablja se za proizvodnjo načrta,
Sales Partner Type,Vrsta prodajnega partnerja,
Contact No.,Kontakt št.,
Contribution (%),Prispevek (%),
Contribution to Net Total,Prispevek k Net Total,
Selling Settings,Prodaja Nastavitve,
Settings for Selling Module,Nastavitve za modul Prodaja,
Customer Naming By,Stranka Imenovanje Z,
Campaign Naming By,Imenovanje akcija Z,
Default Customer Group,Privzeta skupina kupcev,
Default Territory,Privzeto Territory,
Close Opportunity After Days,Zapri Priložnost Po dnevih,
Default Quotation Validity Days,Privzeti dnevi veljavnosti ponudbe,
Sales Update Frequency,Pogostost prodajnega posodabljanja,
Each Transaction,Vsaka transakcija,
SMS Center,SMS center,
Send To,Pošlji,
All Contact,Vse Kontakt,
All Customer Contact,Vse Customer Contact,
All Supplier Contact,Vse Dobavitelj Kontakt,
All Sales Partner Contact,Vse Sales Partner Kontakt,
All Lead (Open),Vse ponudbe (Odprte),
All Employee (Active),Vsi zaposlenih (Active),
All Sales Person,Vse Sales oseba,
Create Receiver List,Ustvarite sprejemnik seznam,
Receiver List,Sprejemnik Seznam,
Messages greater than 160 characters will be split into multiple messages,"Sporočila večji od 160 znakov, bo razdeljeno v več sporočilih",
Total Characters,Skupaj Znaki,
Total Message(s),Skupaj sporočil (-i),
Authorization Control,Pooblastilo za nadzor,
Authorization Rule,Dovoljenje Pravilo,
Average Discount,Povprečen Popust,
Customerwise Discount,Customerwise Popust,
Itemwise Discount,Itemwise Popust,
Customer or Item,Stranka ali Artikel,
Customer / Item Name,Stranka / Ime artikla,
Authorized Value,Dovoljena vrednost,
Applicable To (Role),Ki se uporabljajo za (vloga),
Applicable To (Employee),Ki se uporabljajo za (zaposlenih),
Applicable To (User),Ki se uporabljajo za (Uporabnik),
Applicable To (Designation),Ki se uporabljajo za (Oznaka),
Approving Role (above authorized value),Odobritvi vloge (nad pooblaščeni vrednosti),
Approving User  (above authorized value),Odobritvi uporabnik (zgoraj pooblaščeni vrednosti),
Brand Defaults,Privzete vrednosti blagovne znamke,
Legal Entity / Subsidiary with a separate Chart of Accounts belonging to the Organization.,Pravna oseba / Hčerinska družba z ločenim računom ki pripada organizaciji.,
Change Abbreviation,Spremeni kratico,
Parent Company,Matična družba,
Default Values,Privzete vrednosti,
Default Holiday List,Privzeti seznam praznikov,
Default Selling Terms,Privzeti prodajni pogoji,
Default Buying Terms,Privzeti pogoji nakupa,
Create Chart Of Accounts Based On,"Ustvariti kontni okvir, ki temelji na",
Standard Template,standard Template,
Existing Company,Obstoječe podjetje,
Chart Of Accounts Template,Graf Of predlogo računov,
Existing Company ,obstoječa podjetja,
Date of Establishment,Datum ustanavljanja,
Sales Settings,Nastavitve prodaje,
Monthly Sales Target,Mesečni prodajni cilj,
Sales Monthly History,Mesečna zgodovina prodaje,
Transactions Annual History,Letno zgodovino transakcij,
Total Monthly Sales,Skupna mesečna prodaja,
Default Cash Account,Privzeti gotovinski račun,
Default Receivable Account,Privzeto Terjatve račun,
Round Off Cost Center,Zaokrožen stroškovni center,
Discount Allowed Account,Popust dovoljen račun,
Discount Received Account,Popust s prejetim računom,
Exchange Gain / Loss Account,Exchange Gain / izida,
Unrealized Exchange Gain/Loss Account,Nerealiziran borzni dobiček / izguba,
Allow Account Creation Against Child Company,Dovoli ustvarjanje računa proti otroški družbi,
Default Payable Account,Privzeto plačljivo račun,
Default Employee Advance Account,Privzeti račun zaposlenega,
Default Cost of Goods Sold Account,Privzeto Nabavna vrednost prodanega blaga račun,
Default Income Account,Privzeto Prihodki račun,
Default Deferred Revenue Account,Privzeti odloženi prihodki,
Default Deferred Expense Account,Privzeti odloženi račun za stroške,
Default Payroll Payable Account,Privzeto Plače plačljivo račun,
Default Expense Claim Payable Account,Zahtevani račun za izplačilo neplačila,
Stock Settings,Nastavitve Stock,
Enable Perpetual Inventory,Omogoči nepretrganega popisovanja,
Default Inventory Account,Privzeti Popis račun,
Stock Adjustment Account,Račun prilagoditev zaloge,
Fixed Asset Depreciation Settings,Osnovno sredstvo Nastavitve amortizacije,
Series for Asset Depreciation Entry (Journal Entry),Serija za vpis vrednosti amortizacije (dnevnik),
Gain/Loss Account on Asset Disposal,Dobiček / izguba račun o odlaganju sredstev,
Asset Depreciation Cost Center,Asset Center Amortizacija Stroški,
Budget Detail,Proračun Detail,
Exception Budget Approver Role,Izvršilna vloga za odobritev proračuna,
Company Info,Informacije o podjetju,
For reference only.,Samo za referenco.,
Company Logo,Logo podjetja,
Date of Incorporation,Datum ustanovitve,
Date of Commencement,Datum začetka,
Phone No,Telefon,
Company Description,Opis podjetja,
Registration Details,Podrobnosti registracije,
Company registration numbers for your reference. Tax numbers etc.,Registracijska št. podjetja za lastno evidenco. Davčna številka itn.,
Delete Company Transactions,Izbriši transakcije družbe,
Currency Exchange,Menjalnica,
Specify Exchange Rate to convert one currency into another,Določite Menjalni tečaj za pretvorbo ene valute v drugo,
From Currency,Iz valute,
To Currency,Valutnemu,
For Buying,Za nakup,
For Selling,Za prodajo,
Customer Group Name,Ime skupine strank,
Parent Customer Group,Parent Customer Group,
Only leaf nodes are allowed in transaction,Samo leaf vozlišča so dovoljene v transakciji,
Mention if non-standard receivable account applicable,"Omemba če nestandardni terjatve račun, ki se uporablja",
Credit Limits,Kreditne omejitve,
Email Digest,Email Digest,
Send regular summary reports via Email.,Pošlji redna zbirna poročila preko e-maila.,
Email Digest Settings,E-pošta Digest Nastavitve,
How frequently?,Kako pogosto?,
Next email will be sent on:,Naslednje sporočilo bo poslano na:,
Note: Email will not be sent to disabled users,Opomba: E-mail ne bo poslano uporabnike invalide,
Profit & Loss,Profit &amp; Loss,
New Income,Novi prihodki,
New Expenses,Novi stroški,
Annual Income,Letni dohodek,
Annual Expenses,letni stroški,
Bank Balance,Banka Balance,
Bank Credit Balance,Kreditno stanje banke,
Receivables,Terjatve,
Payables,Obveznosti,
Sales Orders to Bill,Prodajna naročila za Bill,
Purchase Orders to Bill,Naročila za nakup,
New Sales Orders,Novi prodajni nalogi,
New Purchase Orders,Nova naročila,
Sales Orders to Deliver,"Prodajne naloge, ki jih želite oddati",
Purchase Orders to Receive,Naročila za nakup,
New Purchase Invoice,Nov račun za nakup,
New Quotations,Nove ponudbe,
Open Quotations,Odprte Ponudbe,
Open Issues,Odprta vprašanja,
Open Projects,Odprti projekti,
Purchase Orders Items Overdue,Postavke nakupnih naročil so prepozne,
Upcoming Calendar Events,Prihajajoči koledarski dogodki,
Open To Do,Odprto za opravila,
Add Quote,Dodaj Citiraj,
Global Defaults,Globalni Privzeto,
Default Company,Privzeto Podjetje,
Current Fiscal Year,Tekočem proračunskem letu,
Default Distance Unit,Privzeta enota za razdaljo,
Hide Currency Symbol,Skrij valutni simbol,
Do not show any symbol like $ etc next to currencies.,"Ne kažejo vsak simbol, kot $ itd zraven valute.",
"If disable, 'Rounded Total' field will not be visible in any transaction","Če onemogočiti, polje &quot;zaokrožena Skupaj &#39;ne bo viden v vsakem poslu",
Disable In Words,"Onemogoči ""z besedami""",
"If disable, 'In Words' field will not be visible in any transaction","Če onemogočiti, &quot;z besedami&quot; polja ne bo vidna v vsakem poslu",
Item Classification,Postavka Razvrstitev,
General Settings,Splošne nastavitve,
Item Group Name,Item Name Group,
Parent Item Group,Parent Item Group,
Item Group Defaults,Privzete nastavitve skupine elementov,
Item Tax,Postavka Tax,
Check this if you want to show in website,"Označite to, če želite, da kažejo na spletni strani",
Show this slideshow at the top of the page,Pokažite ta diaprojekcije na vrhu strani,
HTML / Banner that will show on the top of product list.,"HTML pasica, ki se bo prikazala na vrhu seznama izdelkov.",
Set prefix for numbering series on your transactions,Nastavite predpona za številčenje serij na vaše transakcije,
Setup Series,Nastavitve zaporedja,
Select Transaction,Izberite Transaction,
Help HTML,Pomoč HTML,
Series List for this Transaction,Seznam zaporedij za to transakcijo,
User must always select,Uporabnik mora vedno izbrati,
Check this if you want to force the user to select a series before saving. There will be no default if you check this.,"Označite to, če želite, da prisili uporabnika, da izberete vrsto pred shranjevanjem. Tam ne bo privzeto, če to preverite.",
Update Series,Posodobi zaporedje,
Change the starting / current sequence number of an existing series.,Spremenite izhodiščno / trenutno zaporedno številko obstoječega zaporedja.,
Prefix,Predpona,
Current Value,Trenutna vrednost,
This is the number of the last created transaction with this prefix,To je številka zadnjega ustvarjene transakcijo s tem predpono,
Update Series Number,Posodobi številko zaporedja,
Quotation Lost Reason,Kotacija Lost Razlog,
A third party distributor / dealer / commission agent / affiliate / reseller who sells the companies products for a commission.,"Distributer tretja oseba / trgovec / provizije agent / podružnica / prodajalec, ki prodaja podjetja, izdelke za provizijo.",
Sales Partner Name,Prodaja Partner Name,
Partner Type,Partner Type,
Address & Contacts,Naslov &amp; Kontakti,
Address Desc,Naslov opis izdelka,
Contact Desc,Kontakt opis izdelka,
Sales Partner Target,Prodaja Partner Target,
Targets,Cilji,
Show In Website,Pokaži V Website,
Referral Code,napotitvena koda,
To Track inbound purchase,Sledenje vhodnemu nakupu,
Logo,Logo,
Partner website,spletna stran partnerja,
All Sales Transactions can be tagged against multiple **Sales Persons** so that you can set and monitor targets.,"Vse prodajne transakcije je lahko označena pred številnimi ** Prodajni Osebe **, tako da lahko nastavite in spremljanje ciljev.",
Name and Employee ID,Ime in zaposlenih ID,
Sales Person Name,Prodaja Oseba Name,
Parent Sales Person,Nadrejena Sales oseba,
Select company name first.,Izberite ime podjetja prvič.,
Sales Person Targets,Prodaja Osebni cilji,
Set targets Item Group-wise for this Sales Person.,Določiti cilje Postavka Group-pametno za te prodaje oseba.,
Supplier Group Name,Ime skupine izvajalcev,
Parent Supplier Group,Matična skupina dobaviteljev,
Target Detail,Ciljna Detail,
Target Qty,Ciljna Kol,
Target  Amount,Ciljni znesek,
Target Distribution,Target Distribution,
"Standard Terms and Conditions that can be added to Sales and Purchases.\n\nExamples:\n\n1. Validity of the offer.\n1. Payment Terms (In Advance, On Credit, part advance etc).\n1. What is extra (or payable by the Customer).\n1. Safety / usage warning.\n1. Warranty if any.\n1. Returns Policy.\n1. Terms of shipping, if applicable.\n1. Ways of addressing disputes, indemnity, liability, etc.\n1. Address and Contact of your Company.","Standardni Pogoji, ki se lahko dodajajo prodaje in nakupe. Primeri: 1. Veljavnost ponudbe. 1. Plačilni pogoji (vnaprej, na kredit, del predujem itd). 1. Kaj je dodatno (ali ga je dolžan plačati davek). Opozorilo / uporaba 1. varnost. 1. Garancija če sploh. 1. Izjava zasebnosti. 1. Pogoji ladijskega prometa, če je to primerno. 1. načine reševanja sporov, jamstva, odgovornosti, itd 1. Naslov in kontaktne vašega podjetja.",
Applicable Modules,Veljavni moduli,
Terms and Conditions Help,Pogoji Pomoč,
Classification of Customers by region,Razvrstitev stranke po regijah,
Territory Name,Territory Name,
Parent Territory,Parent Territory,
Territory Manager,Ozemlje Manager,
For reference,Za sklic,
Territory Targets,Territory cilji,
Set Item Group-wise budgets on this Territory. You can also include seasonality by setting the Distribution.,Set Postavka proračuni Skupina pametno na tem ozemlju. Lahko tudi sezonske z nastavitvijo Distribution.,
UOM Name,UOM Name,
Check this to disallow fractions. (for Nos),"Preverite, da je to prepoveste frakcij. (za številkami)",
Website Item Group,Spletna stran Element Group,
Cross Listing of Item in multiple groups,Cross Uvrstitev točke v več skupinah,
Default settings for Shopping Cart,Privzete nastavitve za Košarica,
Enable Shopping Cart,Omogoči Košarica,
Display Settings,Nastavitve zaslona,
Show Public Attachments,Prikaži Javna Priključki,
Show Price,Prikaži ceno,
Show Stock Availability,Prihranite sedaj null%!,
Show Contact Us Button,Prikaži gumb Stik z nami,
Show Stock Quantity,Prikaži dodatke skladno z RoHS,
Show Apply Coupon Code,Prikaži Uporabi kodo kupona,
Allow items not in stock to be added to cart,"Dovoli, da se izdelki, ki niso na zalogi, dodajo v košarico",
Prices will not be shown if Price List is not set,"Cene se ne bodo pokazale, če Cenik ni nastavljen",
Quotation Series,Zaporedje ponudb,
Checkout Settings,Naročilo Nastavitve,
Enable Checkout,Omogoči Checkout,
Payment Success Url,Plačilo Uspeh URL,
After payment completion redirect user to selected page.,Po zaključku plačila preusmeri uporabnika na izbrano stran.,
Batch Details,Podrobnosti o seriji,
Batch ID,Serija ID,
image,slike,
Parent Batch,nadrejena Serija,
Manufacturing Date,Datum izdelave,
Batch Quantity,Količina serije,
Batch UOM,Paket UOM,
Source Document Type,Vir Vrsta dokumenta,
Source Document Name,Vir Ime dokumenta,
Batch Description,Serija Opis,
Bin,Bin,
Reserved Quantity,Rezervirano Količina,
Actual Quantity,Dejanska količina,
Requested Quantity,Zahtevana količina,
Reserved Qty for sub contract,Rezervirano Kol za podizvajalsko pogodbo,
Moving Average Rate,Moving Average Rate,
FCFS Rate,FCFS Rate,
Customs Tariff Number,Carinska tarifa številka,
Tariff Number,tarifna številka,
Delivery To,Dostava,
MAT-DN-.YYYY.-,MAT-DN-YYYY-,
Is Return,Je Return,
Issue Credit Note,Izdajte kreditno obvestilo,
Return Against Delivery Note,Vrni Proti dobavnica,
Customer's Purchase Order No,Stranke Naročilo Ne,
Billing Address Name,Zaračunavanje Naslov Name,
Required only for sample item.,Zahteva le za točko vzorca.,
"If you have created a standard template in Sales Taxes and Charges Template, select one and click on the button below.","Če ste ustvarili standardno predlogo v prodaji davkov in dajatev predlogo, izberite eno in kliknite na gumb spodaj.",
In Words will be visible once you save the Delivery Note.,"V besedi bo viden, ko boste shranite dobavnici.",
In Words (Export) will be visible once you save the Delivery Note.,"Z besedami (izvoz) bo viden, ko boste shranite dobavnici.",
Transporter Info,Transporter Info,
Driver Name,Ime voznika,
Track this Delivery Note against any Project,Sledi tej dobavnica proti kateri koli projekt,
Inter Company Reference,Inter Company Reference,
Print Without Amount,Natisni Brez Znesek,
% Installed,% nameščeno,
% of materials delivered against this Delivery Note,% materiala dobavljeno po tej dobavnici,
Installation Status,Namestitev Status,
Excise Page Number,Trošarinska Številka strani,
Instructions,Navodila,
From Warehouse,Iz skladišča,
Against Sales Order,Za Naročilo Kupca,
Against Sales Order Item,Proti Sales Order Postavka,
Against Sales Invoice,Za račun,
Against Sales Invoice Item,Proti Sales računa Postavka,
Available Batch Qty at From Warehouse,Dostopno Serija Količina na IZ SKLADIŠČA,
Available Qty at From Warehouse,Na voljo Količina na IZ SKLADIŠČA,
Delivery Settings,Nastavitve dostave,
Dispatch Settings,Nastavitve pošiljanja,
Dispatch Notification Template,Predloga za odpošiljanje,
Dispatch Notification Attachment,Priloga za obvestilo o odpošiljanju,
Leave blank to use the standard Delivery Note format,"Pustite prazno, da uporabite standardno obliko zapisa za dostavo",
Send with Attachment,Pošlji s prilogo,
Delay between Delivery Stops,Zakasnitev med stopnjami dostave,
Delivery Stop,Dostava Stop,
Lock,Zakleni,
Visited,Obiskan,
Order Information,Informacije o naročilu,
Contact Information,Kontaktni podatki,
Email sent to,E-pošta poslana,
Dispatch Information,Informacije o odpremi,
Estimated Arrival,Ocenjeni prihod,
MAT-DT-.YYYY.-,MAT-DT-YYYY-,
Initial Email Notification Sent,Poslano je poslano obvestilo o e-pošti,
Delivery Details,Dostava Podrobnosti,
Driver Email,E-pošta voznika,
Driver Address,Naslov voznika,
Total Estimated Distance,Skupna ocenjena razdalja,
Distance UOM,Razdalja UOM,
Departure Time,Čas odhoda,
Delivery Stops,Dobavni izklopi,
Calculate Estimated Arrival Times,Izračunajte predvideni čas prihoda,
Use Google Maps Direction API to calculate estimated arrival times,Uporabite API za usmerjanje Google Maps za izračun predvidenih časov prihoda,
Optimize Route,Optimizirajte pot,
Use Google Maps Direction API to optimize route,Uporabite API za usmerjanje Google Maps za optimizacijo poti,
In Transit,V tranzitu,
Fulfillment User,Uporabnik izpolnjevanja,
"A Product or a Service that is bought, sold or kept in stock.","Izdelek ali storitev, ki je kupil, prodal ali jih hranijo na zalogi.",
STO-ITEM-.YYYY.-,STO-ITEM-.GGGZ.-,
Variant Of,Varianta,
"If item is a variant of another item then description, image, pricing, taxes etc will be set from the template unless explicitly specified","Če postavka je varianta drug element, potem opis, slike, cene, davki, itd bo določil iz predloge, razen če je izrecno določeno",
Is Item from Hub,Je predmet iz vozlišča,
Default Unit of Measure,Privzeto mersko enoto,
Maintain Stock,Ohraniti Zalogo,
Standard Selling Rate,Standardni Prodajni tečaj,
Auto Create Assets on Purchase,Samodejno ustvari sredstva ob nakupu,
Asset Naming Series,Serija imenovanja sredstev,
Over Delivery/Receipt Allowance (%),Nadomestilo za dostavo / prejem (%),
Barcodes,Črtne kode,
Shelf Life In Days,Rok uporabe v dnevih,
End of Life,End of Life,
Default Material Request Type,Privzeto Material Vrsta Zahteva,
Valuation Method,Metoda vrednotenja,
FIFO,FIFO,
Moving Average,Moving Average,
Warranty Period (in days),Garancijski rok (v dnevih),
Auto re-order,Auto re-order,
Reorder level based on Warehouse,Raven Preureditev temelji na Warehouse,
Will also apply for variants unless overrridden,Bo veljalo tudi za variante razen overrridden,
Units of Measure,Merske enote,
Will also apply for variants,Bo veljalo tudi za variante,
Serial Nos and Batches,Serijska št in Serije,
Has Batch No,Ima številko serije,
Automatically Create New Batch,Samodejno Ustvari novo serijo,
Batch Number Series,Serijska številka serije,
"Example: ABCD.#####. If series is set and Batch No is not mentioned in transactions, then automatic batch number will be created based on this series. If you always want to explicitly mention Batch No for this item, leave this blank. Note: this setting will take priority over the Naming Series Prefix in Stock Settings.","Primer: ABCD. #####. Če je serija nastavljena in številka paketa ni navedena v transakcijah, bo na podlagi te serije izdelana avtomatična serijska številka. Če za to postavko vedno želite izrecno omeniti Lot št., Pustite to prazno. Opomba: ta nastavitev bo imela prednost pred imeniku serije Prefix v nastavitvah zalog.",
Has Expiry Date,Ima rok veljavnosti,
Retain Sample,Ohrani vzorec,
Max Sample Quantity,Max vzorčna količina,
Maximum sample quantity that can be retained,"Največja količina vzorca, ki jo je mogoče obdržati",
Has Serial No,Ima serijsko številko,
Serial Number Series,Serijska številka zaporedja,
"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.","Primer:. ABCD ##### Če je serija nastavljen in serijska številka ni navedena v transakcijah, se bo ustvaril nato samodejno serijska številka, ki temelji na tej seriji. Če ste si vedno želeli izrecno omeniti Serial številk za to postavko. pustite prazno.",
Variants,Variante,
Has Variants,Ima različice,
"If this item has variants, then it cannot be selected in sales orders etc.","Če ima ta postavka variante, potem ne more biti izbran v prodajnih naročil itd",
Variant Based On,"Varianta, ki temelji na",
Item Attribute,Postavka Lastnost,
"Sales, Purchase, Accounting Defaults","Prodaja, nabava, privzete računovodske izkaze",
Item Defaults,Privzeta postavka,
"Purchase, Replenishment Details","Podrobnosti o nakupu, dopolnitvi",
Is Purchase Item,Je Nakup Postavka,
Default Purchase Unit of Measure,Privzeta nabavna enota ukrepa,
Minimum Order Qty,Najmanjše naročilo Kol,
Minimum quantity should be as per Stock UOM,Najmanjša količina mora biti po UOM na zalogi,
Average time taken by the supplier to deliver,"Povprečen čas, ki ga dobavitelj dostaviti",
Is Customer Provided Item,Ali je izdelek s strani stranke,
Delivered by Supplier (Drop Ship),Dostavi dobavitelja (Drop Ship),
Supplier Items,Dobavitelj Items,
Foreign Trade Details,Zunanjo trgovino Podrobnosti,
Country of Origin,Država izvora,
Sales Details,Prodajna Podrobnosti,
Default Sales Unit of Measure,Privzeta prodajna enota ukrepa,
Is Sales Item,Je Sales Postavka,
Max Discount (%),Max Popust (%),
No of Months,Število mesecev,
Customer Items,Artikli stranke,
Inspection Criteria,Merila pregleda,
Inspection Required before Purchase,Pregled Zahtevan pred nakupom,
Inspection Required before Delivery,Pregled Zahtevan pred dostavo,
Default BOM,Privzeta surovina,
Supply Raw Materials for Purchase,Dobava surovine za nakup,
If subcontracted to a vendor,Če podizvajanje prodajalca,
Customer Code,Koda za stranke,
Default Item Manufacturer,Privzeti proizvajalec izdelkov,
Default Manufacturer Part No,Privzeta št. Dela proizvajalca,
Show in Website (Variant),Prikaži na spletni strani (Variant),
Items with higher weightage will be shown higher,Postavke z višjo težo bodo prikazane višje,
Show a slideshow at the top of the page,Prikaži diaprojekcijo na vrhu strani,
Website Image,Slika spletnega mesta,
Website Warehouse,Spletna stran Skladišče,
"Show ""In Stock"" or ""Not in Stock"" based on stock available in this warehouse.","Pokaži &quot;Na zalogi&quot; ali &quot;Ni na zalogi&quot;, ki temelji na zalogi na voljo v tem skladišču.",
Website Item Groups,Spletna stran Element Skupine,
List this Item in multiple groups on the website.,Seznam ta postavka v več skupinah na spletni strani.,
Copy From Item Group,Kopiranje iz postavke skupine,
Website Content,Vsebina spletnega mesta,
You can use any valid Bootstrap 4 markup in this field. It will be shown on your Item Page.,V tem polju lahko uporabite katero koli veljavno oznako Bootstrap 4. To bo prikazano na strani izdelka.,
Total Projected Qty,Skupne projekcije Kol,
Hub Publishing Details,Podrobnosti o objavi vozlišča,
Publish in Hub,Objavite v Hub,
Publish Item to hub.erpnext.com,Objavite element na hub.erpnext.com,
Hub Category to Publish,Kategorija vozlišča za objavo,
Hub Warehouse,Vozliščno skladišče,
"Publish ""In Stock"" or ""Not in Stock"" on Hub based on stock available in this warehouse.","Objavite &quot;Na zalogi&quot; ali &quot;Ni na zalogi&quot; na vozlišču na podlagi zalog, ki so na voljo v tem skladišču.",
Synced With Hub,Sinhronizirano Z Hub,
Item Alternative,Postavka Alternative,
Alternative Item Code,Alternativni koda izdelka,
Two-way,Dvosmerni,
Alternative Item Name,Alternativno ime predmeta,
Attribute Name,Ime atributa,
Numeric Values,Numerične vrednosti,
From Range,Od Območje,
Increment,Prirastek,
To Range,Da Domet,
Item Attribute Values,Postavka Lastnost Vrednote,
Item Attribute Value,Postavka Lastnost Vrednost,
Attribute Value,Vrednosti atributa,
Abbreviation,Kratica,
"This will be appended to the Item Code of the variant. For example, if your abbreviation is ""SM"", and the item code is ""T-SHIRT"", the item code of the variant will be ""T-SHIRT-SM""","To bo dodan Točka Kodeksa variante. Na primer, če je vaša kratica je &quot;SM&quot;, in oznaka postavka je &quot;T-shirt&quot;, postavka koda varianto bo &quot;T-SHIRT-SM&quot;",
Item Barcode,Postavka Barcode,
Barcode Type,Tip črtne kode,
EAN,EAN,
UPC-A,UPC-A,
Item Customer Detail,Postavka Detail Stranka,
"For the convenience of customers, these codes can be used in print formats like Invoices and Delivery Notes","Za udobje kupcev lahko te kode se uporabljajo v tiskanih oblikah, kot so na računih in dobavnicah",
Ref Code,Ref Code,
Item Default,Element Privzeto,
Purchase Defaults,Nakup privzete vrednosti,
Default Buying Cost Center,Privzet stroškovni center za nabavo,
Default Supplier,Privzeto Dobavitelj,
Default Expense Account,Privzeto Expense račun,
Sales Defaults,Privzete prodaje,
Default Selling Cost Center,Privzet stroškovni center prodaje,
Item Manufacturer,Element Proizvajalec,
Item Price,Item Cena,
Packing Unit,Pakirna enota,
Quantity  that must be bought or sold per UOM,"Količina, ki jo je treba kupiti ali prodati na UOM",
Item Quality Inspection Parameter,Postavka Inšpekcijski parametrov kakovosti,
Acceptance Criteria,Merila sprejemljivosti,
Item Reorder,Postavka Preureditev,
Check in (group),Preverite v (skupina),
Request for,Prošnja za,
Re-order Level,Ponovno naročila ravni,
Re-order Qty,Ponovno naročila Kol,
Item Supplier,Postavka Dobavitelj,
Item Variant,Postavka Variant,
Item Variant Attribute,Postavka Variant Lastnost,
Do not update variants on save,Ne shranjujte različic pri shranjevanju,
Fields will be copied over only at time of creation.,Polja bodo kopirana samo v času ustvarjanja.,
Allow Rename Attribute Value,Dovoli preimenovanje vrednosti atributa,
Rename Attribute Value in Item Attribute.,Preimenuj atribut vrednosti atributa elementa.,
Copy Fields to Variant,Kopiraj polja v Variant,
Item Website Specification,Element Spletna stran Specifikacija,
Table for Item that will be shown in Web Site,"Tabela za postavko, ki bo prikazana na spletni strani",
Landed Cost Item,Pristali Stroški Postavka,
Receipt Document Type,Prejem Vrsta dokumenta,
Receipt Document,prejem dokumenta,
Applicable Charges,Veljavnih cenah,
Purchase Receipt Item,Potrdilo o nakupu Postavka,
Landed Cost Purchase Receipt,Pristali Stroški Potrdilo o nakupu,
Landed Cost Taxes and Charges,Iztovorjeni stroškov Davki in prispevki,
Landed Cost Voucher,Pristali Stroški bon,
MAT-LCV-.YYYY.-,MAT-LCV-.YYYY.-,
Purchase Receipts,Odkupne Prejemki,
Purchase Receipt Items,Nakup Prejem Items,
Get Items From Purchase Receipts,Dobili predmetov iz nakupa Prejemki,
Distribute Charges Based On,Distribuirajo pristojbin na podlagi,
Landed Cost Help,Pristali Stroški Pomoč,
Manufacturers used in Items,"Proizvajalci, ki se uporabljajo v postavkah",
Limited to 12 characters,Omejena na 12 znakov,
MAT-MR-.YYYY.-,MAT-MR-.YYYY.-,
Partially Ordered,Delno naročeno,
Transferred,Preneseni,
% Ordered,% Naročeno,
Terms and Conditions Content,Pogoji in vsebina,
Quantity and Warehouse,Količina in skladišča,
Lead Time Date,Lead Time Datum,
Min Order Qty,Min naročilo Kol,
Packed Item,Pakirani Postavka,
To Warehouse (Optional),Da Warehouse (po želji),
Actual Batch Quantity,Dejanska količina serije,
Prevdoc DocType,Prevdoc DOCTYPE,
Parent Detail docname,Parent Detail docname,
"Generate packing slips for packages to be delivered. Used to notify package number, package contents and its weight.","Ustvarjajo dobavnic, da paketi dostavi. Uporablja se za uradno številko paketa, vsebino paketa in njegovo težo.",
Indicates that the package is a part of this delivery (Only Draft),"Kaže, da je paket del tega dostave (samo osnutka)",
MAT-PAC-.YYYY.-,MAT-PAC-.LLLL.-,
From Package No.,Od paketa No.,
Identification of the package for the delivery (for print),Identifikacija paketu za dostavo (za tisk),
To Package No.,Če želite Paket No.,
If more than one package of the same type (for print),Če več paketov istega tipa (v tisku),
Package Weight Details,Paket Teža Podrobnosti,
The net weight of this package. (calculated automatically as sum of net weight of items),Neto teža tega paketa. (samodejno izračuna kot vsota neto težo blaga),
Net Weight UOM,Neto teža UOM,
Gross Weight,Bruto Teža,
The gross weight of the package. Usually net weight + packaging material weight. (for print),Bruto teža paketa. Ponavadi neto teža + embalaža teže. (za tisk),
Gross Weight UOM,Bruto Teža UOM,
Packing Slip Item,Pakiranje Slip Postavka,
DN Detail,DN Detail,
STO-PICK-.YYYY.-,STO-PICK-.YYYY.-,
Material Transfer for Manufacture,Prenos materialov za proizvodnjo,
Qty of raw materials will be decided based on the qty of the Finished Goods Item,Količina surovin se bo določila na podlagi količine postavke končnega blaga,
Parent Warehouse,Parent Skladišče,
Items under this warehouse will be suggested,Predmeti v tem skladišču bodo predlagani,
Get Item Locations,Pridobite lokacije,
Item Locations,Lokacije postavk,
Pick List Item,Izberi element seznama,
Picked Qty,Izbrana količina,
Price List Master,Cenik Master,
Price List Name,Cenik Ime,
Price Not UOM Dependent,Cena ni odvisna od UOM,
Applicable for Countries,Velja za države,
Price List Country,Cenik Država,
MAT-PRE-.YYYY.-,MAT-PRE-.YYYY.-,
Supplier Delivery Note,Opomba: dobavitelj dostava,
Time at which materials were received,"Čas, v katerem so bile prejete materiale",
Return Against Purchase Receipt,Vrni Proti Potrdilo o nakupu,
Rate at which supplier's currency is converted to company's base currency,"Obrestna mera, po kateri dobavitelj je valuti, se pretvori v osnovni valuti družbe",
Sets 'Accepted Warehouse' in each row of the items table.,V vsako vrstico tabele elementov nastavi »Sprejeto skladišče«.,
Sets 'Rejected Warehouse' in each row of the items table.,Nastavi &#39;Zavrnjeno skladišče&#39; v vsaki vrstici tabele elementov.,
Raw Materials Consumed,Porabljene surovine,
Get Current Stock,Pridobite trenutne zaloge,
Consumed Items,Porabljeni predmeti,
Add / Edit Taxes and Charges,Dodaj / Uredi davkov in dajatev,
Auto Repeat Detail,Samodejno ponovite podrobnosti,
Transporter Details,Transporter Podrobnosti,
Vehicle Number,Število vozil,
Vehicle Date,Datum vozilo,
Received and Accepted,Prejme in potrdi,
Accepted Quantity,Accepted Količina,
Rejected Quantity,Zavrnjeno Količina,
Accepted Qty as per Stock UOM,Sprejeta količina po zalogi UOM,
Sample Quantity,Količina vzorca,
Rate and Amount,Stopnja in znesek,
MAT-QA-.YYYY.-,MAT-QA-YYYY-,
Report Date,Poročilo Datum,
Inspection Type,Tip pregleda,
Item Serial No,Postavka Zaporedna številka,
Sample Size,Velikost vzorca,
Inspected By,Pregledal,
Readings,Odčitki,
Quality Inspection Reading,Kakovost Inšpekcijski Reading,
Reading 1,Branje 1,
Reading 2,Branje 2,
Reading 3,Branje 3,
Reading 4,Branje 4,
Reading 5,Branje 5,
Reading 6,Branje 6,
Reading 7,Branje 7,
Reading 8,Branje 8,
Reading 9,Branje 9,
Reading 10,Branje 10,
Quality Inspection Template Name,Kakovostna inšpekcijska preglednica Ime,
Quick Stock Balance,Hitro stanje zalog,
Available Quantity,Količina na voljo,
Distinct unit of an Item,Ločena enota Postavka,
Warehouse can only be changed via Stock Entry / Delivery Note / Purchase Receipt,Skladišče je mogoče spremeniti samo prek borze Vstop / Delivery Note / Potrdilo o nakupu,
Purchase / Manufacture Details,Nakup / Izdelava Podrobnosti,
Creation Document Type,Creation Document Type,
Creation Document No,Za ustvarjanje dokumentov ni,
Creation Date,Datum nastanka,
Creation Time,Čas ustvarjanja,
Asset Details,Podrobnosti o sredstvih,
Asset Status,Stanje sredstev,
Delivery Document Type,Dostava Document Type,
Delivery Document No,Dostava dokument št,
Delivery Time,Čas dostave,
Invoice Details,Podrobnosti na računu,
Warranty / AMC Details,Garancija / AMC Podrobnosti,
Warranty Expiry Date,Garancija Datum preteka,
AMC Expiry Date,AMC preteka Datum,
Under Warranty,Pod garancijo,
Out of Warranty,Iz garancije,
Under AMC,Pod AMC,
Out of AMC,Od AMC,
Warranty Period (Days),Garancijski rok (dni),
Serial No Details,Serijska št Podrobnosti,
MAT-STE-.YYYY.-,MAT-STE-YYYY-,
Stock Entry Type,Vrsta vpisa,
Stock Entry (Outward GIT),Vnos zalog (zunanji GIT),
Material Consumption for Manufacture,Poraba materiala za izdelavo,
Repack,Zapakirajte,
Send to Subcontractor,Pošlji podizvajalcu,
Delivery Note No,Dostava Opomba Ne,
Sales Invoice No,Prodaja Račun Ne,
Purchase Receipt No,Potrdilo o nakupu Ne,
Inspection Required,Pregled Zahtevan,
From BOM,Od BOM,
For Quantity,Za Količino,
As per Stock UOM,Kot je na borzi UOM,
Including items for sub assemblies,"Vključno s postavkami, za sklope",
Default Source Warehouse,Privzeto Vir Skladišče,
Source Warehouse Address,Naslov skladišča vira,
Default Target Warehouse,Privzeto Target Skladišče,
Target Warehouse Address,Naslov tarče skladišča,
Update Rate and Availability,Posodobitev Oceni in razpoložljivost,
Total Incoming Value,Skupaj Dohodni Vrednost,
Total Outgoing Value,Skupaj Odhodni Vrednost,
Total Value Difference (Out - In),Skupna vrednost Razlika (Out - IN),
Additional Costs,Dodatni stroški,
Total Additional Costs,Skupaj Dodatni stroški,
Customer or Supplier Details,Stranka ali dobavitelj Podrobnosti,
Per Transferred,Na preneseno,
Stock Entry Detail,Stock Začetek Detail,
Basic Rate (as per Stock UOM),Osnovni tečaj (kot na borzi UOM),
Basic Amount,Osnovni znesek,
Additional Cost,Dodatne Stroški,
Serial No / Batch,Zaporedna številka / Batch,
BOM No. for a Finished Good Item,BOM No. za Končni Good postavki,
Material Request used to make this Stock Entry,Material Zahteva se uporablja za izdelavo tega staleža Entry,
Subcontracted Item,Postavka s podizvajalci,
Against Stock Entry,Proti vpisu zalog,
Stock Entry Child,Zaloga Otrok,
PO Supplied Item,PO dobavljeni artikel,
Reference Purchase Receipt,Referenčno potrdilo o nakupu,
Stock Ledger Entry,Stock Ledger Entry,
Outgoing Rate,Odhodni Rate,
Actual Qty After Transaction,Dejanska Kol Po Transaction,
Stock Value Difference,Stock Value Razlika,
Stock Queue (FIFO),Stock Queue (FIFO),
Is Cancelled,Je Preklicana,
Stock Reconciliation,Uskladitev zalog,
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.,To orodje vam pomaga posodobiti ali popravite količino in vrednotenje zalog v sistemu. To se ponavadi uporablja za sinhronizacijo sistemske vrednosti in kaj dejansko obstaja v vaših skladiščih.,
MAT-RECO-.YYYY.-,MAT-RECO-.LLLL.-,
Reconciliation JSON,Uskladitev JSON,
Stock Reconciliation Item,Stock Sprava Postavka,
Before reconciliation,Pred uskladitvijo,
Current Serial No,Trenutna serijska št,
Current Valuation Rate,Trenutni tečaj Vrednotenje,
Current Amount,Trenutni znesek,
Quantity Difference,količina Razlika,
Amount Difference,znesek Razlika,
Item Naming By,Postavka Poimenovanje S,
Default Item Group,Privzeto Element Group,
Default Stock UOM,Privzeto Stock UOM,
Sample Retention Warehouse,Skladišče za shranjevanje vzorcev,
Default Valuation Method,Način Privzeto Vrednotenje,
Show Barcode Field,Prikaži Barcode Field,
Convert Item Description to Clean HTML,Preoblikovati postavko Opis za čiščenje HTML,
Allow Negative Stock,Dovoli Negative Stock,
Automatically Set Serial Nos based on FIFO,Samodejno nastavi Serijska št temelji na FIFO,
Auto Material Request,Auto Material Zahteva,
Inter Warehouse Transfer Settings,Nastavitve prenosa Inter Warehouse,
Freeze Stock Entries,Freeze Stock Vnosi,
Stock Frozen Upto,Stock Zamrznjena Stanuje,
Batch Identification,Identifikacija serije,
Use Naming Series,Uporabite Naming Series,
Naming Series Prefix,Namig serijske oznake,
UOM Category,Kategorija UOM,
UOM Conversion Detail,UOM Conversion Detail,
Variant Field,Različno polje,
A logical Warehouse against which stock entries are made.,"Logično Warehouse, zoper katerega so narejeni vnosov zalog.",
Warehouse Detail,Skladišče Detail,
Warehouse Name,Skladišče Ime,
Warehouse Contact Info,Skladišče Kontakt Info,
PIN,PIN,
ISS-.YYYY.-,ISS-.LLLL.-,
Raised By (Email),Postavljeno Z (e-naslov),
Issue Type,Vrsta izdaje,
Issue Split From,Izdaja Split Od,
Service Level,Raven storitev,
Response By,Odgovor avtor,
Response By Variance,Odziv po različici,
Ongoing,V teku,
Resolution By,Resolucija avtorja,
Resolution By Variance,Ločljivost po različici,
Service Level Agreement Creation,Izdelava sporazuma o ravni storitev,
First Responded On,Najprej odgovorila,
Resolution Details,Resolucija Podrobnosti,
Opening Date,Otvoritev Datum,
Opening Time,Otvoritev čas,
Resolution Date,Resolucija Datum,
Via Customer Portal,Preko portala za stranke,
Support Team,Support Team,
Issue Priority,Prednostna izdaja,
Service Day,Dan storitve,
Workday,Delovni dan,
Default Priority,Privzeta prioriteta,
Priorities,Prednostne naloge,
Support Hours,podpora ure,
Support and Resolution,Podpora in ločljivost,
Default Service Level Agreement,Sporazum o ravni privzetih storitev,
Entity,Entiteta,
Agreement Details,Podrobnosti o sporazumu,
Response and Resolution Time,Čas odziva in reševanja,
Service Level Priority,Prednostna raven storitve,
Resolution Time,Čas ločljivosti,
Support Search Source,Podpora v iskalnem omrežju,
Source Type,Vrsta vira,
Query Route String,String String poizvedbe,
Search Term Param Name,Ime izraza Param za iskanje,
Response Options,Možnosti odziva,
Response Result Key Path,Ključna pot Result Result,
Post Route String,String nizov poti,
Post Route Key List,Seznam seznama ključnih besed,
Post Title Key,Ključ za objavo naslova,
Post Description Key,Ključ za opis sporočila,
Link Options,Možnosti povezave,
Source DocType,Vir DocType,
Result Title Field,Polje naslova rezultata,
Result Preview Field,Polje za predogled rezultatov,
Result Route Field,Polje poti rezultatov,
Service Level Agreements,Dogovori o ravni storitev,
Track Service Level Agreement,Sledite sporazumu o ravni storitev,
Allow Resetting Service Level Agreement,Dovoli ponastavitev sporazuma o ravni storitev,
Close Issue After Days,Zapri Težava Po dnevih,
Auto close Issue after 7 days,Auto blizu Izdaja po 7 dneh,
Support Portal,Podporni portal,
Get Started Sections,Začnite razdelke,
Show Latest Forum Posts,Pokaži zadnje objave foruma,
Forum Posts,Objave foruma,
Forum URL,Forum URL,
Get Latest Query,Najnovejša poizvedba,
Response Key List,Seznam odzivnih ključev,
Post Route Key,Ključ objave posta,
Search APIs,API za iskanje,
SER-WRN-.YYYY.-,SER-WRN-.YYYY.-,
Issue Date,Datum izdaje,
Item and Warranty Details,Točka in Garancija Podrobnosti,
Warranty / AMC Status,Garancija / AMC Status,
Resolved By,Rešujejo s,
Service Address,Storitev Naslov,
If different than customer address,Če je drugačen od naslova kupca,
Raised By,Raised By,
From Company,Od družbe,
Rename Tool,Preimenovanje orodje,
Utilities,Utilities,
Type of document to rename.,Vrsta dokumenta preimenovati.,
File to Rename,Datoteka za preimenovanje,
"Attach .csv file with two columns, one for the old name and one for the new name","Pripni datoteko .csv z dvema stolpcema, eno za staro ime in enega za novim imenom",
Rename Log,Preimenovanje Prijava,
SMS Log,SMS Log,
Sender Name,Sender Name,
Sent On,Pošlje On,
No of Requested SMS,Št zaprošene SMS,
Requested Numbers,Zahtevane številke,
No of Sent SMS,Število poslanih SMS,
Sent To,Poslano,
Absent Student Report,Odsoten Student Report,
Assessment Plan Status,Status načrta ocenjevanja,
Asset Depreciation Ledger,Sredstvo Amortizacija Ledger,
Asset Depreciations and Balances,Premoženjem amortizacije in Stanja,
Available Stock for Packing Items,Zaloga za embalirane izdelke,
Bank Clearance Summary,Banka Potrditev Povzetek,
Bank Remittance,Bančno nakazilo,
Batch Item Expiry Status,Serija Točka preteka Status,
Batch-Wise Balance History,Serija-Wise Balance Zgodovina,
BOM Explorer,BOM Explorer,
BOM Search,BOM Iskanje,
BOM Stock Calculated,Izračun BOM,
BOM Variance Report,Poročilo o varstvu BOM,
Campaign Efficiency,kampanja Učinkovitost,
Cash Flow,Denarni tok,
Completed Work Orders,Dokončana delovna naročila,
To Produce,Za izdelavo,
Produced,Proizvedena,
Consolidated Financial Statement,Konsolidirani računovodski izkazi,
Course wise Assessment Report,Tečajno poročilo o oceni,
Customer Acquisition and Loyalty,Stranka Pridobivanje in zvestobe,
Customer Credit Balance,Stranka Credit Balance,
Customer Ledger Summary,Povzetek glavne knjige strank,
Customer-wise Item Price,Cena izdelka za kupce,
Customers Without Any Sales Transactions,Stranke brez prodajnih transakcij,
Daily Timesheet Summary,Dnevni Timesheet Povzetek,
Daily Work Summary Replies,Povzetki dnevnega dela Povzetki,
DATEV,DATEV,
Delayed Item Report,Poročilo o zakasnjeni postavki,
Delayed Order Report,Poročilo o zamudnem naročilu,
Delivered Items To Be Billed,Dobavljeni artikli placevali,
Delivery Note Trends,Dobavnica Trendi,
Electronic Invoice Register,Register elektronskih računov,
Employee Advance Summary,Povzetek zaposlenih,
Employee Billing Summary,Povzetek obračunavanja zaposlenih,
Employee Birthday,Zaposleni Rojstni dan,
Employee Information,Informacije zaposleni,
Employee Leave Balance,Zaposleni Leave Balance,
Employee Leave Balance Summary,Povzetek salda zaposlenih,
Employees working on a holiday,Zaposleni na počitnice,
Eway Bill,Eway Bill,
Expiring Memberships,Izguba članstva,
Fichier des Ecritures Comptables [FEC],Fichier des Ecritures Comptables [FEC],
Final Assessment Grades,Končne ocene,
Fixed Asset Register,Register nepremičnega premoženja,
Gross and Net Profit Report,Poročilo o bruto in neto dobičku,
GST Itemised Purchase Register,DDV Razčlenjeni Nakup Registracija,
GST Itemised Sales Register,DDV Razčlenjeni prodaje Registracija,
GST Purchase Register,DDV Nakup Registracija,
GST Sales Register,DDV prodaje Registracija,
GSTR-1,GSTR-1,
GSTR-2,GSTR-2,
Hotel Room Occupancy,Hotelske sobe,
HSN-wise-summary of outward supplies,HSN-modri povzetek zunanjih dobav,
Inactive Customers,neaktivne stranke,
Inactive Sales Items,Neaktivni prodajni artikli,
IRS 1099,IRS 1099,
Issued Items Against Work Order,Izdane predmete proti delovnemu nalogu,
Projected Quantity as Source,Predvidena količina kot vir,
Item Balance (Simple),Postavka Balance (Enostavno),
Item Price Stock,Cena artikla,
Item Prices,Postavka Cene,
Item Shortage Report,Postavka Pomanjkanje Poročilo,
Item Variant Details,Podrobnosti o elementu Variante,
Item-wise Price List Rate,Element-pametno Cenik Rate,
Item-wise Purchase History,Elementna Zgodovina nakupov,
Item-wise Purchase Register,Elementni Nakupni register,
Item-wise Sales History,Elementna Prodajna Zgodovina,
Item-wise Sales Register,Elementni Prodajni register,
Items To Be Requested,"Predmeti, ki bodo zahtevana",
Reserved,Rezervirano,
Itemwise Recommended Reorder Level,Itemwise Priporočena Preureditev Raven,
Lead Details,Podrobnosti ponudbe,
Lead Owner Efficiency,Svinec Lastnik Učinkovitost,
Loan Repayment and Closure,Povračilo in zaprtje posojila,
Loan Security Status,Stanje varnosti posojila,
Lost Opportunity,Izgubljena priložnost,
Maintenance Schedules,Vzdrževanje Urniki,
Material Requests for which Supplier Quotations are not created,Material Prošnje za katere so Dobavitelj Citati ni ustvaril,
Monthly Attendance Sheet,Mesečni Udeležba Sheet,
Open Work Orders,Odpiranje delovnih nalogov,
Qty to Deliver,Količina na Deliver,
Patient Appointment Analytics,Analitika imenovanja pacientov,
Payment Period Based On Invoice Date,Plačilo obdobju na podlagi računa Datum,
Pending SO Items For Purchase Request,Dokler SO Točke za nakup dogovoru,
Procurement Tracker,Sledilnik javnih naročil,
Product Bundle Balance,Bilanca izdelka,
Production Analytics,proizvodne Analytics,
Profit and Loss Statement,Izkaz poslovnega izida,
Profitability Analysis,Analiza dobičkonosnosti,
Project Billing Summary,Povzetek obračunavanja za projekt,
Project wise Stock Tracking,Projektno sledenje zalog,
Project wise Stock Tracking ,Projekt pametno Stock Tracking,
Prospects Engaged But Not Converted,Obeti Ukvarjajo pa ne pretvorijo,
Purchase Analytics,Odkupne Analytics,
Purchase Invoice Trends,Račun za nakup Trendi,
Qty to Receive,Količina za prejemanje,
Received Qty Amount,Prejeta količina v količini,
Billed Qty,Število računov,
Purchase Order Trends,Naročilnica Trendi,
Purchase Receipt Trends,Nakup Prejem Trendi,
Purchase Register,Nakup Register,
Quotation Trends,Trendi ponudb,
Received Items To Be Billed,Prejete Postavke placevali,
Qty to Order,Količina naročiti,
Requested Items To Be Transferred,Zahtevane blago prenaša,
Qty to Transfer,Količina Prenos,
Salary Register,plača Registracija,
Sales Analytics,Prodajna analitika,
Sales Invoice Trends,Prodajni fakturi Trendi,
Sales Order Trends,Sales Order Trendi,
Sales Partner Commission Summary,Povzetek komisije za prodajne partnerje,
Sales Partner Target Variance based on Item Group,Ciljna varianta prodajnega partnerja na podlagi skupine izdelkov,
Sales Partner Transaction Summary,Povzetek transakcij prodajnega partnerja,
Sales Partners Commission,Partnerji Sales Komisija,
Invoiced Amount (Exclusive Tax),Predračunani znesek (brez davka),
Average Commission Rate,Povprečen Komisija Rate,
Sales Payment Summary,Povzetek prodaje plačila,
Sales Person Commission Summary,Povzetek Komisije za prodajno osebo,
Sales Person Target Variance Based On Item Group,Ciljna odstopanje prodajne osebe na podlagi skupine izdelkov,
Sales Person-wise Transaction Summary,Prodaja Oseba pametno Transakcijski Povzetek,
Sales Register,Prodaja Register,
Serial No Service Contract Expiry,Zaporedna številka Service Contract preteka,
Serial No Status,Serijska Status Ne,
Serial No Warranty Expiry,Zaporedna številka Garancija preteka,
Stock Ageing,Staranje zaloge,
Stock and Account Value Comparison,Primerjava zalog in računa,
Stock Projected Qty,Stock Predvidena Količina,
Student and Guardian Contact Details,Študent in Guardian Kontaktni podatki,
Student Batch-Wise Attendance,Študent šaržno in postrežbo,
Student Fee Collection,Študent Fee Collection,
Student Monthly Attendance Sheet,Študent Mesečni Udeležba Sheet,
Subcontracted Item To Be Received,"Izdelek, ki ga oddate v podizvajanje",
Subcontracted Raw Materials To Be Transferred,Podpogodbene surovine za prenos,
Supplier Ledger Summary,Povzetek glavne knjige dobavitelja,
Supplier-Wise Sales Analytics,Dobavitelj-Wise Prodajna Analytics,
Support Hour Distribution,Podpora Distribution Hour,
TDS Computation Summary,Povzetek izračunov TDS,
TDS Payable Monthly,TDS se plača mesečno,
Territory Target Variance Based On Item Group,Odstopanje glede na ciljno območje glede na skupino izdelkov,
Territory-wise Sales,Ozemeljska prodaja,
Total Stock Summary,Skupaj Stock Povzetek,
Trial Balance,Trial Balance,
Trial Balance (Simple),Preizkusna bilanca (preprosto),
Trial Balance for Party,Trial Balance za stranke,
Unpaid Expense Claim,Neplačana Expense zahtevek,
Warehouse wise Item Balance Age and Value,Skladiščno pametno Postavka Balansna doba in vrednost,
Work Order Stock Report,Poročilo o delovni nalogi,
Work Orders in Progress,Delovni nalogi v teku,
Validation Error,Napaka pri preverjanju,
Automatically Process Deferred Accounting Entry,Samodejno obdelaj odloženi računovodski vnos,
Bank Clearance,Obračun bank,
Bank Clearance Detail,Podrobnosti o bančnem obračunu,
Update Cost Center Name / Number,Posodobi ime / številko stroškovnega mesta,
Journal Entry Template,Predloga za vnos v dnevnik,
Template Title,Naslov predloge,
Journal Entry Type,Vrsta vpisa v revijo,
Journal Entry Template Account,Račun predloge za vnos v dnevnik,
Process Deferred Accounting,Obdelava odloženega računovodstva,
Manual entry cannot be created! Disable automatic entry for deferred accounting in accounts settings and try again,Ročnega vnosa ni mogoče ustvariti! Onemogočite samodejni vnos za odloženo računovodstvo v nastavitvah računov in poskusite znova,
End date cannot be before start date,Končni datum ne sme biti pred začetnim datumom,
Total Counts Targeted,Skupno ciljno štetje,
Total Counts Completed,Skupno štetje zaključenih,
Counts Targeted: {0},Število ciljev: {0},
Payment Account is mandatory,Plačilni račun je obvezen,
"If checked, the full amount will be deducted from taxable income before calculating income tax without any declaration or proof submission.","Če je označeno, se pred izračunom dohodnine odšteje celotni znesek od obdavčljivega dohodka brez kakršne koli izjave ali predložitve dokazila.",
Disbursement Details,Podrobnosti o izplačilu,
Material Request Warehouse,Skladišče zahtev za material,
Select warehouse for material requests,Izberite skladišče za zahteve po materialu,
Transfer Materials For Warehouse {0},Prenos materiala za skladišče {0},
Production Plan Material Request Warehouse,Skladišče zahtev za material načrta proizvodnje,
Sets 'Source Warehouse' in each row of the items table.,Nastavi &#39;Izvorno skladišče&#39; v vsaki vrstici tabele elementov.,
Sets 'Target Warehouse' in each row of the items table.,V vsako vrstico tabele postavk nastavi »Target Warehouse«.,
Show Cancelled Entries,Prikaži preklicane vnose,
Backdated Stock Entry,Vnos zalog z zadnjim datumom,
Row #{}: Currency of {} - {} doesn't matches company currency.,Vrstica št. {}: Valuta {} - {} se ne ujema z valuto podjetja.,
{} Assets created for {},"{} Sredstva, ustvarjena za {}",
{0} Number {1} is already used in {2} {3},{0} Številka {1} je že uporabljena v {2} {3},
Update Bank Clearance Dates,Posodobite datume potrditve bank,
Healthcare Practitioner: ,Zdravstveni delavec:,
Lab Test Conducted: ,Izveden laboratorijski test:,
Lab Test Event: ,Laboratorijski testni dogodek:,
Lab Test Result: ,Rezultat laboratorijskega testa:,
Clinical Procedure conducted: ,Izvedeni klinični postopek:,
Therapy Session Charges: {0},Stroški terapije: {0},
Therapy: ,Terapija:,
Therapy Plan: ,Načrt terapije:,
Total Counts Targeted: ,Skupno ciljno štetje:,
Total Counts Completed: ,Skupno zaključeno štetje:,
Andaman and Nicobar Islands,Andamanski in Nikobarski otoki,
Andhra Pradesh,Andhra Pradesh,
Arunachal Pradesh,Arunachal Pradesh,
Assam,Assam,
Bihar,Bihar,
Chandigarh,Chandigarh,
Chhattisgarh,Chhattisgarh,
Dadra and Nagar Haveli,Dadra in Nagar Haveli,
Daman and Diu,Daman in Diu,
Delhi,Delhi,
Goa,Goa,
Gujarat,Gujarat,
Haryana,Haryana,
Himachal Pradesh,Himachal Pradesh,
Jammu and Kashmir,Džamu in Kašmir,
Jharkhand,Jharkhand,
Karnataka,Karnataka,
Kerala,Kerala,
Lakshadweep Islands,Otoki Lakshadweep,
Madhya Pradesh,Madhya Pradesh,
Maharashtra,Maharaštra,
Manipur,Manipur,
Meghalaya,Meghalaya,
Mizoram,Mizoram,
Nagaland,Nagaland,
Odisha,Odisha,
Other Territory,Drugo ozemlje,
Pondicherry,Pondicherry,
Punjab,Punjab,
Rajasthan,Rajasthan,
Sikkim,Sikkim,
Tamil Nadu,Tamil Nadu,
Telangana,Telangana,
Tripura,Tripura,
Uttar Pradesh,Uttar Pradesh,
Uttarakhand,Uttarakhand,
West Bengal,Zahodna Bengalija,
Is Mandatory,Je obvezno,
Published on,Objavljeno dne,
Service Received But Not Billed,"Storitev prejeta, vendar ne obračunana",
Deferred Accounting Settings,Odložene nastavitve računovodstva,
Book Deferred Entries Based On,Rezervirajte odložene vnose na podlagi,
Days,Dnevi,
Months,Meseci,
Book Deferred Entries Via Journal Entry,Knjižite odložene vnose prek vnosa v dnevnik,
Submit Journal Entries,Predložite vnose v dnevnik,
If this is unchecked Journal Entries will be saved in a Draft state and will have to be submitted manually,"Če to polje ni potrjeno, bodo vnosi v dnevnik shranjeni v stanju osnutka in jih bo treba oddati ročno",
Enable Distributed Cost Center,Omogoči porazdeljeno stroškovno mesto,
Distributed Cost Center,Razdeljeno stroškovno mesto,
Dunning,Dunning,
DUNN-.MM.-.YY.-,DUNN-.MM .-. YY.-,
Overdue Days,Prepozni dnevi,
Dunning Type,Dunning Type,
Dunning Fee,Dunning Fee,
Dunning Amount,Znesek za izplačilo,
Resolved,Razrešeno,
Unresolved,Nerešeno,
Printing Setting,Nastavitve tiskanja,
Body Text,Telo besedila,
Closing Text,Zaključno besedilo,
Resolve,Reši,
Dunning Letter Text,Dunning Letter Besedilo,
Is Default Language,Je privzeti jezik,
Letter or Email Body Text,Telo besedila pisma ali e-pošte,
Letter or Email Closing Text,Zaključno besedilo pisma ali e-pošte,
Body and Closing Text Help,Pomoč za telo in zaključno besedilo,
Overdue Interval,Prepozni 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.","Ta odsek uporabniku omogoča, da na podlagi jezika nastavi jezik besedila Body in Zaključno besedilo Danning Letter za vrsto Dunning, ki ga je mogoče uporabiti v programu Print.",
Reference Detail No,Referenčna podrobnost št,
Custom Remarks,Opombe po meri,
Please select a Company first.,Najprej izberite podjetje.,
"Row #{0}: Reference Document Type must be one of Sales Order, Sales Invoice, Journal Entry or Dunning","Vrstica št. {0}: vrsta referenčnega dokumenta mora biti ena od prodajnih nalogov, prodajnih računov, vnosov v dnevnik ali odštevanje",
POS Closing Entry,POS zapiranje vnosa,
POS Opening Entry,POS otvoritveni vstop,
POS Transactions,POS transakcije,
POS Closing Entry Detail,Podrobnosti o zaključnem vnosu POS,
Opening Amount,Začetni znesek,
Closing Amount,Zaključni znesek,
POS Closing Entry Taxes,POS zaključni vstopni davki,
POS Invoice,POS račun,
ACC-PSINV-.YYYY.-,ACC-PSINV-.LLLL.-,
Consolidated Sales Invoice,Konsolidirani prodajni račun,
Return Against POS Invoice,Vrnitev na račun POS,
Consolidated,Prečiščeno,
POS Invoice Item,Postavka računa na POS-u,
POS Invoice Merge Log,Dnevnik spajanja računov POS,
POS Invoices,POS računi,
Consolidated Credit Note,Konsolidirano dobropis,
POS Invoice Reference,Referenca POS računa,
Set Posting Date,Nastavite datum knjiženja,
Opening Balance Details,Podrobnosti o otvoritvenem stanju,
POS Opening Entry Detail,Podrobnosti o vstopu v POS,
POS Payment Method,POS način plačila,
Payment Methods,načini plačila,
Process Statement Of Accounts,Obdelava izpiskov računov,
General Ledger Filters,Filtri glavne knjige,
Customers,Stranke,
Select Customers By,Izberite Stranke po,
Fetch Customers,Pridobite stranke,
Send To Primary Contact,Pošlji primarnemu stiku,
Print Preferences,Nastavitve tiskanja,
Include Ageing Summary,Vključi povzetek staranja,
Enable Auto Email,Omogoči samodejno e-pošto,
Filter Duration (Months),Trajanje filtra (meseci),
CC To,CC Za,
Help Text,Besedilo pomoči,
Emails Queued,E-poštna sporočila v čakalni vrsti,
Process Statement Of Accounts Customer,Obdelava izpiskov računov stranke,
Billing Email,E-poštni naslov za obračun,
Primary Contact Email,Primarni e-poštni naslov za stik,
PSOA Cost Center,Stroškovno mesto PSOA,
PSOA Project,Projekt PSOA,
ACC-PINV-RET-.YYYY.-,ACC-PINV-RET-.LLLL.-,
Supplier GSTIN,Dobavitelj GSTIN,
Place of Supply,Kraj dobave,
Select Billing Address,Izberite naslov za izstavitev računa,
GST Details,Podrobnosti GST,
GST Category,Kategorija GST,
Registered Regular,Registrirani redni,
Registered Composition,Registrirana sestava,
Unregistered,Neregistrirano,
SEZ,SEZ,
Overseas,V tujini,
UIN Holders,Imetniki UIN,
With Payment of Tax,S plačilom davka,
Without Payment of Tax,Brez plačila davka,
Invoice Copy,Kopija računa,
Original for Recipient,Izvirnik za prejemnika,
Duplicate for Transporter,Dvojnik za Transporter,
Duplicate for Supplier,Dvojnik za dobavitelja,
Triplicate for Supplier,Triplikat za dobavitelja,
Reverse Charge,Povratno polnjenje,
Y,Y.,
N,N,
E-commerce GSTIN,E-trgovina GSTIN,
Reason For Issuing document,Razlog za izdajo dokumenta,
01-Sales Return,01-Vračilo prodaje,
02-Post Sale Discount,Popust za prodajo po 02,
03-Deficiency in services,03-Pomanjkanje storitev,
04-Correction in Invoice,04-Popravek na računu,
05-Change in POS,05-Sprememba POS-a,
06-Finalization of Provisional assessment,06-Dokončanje začasne ocene,
07-Others,07-Drugi,
Eligibility For ITC,Upravičenost do ITC,
Input Service Distributor,Distributer vhodnih storitev,
Import Of Service,Uvoz storitev,
Import Of Capital Goods,Uvoz investicijskega blaga,
Ineligible,Neupravičeno,
All Other ITC,Vsi drugi ITC,
Availed ITC Integrated Tax,Izkoristek integriranega davka ITC,
Availed ITC Central Tax,Izkoristek centralnega davka ITC,
Availed ITC State/UT Tax,Izkoristiv davek ITC State / UT,
Availed ITC Cess,Izkoristek ITC Cess,
Is Nil Rated or Exempted,Ali ni ocenjen ali izvzet,
Is Non GST,Ni GST,
ACC-SINV-RET-.YYYY.-,ACC-SINV-RET-.LLLL.-,
E-Way Bill No.,E-Way Bill No.,
Is Consolidated,Je konsolidirano,
Billing Address GSTIN,Naslov za izstavitev računa GSTIN,
Customer GSTIN,Stranka GSTIN,
GST Transporter ID,ID prevoznika GST,
Distance (in km),Razdalja (v km),
Road,Cesta,
Air,Zrak,
Rail,Železnica,
Ship,Ladja,
GST Vehicle Type,Tip vozila GST,
Over Dimensional Cargo (ODC),Nadimenzionalni tovor (ODC),
Consumer,Potrošnik,
Deemed Export,Predvideni izvoz,
Port Code,Pristaniška koda,
 Shipping Bill Number,Številka pošiljke,
Shipping Bill Date,Datum računa za pošiljanje,
Subscription End Date,Končni datum naročnine,
Follow Calendar Months,Sledite koledarskim mesecem,
If this is checked subsequent new invoices will be created on calendar  month and quarter start dates irrespective of current invoice start date,"Če je to potrjeno, bodo naslednji računi ustvarjeni na začetni datum koledarskega meseca in četrtletja ne glede na začetni datum trenutnega računa",
Generate New Invoices Past Due Date,Ustvari nove račune z zapadlostjo,
New invoices will be generated as per schedule even if current invoices are unpaid or past due date,"Novi računi bodo ustvarjeni po urniku, tudi če so trenutni računi neplačani ali z zapadlostjo",
Document Type ,Vrsta dokumenta,
Subscription Price Based On,Cena naročnine na podlagi,
Fixed Rate,Fiksna stopnja,
Based On Price List,Na podlagi cenika,
Monthly Rate,Mesečna cena,
Cancel Subscription After Grace Period,Prekliči naročnino po milostnem obdobju,
Source State,Država izvora,
Is Inter State,Je Inter State,
Purchase Details,Podrobnosti o nakupu,
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  ","Privzeto je ime dobavitelja nastavljeno kot vneseno ime dobavitelja. Če želite, da dobavitelje imenuje",
 choose the 'Naming Series' option.,izberite možnost »Poimenovanje serij«.,
Configure the default Price List when creating a new Purchase transaction. Item prices will be fetched from this Price List.,Konfigurirajte privzeti cenik pri ustvarjanju nove nabavne transakcije. Cene izdelkov bodo pridobljene iz tega cenika.,
"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.","Če je ta možnost nastavljena na »Da«, vam ERPNext prepreči, da ustvarite račun za nakup ali potrdilo, ne da bi prej ustvarili naročilnico. To konfiguracijo lahko za določenega dobavitelja preglasite tako, da v glavnem meniju dobavitelja omogočite potrditveno polje »Dovoli ustvarjanje računa za nakup brez naročilnice«.",
"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.","Če je ta možnost nastavljena na »Da«, vam ERPNext prepreči, da ustvarite račun za nakup, ne da bi prej ustvarili potrdilo o nakupu. To konfiguracijo lahko za določenega dobavitelja preglasite tako, da v glavnem meniju dobavitelja omogočite potrditveno polje »Dovoli ustvarjanje računa za nakup brez potrdila o nakupu«.",
Quantity & Stock,Količina in zaloge,
Call Details,Podrobnosti klica,
Authorised By,Pooblaščen,
Signee (Company),Podpisnik (podjetje),
Signed By (Company),Podpisal (podjetje),
First Response Time,Prvi odzivni čas,
Request For Quotation,Zahteva za ponudbo,
Opportunity Lost Reason Detail,Podrobnosti o izgubljeni priložnosti,
Access Token Secret,Dostop do žetona Secret,
Add to Topics,Dodaj med teme,
...Adding Article to Topics,... Dodajanje članka temam,
Add Article to Topics,Dodaj članek temam,
This article is already added to the existing topics,Ta članek je že dodan obstoječim temam,
Add to Programs,Dodaj v programe,
Programs,Programi,
...Adding Course to Programs,... Dodajanje tečaja v programe,
Add Course to Programs,Dodajte tečaj v programe,
This course is already added to the existing programs,Ta tečaj je že dodan obstoječim programom,
Learning Management System Settings,Nastavitve sistema za upravljanje učenja,
Enable Learning Management System,Omogoči sistem za upravljanje učenja,
Learning Management System Title,Naslov sistema za upravljanje učenja,
...Adding Quiz to Topics,... Dodajanje kviza temam,
Add Quiz to Topics,Dodaj kviz v teme,
This quiz is already added to the existing topics,Ta kviz je že dodan obstoječim temam,
Enable Admission Application,Omogoči prijavo za sprejem,
EDU-ATT-.YYYY.-,EDU-ATT-.LLLL.-,
Marking attendance,Označevanje prisotnosti,
Add Guardians to Email Group,Dodajte skrbnike v e-poštno skupino,
Attendance Based On,Udeležba na podlagi,
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 to možnost, da označite študenta kot prisotnega, če se študent v vsakem primeru ne udeležuje inštituta, da bi sodeloval ali zastopal inštitut.",
Add to Courses,Dodaj v tečaje,
...Adding Topic to Courses,... Dodajanje teme tečajem,
Add Topic to Courses,Dodaj temo v tečaje,
This topic is already added to the existing courses,Ta tema je že dodana obstoječim tečajem,
"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","Če Shopify v naročilu nima stranke, bo sistem med sinhronizacijo naročil upošteval privzeto stranko za naročilo.",
The accounts are set by the system automatically but do confirm these defaults,"Račune sistem nastavi samodejno, vendar potrdi te privzete vrednosti",
Default Round Off Account,Privzeti zaokroženi račun,
Failed Import Log,Dnevnik uvoza ni uspel,
Fixed Error Log,Dnevnik popravljenih napak,
Company {0} already exists. Continuing will overwrite the Company and Chart of Accounts,Podjetje {0} že obstaja. Nadaljevanje bo prepisalo podjetje in kontni načrt,
Meta Data,Meta podatki,
Unresolve,Nereši,
Create Document,Ustvari dokument,
Mark as unresolved,Označi kot nerešeno,
TaxJar Settings,Nastavitve TaxJar,
Sandbox Mode,Način peskovnika,
Enable Tax Calculation,Omogoči izračun davka,
Create TaxJar Transaction,Ustvari transakcijo TaxJar,
Credentials,Poverilnice,
Live API Key,Ključ API v živo,
Sandbox API Key,Ključ API peskovnika,
Configuration,Konfiguracija,
Tax Account Head,Vodja davčnega računa,
Shipping Account Head,Vodja poštnega računa,
Practitioner Name,Ime izvajalca,
Enter a name for the Clinical Procedure Template,Vnesite ime za predlogo kliničnega postopka,
Set the Item Code which will be used for billing the Clinical Procedure.,"Nastavite kodo artikla, ki bo uporabljena za obračun kliničnega postopka.",
Select an Item Group for the Clinical Procedure Item.,Izberite skupino predmetov za postavko kliničnega postopka.,
Clinical Procedure Rate,Stopnja kliničnega postopka,
Check this if the Clinical Procedure is billable and also set the rate.,"To preverite, če je klinični postopek plačljiv, in nastavite tudi stopnjo.",
Check this if the Clinical Procedure utilises consumables. Click ,"To preverite, če klinični postopek uporablja potrošni material. Kliknite",
 to know more,vedeti več,
"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 predlogo lahko nastavite tudi zdravstveni oddelek. Po shranjevanju dokumenta bo samodejno ustvarjen element za obračun tega kliničnega postopka. To predlogo lahko nato uporabite pri ustvarjanju kliničnih postopkov za bolnike. Predloge vam prihranijo pred polnjenjem odvečnih podatkov vsakič. Ustvarite lahko tudi predloge za druge operacije, kot so laboratorijski testi, terapevtske seje itd.",
Descriptive Test Result,Opisni rezultat testa,
Allow Blank,Dovoli prazno,
Descriptive Test Template,Opisna preskusna predloga,
"If you want to track Payroll and other HRMS operations for a Practitoner, create an Employee and link it here.","Če želite spremljati plačilne liste in druge operacije HRMS za izvajalca, ustvarite zaposlenega in ga povežite tukaj.",
Set the Practitioner Schedule you just created. This will be used while booking appointments.,"Nastavite urnik praktikantov, ki ste ga pravkar ustvarili. To bo uporabljeno med rezervacijo terminov.",
Create a service item for Out Patient Consulting.,Ustvarite element storitve za Out Patient Consulting.,
"If this Healthcare Practitioner works for the In-Patient Department, create a service item for Inpatient Visits.","Če ta zdravnik dela za bolniški oddelek, ustvarite element storitve za bolnišnične obiske.",
Set the Out Patient Consulting Charge for this Practitioner.,Določite strošek svetovanja za pacienta za tega izvajalca.,
"If this Healthcare Practitioner also works for the In-Patient Department, set the inpatient visit charge for this Practitioner.","Če ta zdravstveni delavec deluje tudi v bolnišničnem oddelku, mu določite ceno bolnišničnega obiska.",
"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.","Če potrdite, bo za vsakega pacienta ustvarjena stranka. Pacientovi računi bodo ustvarjeni proti tej stranki. Med ustvarjanjem pacienta lahko izberete tudi obstoječo stranko. To polje je privzeto potrjeno.",
Collect Registration Fee,Pobirajte prijavnino,
"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.","Če vaša zdravstvena ustanova obračunava registracijo pacientov, lahko to preverite in v spodnjem polju nastavite prijavnino. Če to potrdite, bodo privzeto ustvarjeni novi bolniki s statusom invalida, ki bodo omogočeni šele po izstavitvi računa za registracijo.",
Checking this will automatically create a Sales Invoice whenever an appointment is booked for a Patient.,"Če to potrdite, bo samodejno ustvarjen račun za prodajo, kadar koli se sestane pacient.",
Healthcare Service Items,Predmeti zdravstvenih storitev,
"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 ",Ustvarite lahko element storitve za stroške obiska v bolnišnici in ga nastavite tukaj. Podobno lahko v tem razdelku nastavite druge postavke zdravstvenih storitev za obračun. Kliknite,
Set up default Accounts for the Healthcare Facility,Nastavite privzete račune za zdravstveno ustanovo,
"If you wish to override default accounts settings and configure the Income and Receivable accounts for Healthcare, you can do so here.","Če želite preglasiti privzete nastavitve računov in konfigurirati račune dohodka in terjatve za zdravstveno varstvo, lahko to storite tukaj.",
Out Patient SMS alerts,Opozorila za pacientove SMS,
"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 ","Če želite poslati SMS opozorilo ob registraciji bolnika, lahko to možnost omogočite. Podobno lahko v tem razdelku nastavite opozorila za pacientova sporočila SMS za druge funkcije. Kliknite",
Admission Order Details,Podrobnosti o naročilu za sprejem,
Admission Ordered For,Vstop naročen za,
Expected Length of Stay,Pričakovana dolžina bivanja,
Admission Service Unit Type,Vrsta enote sprejemne službe,
Healthcare Practitioner (Primary),Zdravnik (primarni),
Healthcare Practitioner (Secondary),Zdravstveni delavec (sekundarni),
Admission Instruction,Navodila za sprejem,
Chief Complaint,Pritožba načelnika,
Medications,Zdravila,
Investigations,Preiskave,
Discharge Detials,Razrešnice,
Discharge Ordered Date,Datum odredbe o odpustu,
Discharge Instructions,Navodila za izpust,
Follow Up Date,Datum nadaljnjega spremljanja,
Discharge Notes,Opombe o izpustu,
Processing Inpatient Discharge,Obdelava bolnišničnega odpusta,
Processing Patient Admission,Obdelava pacientovega sprejema,
Check-in time cannot be greater than the current time,Čas prijave ne sme biti daljši od trenutnega časa,
Process Transfer,Prenos procesa,
HLC-LAB-.YYYY.-,HLC-LAB-.LLLL.-,
Expected Result Date,Pričakovani datum rezultata,
Expected Result Time,Pričakovani čas rezultata,
Printed on,Natisnjeno dne,
Requesting Practitioner,Prosilec za prakso,
Requesting Department,Oddelek za prošnje,
Employee (Lab Technician),Zaposlen (laboratorijski tehnik),
Lab Technician Name,Ime laboratorijskega tehnika,
Lab Technician Designation,Določitev laboratorijskega tehnika,
Compound Test Result,Rezultat sestavljenega testa,
Organism Test Result,Rezultat testa organizma,
Sensitivity Test Result,Rezultat testa občutljivosti,
Worksheet Print,Tiskanje delovnega lista,
Worksheet Instructions,Navodila za delovni list,
Result Legend Print,Rezultat Legenda Natisni,
Print Position,Položaj tiskanja,
Bottom,Spodaj,
Top,Na vrh,
Both,Oboje,
Result Legend,Legenda rezultata,
Lab Tests,Laboratorijski testi,
No Lab Tests found for the Patient {0},Za pacienta niso bili najdeni laboratorijski testi {0},
"Did not send SMS, missing patient mobile number or message content.","Nisem poslal SMS-a, manjkajoče številke mobilnega telefona ali vsebine sporočila.",
No Lab Tests created,Ustvarjeni niso bili nobeni laboratorijski testi,
Creating Lab Tests...,Ustvarjanje laboratorijskih testov ...,
Lab Test Group Template,Predloga laboratorijske testne skupine,
Add New Line,Dodaj novo vrstico,
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>Posamezen</b> : rezultati, ki zahtevajo samo en vnos.<br> <b>Sestavljeno</b> : Rezultati, ki zahtevajo več vnosov dogodkov.<br> <b>Opisno</b> : preskusi z več komponentami rezultata z ročnim vnosom rezultata.<br> <b>Združene</b> : Preskusne predloge, ki so skupina drugih preskusnih predlog.<br> <b>Brez rezultata</b> : Testi brez rezultatov jih je mogoče naročiti in zaračunati, vendar laboratorijski test ne bo ustvarjen. npr. Podtesti za združene rezultate",
"If unchecked, the item will not be available in Sales Invoices for billing but can be used in group test creation. ","Če tega polja ne potrdite, izdelek ne bo na voljo v računih za prodajo za obračun, vendar ga je mogoče uporabiti pri ustvarjanju skupinskega preizkusa.",
Description ,Opis,
Descriptive Test,Opisni test,
Group Tests,Skupinski testi,
Instructions to be printed on the worksheet,Navodila za tiskanje na delovnem listu,
"Information to help easily interpret the test report, will be printed as part of the Lab Test result.",Podatki za lažjo razlago poročila o preskusu bodo natisnjeni kot del rezultata laboratorijskega testa.,
Normal Test Result,Običajni rezultat testa,
Secondary UOM Result,Sekundarni rezultat UOM,
Italic,Ležeče,
Underline,Podčrtaj,
Organism,Organizem,
Organism Test Item,Preizkusni element za organizem,
Colony Population,Prebivalstvo kolonij,
Colony UOM,Kolonija UOM,
Tobacco Consumption (Past),Poraba tobaka (preteklost),
Tobacco Consumption (Present),Uživanje tobaka (trenutno),
Alcohol Consumption (Past),Poraba alkohola (preteklost),
Alcohol Consumption (Present),Uživanje alkohola (trenutno),
Billing Item,Element za obračun,
Medical Codes,Medicinske kode,
Clinical Procedures,Klinični postopki,
Order Admission,Naroči sprejem,
Scheduling Patient Admission,Načrtovanje sprejema pacientov,
Order Discharge,Razrešnica naročila,
Sample Details,Podrobnosti vzorca,
Collected On,Zbrano dne,
No. of prints,Število odtisov,
Number of prints required for labelling the samples,"Število odtisov, potrebnih za označevanje vzorcev",
HLC-VTS-.YYYY.-,HLC-VTS-.LLLL.-,
In Time,Pravočasno,
Out Time,Čas izteka,
Payroll Cost Center,Stroškovno središče za plače,
Approvers,Odobritelji,
The first Approver in the list will be set as the default Approver.,Prvi odobritelj na seznamu bo nastavljen kot privzeti odobritelj.,
Shift Request Approver,Odobritelj zahteve za premik,
PAN Number,Številka PAN,
Provident Fund Account,Račun rezervnega sklada,
MICR Code,Koda MICR,
Repay unclaimed amount from salary,Vrnite neizterjani znesek iz plače,
Deduction from salary,Odbitek od plače,
Expired Leaves,Potekli listi,
Reference No,Referenčna št,
Haircut percentage is the percentage difference between market value of the Loan Security and the value ascribed to that Loan Security when used as collateral for that loan.,"Odstotek odbitka je odstotna razlika med tržno vrednostjo varščine za posojilo in vrednostjo, pripisano tej garanciji za posojilo, če se uporablja kot zavarovanje za to posojilo.",
Loan To Value Ratio expresses the ratio of the loan amount to the value of the security pledged. A loan security shortfall will be triggered if this falls below the specified value for any loan ,"Razmerje med posojilom in vrednostjo izraža razmerje med zneskom posojila in vrednostjo zastavljene vrednostne papirje. Pomanjkanje varščine za posojilo se sproži, če ta pade pod določeno vrednost za katero koli posojilo",
If this is not checked the loan by default will be considered as a Demand Loan,"Če to ni potrjeno, bo posojilo privzeto obravnavano kot posojilo na zahtevo",
This account is used for booking loan repayments from the borrower and also disbursing loans to the borrower,Ta račun se uporablja za rezervacijo odplačil posojilojemalca in tudi za izplačilo posojil posojilojemalcu,
This account is capital account which is used to allocate capital for loan disbursal account ,"Ta račun je račun kapitala, ki se uporablja za dodelitev kapitala za račun izplačila posojila",
This account will be used for booking loan interest accruals,Ta račun bo uporabljen za knjiženje pasivnih časovnih razmejitev,
This account will be used for booking penalties levied due to delayed repayments,"Ta račun bo uporabljen za rezervacijo kazni, zaračunane zaradi zamud pri odplačilu",
Variant BOM,Varianta BOM,
Template Item,Element predloge,
Select template item,Izberite element predloge,
Select variant item code for the template item {0},Izberite različico kode elementa za element predloge {0},
Downtime Entry,Vstop v čas izpadov,
DT-,DT-,
Workstation / Machine,Delovna postaja / stroj,
Operator,Operater,
In Mins,V min,
Downtime Reason,Razlog za izpad,
Stop Reason,Ustavite razlog,
Excessive machine set up time,Prekomerni čas nastavitve stroja,
Unplanned machine maintenance,Nenačrtovano vzdrževanje stroja,
On-machine press checks,Preverjanje tiska v stroju,
Machine operator errors,Napake upravljavca stroja,
Machine malfunction,Okvara stroja,
Electricity down,Zmanjšana elektrika,
Operation Row Number,Številka vrstice operacije,
Operation {0} added multiple times in the work order {1},Operacija {0} je bila večkrat dodana v delovni nalog {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.","Če je označeno, lahko za en delovni nalog uporabite več materialov. To je koristno, če izdelujete enega ali več zamudnih izdelkov.",
Backflush Raw Materials,Surovine za povratno splakovanje,
"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.","Vnos zalog tipa „Izdelava“ je znan kot povratno splakovanje. Surovine, ki se porabijo za proizvodnjo končnih izdelkov, so znane kot povratni splak.<br><br> Pri ustvarjanju vnosa v proizvodnjo se surovinski elementi ponovno splakujejo na podlagi specifikacije proizvodnega izdelka. Če želite, da se predmeti surovin naknadno splaknejo na podlagi vnosa prenosa materiala, ki je bil narejen za ta delovni nalog, ga lahko nastavite v tem polju.",
Work In Progress Warehouse,Skladišče v teku,
This Warehouse will be auto-updated in the Work In Progress Warehouse field of Work Orders.,To skladišče se bo samodejno posodobilo v polju Skladišče nedokončane obdelave delovnih nalogov.,
Finished Goods Warehouse,Skladišče končnih izdelkov,
This Warehouse will be auto-updated in the Target Warehouse field of Work Order.,To skladišče bo samodejno posodobljeno v polju Target Warehouse delovnega naloga.,
"If ticked, the BOM cost will be automatically updated based on Valuation Rate / Price List Rate / last purchase rate of raw materials.","Če je označeno, se BOM stroški samodejno posodobijo na podlagi stopnje vrednotenja / stopnje cenika / stopnje zadnjega odkupa surovin.",
Source Warehouses (Optional),Izvorni skladišča (neobvezno),
"System will pickup the materials from the selected warehouses. If not specified, system will create material request for purchase.","Sistem bo prevzel materiale iz izbranih skladišč. Če ni določeno, bo sistem ustvaril materialno zahtevo za nakup.",
Lead Time,Dobavni rok,
PAN Details,Podrobnosti o PAN,
Create Customer,Ustvari stranko,
Invoicing,Izdajanje računov,
Enable Auto Invoicing,Omogoči samodejno izdajanje računov,
Send Membership Acknowledgement,Pošljite potrditev članstva,
Send Invoice with Email,Pošljite račun z e-pošto,
Membership Print Format,Oblika tiskanja članstva,
Invoice Print Format,Oblika tiskanja računa,
Revoke <Key></Key>,Preklic&lt;Key&gt;&lt;/Key&gt;,
You can learn more about memberships in the manual. ,Več o članstvu lahko izveste v priročniku.,
ERPNext Docs,ERPNext Docs,
Regenerate Webhook Secret,Obnovi skrivnost Webhook,
Generate Webhook Secret,Ustvari skrivnost Webhook,
Copy Webhook URL,Kopirajte URL spletnega kljuka,
Linked Item,Povezani element,
Is Recurring,Se ponavlja,
HRA Exemption,Izjema HRA,
Monthly House Rent,Mesečni najem hiše,
Rented in Metro City,Oddano v Metro Cityju,
HRA as per Salary Structure,HRA po strukturi plač,
Annual HRA Exemption,Letna izjema HRA,
Monthly HRA Exemption,Mesečna izjema HRA,
House Rent Payment Amount,Znesek plačila najemnine za hišo,
Rented From Date,Oddano od datuma,
Rented To Date,Oddano do danes,
Monthly Eligible Amount,Mesečni upravičeni znesek,
Total Eligible HRA Exemption,Popolna upravičena izjema HRA,
Validating Employee Attendance...,Preverjanje prisotnosti zaposlenih ...,
Submitting Salary Slips and creating Journal Entry...,Predložitev plačnih lističev in ustvarjanje vnosa v dnevnik ...,
Calculate Payroll Working Days Based On,Izračunajte delovne dni izplačane plače na podlagi,
Consider Unmarked Attendance As,Neoznačeno udeležbo obravnavajte kot,
Fraction of Daily Salary for Half Day,Delež dnevne plače za pol dneva,
Component Type,Vrsta komponente,
Provident Fund,Provident Fund,
Additional Provident Fund,Dodatni skrbniški sklad,
Provident Fund Loan,Posojilo sklada Provident,
Professional Tax,Poklicni davek,
Is Income Tax Component,Je sestavina davka na dohodek,
Component properties and references ,Lastnosti komponent in reference,
Additional Salary ,Dodatna plača,
Unmarked days,Neoznačeni dnevi,
Absent Days,Odsotni dnevi,
Conditions and Formula variable and example,Pogoji in spremenljivka formule in primer,
Feedback By,Povratne informacije avtorja,
Manufacturing Section,Oddelek za proizvodnjo,
"By default, the Customer Name is set as per the Full Name entered. If you want Customers to be named by a ","Privzeto je ime stranke nastavljeno na vneseno polno ime. Če želite, da stranke imenuje",
Configure the default Price List when creating a new Sales transaction. Item prices will be fetched from this Price List.,Konfigurirajte privzeti cenik pri ustvarjanju nove prodajne transakcije. Cene izdelkov bodo pridobljene iz tega cenika.,
"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.","Če je ta možnost nastavljena na »Da«, vam ERPNext prepreči ustvarjanje prodajnega računa ali dobavnice, ne da bi prej ustvarili prodajno naročilo. To konfiguracijo lahko za določeno stranko preglasite tako, da v glavnem meniju stranke omogočite potrditveno polje »Dovoli ustvarjanje prodajnega računa brez prodajnega naloga«.",
"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.","Če je ta možnost nastavljena na »Da«, vam ERPNext prepreči, da ustvarite prodajni račun, ne da bi prej ustvarili dobavnico. To konfiguracijo lahko za določeno stranko preglasite tako, da v glavnem meniju stranke omogočite potrditveno polje »Dovoli ustvarjanje prodajnega računa brez dobavnice«.",
Default Warehouse for Sales Return,Privzeto skladišče za vračilo prodaje,
Default In Transit Warehouse,Privzeto v tranzitnem skladišču,
Enable Perpetual Inventory For Non Stock Items,Omogočite neprekinjeni inventar za ne zaloge,
HRA Settings,Nastavitve HRA,
Basic Component,Osnovna komponenta,
HRA Component,Komponenta HRA,
Arrear Component,Zaostala komponenta,
Please enter the company name to confirm,Vnesite ime podjetja za potrditev,
Quotation Lost Reason Detail,Podrobnosti ponudbe za izgubljeni razlog,
Enable Variants,Omogoči različice,
Save Quotations as Draft,Shrani ponudbe kot osnutek,
MAT-DN-RET-.YYYY.-,MAT-DN-RET-.LLLL.-,
Please Select a Customer,"Prosimo, izberite stranko",
Against Delivery Note Item,Proti postavki dobavnice,
Is Non GST ,Ni GST,
Image Description,Opis slike,
Transfer Status,Status prenosa,
MAT-PR-RET-.YYYY.-,MAT-PR-RET-.LLLL.-,
Track this Purchase Receipt against any Project,Sledite temu potrdilu o nakupu glede na kateri koli projekt,
Please Select a Supplier,"Prosimo, izberite dobavitelja",
Add to Transit,Dodaj v tranzit,
Set Basic Rate Manually,Ročno nastavite osnovno stopnjo,
"By default, the Item Name is set as per the Item Code entered. If you want Items to be named by a ","Ime artikla je privzeto nastavljeno glede na vneseno kodo artikla. Če želite, da elemente imenuje",
Set a Default Warehouse for Inventory Transactions. This will be fetched into the Default Warehouse in the Item master.,Nastavite privzeto skladišče za transakcije z zalogami. To bo preneseno v privzeto skladišče v glavnem elementu.,
"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 bo omogočilo prikaz zalog v negativnih vrednostih. Uporaba te možnosti je odvisna od primera vaše uporabe. Če ta možnost ni označena, sistem opozori, preden ovira transakcijo, ki povzroča negativne zaloge.",
Choose between FIFO and Moving Average Valuation Methods. Click ,Izbirajte med metodama vrednotenja FIFO in drsečim povprečjem. Kliknite,
 to know more about them.,če želite izvedeti več o njih.,
Show 'Scan Barcode' field above every child table to insert Items with ease.,"Pokažite polje »Optično branje črtne kode« nad vsako podrejeno tabelo, da z lahkoto vstavite 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.","Serijske številke zalog se bodo samodejno nastavile na podlagi postavk, vnesenih glede na prvi vnos, prvi odhod v transakcijah, kot so računi za nakup / prodajo, dobavnice itd.",
"If blank, parent Warehouse Account or company default will be considered in transactions","Če je prazno, bo pri transakcijah upoštevan nadrejeni račun skladišča ali privzeto podjetje",
Service Level Agreement Details,Podrobnosti sporazuma o ravni storitve,
Service Level Agreement Status,Stanje sporazuma o ravni storitve,
On Hold Since,Na čakanju od,
Total Hold Time,Skupni čas zadrževanja,
Response Details,Podrobnosti o odzivu,
Average Response Time,Povprečni odzivni čas,
User Resolution Time,Čas ločljivosti uporabnika,
SLA is on hold since {0},SLA je na čakanju od {0},
Pause SLA On Status,Začasno ustavi SLA On Status,
Pause SLA On,Začasno ustavi SLA,
Greetings Section,Oddelek za pozdrave,
Greeting Title,Pozdravni naslov,
Greeting Subtitle,Pozdravni podnaslov,
Youtube ID,ID YouTube,
Youtube Statistics,Statistika Youtube,
Views,Pogledi,
Dislikes,Ne mara,
Video Settings,Video Settings,
Enable YouTube Tracking,Omogočite sledenje v YouTubu,
30 mins,30 min,
1 hr,1 uro,
6 hrs,6 ur,
Patient Progress,Napredek bolnika,
Targetted,Ciljano,
Score Obtained,Pridobljena ocena,
Sessions,Seje,
Average Score,Povprečna ocena,
Select Assessment Template,Izberite Predloga ocenjevanja,
 out of ,iz,
Select Assessment Parameter,Izberite ocenjevalni parameter,
Gender: ,Spol:,
Contact: ,Kontakt:,
Total Therapy Sessions: ,Skupne terapevtske seje:,
Monthly Therapy Sessions: ,Mesečne terapevtske seje:,
Patient Profile,Profil bolnika,
Point Of Sale,Prodajno mesto,
Email sent successfully.,E-poštno sporočilo je bilo uspešno poslano.,
Search by invoice id or customer name,Iskanje po ID-ju računa ali imenu stranke,
Invoice Status,Stanje računa,
Filter by invoice status,Filtriraj po stanju računa,
Select item group,Izberite skupino predmetov,
No items found. Scan barcode again.,Ni najdenih predmetov. Ponovno optično preberite črtno kodo.,
"Search by customer name, phone, email.","Poiščite po imenu stranke, telefonu, e-pošti.",
Enter discount percentage.,Vnesite odstotek popusta.,
Discount cannot be greater than 100%,Popust ne sme biti večji od 100%,
Enter customer's email,Vnesite e-poštni naslov stranke,
Enter customer's phone number,Vnesite telefonsko številko stranke,
Customer contact updated successfully.,Kontakt s stranko je bil uspešno posodobljen.,
Item will be removed since no serial / batch no selected.,"Izdelek bo odstranjen, ker ni izbrana nobena serijska / serijska nobena.",
Discount (%),Popust (%),
You cannot submit the order without payment.,Naročila ne morete oddati brez plačila.,
You cannot submit empty order.,Ne morete oddati praznega naročila.,
To Be Paid,Biti plačan,
Create POS Opening Entry,Ustvari otvoritveni vnos v POS,
Please add Mode of payments and opening balance details.,"Prosimo, dodajte podrobnosti o načinu plačila in začetnem stanju.",
Toggle Recent Orders,Preklopi nedavna naročila,
Save as Draft,Shranite kot osnutek,
You must add atleast one item to save it as draft.,"Če želite shraniti kot osnutek, morate dodati vsaj en element.",
There was an error saving the document.,Pri shranjevanju dokumenta je prišlo do napake.,
You must select a customer before adding an item.,Pred dodajanjem izdelka morate izbrati stranko.,
Please Select a Company,Izberite podjetje,
Active Leads,Aktivne potencialne stranke,
Please Select a Company.,"Prosimo, izberite podjetje.",
BOM Operations Time,Čas delovanja BOM,
BOM ID,ID BOM,
BOM Item Code,Koda elementa BOM,
Time (In Mins),Čas (v minutah),
Sub-assembly BOM Count,Število specifikacij podsklopa,
View Type,Vrsta pogleda,
Total Delivered Amount,Skupni dostavljeni znesek,
Downtime Analysis,Analiza izpadov,
Machine,Stroj,
Downtime (In Hours),Izpad (v urah),
Employee Analytics,Analitika zaposlenih,
"""From date"" can not be greater than or equal to ""To date""",&quot;Od datuma&quot; ne sme biti večji ali enak &quot;Do danes&quot;,
Exponential Smoothing Forecasting,Napoved eksponentnega glajenja,
First Response Time for Issues,Prvi odzivni čas za vprašanja,
First Response Time for Opportunity,Prvi odzivni čas za priložnost,
Depreciatied Amount,Amortizirani znesek,
Period Based On,Obdobje na podlagi,
Date Based On,Datum temelji na,
{0} and {1} are mandatory,{0} in {1} sta obvezna,
Consider Accounting Dimensions,Razmislite o računovodskih razsežnostih,
Income Tax Deductions,Odbitki za davek od dohodka,
Income Tax Component,Komponenta davka na dohodek,
Income Tax Amount,Znesek davka od dohodka,
Reserved Quantity for Production,Rezervirana količina za proizvodnjo,
Projected Quantity,Predvidena količina,
 Total Sales Amount,Skupni znesek prodaje,
Job Card Summary,Povzetek delovne kartice,
Id,Id,
Time Required (In Mins),Potreben čas (v minutah),
From Posting Date,Od datuma knjiženja,
To Posting Date,Na datum knjiženja,
No records found,Ni najdenih zapisov,
Customer/Lead Name,Ime stranke / možnega kupca,
Unmarked Days,Neoznačeni dnevi,
Jan,Jan,
Feb,Februar,
Mar,Mar,
Apr,Apr,
Aug,Avg,
Sep,September,
Oct,Okt,
Nov,Nov,
Dec,Dec,
Summarized View,Povzeti pogled,
Production Planning Report,Poročilo o načrtovanju proizvodnje,
Order Qty,Količina naročila,
Raw Material Code,Koda surovin,
Raw Material Name,Ime surovine,
Allotted Qty,Dodeljena količina,
Expected Arrival Date,Pričakovani datum prihoda,
Arrival Quantity,Količina prihoda,
Raw Material Warehouse,Skladišče surovin,
Order By,Naroči po,
Include Sub-assembly Raw Materials,Vključite podsestavne surovine,
Professional Tax Deductions,Poklicni davčni odbitki,
Program wise Fee Collection,Programsko zbiranje pristojbin,
Fees Collected,Pobrane pristojbine,
Project Summary,Povzetek projekta,
Total Tasks,Skupaj naloge,
Tasks Completed,Naloge dokončane,
Tasks Overdue,Naloge zapadle,
Completion,Dokončanje,
Provident Fund Deductions,Odbitki sklada Provident,
Purchase Order Analysis,Analiza naročilnice,
From and To Dates are required.,Potrebni so datumi od in do.,
To Date cannot be before From Date.,Do datuma ne more biti pred Od datuma.,
Qty to Bill,Količina za Billa,
Group by Purchase Order,Razvrsti po naročilu,
 Purchase Value,Nabavna vrednost,
Total Received Amount,Skupni prejeti znesek,
Quality Inspection Summary,Povzetek inšpekcijskega pregleda kakovosti,
 Quoted Amount,Navedeni znesek,
Lead Time (Days),Čas izvedbe (dnevi),
Include Expired,Vključi poteklo,
Recruitment Analytics,Analiza zaposlovanja,
Applicant name,Ime prosilca,
Job Offer status,Stanje ponudbe za delo,
On Date,Na datum,
Requested Items to Order and Receive,Zahtevani predmeti za naročanje in prejemanje,
Salary Payments Based On Payment Mode,Plačila plač glede na način plačila,
Salary Payments via ECS,Plačila preko ECS,
Account No,Številka računa,
IFSC,IFSC,
MICR,MICR,
Sales Order Analysis,Analiza prodajnih nalogov,
Amount Delivered,Dostavljeni znesek,
Delay (in Days),Zamuda (v dneh),
Group by Sales Order,Razvrsti po prodajnem naročilu,
 Sales Value,Vrednost prodaje,
Stock Qty vs Serial No Count,Zaloga glede na serijsko število,
Serial No Count,Številka serijske številke,
Work Order Summary,Povzetek delovnega naloga,
Produce Qty,Izdelajte količino,
Lead Time (in mins),Čas izvedbe (v minutah),
Charts Based On,Grafikoni na podlagi,
YouTube Interactions,YouTubove interakcije,
Published Date,Datum objave,
Barnch,Barnch,
Select a Company,Izberite podjetje,
Opportunity {0} created,Ustvarjena priložnost {0},
Kindly select the company first,Najprej izberite podjetje,
Please enter From Date and To Date to generate JSON,"Vnesite Od datuma in do datuma, da ustvarite JSON",
PF Account,Račun PF,
PF Amount,Znesek PF,
Additional PF,Dodatni PF,
PF Loan,Posojilo PF,
Download DATEV File,Prenesite datoteko DATEV,
Numero has not set in the XML file,Numero ni nastavljen v datoteki XML,
Inward Supplies(liable to reverse charge),Notranji material (lahko se obrne),
This is based on the course schedules of this Instructor,To temelji na urnikih tečajev tega inštruktorja,
Course and Assessment,Tečaj in ocenjevanje,
Course {0} has been added to all the selected programs successfully.,Tečaj {0} je bil uspešno dodan vsem izbranim programom.,
Programs updated,Programi posodobljeni,
Program and Course,Program in tečaj,
{0} or {1} is mandatory,{0} ali {1} je obvezen,
Mandatory Fields,Obvezna polja,
Student {0}: {1} does not belong to Student Group {2},Študent {0}: {1} ne pripada študentski skupini {2},
Student Attendance record {0} already exists against the Student {1},Zapis o udeležbi študenta {0} že obstaja proti študentu {1},
Duplicate Entry,Podvojen vnos,
Course and Fee,Tečaj in provizija,
Not eligible for the admission in this program as per Date Of Birth,Na datum rojstva ni upravičen do vstopa v ta program,
Topic {0} has been added to all the selected courses successfully.,Tema {0} je bila uspešno dodana vsem izbranim tečajem.,
Courses updated,Tečaji posodobljeni,
{0} {1} has been added to all the selected topics successfully.,{0} {1} je bil uspešno dodan vsem izbranim temam.,
Topics updated,Teme posodobljene,
Academic Term and Program,Akademski izraz in program,
Please remove this item and try to submit again or update the posting time.,Odstranite ta element in poskusite znova poslati ali posodobite čas objave.,
Failed to Authenticate the API key.,Preverjanje pristnosti ključa API ni uspelo.,
Invalid Credentials,Neveljavna pooblastila,
URL can only be a string,URL je lahko samo niz,
"Here is your webhook secret, this will be shown to you only once.","Tu je vaša skrivnost spletnega kljuka, ki vam bo prikazana samo enkrat.",
The payment for this membership is not paid. To generate invoice fill the payment details,"Plačilo za to članstvo ni plačano. Če želite ustvariti račun, izpolnite podatke o plačilu",
An invoice is already linked to this document,Račun je že povezan s tem dokumentom,
No customer linked to member {},Nobena stranka ni povezana s članom {},
You need to set <b>Debit Account</b> in Membership Settings,V nastavitvah članstva morate nastaviti <b>debetni račun</b>,
You need to set <b>Default Company</b> for invoicing in Membership Settings,Za izdajanje računov morate v <b>privzetih</b> nastavitvah članstva nastaviti <b>privzeto podjetje</b>,
You need to enable <b>Send Acknowledge Email</b> in Membership Settings,V nastavitvah članstva morate omogočiti <b>e-pošto za potrditev pošiljanja</b>,
Error creating membership entry for {0},Napaka pri ustvarjanju vnosa za članstvo za {0},
A customer is already linked to this Member,Stranka je že povezana s tem članom,
End Date must not be lesser than Start Date,Končni datum ne sme biti manjši od začetnega datuma,
Employee {0} already has Active Shift {1}: {2},Zaposleni {0} že ima Active Shift {1}: {2},
 from {0},od {0},
 to {0},do {0},
Please select Employee first.,Najprej izberite zaposlenega.,
Please set {0} for the Employee or for Department: {1},Nastavite {0} za zaposlenega ali za oddelek: {1},
To Date should be greater than From Date,Do datuma mora biti večji od datuma,
Employee Onboarding: {0} is already for Job Applicant: {1},Vkrcanje zaposlenih: {0} je že za kandidata za zaposlitev: {1},
Job Offer: {0} is already for Job Applicant: {1},Ponudba za delo: {0} že velja za kandidata za delo: {1},
Only Shift Request with status 'Approved' and 'Rejected' can be submitted,Predložiti je mogoče samo zahtevo za preusmeritev s statusom &quot;Odobreno&quot; in &quot;Zavrnjeno&quot;,
Shift Assignment: {0} created for Employee: {1},Shift Assignment: {0} ustvarjeno za zaposlenega: {1},
You can not request for your Default Shift: {0},Za privzeti premik ne morete zahtevati: {0},
Only Approvers can Approve this Request.,To zahtevo lahko odobrijo samo odobritelji.,
Asset Value Analytics,Analiza vrednosti sredstev,
Category-wise Asset Value,Vrednost sredstev glede na kategorije,
Total Assets,Bilančna vsota,
New Assets (This Year),Nova sredstva (letos),
Row #{}: Depreciation Posting Date should not be equal to Available for Use Date.,Vrstica št. {}: Datum knjiženja amortizacije ne sme biti enak datumu razpoložljivosti za uporabo.,
Incorrect Date,Nepravilen datum,
Invalid Gross Purchase Amount,Neveljaven bruto znesek nakupa,
There are active maintenance or repairs against the asset. You must complete all of them before cancelling the asset.,Aktivno poteka vzdrževanje ali popravilo sredstva. Pred preklicem sredstva jih morate izpolniti.,
% Complete,% Izpolnjeno,
Back to Course,Nazaj na tečaj,
Finish Topic,Končaj temo,
Mins,Min,
by,avtor,
Back to,Nazaj k,
Enrolling...,Vpis ...,
You have successfully enrolled for the program ,Uspešno ste se prijavili na program,
Enrolled,Vpisan,
Watch Intro,Oglejte si uvod,
We're here to help!,"Tu smo, da vam pomagamo!",
Frequently Read Articles,Pogosto prebrani članki,
Please set a default company address,"Prosimo, nastavite privzeti naslov podjetja",
{0} is not a valid state! Check for typos or enter the ISO code for your state.,"{0} ni veljavno stanje! Preverite, ali ste natipkali ali vnesite kodo ISO za svoje stanje.",
Error occured while parsing Chart of Accounts: Please make sure that no two accounts have the same name,"Napaka pri razčlenjevanju kontnega načrta: Prepričajte se, da noben račun nima enakega imena",
Plaid invalid request error,Napaka neveljavne zahteve plaida,
Please check your Plaid client ID and secret values,"Prosimo, preverite svoj ID odjemalca Plaid in tajne vrednosti",
Bank transaction creation error,Napaka pri ustvarjanju bančne transakcije,
Unit of Measurement,Merska enota,
Fiscal Year {0} Does Not Exist,Proračunsko leto {0} ne obstaja,
Row # {0}: Returned Item {1} does not exist in {2} {3},Vrstica št. {0}: Vrnjeni izdelek {1} ne obstaja v {2} {3},
Valuation type charges can not be marked as Inclusive,Stroškov vrste vrednotenja ni mogoče označiti kot Vključno,
You do not have permissions to {} items in a {}.,Nimate dovoljenj za {} elementov v {}.,
Insufficient Permissions,Nezadostna dovoljenja,
You are not allowed to update as per the conditions set in {} Workflow.,"Posodobitev ni dovoljena v skladu s pogoji, določenimi v {} Potek dela.",
Expense Account Missing,Manjka račun za stroške,
{0} is not a valid Value for Attribute {1} of Item {2}.,{0} ni veljavna vrednost za atribut {1} elementa {2}.,
Invalid Value,Neveljavna vrednost,
The value {0} is already assigned to an existing Item {1}.,Vrednost {0} je že dodeljena obstoječemu elementu {1}.,
"To still proceed with editing this Attribute Value, enable {0} in Item Variant Settings.","Če želite še naprej urejati to vrednost atributa, v nastavitvah različice elementa omogočite {0}.",
Edit Not Allowed,Urejanje ni dovoljeno,
Row #{0}: Item {1} is already fully received in Purchase Order {2},Vrstica št. {0}: Element {1} je že v celoti prejet v naročilu {2},
You cannot create or cancel any accounting entries with in the closed Accounting Period {0},V zaprtem obračunskem obdobju {0} ne morete ustvariti ali preklicati računovodskih postavk.,
POS Invoice should have {} field checked.,POS račun mora imeti označeno polje {}.,
Invalid Item,Neveljaven izdelek,
Row #{}: You cannot add postive quantities in a return invoice. Please remove item {} to complete the return.,"Vrstica # {}: Na vračilnem računu ne morete dodati pozitivnih količin. Odstranite element {}, da dokončate vračilo.",
The selected change account {} doesn't belongs to Company {}.,Izbrani račun za spremembo {} ne pripada podjetju {}.,
Atleast one invoice has to be selected.,Izbrati je treba vsaj en račun.,
Payment methods are mandatory. Please add at least one payment method.,Načini plačila so obvezni. Dodajte vsaj eno plačilno sredstvo.,
Please select a default mode of payment,Izberite privzeti način plačila,
You can only select one mode of payment as default,Kot privzeti lahko izberete samo en način plačila,
Missing Account,Manjkajoči račun,
Customers not selected.,Stranke niso izbrane.,
Statement of Accounts,Izpisek računov,
Ageing Report Based On ,Poročilo o staranju na podlagi,
Please enter distributed cost center,Vnesite razdeljeno stroškovno mesto,
Total percentage allocation for distributed cost center should be equal to 100,Skupna dodelitev odstotkov za razdeljeno stroškovno mesto mora biti enaka 100,
Cannot enable Distributed Cost Center for a Cost Center already allocated in another Distributed Cost Center,"Razdeljenega stroškovnega mesta ni mogoče omogočiti za stroškovno mesto, ki je že dodeljeno v drugem razdeljenem stroškovnem mestu",
Parent Cost Center cannot be added in Distributed Cost Center,Starševskega stroškovnega mesta ni mogoče dodati v razdeljeno stroškovno mesto,
A Distributed Cost Center cannot be added in the Distributed Cost Center allocation table.,Razdeljenega stroškovnega mesta ni mogoče dodati v tabelo razporejanja stroškovnih mest.,
Cost Center with enabled distributed cost center can not be converted to group,Stroškovnega mesta z omogočenim porazdeljenim stroškovnim mestom ni mogoče pretvoriti v skupino,
Cost Center Already Allocated in a Distributed Cost Center cannot be converted to group,"Stroškovnega mesta, ki je že dodeljeno v porazdeljenem stroškovnem mestu, ni mogoče pretvoriti v skupino",
Trial Period Start date cannot be after Subscription Start Date,Začetni datum preizkusnega obdobja ne sme biti po začetnem datumu naročnine,
Subscription End Date must be after {0} as per the subscription plan,Končni datum naročnine mora biti po {0} v skladu z naročniškim načrtom,
Subscription End Date is mandatory to follow calendar months,Končni datum naročnine je obvezen za koledarske mesece,
Row #{}: POS Invoice {} is not against customer {},Vrstica {{}: Račun POS {} ni proti stranki {},
Row #{}: POS Invoice {} is not submitted yet,Vrstica št. {}: Račun POS {} še ni oddan,
Row #{}: POS Invoice {} has been {},Vrstica # {}: Račun POS {} je bil {},
No Supplier found for Inter Company Transactions which represents company {0},"Za transakcije med podjetji, ki zastopa podjetje, ni bilo mogoče najti dobavitelja {0}",
No Customer found for Inter Company Transactions which represents company {0},"Za transakcije med podjetji, ki zastopa podjetje, ni bilo mogoče najti nobene stranke {0}",
Invalid Period,Neveljavno obdobje,
Selected POS Opening Entry should be open.,Izbrani otvoritveni vnos POS mora biti odprt.,
Invalid Opening Entry,Neveljaven uvodni vnos,
Please set a Company,"Prosimo, nastavite podjetje",
"Sorry, this coupon code's validity has not started",Veljavnost te kode kupona se še ni začela,
"Sorry, this coupon code's validity has expired",Žal je veljavnost te kode kupona potekla,
"Sorry, this coupon code is no longer valid",Koda kupona žal ni več veljavna,
For the 'Apply Rule On Other' condition the field {0} is mandatory,V pogoju »Uporabi pravilo za drugo« je polje {0} obvezno,
{1} Not in Stock,{1} Ni na zalogi,
Only {0} in Stock for item {1},Le {0} na zalogi za izdelek {1},
Please enter a coupon code,Vnesite kodo kupona,
Please enter a valid coupon code,Vnesite veljavno kodo kupona,
Invalid Child Procedure,Neveljaven otroški postopek,
Import Italian Supplier Invoice.,Uvozite račun italijanskega dobavitelja.,
"Valuation Rate for the Item {0}, is required to do accounting entries for {1} {2}.",Stopnja vrednotenja postavke {0} je potrebna za knjiženje računovodskih izkazov za {1} {2}.,
 Here are the options to proceed:,Tu so možnosti za nadaljevanje:,
"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.","Če element v tem vnosu trguje kot element z ničelno vrednostjo, v tabeli {0} Elementi omogočite možnost »Dovoli ničelno stopnjo vrednotenja«.",
"If not, you can Cancel / Submit this entry ",V nasprotnem primeru lahko prekličete / oddate ta vnos,
 performing either one below:,izvedba enega od spodaj:,
Create an incoming stock transaction for the Item.,Ustvarite dohodno transakcijo zalog za postavko.,
Mention Valuation Rate in the Item master.,Omenite stopnjo vrednotenja v glavnem elementu.,
Valuation Rate Missing,Manjka stopnja vrednotenja,
Serial Nos Required,Zahtevane serijske številke,
Quantity Mismatch,Količinsko neusklajenost,
"Please Restock Items and Update the Pick List to continue. To discontinue, cancel the Pick List.","Za nadaljevanje obnovite izdelke in posodobite seznam za izbiro. Če želite prekiniti, prekličite izbirni seznam.",
Out of Stock,Ni na zalogi,
{0} units of Item {1} is not available.,{0} enot izdelka {1} ni na voljo.,
Item for row {0} does not match Material Request,Element za vrstico {0} se ne ujema z zahtevo za material,
Warehouse for row {0} does not match Material Request,Skladišče za vrstico {0} se ne ujema z zahtevo za material,
Accounting Entry for Service,Računovodski vnos za storitev,
All items have already been Invoiced/Returned,Vsi predmeti so že fakturirani / vrnjeni,
All these items have already been Invoiced/Returned,Vsi ti izdelki so že fakturirani / vrnjeni,
Stock Reconciliations,Usklajevanje zalog,
Merge not allowed,Spajanje ni dovoljeno,
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.,"Naslednji izbrisani atributi obstajajo v različicah, v predlogi pa ne. Različice lahko izbrišete ali pa atribute zadržite v predlogi.",
Variant Items,Različne postavke,
Variant Attribute Error,Napaka različice atributa,
The serial no {0} does not belong to item {1},Serijska številka {0} ne spada v element {1},
There is no batch found against the {0}: {1},Za {0}: {1} ni najdene serije,
Completed Operation,Končana operacija,
Work Order Analysis,Analiza delovnega naloga,
Quality Inspection Analysis,Analiza nadzora kakovosti,
Pending Work Order,Čakanje na delovni nalog,
Last Month Downtime Analysis,Analiza izpada zadnjega meseca,
Work Order Qty Analysis,Analiza količine delovnega naloga,
Job Card Analysis,Analiza delovnih kartic,
Monthly Total Work Orders,Mesečni skupni delovni nalogi,
Monthly Completed Work Orders,Mesečno izpolnjeni delovni nalogi,
Ongoing Job Cards,Tekoče razglednice,
Monthly Quality Inspections,Mesečni pregledi kakovosti,
(Forecast),(Napoved),
Total Demand (Past Data),Skupno povpraševanje (pretekli podatki),
Total Forecast (Past Data),Skupna napoved (pretekli podatki),
Total Forecast (Future Data),Skupna napoved (prihodnji podatki),
Based On Document,Na podlagi dokumenta,
Based On Data ( in years ),Na podlagi podatkov (v letih),
Smoothing Constant,Stalna glajenje,
Please fill the Sales Orders table,"Prosimo, izpolnite tabelo Prodajna naročila",
Sales Orders Required,Zahtevana prodajna naročila,
Please fill the Material Requests table,"Prosimo, izpolnite tabelo Zahteve za material",
Material Requests Required,Zahtevane materialne zahteve,
Items to Manufacture are required to pull the Raw Materials associated with it.,"Izdelki za izdelavo morajo vleči surovine, povezane z njimi.",
Items Required,Potrebni predmeti,
Operation {0} does not belong to the work order {1},Operacija {0} ne spada v delovni nalog {1},
Print UOM after Quantity,Natisni UOM po količini,
Set default {0} account for perpetual inventory for non stock items,Nastavite privzeti račun {0} za večni inventar za neoskrbljene predmete,
Loan Security {0} added multiple times,Varnost posojila {0} je bila dodana večkrat,
Loan Securities with different LTV ratio cannot be pledged against one loan,Vrednostnih papirjev z drugačnim razmerjem LTV ni mogoče zastaviti za eno posojilo,
Qty or Amount is mandatory for loan security!,Količina ali znesek je obvezen za zavarovanje posojila!,
Only submittted unpledge requests can be approved,Odobriti je mogoče samo predložene zahtevke za neuporabo,
Interest Amount or Principal Amount is mandatory,Znesek obresti ali znesek glavnice je obvezen,
Disbursed Amount cannot be greater than {0},Izplačani znesek ne sme biti večji od {0},
Row {0}: Loan Security {1} added multiple times,Vrstica {0}: Varnost posojila {1} je bila dodana večkrat,
Row #{0}: Child Item should not be a Product Bundle. Please remove Item {1} and Save,Vrstica št. {0}: podrejeni element ne sme biti paket izdelkov. Odstranite element {1} in shranite,
Credit limit reached for customer {0},Dosežena kreditna omejitev za stranko {0},
Could not auto create Customer due to the following missing mandatory field(s):,Kupca ni bilo mogoče samodejno ustvariti zaradi naslednjih manjkajočih obveznih polj:,
Please create Customer from Lead {0}.,Ustvarite stranko iz potencialne stranke {0}.,
Mandatory Missing,Obvezno manjka,
Please set Payroll based on in Payroll settings,"Prosimo, nastavite plače glede na nastavitve plač",
Additional Salary: {0} already exist for Salary Component: {1} for period {2} and {3},Dodatna plača: {0} že obstaja za komponento plače: {1} za obdobje {2} in {3},
From Date can not be greater than To Date.,Od datuma ne sme biti daljši od datuma.,
Payroll date can not be less than employee's joining date.,Datum izplačil ne sme biti krajši od datuma zaposlitve zaposlenega.,
From date can not be less than employee's joining date.,"Od datuma ne sme biti manjši od datuma, ko se zaposleni pridruži.",
To date can not be greater than employee's relieving date.,Do danes ne more biti daljši od datuma razbremenitve zaposlenega.,
Payroll date can not be greater than employee's relieving date.,Datum izplačil ne more biti daljši od datuma razrešitve zaposlenega.,
Row #{0}: Please enter the result value for {1},Vrstica # {0}: vnesite vrednost rezultata za {1},
Mandatory Results,Obvezni rezultati,
Sales Invoice or Patient Encounter is required to create Lab Tests,Za izdelavo laboratorijskih testov je potreben prodajni račun ali pacientovo srečanje,
Insufficient Data,Nezadostni podatki,
Lab Test(s) {0} created successfully,Laboratorijski preizkusi {0} so bili uspešno ustvarjeni,
Test :,Preizkus:,
Sample Collection {0} has been created,Zbirka vzorcev {0} je bila ustvarjena,
Normal Range: ,Običajni obseg:,
Row #{0}: Check Out datetime cannot be less than Check In datetime,Vrstica št. {0}: datum odjave ne sme biti krajši od datuma ure prijave,
"Missing required details, did not create Inpatient Record",Manjkajoče zahtevane podrobnosti niso ustvarile bolniškega zapisa,
Unbilled Invoices,Neračunani računi,
Standard Selling Rate should be greater than zero.,Standardna prodajna stopnja mora biti večja od nič.,
Conversion Factor is mandatory,Faktor pretvorbe je obvezen,
Row #{0}: Conversion Factor is mandatory,Vrstica št. {0}: faktor pretvorbe je obvezen,
Sample Quantity cannot be negative or 0,Količina vzorca ne sme biti negativna ali 0,
Invalid Quantity,Neveljavna količina,
"Please set defaults for Customer Group, Territory and Selling Price List in Selling Settings","V nastavitvah prodaje nastavite privzete vrednosti za skupino strank, ozemlje in prodajni cenik",
{0} on {1},{0} dne {1},
{0} with {1},{0} z {1},
Appointment Confirmation Message Not Sent,Sporočilo o potrditvi sestanka ni poslano,
"SMS not sent, please check SMS Settings","SMS ni poslan, preverite nastavitve SMS",
Healthcare Service Unit Type cannot have both {0} and {1},Vrsta enote zdravstvenih storitev ne sme imeti {0} in {1},
Healthcare Service Unit Type must allow atleast one among {0} and {1},Vrsta enote zdravstvenih storitev mora omogočati vsaj eno med {0} in {1},
Set Response Time and Resolution Time for Priority {0} in row {1}.,Nastavite odzivni čas in čas ločljivosti za prioriteto {0} v vrstici {1}.,
Response Time for {0} priority in row {1} can't be greater than Resolution Time.,Odzivni čas za {0} prednost v vrstici {1} ne sme biti daljši od časa ločljivosti.,
{0} is not enabled in {1},{0} ni omogočen v {1},
Group by Material Request,Razvrsti po zahtevi za material,
Email Sent to Supplier {0},E-poštno sporočilo poslano dobavitelju {0},
"The Access to Request for Quotation From Portal is Disabled. To Allow Access, Enable it in Portal Settings.","Dostop do zahteve za ponudbo s portala je onemogočen. Če želite dovoliti dostop, ga omogočite v nastavitvah portala.",
Supplier Quotation {0} Created,Navedba ponudnika {0} Ustvarjena,
Valid till Date cannot be before Transaction Date,"Velja do datuma, ne sme biti pred datumom transakcije",
Unlink Advance Payment on Cancellation of Order,Preklic predplačila ob preklicu naročila,
"Simple Python Expression, Example: territory != 'All Territories'","Preprost izraz Python, primer: teritorij! = &#39;Vsa ozemlja&#39;",
Sales Contributions and Incentives,Prispevki in spodbude za prodajo,
Sourced by Supplier,Vir: Dobavitelj,
Total weightage assigned should be 100%.<br>It is {0},Skupna dodeljena utež mora biti 100%.<br> Je {0},
Account {0} exists in parent company {1}.,Račun {0} obstaja v nadrejeni družbi {1}.,
"To overrule this, enable '{0}' in company {1}","Če želite to preglasiti, omogočite »{0}« v podjetju {1}",
Invalid condition expression,Neveljaven izraz pogoja,
Please Select a Company First,Najprej izberite podjetje,
Please Select Both Company and Party Type First,Najprej izberite vrsto podjetja in stranke,
Provide the invoice portion in percent,Navedite del računa v odstotkih,
Give number of days according to prior selection,Navedite število dni glede na predhodno izbiro,
Email Details,Podrobnosti o e-pošti,
"Select a greeting for the receiver. E.g. Mr., Ms., etc.","Izberite pozdrav za sprejemnika. Npr. Gospod, gospa itd.",
Preview Email,Predogled e-pošte,
Please select a Supplier,"Prosimo, izberite dobavitelja",
Supplier Lead Time (days),Čas dobave dobavitelja (dnevi),
"Home, Work, etc.","Dom, služba itd.",
Exit Interview Held On,Izhodni intervju je potekal,
Condition and formula,Pogoj in formula,
Sets 'Target Warehouse' in each row of the Items table.,Nastavi &#39;Target Warehouse&#39; v vsaki vrstici tabele Predmeti.,
Sets 'Source Warehouse' in each row of the Items table.,Nastavi &#39;Izvorno skladišče&#39; v vsaki vrstici tabele Predmeti.,
POS Register,POS register,
"Can not filter based on POS Profile, if grouped by POS Profile","Ni mogoče filtrirati na podlagi POS profila, če je združeno po POS profilu",
"Can not filter based on Customer, if grouped by Customer","Ni mogoče filtrirati glede na stranko, če jo razvrsti stranka",
"Can not filter based on Cashier, if grouped by Cashier","Ni mogoče filtrirati na podlagi blagajne, če jo razvrsti po blagajni",
Payment Method,Način plačila,
"Can not filter based on Payment Method, if grouped by Payment Method","Ni mogoče filtrirati glede na način plačila, če je razvrščen po načinu plačila",
Supplier Quotation Comparison,Primerjava ponudb,
Price per Unit (Stock UOM),Cena na enoto (zaloga UOM),
Group by Supplier,Skupina po dobaviteljih,
Group by Item,Razvrsti po postavkah,
Remember to set {field_label}. It is required by {regulation}.,Ne pozabite nastaviti {field_label}. Zahteva {uredba}.,
Enrollment Date cannot be before the Start Date of the Academic Year {0},Datum vpisa ne sme biti pred začetkom študijskega leta {0},
Enrollment Date cannot be after the End Date of the Academic Term {0},Datum vpisa ne sme biti po končnem datumu študijskega obdobja {0},
Enrollment Date cannot be before the Start Date of the Academic Term {0},Datum vpisa ne sme biti pred začetnim datumom študijskega obdobja {0},
Future Posting Not Allowed,Objavljanje v prihodnosti ni dovoljeno,
"To enable Capital Work in Progress Accounting, ","Če želite omogočiti računovodstvo kapitalskega dela v teku,",
you must select Capital Work in Progress Account in accounts table,v tabeli računov morate izbrati račun Capital Work in Progress,
You can also set default CWIP account in Company {},Privzeti račun CWIP lahko nastavite tudi v podjetju {},
The Request for Quotation can be accessed by clicking on the following button,Do zahteve za ponudbo lahko dostopate s klikom na naslednji gumb,
Regards,S spoštovanjem,
Please click on the following button to set your new password,Za nastavitev novega gesla kliknite naslednji gumb,
Update Password,Posodobi geslo,
Row #{}: Selling rate for item {} is lower than its {}. Selling {} should be atleast {},Vrstica št. {}: Stopnja prodaje izdelka {} je nižja od vrednosti {}. Prodaja {} mora biti vsaj {},
You can alternatively disable selling price validation in {} to bypass this validation.,"Lahko tudi onemogočite preverjanje prodajne cene v {}, da to preverjanje zaobidete.",
Invalid Selling Price,Neveljavna prodajna cena,
Address needs to be linked to a Company. Please add a row for Company in the Links table.,Naslov mora biti povezan s podjetjem. V tabelo Povezave dodajte vrstico za podjetje.,
Company Not Linked,Podjetje ni povezano,
Import Chart of Accounts from CSV / Excel files,Uvozite kontni načrt iz datotek CSV / Excel,
Completed Qty cannot be greater than 'Qty to Manufacture',Dokončana količina ne sme biti večja od „Količina za izdelavo“,
"Row {0}: For Supplier {1}, Email Address is Required to send an email",Vrstica {0}: Za dobavitelja {1} je za pošiljanje e-pošte potreben e-poštni naslov,
"If enabled, the system will post accounting entries for inventory automatically","Če je omogočeno, bo sistem samodejno knjižil računovodske vnose za zaloge",
Accounts Frozen Till Date,Računi zamrznjeni do datuma,
Accounting entries are frozen up to this date. Nobody can create or modify entries except users with the role specified below,"Knjigovodske postavke so do tega datuma zamrznjene. Nihče ne more ustvarjati ali spreminjati vnosov, razen uporabnikov s spodnjo vlogo",
Role Allowed to Set Frozen Accounts and Edit Frozen Entries,Vloga dovoljena za nastavitev zamrznjenih računov in urejanje zamrznjenih vnosov,
Address used to determine Tax Category in transactions,"Naslov, ki se uporablja za določitev davčne kategorije pri transakcijah",
"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 ","Odstotek, s katerim lahko zaračunate več od naročenega zneska. Če je na primer vrednost naročila 100 USD za izdelek in je dovoljeno odstopanje 10%, potem lahko obračunate do 110 USD",
This role is allowed to submit transactions that exceed credit limits,"Ta vloga lahko oddaja transakcije, ki presegajo kreditne omejitve",
"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","Če je izbrana možnost »Meseci«, se fiksni znesek knjiži kot odloženi prihodek ali odhodek za vsak mesec, ne glede na število dni v mesecu. Razporejeno bo, če odloženi prihodki ali odhodki ne bodo knjiženi ves mesec",
"If this is unchecked, direct GL entries will be created to book deferred revenue or expense","Če to možnost ni potrjeno, bodo ustvarjeni neposredni vnosi GL za knjiženje odloženih prihodkov ali odhodkov",
Show Inclusive Tax in Print,Prikaži vključen davek v tiskani obliki,
Only select this if you have set up the Cash Flow Mapper documents,"To izberite samo, če ste nastavili dokumente Map Cash Flow Mapper",
Payment Channel,Plačilni kanal,
Is Purchase Order Required for Purchase Invoice & Receipt Creation?,Ali je naročilnica potrebna za izdelavo računa in potrdila o nakupu?,
Is Purchase Receipt Required for Purchase Invoice Creation?,Ali je za izdelavo računa za nakup potreben potrdilo o nakupu?,
Maintain Same Rate Throughout the Purchase Cycle,V celotnem ciklu nabave ohranite enako stopnjo,
Allow Item To Be Added Multiple Times in a Transaction,"Dovoli, da se element v transakciji doda večkrat",
Suppliers,Dobavitelji,
Send Emails to Suppliers,Pošljite e-pošto dobaviteljem,
Select a Supplier,Izberite dobavitelja,
Cannot mark attendance for future dates.,Udeležbe ni mogoče označiti za prihodnje datume.,
Do you want to update attendance? <br> Present: {0} <br> Absent: {1},Ali želite posodobiti prisotnost?<br> Prisotno: {0}<br> Odsoten: {1},
Mpesa Settings,Nastavitve Mpesa,
Initiator Name,Ime pobudnika,
Till Number,Do številke,
Sandbox,Peskovnik,
 Online PassKey,Spletni PassKey,
Security Credential,Varnostna poverilnica,
Get Account Balance,Pridobite dobroimetje na računu,
Please set the initiator name and the security credential,Nastavite ime pobudnika in varnostne poverilnice,
Inpatient Medication Entry,Vnos bolnišničnih zdravil,
HLC-IME-.YYYY.-,HLC-IME-.LLLL.-,
Item Code (Drug),Koda izdelka (zdravilo),
Medication Orders,Naročila za zdravila,
Get Pending Medication Orders,Pridobite čakajoča naročila za zdravila,
Inpatient Medication Orders,Naročila za bolniška zdravila,
Medication Warehouse,Skladišče zdravil,
Warehouse from where medication stock should be consumed,"Skladišče, od koder bi morali porabiti zaloge zdravil",
Fetching Pending Medication Orders,Pridobivanje čakajočih nalogov za zdravila,
Inpatient Medication Entry Detail,Podrobnosti o vnosu bolnišničnih zdravil,
Medication Details,Podrobnosti o zdravilih,
Drug Code,Koda o drogah,
Drug Name,Ime zdravila,
Against Inpatient Medication Order,Proti odredbi o bolnišničnih zdravilih,
Against Inpatient Medication Order Entry,Proti vnosu naročila za bolniška zdravila,
Inpatient Medication Order,Naročilo za bolniška zdravila,
HLC-IMO-.YYYY.-,FHP-IMO-.LLLL.-,
Total Orders,Skupaj naročil,
Completed Orders,Dokončana naročila,
Add Medication Orders,Dodajte naročila za zdravila,
Adding Order Entries,Dodajanje vnosov v naročilo,
{0} medication orders completed,{0} naročil zdravil je zaključenih,
{0} medication order completed,{0} naročilo zdravil končano,
Inpatient Medication Order Entry,Vnos naročila za bolniška zdravila,
Is Order Completed,Ali je naročilo zaključeno,
Employee Records to Be Created By,"Zapisi zaposlenih, ki jih bo ustvaril",
Employee records are created using the selected field,Zapisi zaposlenih so ustvarjeni z uporabo izbranega polja,
Don't send employee birthday reminders,Ne pošiljajte opominov za rojstni dan zaposlenih,
Restrict Backdated Leave Applications,Omejite aplikacije za dopust z zadnjim datumom,
Sequence ID,ID zaporedja,
Sequence Id,ID zaporedja,
Allow multiple material consumptions against a Work Order,Dovoli večkratno porabo materiala za delovni nalog,
Plan time logs outside Workstation working hours,Načrtujte dnevnike izven delovnega časa delovne postaje,
Plan operations X days in advance,Načrtujte operacije X dni vnaprej,
Time Between Operations (Mins),Čas med operacijami (min),
Default: 10 mins,Privzeto: 10 min,
Overproduction for Sales and Work Order,Prekomerna proizvodnja za prodajne naloge in delovne naloge,
"Update BOM cost automatically via scheduler, based on the latest Valuation Rate/Price List Rate/Last Purchase Rate of raw materials",Stroške BOM samodejno posodobite prek načrtovalca na podlagi najnovejše stopnje vrednotenja / stopnje cenika / stopnje zadnjega odkupa surovin,
Purchase Order already created for all Sales Order items,Naročilo je že ustvarjeno za vse postavke prodajnega naročila,
Select Items,Izberite Elemente,
Against Default Supplier,Proti privzetemu dobavitelju,
Auto close Opportunity after the no. of days mentioned above,Samodejno zapri Priložnost po št. zgoraj omenjenih dni,
Is Sales Order Required for Sales Invoice & Delivery Note Creation?,Ali je za izdelavo prodajnega računa in dobavnice potrebno prodajno naročilo?,
Is Delivery Note Required for Sales Invoice Creation?,Ali je za izdelavo prodajnega računa potrebno dobavnico?,
How often should Project and Company be updated based on Sales Transactions?,Kako pogosto je treba projekt in podjetje posodabljati na podlagi prodajnih transakcij?,
Allow User to Edit Price List Rate in Transactions,"Dovoli uporabniku, da v transakcijah ureja stopnjo cenika",
Allow Item to Be Added Multiple Times in a Transaction,"Dovoli, da se element v transakciji doda večkrat",
Allow Multiple Sales Orders Against a Customer's Purchase Order,Dovoli več prodajnih naročil zoper naročilnico stranke,
Validate Selling Price for Item Against Purchase Rate or Valuation Rate,Potrdite prodajno ceno za izdelek glede na nabavno stopnjo ali stopnjo vrednotenja,
Hide Customer's Tax ID from Sales Transactions,Skrij davčno številko stranke iz prodajnih transakcij,
"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.","Odstotek, ki ga lahko prejmete ali dostavite več od naročene količine. Če ste na primer naročili 100 enot in je Vaš dodatek 10%, potem lahko prejmete 110 enot.",
Action If Quality Inspection Is Not Submitted,"Ukrep, če pregled kakovosti ni predložen",
Auto Insert Price List Rate If Missing,"Samodejno vstavi cenik, če manjka",
Automatically Set Serial Nos Based on FIFO,Samodejno nastavi serijske številke na podlagi FIFO,
Set Qty in Transactions Based on Serial No Input,Nastavite količino v transakcijah na podlagi serijskega vnosa,
Raise Material Request When Stock Reaches Re-order Level,"Dvignite zahtevo za material, ko zaloge dosežejo nivo ponovnega naročila",
Notify by Email on Creation of Automatic Material Request,Obvestite po e-pošti o ustvarjanju samodejne zahteve za material,
Allow Material Transfer from Delivery Note to Sales Invoice,Dovoli prenos materiala iz dobavnice na prodajni račun,
Allow Material Transfer from Purchase Receipt to Purchase Invoice,Dovoli prenos materiala s potrdila o nakupu na račun za nakup,
Freeze Stocks Older Than (Days),"Zamrznite zaloge, starejše od (dni)",
Role Allowed to Edit Frozen Stock,Vloga dovoljena za urejanje zamrznjenih zalog,
The unallocated amount of Payment Entry {0} is greater than the Bank Transaction's unallocated amount,Nerazporejeni znesek vnosa za plačilo {0} je večji od nedodeljenega zneska bančne transakcije,
Payment Received,Plačilo sprejeto,
Attendance cannot be marked outside of Academic Year {0},Udeležbe ni mogoče označiti izven študijskega leta {0},
Student is already enrolled via Course Enrollment {0},Študent je že vpisan prek vpisa na tečaj {0},
Attendance cannot be marked for future dates.,Udeležbe ni mogoče označiti za prihodnje datume.,
Please add programs to enable admission application.,"Prosimo, dodajte programe, da omogočite prijavo.",
The following employees are currently still reporting to {0}:,Naslednji zaposleni trenutno še vedno poročajo {0}:,
Please make sure the employees above report to another Active employee.,"Prepričajte se, da se zgornji zaposleni prijavijo drugemu zaposlenemu.",
Cannot Relieve Employee,Ne morem razbremeniti zaposlenega,
Please enter {0},Vnesite {0},
Please select another payment method. Mpesa does not support transactions in currency '{0}',Izberite drugo plačilno sredstvo. Mpesa ne podpira transakcij v valuti &#39;{0}&#39;,
Transaction Error,Napaka pri transakciji,
Mpesa Express Transaction Error,Napaka Mpesa Express Transaction,
"Issue detected with Mpesa configuration, check the error logs for more details","Težava je bila odkrita pri konfiguraciji Mpesa, za več podrobnosti preverite dnevnike napak",
Mpesa Express Error,Napaka Mpesa Express,
Account Balance Processing Error,Napaka pri obdelavi stanja računa,
Please check your configuration and try again,Preverite svojo konfiguracijo in poskusite znova,
Mpesa Account Balance Processing Error,Napaka pri obdelavi stanja na računu Mpesa,
Balance Details,Podrobnosti stanja,
Current Balance,Trenutno stanje,
Available Balance,Razpoložljivo stanje,
Reserved Balance,Rezervirano stanje,
Uncleared Balance,Nejasno ravnovesje,
Payment related to {0} is not completed,Plačilo v zvezi z {0} ni zaključeno,
Row #{}: Item Code: {} is not available under warehouse {}.,Vrstica # {}: Koda artikla: {} ni na voljo v skladišču {}.,
Row #{}: Stock quantity not enough for Item Code: {} under warehouse {}. Available quantity {}.,Vrstica št. {}: Količina zaloge ni dovolj za kodo artikla: {} v skladišču {}. Razpoložljiva količina {}.,
Row #{}: Please select a serial no and batch against item: {} or remove it to complete transaction.,"Vrstica # {}: izberite serijsko številko in paket proti elementu: {} ali jo odstranite, če želite dokončati transakcijo.",
Row #{}: No serial number selected against item: {}. Please select one or remove it to complete transaction.,Vrstica # {}: Za element ni izbrana serijska številka: {}. Za dokončanje transakcije izberite eno ali jo odstranite.,
Row #{}: No batch selected against item: {}. Please select a batch or remove it to complete transaction.,Vrstica # {}: Za element ni izbrana nobena serija: {}. Za dokončanje transakcije izberite paket ali ga odstranite.,
Payment amount cannot be less than or equal to 0,Znesek plačila ne sme biti manjši ali enak 0,
Please enter the phone number first,Najprej vnesite telefonsko številko,
Row #{}: {} {} does not exist.,Vrstica # {}: {} {} ne obstaja.,
Row #{0}: {1} is required to create the Opening {2} Invoices,Vrstica št. {0}: {1} je potrebna za ustvarjanje uvodnih računov {2},
You had {} errors while creating opening invoices. Check {} for more details,Pri ustvarjanju računov za odpiranje ste imeli toliko napak: {}. Za več podrobnosti poglejte {},
Error Occured,Prišlo je do napake,
Opening Invoice Creation In Progress,Začetno ustvarjanje računa v teku,
Creating {} out of {} {},Ustvarjanje {} od {} {},
(Serial No: {0}) cannot be consumed as it's reserverd to fullfill Sales Order {1}.,"(Serijska številka: {0}) ni mogoče porabiti, ker je rezervirano za polno prodajno naročilo {1}.",
Item {0} {1},Element {0} {1},
Last Stock Transaction for item {0} under warehouse {1} was on {2}.,Zadnja transakcija zaloge za artikel {0} v skladišču {1} je bila dne {2}.,
Stock Transactions for Item {0} under warehouse {1} cannot be posted before this time.,Transakcij zalog za postavko {0} v skladišču {1} ni mogoče objaviti pred tem časom.,
Posting future stock transactions are not allowed due to Immutable Ledger,Knjiženje prihodnjih delniških transakcij zaradi nespremenljive knjige ni dovoljeno,
A BOM with name {0} already exists for item {1}.,BOM z imenom {0} že obstaja za element {1}.,
{0}{1} Did you rename the item? Please contact Administrator / Tech support,{0} {1} Ste element preimenovali? Obrnite se na skrbnika / tehnično podporo,
At row #{0}: the sequence id {1} cannot be less than previous row sequence id {2},V vrstici št. {0}: ID zaporedja {1} ne sme biti manjši od ID zaporedja vrstice {2},
The {0} ({1}) must be equal to {2} ({3}),{0} ({1}) mora biti enako {2} ({3}),
"{0}, complete the operation {1} before the operation {2}.","{0}, dokončajte operacijo {1} pred operacijo {2}.",
Cannot ensure delivery by Serial No as Item {0} is added with and without Ensure Delivery by Serial No.,"Ne morem zagotoviti dostave s serijsko številko, saj je element {0} dodan s serijsko številko in brez nje.",
Item {0} has no Serial No. Only serilialized items can have delivery based on Serial No,Element {0} nima serijske številke. Dobavo na podlagi serijske št. Lahko oddajo samo serializirani predmeti,
No active BOM found for item {0}. Delivery by Serial No cannot be ensured,Za element {0} ni bilo mogoče najti aktivne specifikacije. Dostave s serijsko številko ni mogoče zagotoviti,
No pending medication orders found for selected criteria,Za izbrana merila ni bilo mogoče najti nobenega čakajočega naročila zdravil,
From Date cannot be after the current date.,Od datuma ne more biti po trenutnem datumu.,
To Date cannot be after the current date.,Do datuma ne more biti po trenutnem datumu.,
From Time cannot be after the current time.,Od časa ne more biti po trenutnem času.,
To Time cannot be after the current time.,To Time ne more biti po trenutnem času.,
Stock Entry {0} created and ,Vnos zalog {0} je ustvarjen in,
Inpatient Medication Orders updated successfully,Naročila za bolniška zdravila so bila uspešno posodobljena,
Row {0}: Cannot create Inpatient Medication Entry against cancelled Inpatient Medication Order {1},Vrstica {0}: Ne morem ustvariti vnosa v bolnišnično zdravilo za preklicano naročilo bolnišničnih zdravil {1},
Row {0}: This Medication Order is already marked as completed,Vrstica {0}: to naročilo za zdravila je že označeno kot izpolnjeno,
Quantity not available for {0} in warehouse {1},Količina ni na voljo za {0} v skladišču {1},
Please enable Allow Negative Stock in Stock Settings or create Stock Entry to proceed.,V nadaljevanju omogočite možnost Dovoli negativne zaloge ali ustvarite vnos zalog.,
No Inpatient Record found against patient {0},Za pacienta ni bil najden noben zapis o bolnišnici {0},
An Inpatient Medication Order {0} against Patient Encounter {1} already exists.,Nalog za bolnišnično zdravljenje {0} proti srečanju bolnika {1} že obstaja.,
Allow In Returns,Dovoli vračila,
Hide Unavailable Items,Skrij nedosegljive elemente,
Apply Discount on Discounted Rate,Uporabite popust na popust,
Therapy Plan Template,Predloga načrta terapije,
Fetching Template Details,Pridobivanje podrobnosti o predlogi,
Linked Item Details,Podrobnosti povezanih elementov,
Therapy Types,Vrste terapije,
Therapy Plan Template Detail,Podrobnosti predloge načrta terapije,
Non Conformance,Neskladnost,
Process Owner,Lastnik postopka,
Corrective Action,Korektivni ukrepi,
Preventive Action,Preventivna akcija,
Problem,Težava,
Responsible,Odgovorno,
Completion By,Dokončanje:,
Process Owner Full Name,Polno ime lastnika postopka,
Right Index,Kazalo desno,
Left Index,Levi kazalec,
Sub Procedure,Podproces,
Passed,Uspešno,
Print Receipt,Potrdilo o tiskanju,
Edit Receipt,Uredi potrdilo,
Focus on search input,Osredotočite se na vnos iskanja,
Focus on Item Group filter,Osredotočite se na filter skupine predmetov,
Checkout Order / Submit Order / New Order,Naročilo za plačilo / oddajo naročila / novo naročilo,
Add Order Discount,Dodajte popust za naročilo,
Item Code: {0} is not available under warehouse {1}.,Koda artikla: {0} ni na voljo v skladišču {1}.,
Serial numbers unavailable for Item {0} under warehouse {1}. Please try changing warehouse.,Serijske številke niso na voljo za izdelek {0} v skladišču {1}. Poskusite zamenjati skladišče.,
Fetched only {0} available serial numbers.,Pridobljeno le {0} razpoložljivih serijskih številk.,
Switch Between Payment Modes,Preklapljanje med načini plačila,
Enter {0} amount.,Vnesite {0} znesek.,
You don't have enough points to redeem.,Nimate dovolj točk za unovčenje.,
You can redeem upto {0}.,Unovčite lahko do {0}.,
Enter amount to be redeemed.,"Vnesite znesek, ki ga želite uveljaviti.",
You cannot redeem more than {0}.,Ne morete unovčiti več kot {0}.,
Open Form View,Odprite pogled obrazca,
POS invoice {0} created succesfully,POS račun {0} je bil uspešno ustvarjen,
Stock quantity not enough for Item Code: {0} under warehouse {1}. Available quantity {2}.,Zaloga ni dovolj za kodo artikla: {0} v skladišču {1}. Razpoložljiva količina {2}.,
Serial No: {0} has already been transacted into another POS Invoice.,Serijska številka: {0} je že opravljena na drug račun POS.,
Balance Serial No,Serijska št,
Warehouse: {0} does not belong to {1},Skladišče: {0} ne pripada {1},
Please select batches for batched item {0},Izberite serije za serijski izdelek {0},
Please select quantity on row {0},Izberite količino v vrstici {0},
Please enter serial numbers for serialized item {0},Vnesite serijske številke za zaporedni izdelek {0},
Batch {0} already selected.,Paket {0} je že izbran.,
Please select a warehouse to get available quantities,"Prosimo, izberite skladišče, da dobite razpoložljive količine",
"For transfer from source, selected quantity cannot be greater than available quantity",Za prenos iz vira izbrana količina ne sme biti večja od razpoložljive količine,
Cannot find Item with this Barcode,Elementa s to črtno kodo ni mogoče najti,
{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2},{0} je obvezen. Morda zapis menjalnice ni ustvarjen za obdobje od {1} do {2},
{} has submitted assets linked to it. You need to cancel the assets to create purchase return.,"Oseba {} je poslala sredstva, povezana z njo. Če želite ustvariti donos nakupa, morate preklicati sredstva.",
Cannot cancel this document as it is linked with submitted asset {0}. Please cancel it to continue.,"Tega dokumenta ni mogoče preklicati, ker je povezan s predloženim sredstvom {0}. Za nadaljevanje ga prekinite.",
Row #{}: Serial No. {} has already been transacted into another POS Invoice. Please select valid serial no.,Vrstica št. {}: Serijska številka {} je že bila prenesena na drug račun POS. Izberite veljavno serijsko št.,
Row #{}: Serial Nos. {} has already been transacted into another POS Invoice. Please select valid serial no.,Vrstica št. {}: Zaporedne številke. {} Je že bila prenesena na drug račun POS. Izberite veljavno serijsko št.,
Item Unavailable,Element ni na voljo,
Row #{}: Serial No {} cannot be returned since it was not transacted in original invoice {},"Vrstica # {}: zaporedne številke {} ni mogoče vrniti, ker ni bila izvedena v prvotnem računu {}",
Please set default Cash or Bank account in Mode of Payment {},V načinu plačila nastavite privzeti gotovinski ali bančni račun {},
Please set default Cash or Bank account in Mode of Payments {},Nastavite privzeti gotovinski ali bančni račun v načinu plačila {},
Please ensure {} account is a Balance Sheet account. You can change the parent account to a Balance Sheet account or select a different account.,"Preverite, ali je račun {} račun bilance stanja. Nadrejeni račun lahko spremenite v račun bilance stanja ali izberete drugega.",
Please ensure {} account is a Payable account. Change the account type to Payable or select a different account.,"Preverite, ali je račun {} plačljiv račun. Spremenite vrsto računa na Plačljivo ali izberite drugega.",
Row {}: Expense Head changed to {} ,Vrstica {}: Izdatna glava spremenjena v {},
because account {} is not linked to warehouse {} ,ker račun {} ni povezan s skladiščem {},
or it is not the default inventory account,ali ni privzeti račun zalog,
Expense Head Changed,Spremenjena glava odhodka,
because expense is booked against this account in Purchase Receipt {},ker so stroški knjiženi na ta račun v potrdilu o nakupu {},
as no Purchase Receipt is created against Item {}. ,ker za artikel {} ni ustvarjen noben potrdilo o nakupu.,
This is done to handle accounting for cases when Purchase Receipt is created after Purchase Invoice,"To se naredi za obravnavanje primerov, ko je potrdilo o nakupu ustvarjeno po računu za nakup",
Purchase Order Required for item {},Naročilo je obvezno za izdelek {},
To submit the invoice without purchase order please set {} ,"Če želite oddati račun brez naročilnice, nastavite {}",
as {} in {},kot v {},
Mandatory Purchase Order,Obvezno naročilo,
Purchase Receipt Required for item {},Za artikel {} je potrebno potrdilo o nakupu,
To submit the invoice without purchase receipt please set {} ,"Če želite oddati račun brez potrdila o nakupu, nastavite {}",
Mandatory Purchase Receipt,Obvezno potrdilo o nakupu,
POS Profile {} does not belongs to company {},POS profil {} ne pripada podjetju {},
User {} is disabled. Please select valid user/cashier,Uporabnik {} je onemogočen. Izberite veljavnega uporabnika / blagajnika,
Row #{}: Original Invoice {} of return invoice {} is {}. ,Vrstica št. {}: Prvotni račun {} na računu za vračilo {} je {}.,
Original invoice should be consolidated before or along with the return invoice.,Prvotni račun je treba konsolidirati pred računom za vračilo ali skupaj z njim.,
You can add original invoice {} manually to proceed.,Za nadaljevanje lahko ročno dodate račun {}.,
Please ensure {} account is a Balance Sheet account. ,"Preverite, ali je račun {} račun bilance stanja.",
You can change the parent account to a Balance Sheet account or select a different account.,Nadrejeni račun lahko spremenite v račun bilance stanja ali izberete drugega.,
Please ensure {} account is a Receivable account. ,"Preverite, ali je račun {} terjatev.",
Change the account type to Receivable or select a different account.,Spremenite vrsto računa v Terjatev ali izberite drug račun.,
{} can't be cancelled since the Loyalty Points earned has been redeemed. First cancel the {} No {},"{} ni mogoče preklicati, ker so bile pridobljene točke zvestobe unovčene. Najprej prekličite {} Ne {}",
already exists,že obstaja,
POS Closing Entry {} against {} between selected period,POS zapiranje vnosa {} proti {} med izbranim obdobjem,
POS Invoice is {},POS račun je {},
POS Profile doesn't matches {},POS profil se ne ujema {},
POS Invoice is not {},POS račun ni {},
POS Invoice isn't created by user {},POS računa ne ustvari uporabnik {},
Row #{}: {},Vrstica # {}: {},
Invalid POS Invoices,Neveljavni računi POS,
Please add the account to root level Company - {},"Prosimo, dodajte račun na korenski nivo podjetja - {}",
"While creating account for Child Company {0}, parent account {1} not found. Please create the parent account in corresponding COA","Med ustvarjanjem računa za otroško podjetje {0} nadrejenega računa {1} ni mogoče najti. Prosimo, ustvarite nadrejeni račun v ustreznem potrdilu o pristnosti",
Account Not Found,Računa ni mogoče najti,
"While creating account for Child Company {0}, parent account {1} found as a ledger account.",Med ustvarjanjem računa za otroško podjetje {0} je bil nadrejeni račun {1} najden kot račun glavne knjige.,
Please convert the parent account in corresponding child company to a group account.,"Prosimo, pretvorite starševski račun v ustreznem podrejenem podjetju v račun skupine.",
Invalid Parent Account,Neveljaven starševski račun,
"Renaming it is only allowed via parent company {0}, to avoid mismatch.","Preimenovanje je dovoljeno samo prek nadrejene družbe {0}, da se prepreči neskladje.",
"If you {0} {1} quantities of the item {2}, the scheme {3} will be applied on the item.","Če {0} {1} količine izdelka {2}, bo za izdelek uporabljena shema {3}.",
"If you {0} {1} worth item {2}, the scheme {3} will be applied on the item.","Če ste {0} {1} vredni izdelka {2}, bo za izdelek uporabljena shema {3}.",
"As the field {0} is enabled, the field {1} is mandatory.","Ker je polje {0} omogočeno, je polje {1} obvezno.",
"As the field {0} is enabled, the value of the field {1} should be more than 1.","Ko je polje {0} omogočeno, mora biti vrednost polja {1} večja od 1.",
Cannot deliver Serial No {0} of item {1} as it is reserved to fullfill Sales Order {2},"Serijske številke {0} izdelka {1} ni mogoče dostaviti, ker je rezervirana za popolno prodajno naročilo {2}",
"Sales Order {0} has reservation for the item {1}, you can only deliver reserved {1} against {0}.","Prodajno naročilo {0} ima rezervacijo za artikel {1}, rezervirano {1} lahko dostavite samo proti {0}.",
{0} Serial No {1} cannot be delivered,{0} Serijske številke {1} ni mogoče dostaviti,
Row {0}: Subcontracted Item is mandatory for the raw material {1},Vrstica {0}: Izdelek s podizvajalci je obvezen za surovino {1},
"As there are sufficient raw materials, Material Request is not required for Warehouse {0}.","Ker je dovolj surovin, zahteva za material za skladišče {0} ni potrebna.",
" If you still want to proceed, please enable {0}.","Če še vedno želite nadaljevati, omogočite {0}.",
The item referenced by {0} - {1} is already invoiced,"Element, na katerega se sklicuje {0} - {1}, je že fakturiran",
Therapy Session overlaps with {0},Seja terapije se prekriva z {0},
Therapy Sessions Overlapping,Terapijske seje se prekrivajo,
Therapy Plans,Načrti terapije,
"Item Code, warehouse, quantity are required on row {0}","Koda artikla, skladišče, količina so obvezni v vrstici {0}",
Get Items from Material Requests against this Supplier,Pridobite izdelke iz materialnih zahtevkov pri tem dobavitelju,
Enable European Access,Omogoči evropski dostop,
Creating Purchase Order ...,Ustvarjanje naročilnice ...,
"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.","Izberite dobavitelja med privzetimi dobavitelji spodnjih elementov. Po izbiri bo naročilnica narejena samo za izdelke, ki pripadajo izbranemu dobavitelju.",
Row #{}: You must select {} serial numbers for item {}.,Vrstica # {}: Izbrati morate {} serijske številke za izdelek {}.,
