"""Customer Provided Item"" cannot be Purchase Item also",„Hlutur veittur af viðskiptavini“ getur ekki verið keyptur hlutur,
"""Customer Provided Item"" cannot have Valuation Rate",„Hlutur sem veittur er af viðskiptavini“ getur ekki haft matshlutfall,
"""Is Fixed Asset"" cannot be unchecked, as Asset record exists against the item","&quot;Er Fast Asset&quot; getur ekki verið valið, eins Asset met hendi á móti hlut",
'Based On' and 'Group By' can not be same,"""Byggt á' og 'hópað eftir' getur ekki verið það sama",
'Days Since Last Order' must be greater than or equal to zero,'Dagar frá síðustu pöntun' verður að vera meiri en eða jafnt og núll,
'Entries' cannot be empty,&#39;Færslur&#39; má ekki vera autt,
'From Date' is required,&quot;Frá Dagsetning &#39;er krafist,
'From Date' must be after 'To Date',&quot;Frá Dagsetning &#39;verður að vera eftir&#39; Til Dagsetning &#39;,
'Has Serial No' can not be 'Yes' for non-stock item,&quot;Hefur Serial Nei &#39;getur ekki verið&#39; Já &#39;fyrir non-lager lið,
'Opening',&#39;Opening&#39;,
'To Case No.' cannot be less than 'From Case No.',&quot;Til Case No. &#39; má ekki vera minna en &quot;Frá Case nr &#39;,
'To Date' is required,&quot;Til Dagsetning &#39;er krafist,
'Total',&#39;Total&#39;,
'Update Stock' can not be checked because items are not delivered via {0},&#39;Uppfæra Stock&#39; Ekki er hægt að athuga vegna þess að hlutir eru ekki send með {0},
'Update Stock' cannot be checked for fixed asset sale,&#39;Uppfæra Stock&#39; Ekki er hægt að athuga fasta sölu eigna,
) for {0},) fyrir {0},
1 exact match.,1 nákvæm samsvörun.,
90-Above,90-Above,
A Customer Group exists with same name please change the Customer name or rename the Customer Group,A Viðskiptavinur Group til staðar með sama nafni vinsamlegast breyta Customer Name eða endurnefna Viðskiptavinur Group,
A Default Service Level Agreement already exists.,Sjálfgefinn þjónustustigssamningur er þegar til.,
A Lead requires either a person's name or an organization's name,Leiðtogi þarf annað hvort nafn einstaklings eða nafn stofnunar,
A customer with the same name already exists,Viðskiptavinur með sama nafni er þegar til,
A question must have more than one options,Spurning verður að hafa fleiri en einn valkost,
A qustion must have at least one correct options,Efni þarf að hafa að minnsta kosti einn réttan valkost,
A {0} exists between {1} and {2} (,A {0} er á milli {1} og {2} (,
A4,A4,
API Endpoint,API endapunktur,
API Key,API Key,
Abbr can not be blank or space,Skammstöfun má ekki vera autt eða bil,
Abbreviation already used for another company,Skammstöfun þegar notuð fyrir annað fyrirtæki,
Abbreviation cannot have more than 5 characters,Skammstöfun getur ekki haft fleiri en 5 stafi,
Abbreviation is mandatory,Skammstöfun er nauðsynlegur,
About the Company,Um fyrirtækið,
About your company,Um fyrirtækið þitt,
Above,hér að framan,
Absent,Absent,
Academic Term,fræðihugtak,
Academic Term: ,Fræðigrein:,
Academic Year,skólaárinu,
Academic Year: ,Námsár:,
Accepted + Rejected Qty must be equal to Received quantity for Item {0},Samþykkt + Hafnað Magn verður að vera jöfn Móttekin magn fyrir lið {0},
Access Token,aðgangur Token,
Accessable Value,Aðgengilegt gildi,
Account,Reikningur,
Account Number,Reikningsnúmer,
Account Number {0} already used in account {1},Reikningsnúmer {0} þegar notað í reikningnum {1},
Account Pay Only,Reikningur Pay Aðeins,
Account Type,Tegund reiknings,
Account Type for {0} must be {1},Reikningur Type fyrir {0} verður að vera {1},
"Account balance already in Credit, you are not allowed to set 'Balance Must Be' as 'Debit'","Viðskiptajöfnuður þegar í Credit, þú ert ekki leyft að setja &#39;Balance Verður Be&#39; eins og &#39;Debit &quot;",
"Account balance already in Debit, you are not allowed to set 'Balance Must Be' as 'Credit'","Viðskiptajöfnuður þegar í Debit, þú ert ekki leyft að setja &#39;Balance Verður Be&#39; eins og &#39;Credit &quot;",
Account number for account {0} is not available.<br> Please setup your Chart of Accounts correctly.,Reikningsnúmer fyrir reikning {0} er ekki tiltækt. <br> Vinsamlegast settu upp reikningsskýrsluna þína rétt.,
Account with child nodes cannot be converted to ledger,Reikningur með hnúta barn er ekki hægt að breyta í höfuðbók,
Account with child nodes cannot be set as ledger,Reikningur með hnúta barn er ekki hægt að setja eins og höfuðbók,
Account with existing transaction can not be converted to group.,Reikningur með núverandi viðskipti er ekki hægt að breyta í hópinn.,
Account with existing transaction can not be deleted,Reikningur með núverandi viðskipti getur ekki eytt,
Account with existing transaction cannot be converted to ledger,Reikningur með núverandi viðskipti er ekki hægt að breyta í höfuðbók,
Account {0} does not belong to company: {1},Reikningur {0} ekki tilheyra fyrirtæki: {1},
Account {0} does not belongs to company {1},Reikningur {0} er ekki tilheyrir fyrirtækinu {1},
Account {0} does not exist,Reikningur {0} er ekki til,
Account {0} does not exists,Reikningur {0} er ekki til,
Account {0} does not match with Company {1} in Mode of Account: {2},Reikningur {0} passar ekki við fyrirtæki {1} í reikningsaðferð: {2},
Account {0} has been entered multiple times,Reikningur {0} hefur verið slegið mörgum sinnum,
Account {0} is added in the child company {1},Reikningur {0} er bætt við í barnafyrirtækinu {1},
Account {0} is frozen,Reikningur {0} er frosinn,
Account {0} is invalid. Account Currency must be {1},Reikningur {0} er ógild. Reikningur Gjaldmiðill verður að vera {1},
Account {0}: Parent account {1} can not be a ledger,Reikningur {0}: Foreldri reikningur {1} getur ekki verið höfuðbók,
Account {0}: Parent account {1} does not belong to company: {2},Reikningur {0}: Foreldri reikningur {1} ekki tilheyra fyrirtæki: {2},
Account {0}: Parent account {1} does not exist,Reikningur {0}: Foreldri reikningur {1} er ekki til,
Account {0}: You can not assign itself as parent account,Reikningur {0}: Þú getur ekki framselt sig sem foreldri reikning,
Account: {0} can only be updated via Stock Transactions,Reikningur: {0} Aðeins er hægt að uppfæra í gegnum lager Viðskipti,
Account: {0} with currency: {1} can not be selected,Reikningur: {0} með gjaldeyri: {1} Ekki er hægt að velja,
Accountant,Endurskoðandi,
Accounting,Bókhald,
Accounting Entry for Asset,Reikningsskil fyrir eign,
Accounting Entry for Stock,Bókhalds Færsla fyrir Lager,
Accounting Entry for {0}: {1} can only be made in currency: {2},Bókhald Entry fyrir {0}: {1} Aðeins er hægt að gera í gjaldmiðli: {2},
Accounting Ledger,bókhald Ledger,
Accounting journal entries.,Bókhald dagbók færslur.,
Accounts,Reikningar,
Accounts Manager,Accounts Manager,
Accounts Payable,Viðskiptaskuldir,
Accounts Payable Summary,Viðskiptaskuldir Yfirlit,
Accounts Receivable,Reikningur fáanlegur,
Accounts Receivable Summary,Viðskiptakröfur Yfirlit,
Accounts User,notendareikninga,
Accounts table cannot be blank.,Reikninga borð getur ekki verið autt.,
Accrual Journal Entry for salaries from {0} to {1},Ársreikningur Innsláttur launa frá {0} til {1},
Accumulated Depreciation,uppsöfnuðum afskriftum,
Accumulated Depreciation Amount,Uppsöfnuðum afskriftum Upphæð,
Accumulated Depreciation as on,Uppsöfnuðum afskriftum og á,
Accumulated Monthly,Uppsafnaður Monthly,
Accumulated Values,Uppsafnaður Gildi,
Accumulated Values in Group Company,Uppsöfnuð gildi í fyrirtækinu,
Achieved ({}),Náð ({}),
Action,Aðgerð,
Action Initialised,Aðgerð hafin,
Actions,Aðgerðir,
Active,virk,
Active Leads / Customers,Virkar leiðir / viðskiptavinir,
Activity Cost exists for Employee {0} against Activity Type - {1},Virkni Kostnaður er til fyrir Starfsmaður {0} gegn Activity Tegund - {1},
Activity Cost per Employee,Virkni Kostnaður á hvern starfsmann,
Activity Type,virkni Type,
Actual Cost,Raunverulegur kostnaður,
Actual Delivery Date,Raunverulegur Afhendingardagur,
Actual Qty,Raunveruleg Magn,
Actual Qty is mandatory,Raunveruleg Magn er nauðsynlegur,
Actual Qty {0} / Waiting Qty {1},Raunverulegur fjöldi {0} / biðþáttur {1},
Actual Qty: Quantity available in the warehouse.,Raunverulegur fjöldi: Magn í boði á lager,
Actual qty in stock,Raunverulegur fjöldi á lager,
Actual type tax cannot be included in Item rate in row {0},Raunveruleg gerð skattur getur ekki verið með í Liður hlutfall í röð {0},
Add,Bæta,
Add / Edit Prices,Bæta við / Breyta Verð,
Add All Suppliers,Bæta við öllum birgjum,
Add Comment,Bæta við athugasemd,
Add Customers,Bæta við viðskiptavinum,
Add Employees,Bæta Starfsmenn,
Add Item,Bæta Hlutir,
Add Items,Bæta Hlutir,
Add Leads,Bæta við leiðum,
Add Multiple Tasks,Bæta við mörgum verkefnum,
Add Row,Bæta Row,
Add Sales Partners,Bæta við söluaðilum,
Add Serial No,Bæta Serial Nei,
Add Students,Bæta Nemendur,
Add Suppliers,Bæta við birgja,
Add Time Slots,Bæta við tímaslóðum,
Add Timesheets,bæta við timesheets,
Add Timeslots,Bæta við tímasetningum,
Add Users to Marketplace,Bæta notendum við markaðinn,
Add a new address,Bættu við nýju netfangi,
Add cards or custom sections on homepage,Bættu við kortum eða sérsniðnum hlutum á heimasíðunni,
Add more items or open full form,Bæta við fleiri atriði eða opnu fulla mynd,
Add notes,Bættu við athugasemdum,
Add the rest of your organization as your users. You can also add invite Customers to your portal by adding them from Contacts,Bætið restinni af fyrirtækinu þínu sem notendur. Þú getur einnig bætt við boðið viðskiptavinum sínum að vefsíðunni þinni með því að bæta þeim við úr Tengiliðum,
Add to Details,Bæta við upplýsingum,
Add/Remove Recipients,Bæta við / fjarlægja viðtakendur,
Added,Bætt við,
Added to details,Bætt við smáatriði,
Added {0} users,Bætt við {0} notendum,
Additional Salary Component Exists.,Viðbótarupplýsingar um launahluta eru til.,
Address,Heimilisfang,
Address Line 2,Heimilisfang lína 2,
Address Name,netfang Nafn,
Address Title,Heimilisfang Titill,
Address Type,Heimilisfang Tegund,
Administrative Expenses,rekstrarkostnaður,
Administrative Officer,Administrative Officer,
Administrator,Stjórnandi,
Admission,Aðgangseyrir,
Admission and Enrollment,Aðgangseyrir og innritun,
Admissions for {0},Innlagnir fyrir {0},
Admit,Viðurkenna,
Admitted,viðurkenndi,
Advance Amount,Advance Magn,
Advance Payments,Fyrirframgreiðslur,
Advance account currency should be same as company currency {0},Forgangsreikningur gjaldmiðill ætti að vera sá sami og gjaldmiðill fyrirtækisins {0},
Advance amount cannot be greater than {0} {1},Fyrirfram upphæð getur ekki verið meiri en {0} {1},
Advertising,Auglýsingar,
Aerospace,Aerospace,
Against,Gegn,
Against Account,Against reikninginn,
Against Journal Entry {0} does not have any unmatched {1} entry,Gegn Journal Entry {0} hjartarskinn ekki hafa allir ósamþykkt {1} færslu,
Against Journal Entry {0} is already adjusted against some other voucher,Gegn Journal Entry {0} er þegar leiðrétt gagnvart einhverjum öðrum skírteini,
Against Supplier Invoice {0} dated {1},Gegn Birgir Invoice {0} dagsett {1},
Against Voucher,Against Voucher,
Against Voucher Type,Against Voucher Tegund,
Age,Aldur,
Age (Days),Aldur (dagar),
Ageing Based On,Öldrun byggt á,
Ageing Range 1,Ageing Range 1,
Ageing Range 2,Ageing Range 2,
Ageing Range 3,Ageing Range 3,
Agriculture,Landbúnaður,
Agriculture (beta),Landbúnaður (beta),
Airline,Airline,
All Accounts,Allar reikningar,
All Addresses.,Öllum vistföngum.,
All Assessment Groups,Allir Námsmat Hópar,
All BOMs,Allir BOMs,
All Contacts.,Allir tengiliðir.,
All Customer Groups,Allir hópar viðskiptavina,
All Day,Allan daginn,
All Departments,Allar deildir,
All Healthcare Service Units,Allir heilbrigðisþjónustudeildir,
All Item Groups,Allir Item Hópar,
All Jobs,Allir Jobs,
All Products,Allar vörur,
All Products or Services.,Allar vörur eða þjónustu.,
All Student Admissions,Allir Student Innlagnir,
All Supplier Groups,Allir Birgir Hópar,
All Supplier scorecards.,Allir birgir skorar.,
All Territories,Allir Territories,
All Warehouses,Allir Vöruhús,
All communications including and above this shall be moved into the new Issue,"Öll samskipti, þ.mt og yfir þetta, skulu flutt í nýju útgáfuna",
All items have already been invoiced,Allir hlutir hafa nú þegar verið færðar á vörureikning,
All items have already been transferred for this Work Order.,Öll atriði hafa nú þegar verið flutt fyrir þessa vinnuáætlun.,
All other ITC,Allt annað ITC,
All the mandatory Task for employee creation hasn't been done yet.,Öll lögboðin verkefni fyrir sköpun starfsmanna hefur ekki enn verið gerðar.,
All these items have already been invoiced,Öll þessi atriði hafa þegar verið reikningsfærð,
Allocate Payment Amount,Úthluta Greiðsla Upphæð,
Allocated Amount,úthlutað magn,
Allocated Leaves,Úthlutað blöð,
Allocating leaves...,Úthluta leyfi ...,
Allow Delete,Leyfa Eyða,
Already record exists for the item {0},Nú þegar er skrá fyrir hlutinn {0},
"Already set default in pos profile {0} for user {1}, kindly disabled default","Setja sjálfgefið sjálfgefið í pósti prófíl {0} fyrir notanda {1}, vinsamlega slökkt á sjálfgefið",
Alternate Item,Varahlutir,
Alternative item must not be same as item code,Annað atriði má ekki vera eins og hlutkóði,
Amended From,Breytt frá,
Amount,upphæð,
Amount After Depreciation,Upphæð Eftir Afskriftir,
Amount of Integrated Tax,Fjárhæð samþætts skatts,
Amount of TDS Deducted,Fjárhæð TDS frádráttur,
Amount should not be less than zero.,Upphæðin ætti ekki að vera minni en núll.,
Amount to Bill,Upphæð Bill,
Amount {0} {1} against {2} {3},Upphæð {0} {1} gegn {2} {3},
Amount {0} {1} deducted against {2},Upphæð {0} {1} frádráttar {2},
Amount {0} {1} transferred from {2} to {3},Upphæð {0} {1} flutt frá {2} til {3},
Amount {0} {1} {2} {3},Upphæð {0} {1} {2} {3},
Amt,Amt,
"An Item Group exists with same name, please change the item name or rename the item group","An Item Group til staðar með sama nafni, vinsamlegast breyta hlutinn nafni eða endurnefna atriði hópinn",
An academic term with this 'Academic Year' {0} and 'Term Name' {1} already exists. Please modify these entries and try again.,An fræðihugtak með þessu &quot;skólaárinu &#39;{0} og&#39; Term Name &#39;{1} er þegar til. Vinsamlegast breyttu þessum færslum og reyndu aftur.,
An error occurred during the update process,Villa kom upp við uppfærsluferlið,
"An item exists with same name ({0}), please change the item group name or rename the item",Atriði til staðar með sama nafni ({0}) skaltu breyta liður heiti hópsins eða endurnefna hlutinn,
Analyst,Analyst,
Analytics,Analytics,
Annual Billing: {0},Árleg Billing: {0},
Annual Salary,árslaunum,
Anonymous,Nafnlaus,
Another Budget record '{0}' already exists against {1} '{2}' and account '{3}' for fiscal year {4},Annað fjárhagsáætlun &quot;{0}&quot; er nú þegar fyrir hendi við {1} &#39;{2}&#39; og reikning &#39;{3}&#39; fyrir reikningsár {4},
Another Period Closing Entry {0} has been made after {1},Annar Tímabil Lokar Entry {0} hefur verið gert eftir {1},
Another Sales Person {0} exists with the same Employee id,Annar velta manneskja {0} staðar með sama Starfsmannafélag id,
Antibiotic,Sýklalyf,
Apparel & Accessories,Fatnaður &amp; Aukabúnaður,
Applicable For,gildir til,
"Applicable if the company is SpA, SApA or SRL","Gildir ef fyrirtækið er SpA, SApA eða SRL",
Applicable if the company is a limited liability company,Gildir ef fyrirtækið er hlutafélag,
Applicable if the company is an Individual or a Proprietorship,Gildir ef fyrirtækið er einstaklingur eða eignaraðild,
Applicant,Umsækjandi,
Applicant Type,Umsækjandi Tegund,
Application of Funds (Assets),Umsókn um Funds (eignum),
Application period cannot be across two allocation records,Umsóknarfrestur getur ekki verið yfir tveimur úthlutunarskrám,
Application period cannot be outside leave allocation period,Umsókn tímabil getur ekki verið úti leyfi úthlutun tímabil,
Applied,Applied,
Apply Now,Sæktu um núna,
Appointment Confirmation,Ráðstefna staðfestingar,
Appointment Duration (mins),Skipunartími (mín.),
Appointment Type,Skipunartegund,
Appointment {0} and Sales Invoice {1} cancelled,Skipun {0} og sölureikningur {1} fellur niður,
Appointments and Encounters,Tilnefningar og fundir,
Appointments and Patient Encounters,Tilnefningar og þolinmæði,
Appraisal {0} created for Employee {1} in the given date range,Úttekt {0} búin til starfsmanns {1} á tilteknu tímabili,
Apprentice,Lærlingur,
Approval Status,Staða samþykkis,
Approval Status must be 'Approved' or 'Rejected',Samþykki Staða verður &quot;Samþykkt&quot; eða &quot;Hafnað &#39;,
Approve,Samþykkja,
Approving Role cannot be same as role the rule is Applicable To,Samþykkir hlutverki getur ekki verið sama og hlutverk reglan er við að,
Approving User cannot be same as user the rule is Applicable To,Samþykkir notandi getur ekki verið sama og notandinn reglan er við að,
"Apps using current key won't be able to access, are you sure?","Forrit sem nota núverandi lykil vilja ekki geta nálgast, ertu viss?",
Are you sure you want to cancel this appointment?,Ertu viss um að þú viljir hætta við þessa stefnumót?,
Arrear,Arrear,
As Examiner,Sem prófdómari,
As On Date,Eins á degi,
As Supervisor,Sem umsjónarmaður,
As per rules 42 & 43 of CGST Rules,Samkvæmt reglum 42 og 43 í CGST reglum,
As per section 17(5),Samkvæmt 5. lið (5),
As per your assigned Salary Structure you cannot apply for benefits,Eins og á úthlutað launasamningi þínum er ekki hægt að sækja um bætur,
Assessment,Mat,
Assessment Criteria,Námsmat Viðmið,
Assessment Group,mat Group,
Assessment Group: ,Námsmat:,
Assessment Plan,mat Plan,
Assessment Plan Name,Námsmat,
Assessment Report,Matsskýrsla,
Assessment Reports,Matsskýrslur,
Assessment Result,mat Niðurstaða,
Assessment Result record {0} already exists.,Niðurstaða mats {0} er þegar til.,
Asset,Asset,
Asset Category,Asset Flokkur,
Asset Category is mandatory for Fixed Asset item,Asset Flokkur er nauðsynlegur fyrir Fast eignalið,
Asset Maintenance,Eignastýring,
Asset Movement,Asset Hreyfing,
Asset Movement record {0} created,Eignastýring Hreyfing met {0} búin,
Asset Name,Asset Name,
Asset Received But Not Billed,Eign tekin en ekki reiknuð,
Asset Value Adjustment,Breyting eignaverðs,
"Asset cannot be cancelled, as it is already {0}","Eign er ekki hætt, eins og það er nú þegar {0}",
Asset scrapped via Journal Entry {0},Eignastýring rifið um dagbókarfærslu {0},
"Asset {0} cannot be scrapped, as it is already {1}","Eignastýring {0} er ekki hægt að rífa, eins og það er nú þegar {1}",
Asset {0} does not belong to company {1},Eignastýring {0} ekki tilheyra félaginu {1},
Asset {0} must be submitted,Eignastýring {0} Leggja skal fram,
Assets,Eignir,
Assign,Úthluta,
Assign Salary Structure,Úthluta launasamsetningu,
Assign To,Úthluta til,
Assign to Employees,Úthlutaðu starfsmönnum,
Assigning Structures...,Úthlutar mannvirkjum ...,
Associate,Félagi,
At least one mode of payment is required for POS invoice.,Að minnsta kosti einn háttur af greiðslu er krafist fyrir POS reikningi.,
Atleast one item should be entered with negative quantity in return document,Atleast eitt atriði skal færa með neikvæðum magni í staðinn skjal,
Atleast one of the Selling or Buying must be selected,Atleast einn af selja eða kaupa verður að vera valinn,
Atleast one warehouse is mandatory,Atleast einn vöruhús er nauðsynlegur,
Attach Logo,hengja Logo,
Attachment,Viðhengi,
Attachments,Viðhengi,
Attendance,Aðsókn,
Attendance From Date and Attendance To Date is mandatory,Aðsókn Frá Dagsetning og Aðsókn hingað til er nauðsynlegur,
Attendance Record {0} exists against Student {1},Aðsókn Record {0} hendi á móti Student {1},
Attendance can not be marked for future dates,Aðsókn er ekki hægt að merkja fyrir framtíð dagsetningar,
Attendance date can not be less than employee's joining date,Mæting dagsetning má ekki vera minna en inngöngu dagsetningu starfsmanns,
Attendance for employee {0} is already marked,Mæting fyrir starfsmann {0} er þegar merkt,
Attendance for employee {0} is already marked for this day,Mæting fyrir starfsmann {0} er þegar merkt fyrir þennan dag,
Attendance has been marked successfully.,Aðsókn hefur verið merkt með góðum árangri.,
Attendance not submitted for {0} as it is a Holiday.,Þáttur ekki sendur fyrir {0} eins og það er frídagur.,
Attendance not submitted for {0} as {1} on leave.,Þáttur ekki sendur fyrir {0} sem {1} í leyfi.,
Attribute table is mandatory,Eiginleiki borð er nauðsynlegur,
Attribute {0} selected multiple times in Attributes Table,Eiginleiki {0} valin mörgum sinnum í eigindum töflu,
Author,Höfundur,
Authorized Signatory,Leyft Undirritaður,
Auto Material Requests Generated,Auto Efni Beiðnir Myndað,
Auto Repeat,Sjálfvirk endurtaka,
Auto repeat document updated,Sjálfvirk endurtaka skjal uppfært,
Automotive,Automotive,
Available,Laus,
Available Leaves,Lausar blöð,
Available Qty,Laus magn,
Available Selling,Laus selja,
Available for use date is required,Til staðar er hægt að nota dagsetninguna,
Available slots,Lausar rifa,
Available {0},Laus {0},
Available-for-use Date should be after purchase date,Laus-til-nota Dagsetning ætti að vera eftir kaupdegi,
Average Age,Meðalaldur,
Average Rate,Meðaltal,
Avg Daily Outgoing,Avg Daily Outgoing,
Avg. Buying Price List Rate,Meðaltal Kaupverðskrárgengi,
Avg. Selling Price List Rate,Meðaltal Selja Verðskrá Rate,
Avg. Selling Rate,Avg. sölugengi,
BOM,BOM,
BOM Browser,BOM Browser,
BOM No,BOM Nei,
BOM Rate,BOM Rate,
BOM Stock Report,BOM Stock Report,
BOM and Manufacturing Quantity are required,BOM og framleiðsla Magn þarf,
BOM does not contain any stock item,BOM inniheldur ekki lager atriði,
BOM {0} does not belong to Item {1},BOM {0} ekki tilheyra lið {1},
BOM {0} must be active,BOM {0} verður að vera virkt,
BOM {0} must be submitted,BOM {0} Leggja skal fram,
Balance,Balance,
Balance (Dr - Cr),Jafnvægi (Dr - Cr),
Balance ({0}),Jafnvægi ({0}),
Balance Qty,Balance Magn,
Balance Sheet,Efnahagsreikningur,
Balance Value,Balance Value,
Balance for Account {0} must always be {1},Stöðunni á reikningnum {0} verður alltaf að vera {1},
Bank,Bank,
Bank Account,Bankareikning,
Bank Accounts,Reikningar,
Bank Draft,Bank Draft,
Bank Entries,Bank Entries,
Bank Name,Nafn banka,
Bank Overdraft Account,Bank Heimildarlás Account,
Bank Reconciliation,Bank Sættir,
Bank Reconciliation Statement,Bank Sættir Yfirlýsing,
Bank Statement,Reikningsyfirlit,
Bank Statement Settings,Staða bankareiknings,
Bank Statement balance as per General Ledger,Bankayfirlit jafnvægi eins og á General Ledger,
Bank account cannot be named as {0},bankareikningur getur ekki verið nefnt sem {0},
Bank/Cash transactions against party or for internal transfer,Bank / reiðufé gagnvart aðila eða fyrir innra flytja,
Banking,Banking,
Banking and Payments,Bankastarfsemi og greiðslur,
Barcode {0} already used in Item {1},Strikamerki {0} nú þegar notuð í lið {1},
Barcode {0} is not a valid {1} code,Strikamerki {0} er ekki gilt {1} kóða,
Base,Base,
Base URL,Undirstaða vefslóð,
Based On,Byggt á,
Based On Payment Terms,Byggt á greiðsluskilmálum,
Basic,Basic,
Batch,Hópur,
Batch Entries,Hópafærslur,
Batch ID is mandatory,Hópur auðkenni er nauðsynlegur,
Batch Inventory,hópur Inventory,
Batch Name,hópur Name,
Batch No,hópur Nei,
Batch number is mandatory for Item {0},Lotunúmer er nauðsynlegur fyrir lið {0},
Batch {0} of Item {1} has expired.,Hópur {0} af Liður {1} hefur runnið út.,
Batch {0} of Item {1} is disabled.,Hópur {0} í lið {1} er óvirkur.,
Batch: ,Hópur:,
Batches,Hópur,
Become a Seller,Gerast seljandi,
Beginner,Beginner,
Bill,Bill,
Bill Date,Bill Dagsetning,
Bill No,Bill Nei,
Bill of Materials,Bill of Materials,
Bill of Materials (BOM),Bill of Materials (BOM),
Billable Hours,Reikningstímar,
Billed,billed,
Billed Amount,billed Upphæð,
Billing,Innheimtu,
Billing Address,Greiðslufang,
Billing Address is same as Shipping Address,Innheimtu heimilisfang er það sama og póstfang,
Billing Amount,Innheimta Upphæð,
Billing Status,Innheimta Staða,
Billing currency must be equal to either default company's currency or party account currency,Innheimtargjald verður að vera jafnt gjaldmiðli gjaldmiðils eða félagsreiknings gjaldmiðils,
Bills raised by Suppliers.,Víxlar hækkaðir um birgja.,
Bills raised to Customers.,Víxlar vakti til viðskiptavina.,
Biotechnology,Líftækni,
Birthday Reminder,Afmælisdagur afmæli,
Black,Black,
Blanket Orders from Costumers.,Pantanir á teppi frá viðskiptavinum.,
Block Invoice,Loka innheimtu,
Boms,Boms,
Bonus Payment Date cannot be a past date,Bónus Greiðsludagur getur ekki verið síðasta dagsetning,
Both Trial Period Start Date and Trial Period End Date must be set,Bæði upphafstímabil og prófunartímabil verður að vera stillt,
Both Warehouse must belong to same Company,Bæði Warehouse að tilheyra sama Company,
Branch,Branch,
Broadcasting,Broadcasting,
Brokerage,Miðlari,
Browse BOM,Fletta BOM,
Budget Against,Budget Against,
Budget List,Fjárhagsáætlunarlisti,
Budget Variance Report,Budget Dreifni Report,
Budget cannot be assigned against Group Account {0},Fjárhagsáætlun er ekki hægt að úthlutað gegn Group reikninginn {0},
"Budget cannot be assigned against {0}, as it's not an Income or Expense account","Fjárhagsáætlun er ekki hægt að úthlutað gegn {0}, eins og það er ekki tekjur eða gjöld reikning",
Buildings,Byggingar,
Bundle items at time of sale.,Knippi atriði á sölu.,
Business Development Manager,Business Development Manager,
Buy,Kaupa,
Buying,Kaup,
Buying Amount,Kaup Upphæð,
Buying Price List,Kaupverðskrá,
Buying Rate,Kaupgengi,
"Buying must be checked, if Applicable For is selected as {0}","Kaup verður að vera merkt, ef við á er valið sem {0}",
By {0},Eftir {0},
Bypass credit check at Sales Order ,Bannað lánshæfiseinkunn á söluskilningi,
C-Form records,C-Form færslur,
C-form is not applicable for Invoice: {0},C-form er ekki fyrir Invoice: {0},
CEO,Forstjóri,
CESS Amount,CESS upphæð,
CGST Amount,CGST upphæð,
CRM,CRM,
CWIP Account,CWIP reikningur,
Calculated Bank Statement balance,Útreiknuð Bank Yfirlýsing jafnvægi,
Calls,Símtöl,
Campaign,Herferð,
Can be approved by {0},Getur verið samþykkt af {0},
"Can not filter based on Account, if grouped by Account","Getur ekki síað byggð á reikning, ef flokkaðar eftir reikningi",
"Can not filter based on Voucher No, if grouped by Voucher",Getur ekki síað byggð á skírteini nr ef flokkaðar eftir skírteini,
"Can not mark Inpatient Record Discharged, there are Unbilled Invoices {0}","Ekki er hægt að merkja innritunarskammtalaga losað, það eru óskýrðir reikningar {0}",
Can only make payment against unbilled {0},Getur aðeins gera greiðslu gegn ógreitt {0},
Can refer row only if the charge type is 'On Previous Row Amount' or 'Previous Row Total',Getur átt röð ef gjaldið er af gerðinni &#39;On Fyrri Row Upphæð&#39; eða &#39;Fyrri Row Total&#39;,
"Can't change valuation method, as there are transactions against some items which does not have it's own valuation method","Ekki er hægt að breyta matunaraðferð, þar sem viðskipti eiga sér stað gegn sumum hlutum sem ekki hafa eigin matunaraðferð",
Can't create standard criteria. Please rename the criteria,Ekki er hægt að búa til staðlaðar forsendur. Vinsamlegast breyttu viðmiðunum,
Cancel,Hætta,
Cancel Material Visit {0} before cancelling this Warranty Claim,Hætta Efni Visit {0} áður hætta þessu ábyrgð kröfu,
Cancel Material Visits {0} before cancelling this Maintenance Visit,Hætta Efni Heimsóknir {0} áður hætta þessu Viðhald Farðu,
Cancel Subscription,Hætta við áskrift,
Cancel the journal entry {0} first,Hætta við dagbókarfærsluna {0} fyrst,
Canceled,Hætt við,
"Cannot Submit, Employees left to mark attendance","Get ekki sent, Starfsmenn vinstri til að merkja aðsókn",
Cannot be a fixed asset item as Stock Ledger is created.,Ekki er hægt að vera fast eignalýsing þar sem birgir er búið til.,
Cannot cancel because submitted Stock Entry {0} exists,Ekki er hægt að hætta við vegna þess að lögð Stock Entry {0} hendi,
Cannot cancel transaction for Completed Work Order.,Ekki er hægt að hætta við viðskipti fyrir lokaðan vinnuskilríki.,
Cannot cancel {0} {1} because Serial No {2} does not belong to the warehouse {3},Ekki er hægt að hætta við {0} {1} vegna þess að raðnúmer {2} er ekki til vörunnar {3},
Cannot change Attributes after stock transaction. Make a new Item and transfer stock to the new Item,Get ekki breytt eiginleiki eftir viðskipti með hlutabréf. Búðu til nýtt hlut og flytja birgðir til nýju hlutarins,
Cannot change Fiscal Year Start Date and Fiscal Year End Date once the Fiscal Year is saved.,Get ekki breytt Fiscal Year upphafsdagur og reikningsár lokadag þegar Fiscal Year er vistuð.,
Cannot change Service Stop Date for item in row {0},Ekki er hægt að breyta þjónustustöðvunardegi fyrir atriði í röð {0},
Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,Ekki er hægt að breyta Variant eignum eftir viðskipti með hlutabréf. Þú verður að búa til nýtt atriði til að gera þetta.,
"Cannot change company's default currency, because there are existing transactions. Transactions must be cancelled to change the default currency.","Get ekki breytt sjálfgefið mynt félagsins, vegna þess að það eru núverandi viðskiptum. Viðskipti verða að vera lokað til að breyta sjálfgefið mynt.",
Cannot change status as student {0} is linked with student application {1},Get ekki breytt stöðu sem nemandi {0} er tengd við beitingu nemandi {1},
Cannot convert Cost Center to ledger as it has child nodes,Ekki hægt að umbreyta Kostnaður Center til aðalbók eins og það hefur barnið hnúta,
Cannot covert to Group because Account Type is selected.,Get ekki leynilegar að samstæðunnar vegna Tegund reiknings er valinn.,
Cannot create Retention Bonus for left Employees,Get ekki búið til viðhaldsbónus fyrir vinstri starfsmenn,
Cannot create a Delivery Trip from Draft documents.,Ekki hægt að búa til afhendingarferð úr drögum skjala.,
Cannot deactivate or cancel BOM as it is linked with other BOMs,Ekki er hægt að slökkva eða hætta BOM eins og það er tengt við önnur BOMs,
"Cannot declare as lost, because Quotation has been made.","Get ekki lýst því sem glatast, af því Tilvitnun hefur verið gert.",
Cannot deduct when category is for 'Valuation' or 'Valuation and Total',Get ekki draga þegar flokkur er fyrir &#39;Verðmat&#39; eða &#39;Verðmat og heildar&#39;,
Cannot deduct when category is for 'Valuation' or 'Vaulation and Total',Get ekki draga þegar flokkur er fyrir &#39;Verðmat&#39; eða &#39;Vaulation og heildar&#39;,
"Cannot delete Serial No {0}, as it is used in stock transactions","Ekki hægt að eyða Serial Nei {0}, eins og það er notað í lager viðskiptum",
Cannot enroll more than {0} students for this student group.,Ekki er hægt að innritast meira en {0} nemendum fyrir þessum nemendahópi.,
Cannot find Item with this barcode,Get ekki fundið hlut með þessum strikamerki,
Cannot find active Leave Period,Get ekki fundið virka skiladag,
Cannot produce more Item {0} than Sales Order quantity {1},Geta ekki framleitt meira ítarefni {0} en Sales Order Magn {1},
Cannot promote Employee with status Left,Get ekki kynnt starfsmanni með stöðu vinstri,
Cannot refer row number greater than or equal to current row number for this Charge type,Getur ekki átt línunúmeri meiri en eða jafnt og núverandi röð númer fyrir þessa Charge tegund,
Cannot select charge type as 'On Previous Row Amount' or 'On Previous Row Total' for first row,Get ekki valið gjald tegund sem &quot;On Fyrri Row Upphæð &#39;eða&#39; Á fyrri röðinni Samtals &#39;fyrir fyrstu röðinni,
Cannot set a received RFQ to No Quote,Ekki er hægt að stilla móttekið RFQ til neins vitna,
Cannot set as Lost as Sales Order is made.,Get ekki stillt eins Lost og Sales Order er gert.,
Cannot set authorization on basis of Discount for {0},Get ekki stillt leyfi á grundvelli afsláttur fyrir {0},
Cannot set multiple Item Defaults for a company.,Ekki er hægt að stilla mörg atriði sjálfgefna fyrir fyrirtæki.,
Cannot set quantity less than delivered quantity,Ekki hægt að stilla magn minna en afhent magn,
Cannot set quantity less than received quantity,Ekki hægt að stilla magn minna en móttekið magn,
Cannot set the field <b>{0}</b> for copying in variants,Ekki hægt að stilla reitinn <b>{0}</b> til afritunar í afbrigðum,
Cannot transfer Employee with status Left,Ekki er hægt að flytja starfsmann með stöðu Vinstri,
Cannot {0} {1} {2} without any negative outstanding invoice,Get ekki {0} {1} {2} án neikvætt framúrskarandi Reikningar,
Capital Equipments,Capital útbúnaður,
Capital Stock,Capital Stock,
Capital Work in Progress,Capital vinna í framfarir,
Cart,Körfu,
Cart is Empty,Karfan er tóm,
Case No(s) already in use. Try from Case No {0},Case Nei (s) þegar í notkun. Prófaðu frá máli nr {0},
Cash,Cash,
Cash Flow Statement,Sjóðstreymi,
Cash Flow from Financing,Cash Flow frá fjármögnun,
Cash Flow from Investing,Cash Flow frá Fjárfesting,
Cash Flow from Operations,Handbært fé frá rekstri,
Cash In Hand,Handbært fé,
Cash or Bank Account is mandatory for making payment entry,Cash eða Bank Account er nauðsynlegur til að gera greiðslu færslu,
Cashier Closing,Gjaldkeri,
Casual Leave,Kjóll Leave,
Category,Flokkur,
Category Name,Flokkur Nafn,
Caution,Varúð,
Central Tax,Miðskattur,
Certification,Vottun,
Cess,Skil,
Change Amount,Breyta upphæð,
Change Item Code,Breyta vöruheiti,
Change POS Profile,Breyta POS Profile,
Change Release Date,Breyta útgáfudegi,
Change Template Code,Breyta Sniðmát,
Changing Customer Group for the selected Customer is not allowed.,Breyting viðskiptavinahóps fyrir valda viðskiptavini er ekki leyfilegt.,
Chapter,Kafli,
Chapter information.,Upplýsingar um kafla.,
Charge of type 'Actual' in row {0} cannot be included in Item Rate,Gjald af gerðinni &#39;Raunveruleg&#39; í röð {0} er ekki að vera með í Item Rate,
Chargeble,Gjaldtaka,
Charges are updated in Purchase Receipt against each item,Gjöld eru uppfærðar á kvittun við hvert atriði,
"Charges will be distributed proportionately based on item qty or amount, as per your selection","Gjöld verður dreift hlutfallslega miðað hlut Fjöldi eða magn, eins og á val þitt",
Chart Of Accounts,Mynd reikninga,
Chart of Cost Centers,Mynd af stoðsviða,
Check all,Athugaðu alla,
Checkout,Athuga,
Chemical,Chemical,
Cheque,ávísun,
Cheque/Reference No,Ávísun / tilvísunarnúmer,
Cheques Required,Athuganir krafist,
Cheques and Deposits incorrectly cleared,Tékkar og Innlán rangt hreinsaðar,
Child Item should not be a Product Bundle. Please remove item `{0}` and save,Barnið Item ætti ekki að vera Product Knippi. Fjarlægðu hlut `{0}` og vista,
Child Task exists for this Task. You can not delete this Task.,Barnaskipti er til fyrir þetta verkefni. Þú getur ekki eytt þessu verkefni.,
Child nodes can be only created under 'Group' type nodes,Barn hnútar geta verið aðeins búin undir &#39;group&#39; tegund hnúta,
Child warehouse exists for this warehouse. You can not delete this warehouse.,Barnið vöruhús er til fyrir þetta vöruhús. Þú getur ekki eytt þessari vöruhús.,
Circular Reference Error,Hringlaga Tilvísun Villa,
City,Borg,
City/Town,City / Town,
Claimed Amount,Krafist upphæð,
Clay,Leir,
Clear filters,Hreinsaðu síur,
Clear values,Skýr gildi,
Clearance Date,úthreinsun Dagsetning,
Clearance Date not mentioned,Úthreinsun Date ekki getið,
Clearance Date updated,Úthreinsun Date uppfært,
Client,Viðskiptavinur,
Client ID,Viðskiptavinur ID,
Client Secret,Viðskiptavinur Secret,
Clinical Procedure,Klínísk aðferð,
Clinical Procedure Template,Klínísk málsmeðferð,
Close Balance Sheet and book Profit or Loss.,Loka Efnahagur og bók hagnaður eða tap.,
Close Loan,Loka láni,
Close the POS,Lokaðu POS,
Closed,Lokað,
Closed order cannot be cancelled. Unclose to cancel.,Lokað þess geta ekki verið lokað. Unclose að hætta.,
Closing (Cr),Lokun (Cr),
Closing (Dr),Lokun (Dr),
Closing (Opening + Total),Lokun (Opnun + Samtals),
Closing Account {0} must be of type Liability / Equity,Lokun reikning {0} verður að vera af gerðinni ábyrgðar / Equity,
Closing Balance,Lokajafnvægi,
Code,code,
Collapse All,fella saman alla,
Color,Litur,
Colour,Colour,
Combined invoice portion must equal 100%,Sameinað reikningshluti verður jafn 100%,
Commercial,Commercial,
Commission,þóknun,
Commission Rate %,Framkvæmdastjórnarhlutfall%,
Commission on Sales,Þóknun á sölu,
Commission rate cannot be greater than 100,hlutfall Framkvæmdastjórnin getur ekki verið meiri en 100,
Community Forum,Forum Community,
Company (not Customer or Supplier) master.,Company (ekki viðskiptamenn eða birgja) skipstjóri.,
Company Abbreviation,Fyrirtæki Skammstöfun,
Company Abbreviation cannot have more than 5 characters,Fyrirtæki Skammstöfun getur ekki haft meira en 5 stafi,
Company Name,nafn fyrirtækis,
Company Name cannot be Company,Nafn fyrirtækis er ekki hægt Company,
Company currencies of both the companies should match for Inter Company Transactions.,Fyrirtækjafjármunir bæði fyrirtækjanna ættu að passa við viðskipti milli fyrirtækja.,
Company is manadatory for company account,Félagið er stjórnarskrá fyrir félagsreikning,
Company name not same,Nafn fyrirtækis er ekki sama,
Company {0} does not exist,Fyrirtæki {0} er ekki til,
"Company, Payment Account, From Date and To Date is mandatory","Fyrirtæki, greiðslureikningur, frá dagsetningu og dagsetningu er skylt",
Compensatory Off,jöfnunaraðgerðir Off,
Compensatory leave request days not in valid holidays,Dagbætur vegna bótaábyrgðar ekki í gildum frídagum,
Complaint,Kvörtun,
Completed Qty can not be greater than 'Qty to Manufacture',Lokið Magn má ekki vera meiri en &#39;Magn í Manufacture&#39;,
Completion Date,Verklok,
Computer,Tölva,
Condition,Ástand,
Configure,Stilla,
Configure {0},Stilla {0},
Confirmed orders from Customers.,Staðfest pantanir frá viðskiptavinum.,
Connect Amazon with ERPNext,Tengdu Amazon með ERPNext,
Connect Shopify with ERPNext,Tengdu Shopify með ERPNext,
Connect to Quickbooks,Tengdu við Quickbooks,
Connected to QuickBooks,Tengdur við QuickBooks,
Connecting to QuickBooks,Tengist við QuickBooks,
Consultation,Samráð,
Consultations,Samráð,
Consulting,Ráðgjöf,
Consumable,einnota,
Consumed,Neytt,
Consumed Amount,neytt Upphæð,
Consumed Qty,neytt Magn,
Consumer Products,Consumer Products,
Contact,Viltu samband við,
Contact Details,Tengiliðaupplýsingar,
Contact Number,Númer tengiliðs,
Contact Us,Hafðu samband við okkur,
Content,Innihald,
Content Masters,Innihald meistarar,
Content Type,content Type,
Continue Configuration,Haltu áfram með stillingar,
Contract,Samningur,
Contract End Date must be greater than Date of Joining,Samningur Lokadagur verður að vera hærri en Dagsetning Tengja,
Contribution %,framlag%,
Contribution Amount,framlag Upphæð,
Conversion factor for default Unit of Measure must be 1 in row {0},Breytistuðull fyrir sjálfgefið Mælieiningin skal vera 1 í röðinni {0},
Conversion rate cannot be 0 or 1,Viðskiptahlutfall er ekki hægt að 0 eða 1,
Convert to Group,Umbreyta í Group,
Convert to Non-Group,Umbreyta til non-Group,
Cosmetics,Snyrtivörur,
Cost Center,Kostnaður Center,
Cost Center Number,Kostnaðurarmiðstöð Fjöldi,
Cost Center and Budgeting,Kostnaðarmiðstöð og fjárlagagerð,
Cost Center is required in row {0} in Taxes table for type {1},Kostnaður Center er krafist í röð {0} skatta borð fyrir tegund {1},
Cost Center with existing transactions can not be converted to group,Kostnaður Center við núverandi viðskipti er ekki hægt að breyta í hópinn,
Cost Center with existing transactions can not be converted to ledger,Kostnaður Center við núverandi viðskipti er ekki hægt að breyta í höfuðbók,
Cost Centers,stoðsviða,
Cost Updated,Kostnaður Uppfært,
Cost as on,Kostnaður og á,
Cost of Delivered Items,Kostnaður við afhent Items,
Cost of Goods Sold,Kostnaður af seldum vörum,
Cost of Issued Items,Kostnaður af úthlutuðum Items,
Cost of New Purchase,Kostnaður við nýja kaup,
Cost of Purchased Items,Kostnaður vegna aðkeyptrar atriði,
Cost of Scrapped Asset,Kostnaður við rifið Eignastýring,
Cost of Sold Asset,Kostnaðarverð seldrar Eignastýring,
Cost of various activities,Kostnaður við ýmiss konar starfsemi,
"Could not create Credit Note automatically, please uncheck 'Issue Credit Note' and submit again","Ekki tókst að búa til kreditkort sjálfkrafa, vinsamlegast hakið úr &#39;Útgáfa lánshæfismats&#39; og sendu aftur inn",
Could not generate Secret,Gat ekki búið til leyndarmál,
Could not retrieve information for {0}.,Gat ekki sótt upplýsingar um {0}.,
Could not solve criteria score function for {0}. Make sure the formula is valid.,Gat ekki leyst forsendur skora virka fyrir {0}. Gakktu úr skugga um að formúlan sé gild.,
Could not solve weighted score function. Make sure the formula is valid.,Gat ekki leyst veginn skora virka. Gakktu úr skugga um að formúlan sé gild.,
Could not submit some Salary Slips,Gat ekki sent inn launatölur,
"Could not update stock, invoice contains drop shipping item.","Gat ekki uppfært lager, reikningsnúmer inniheldur falla skipum hlut.",
Country wise default Address Templates,Land vitur sjálfgefið veffang Sniðmát,
Course,Námskeið,
Course Code: ,Námskeiðskóði:,
Course Enrollment {0} does not exists,Skráning á námskeið {0} er ekki til,
Course Schedule,námskeið Stundaskrá,
Course: ,Námskeið:,
Cr,Cr,
Create,Búa,
Create BOM,Búðu til BOM,
Create Delivery Trip,Búðu til afhendingarferð,
Create Disbursement Entry,Búðu til útborgun,
Create Employee,Búa til starfsmann,
Create Employee Records,Búa Employee Records,
"Create Employee records to manage leaves, expense claims and payroll","Búa Employee skrár til að stjórna lauf, kostnað kröfur og launaskrá",
Create Fee Schedule,Búðu til gjaldskrá,
Create Fees,Búðu til gjöld,
Create Inter Company Journal Entry,Búðu til færslu Inter Company Journal,
Create Invoice,Búðu til reikning,
Create Invoices,Búðu til reikninga,
Create Job Card,Búðu til atvinnukort,
Create Journal Entry,Búðu til dagbókarfærslu,
Create Lab Test,Búa til Lab Test,
Create Lead,Búðu til blý,
Create Leads,Búa Leiða,
Create Maintenance Visit,Búðu til viðhaldsheimsókn,
Create Material Request,Búðu til efnisbeiðni,
Create Multiple,Búðu til marga,
Create Opening Sales and Purchase Invoices,Búðu til opnunarsölu og innheimtuseðla,
Create Payment Entries,Búðu til greiðslufærslur,
Create Payment Entry,Búðu til greiðslufærslu,
Create Print Format,Búa prenta sniði,
Create Purchase Order,Búðu til innkaupapöntun,
Create Purchase Orders,Búa innkaupapantana,
Create Quotation,Búðu til tilvitnun,
Create Salary Slip,Búa Laun Slip,
Create Salary Slips,Búðu til launaákvarðanir,
Create Sales Invoice,Búa til sölureikning,
Create Sales Order,Búðu til sölupöntun,
Create Sales Orders to help you plan your work and deliver on-time,Búðu til sölupantanir til að hjálpa þér að skipuleggja vinnu þína og skila á réttum tíma,
Create Sample Retention Stock Entry,Búðu til sýnishorn af lagerupptöku,
Create Student,Búðu til námsmann,
Create Student Batch,Búðu til námsmannahóp,
Create Student Groups,Búa Student Hópar,
Create Supplier Quotation,Búðu til tilboðs til birgja,
Create Tax Template,Búðu til skattskjal,
Create Timesheet,Búðu til tímarit,
Create User,Búa til notanda,
Create Users,Búa notendur,
Create Variant,Búa til afbrigði,
Create Variants,Búðu til afbrigði,
Create a new Customer,Búa til nýja viðskiptavini,
"Create and manage daily, weekly and monthly email digests.","Búa til og stjórna daglega, vikulega og mánaðarlega email meltir.",
Create customer quotes,Búa viðskiptavina tilvitnanir,
Create rules to restrict transactions based on values.,Búa til reglur til að takmarka viðskipti sem byggjast á gildum.,
Created By,Búið til af,
Created {0} scorecards for {1} between: ,Búið til {0} stigakort fyrir {1} á milli:,
Creating Company and Importing Chart of Accounts,Að stofna fyrirtæki og flytja inn reikningskort,
Creating Fees,Búa til gjöld,
Creating Payment Entries......,Búa til greiðslufærslur ......,
Creating Salary Slips...,Búa til launaákvarðanir ...,
Creating student groups,Búa til nemendahópa,
Creating {0} Invoice,Búa til {0} Reikningur,
Credit,Credit,
Credit ({0}),Credit ({0}),
Credit Account,Credit Reikningur,
Credit Balance,Inneignin,
Credit Card,Kreditkort,
Credit Days cannot be a negative number,Credit Days má ekki vera neikvætt númer,
Credit Limit,Skuldfærsluhámark,
Credit Note,Inneignarnótu,
Credit Note Amount,Lánshæð upphæð,
Credit Note Issued,Credit Note Útgefið,
Credit Note {0} has been created automatically,Lánshæfiseinkunn {0} hefur verið búið til sjálfkrafa,
Credit limit has been crossed for customer {0} ({1}/{2}),Lánshæfismat hefur verið farið fyrir viðskiptavininn {0} ({1} / {2}),
Creditors,lánardrottnar,
Criteria weights must add up to 100%,Viðmiðunarþyngd verður að bæta allt að 100%,
Crop Cycle,Ræktunarhringur,
Crops & Lands,Korn og lönd,
Currency Exchange must be applicable for Buying or for Selling.,Gjaldmiðill verður að eiga við um kaup eða sölu.,
Currency can not be changed after making entries using some other currency,Gjaldmiðill er ekki hægt að breyta eftir að færslur með einhverja aðra mynt,
Currency exchange rate master.,Gengi meistara.,
Currency for {0} must be {1},Gjaldeyri fyrir {0} verður að vera {1},
Currency is required for Price List {0},Gjaldmiðill er nauðsynlegt til verðlisti {0},
Currency of the Closing Account must be {0},Gjaldmiðill lokun reiknings skal vera {0},
Currency of the price list {0} must be {1} or {2},Gjaldmiðill verðlista {0} verður að vera {1} eða {2},
Currency should be same as Price List Currency: {0},Gjaldmiðill ætti að vera eins og verðskrá Gjaldmiðill: {0},
Current,Núverandi,
Current Assets,Veltufjármunir,
Current BOM and New BOM can not be same,Núverandi BOM og New BOM getur ekki verið það sama,
Current Job Openings,Núverandi Op Atvinna,
Current Liabilities,Núverandi skuldir,
Current Qty,Núverandi Magn,
Current invoice {0} is missing,Núverandi reikningur {0} vantar,
Custom HTML,Custom HTML,
Custom?,Custom?,
Customer,Viðskiptavinur,
Customer Addresses And Contacts,Viðskiptavinur heimilisföngum og Tengiliðir,
Customer Contact,viðskiptavinur samband við,
Customer Database.,Viðskiptavinur gagnasafn.,
Customer Group,viðskiptavinur Group,
Customer Group is Required in POS Profile,Viðskiptavinahópur er krafist í POS Profile,
Customer LPO,Viðskiptavinur LPO,
Customer LPO No.,Viðskiptavinur LPO nr.,
Customer Name,Nafn viðskiptavinar,
Customer POS Id,Viðskiptavinur POS-auðkenni,
Customer Service,Þjónustuver,
Customer and Supplier,Viðskiptavinur og birgir,
Customer is required,Viðskiptavinur er krafist,
Customer isn't enrolled in any Loyalty Program,Viðskiptavinur er ekki skráður í neina hollustuáætlun,
Customer required for 'Customerwise Discount',Viðskiptavinur þarf að &#39;Customerwise Afsláttur&#39;,
Customer {0} does not belong to project {1},Viðskiptavinur {0} ekki tilheyra verkefninu {1},
Customer {0} is created.,Viðskiptavinur {0} er búinn til.,
Customers in Queue,Viðskiptavinir í biðröð,
Customize Homepage Sections,Sérsníddu heimasíður,
Customizing Forms,sérsníða Eyðublöð,
Daily Project Summary for {0},Daglegt yfirlit verkefnisins fyrir {0},
Daily Reminders,Daglegar áminningar,
Daily Work Summary,Daily Work Yfirlit,
Daily Work Summary Group,Dagleg vinnusamningshópur,
Data Import and Export,Gögn Innflutningur og útflutningur,
Data Import and Settings,Gagnainnflutningur og stillingar,
Database of potential customers.,Gagnagrunnur hugsanlegra viðskiptavina.,
Date Format,Dagsetning Format,
Date Of Retirement must be greater than Date of Joining,Dagsetning starfsloka verður að vera hærri en Dagsetning Tengja,
Date is repeated,Dagsetning er endurtekin,
Date of Birth,Fæðingardagur,
Date of Birth cannot be greater than today.,Fæðingardagur getur ekki verið meiri en í dag.,
Date of Commencement should be greater than Date of Incorporation,Upphafsdagur ætti að vera meiri en upphafsdagur,
Date of Joining,Dagsetning Tengja,
Date of Joining must be greater than Date of Birth,Dagsetning Tengja verður að vera meiri en Fæðingardagur,
Date of Transaction,Dagsetning viðskipta,
Datetime,Datetime,
Day,Dagur,
Debit,debet,
Debit ({0}),Skuldfærslu ({0}),
Debit A/C Number,A / C númer debet,
Debit Account,skuldfærslureikning,
Debit Note,debet Note,
Debit Note Amount,Gengisskuldbinding,
Debit Note Issued,Debet Note Útgefið,
Debit To is required,Skuldfærslu Til er krafist,
Debit and Credit not equal for {0} #{1}. Difference is {2}.,Greiðslu- ekki jafnir fyrir {0} # {1}. Munurinn er {2}.,
Debtors,Skuldunautar,
Debtors ({0}),Skuldarar ({0}),
Declare Lost,Lýsa týndum,
Deduction,Frádráttur,
Default Activity Cost exists for Activity Type - {0},Sjálfgefið Activity Kostnaður er fyrir hendi Activity Tegund - {0},
Default BOM ({0}) must be active for this item or its template,Sjálfgefið BOM ({0}) verður að vera virkt fyrir þetta atriði eða sniðmátið sitt,
Default BOM for {0} not found,Sjálfgefið BOM fyrir {0} fannst ekki,
Default BOM not found for Item {0} and Project {1},Sjálfgefið BOM fannst ekki fyrir lið {0} og verkefni {1},
Default Letter Head,Sjálfgefin bréf höfuð,
Default Tax Template,Sjálfgefið Skattamót,
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.,Default Mælieiningin fyrir lið {0} Ekki er hægt að breyta beint vegna þess að þú hefur nú þegar gert nokkrar viðskiptin (s) með öðru UOM. Þú þarft að búa til nýjan hlut til að nota aðra Sjálfgefin UOM.,
Default Unit of Measure for Variant '{0}' must be same as in Template '{1}',Default Mælieiningin fyrir Variant &#39;{0}&#39; verða að vera sama og í sniðmáti &#39;{1}&#39;,
Default settings for buying transactions.,Sjálfgefnar stillingar til að kaupa viðskiptum.,
Default settings for selling transactions.,Sjálfgefnar stillingar fyrir að selja viðskiptum.,
Default tax templates for sales and purchase are created.,Sjálfgefin skatta sniðmát fyrir sölu og kaup eru búnar til.,
Default warehouse is required for selected item,Sjálfgefið vöruhús er nauðsynlegt til valið atriði,
Defaults,vanskil,
Defense,Defense,
Define Project type.,Skilgreindu tegund verkefnisins.,
Define budget for a financial year.,Skilgreina fjárhagsáætlun fyrir fjárhagsár.,
Define various loan types,Skilgreina ýmsar tegundir lána,
Del,Del,
Delay in payment (Days),Töf á greiðslu (dagar),
Delete all the Transactions for this Company,Eyða öllum viðskiptum fyrir þetta fyrirtæki,
Delete permanently?,Eyða varanlega?,
Deletion is not permitted for country {0},Eyðing er ekki leyfð fyrir land {0},
Delivered,Afhent,
Delivered Amount,Skilað Upphæð,
Delivered Qty,Skilað Magn,
Delivered: {0},Afhent: {0},
Delivery,Afhending,
Delivery Date,Afhendingardagur,
Delivery Note,Afhendingarseðilinn,
Delivery Note {0} is not submitted,Afhending Note {0} er ekki lögð,
Delivery Note {0} must not be submitted,Afhending Note {0} Ekki má leggja,
Delivery Notes {0} must be cancelled before cancelling this Sales Order,Afhending Skýringar {0} verður lokað áður en hætta þessu Velta Order,
Delivery Notes {0} updated,Sendingarskýringar {0} uppfærðar,
Delivery Status,Afhending Staða,
Delivery Trip,Afhendingartími,
Delivery warehouse required for stock item {0},Afhending vöruhús krafist fyrir hlutabréfum lið {0},
Department,Deild,
Department Stores,Department Stores,
Depreciation,gengislækkun,
Depreciation Amount,Afskriftir Upphæð,
Depreciation Amount during the period,Afskriftir Upphæð á tímabilinu,
Depreciation Date,Afskriftir Dagsetning,
Depreciation Eliminated due to disposal of assets,Afskriftir Féll út vegna ráðstöfunar eigna,
Depreciation Entry,Afskriftir Entry,
Depreciation Method,Afskriftir Method,
Depreciation Row {0}: Depreciation Start Date is entered as past date,Afskriftir Róður {0}: Afskriftir Upphafsdagur er sleginn inn sem fyrri dagsetning,
Depreciation Row {0}: Expected value after useful life must be greater than or equal to {1},Afskriftir Rauða {0}: Vænt gildi eftir nýtingartíma verður að vera meiri en eða jafnt við {1},
Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,Afskriftir Rauða {0}: Næsta Afskriftir Dagsetning má ekki vera fyrr en hægt er að nota Dagsetning,
Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,Afskriftir Róður {0}: Næsta Afskriftir Dagsetning getur ekki verið fyrir Innkaupardagur,
Designer,Hönnuður,
Detailed Reason,Nákvæm ástæða,
Details,Nánar,
Details of Outward Supplies and inward supplies liable to reverse charge,Upplýsingar um útflutningsbirgðir og vistir til innflutnings sem geta verið gjaldfærðar til baka,
Details of the operations carried out.,Upplýsingar um starfsemi fram.,
Diagnosis,Greining,
Did not find any item called {0},Fékk ekki fundið neitt atriði sem heitir {0},
Diff Qty,Diff Magn,
Difference Account,munurinn Reikningur,
"Difference Account must be a Asset/Liability type account, since this Stock Reconciliation is an Opening Entry","Munurinn Reikningur verður að vera Eigna- / Ábyrgðartegund reikningur, þar sem þetta Stock Sáttargjörð er Opening Entry",
Difference Amount,munurinn Upphæð,
Difference Amount must be zero,Munurinn Upphæð verður að vera núll,
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.,Mismunandi UOM að atriðum mun leiða til rangrar (alls) nettóþyngd gildi. Gakktu úr skugga um að nettóþyngd hvern hlut er í sama UOM.,
Direct Expenses,Bein útgjöld,
Direct Income,Bein tekjur,
Disable,Slökkva,
Disabled template must not be default template,Óvirkt sniðmát má ekki vera sjálfgefið sniðmát,
Disburse Loan,Útborgunarlán,
Disbursed,Útborgað,
Disc,Diskur,
Discharge,Losun,
Discount,Afsláttur,
Discount Percentage can be applied either against a Price List or for all Price List.,Afsláttur Hlutfall hægt að beita annaðhvort á móti verðskrá eða fyrir alla verðlista.,
Discount amount cannot be greater than 100%,Afsláttarfjárhæð getur ekki verið meiri en 100%,
Discount must be less than 100,Afsláttur verður að vera minna en 100,
Diseases & Fertilizers,Sjúkdómar og áburður,
Dispatch,Sending,
Dispatch Notification,Sendingarnúmer,
Dispatch State,Sendingarríki,
Distance,Fjarlægð,
Distribution,Dreifing,
Distributor,Dreifingaraðili,
Dividends Paid,arður Greiddur,
Do you really want to restore this scrapped asset?,Viltu virkilega að endurheimta rifið eign?,
Do you really want to scrap this asset?,Viltu virkilega að skrappa þessa eign?,
Do you want to notify all the customers by email?,Viltu tilkynna öllum viðskiptavinum með tölvupósti?,
Doc Date,Skjal dagsetning,
Doc Name,Doc Name,
Doc Type,Doc Tegund,
Docs Search,Docs Search,
Document Name,Document Name,
Document Status,skjal Staða,
Document Type,Document Type,
Documentation,Documentation,
Domain,Domain,
Domains,Lén,
Done,Lokið,
Donor,Gjafa,
Donor Type information.,Upplýsingar um gjafa Upplýsingar.,
Donor information.,Upplýsingar um gjafa.,
Download JSON,Sæktu JSON,
Draft,Drög,
Drop Ship,Drop Ship,
Drug,Lyf,
Due / Reference Date cannot be after {0},Vegna / Reference Dagsetning má ekki vera á eftir {0},
Due Date cannot be before Posting / Supplier Invoice Date,Gjalddagi má ekki vera fyrir birtingu / Reikningardagsetning birgja,
Due Date is mandatory,Skiladagur er nauðsynlegur,
Duplicate Entry. Please check Authorization Rule {0},Afrit Entry. Vinsamlegast athugaðu Heimild Rule {0},
Duplicate Serial No entered for Item {0},Afrit Serial Nei slegið í lið {0},
Duplicate customer group found in the cutomer group table,Afrit viðskiptavinar hópur í cutomer töflunni,
Duplicate entry,afrit færslu,
Duplicate item group found in the item group table,Afrit atriði hópur í lið töflunni,
Duplicate roll number for student {0},Afrita rúlla númer fyrir nemanda {0},
Duplicate row {0} with same {1},Afrit róður {0} með sama {1},
Duplicate {0} found in the table,Afrit {0} fannst í töflunni,
Duration in Days,Lengd í dögum,
Duties and Taxes,Skyldur og skattar,
E-Invoicing Information Missing,Upplýsingar um rafræn reikning vantar,
ERPNext Demo,ERPNext Demo,
ERPNext Settings,ERPNext Stillingar,
Earliest,elstu,
Earnest Money,Earnest Money,
Earning,Earnings,
Edit,Breyta,
Edit Publishing Details,Breyta upplýsingum um útgáfu,
"Edit in full page for more options like assets, serial nos, batches etc.","Breyta í fullri síðu fyrir fleiri valkosti eins og eignir, raðnúmer, lotur osfrv.",
Education,Menntun,
Either location or employee must be required,Annaðhvort þarf að vera staðsetning eða starfsmaður,
Either target qty or target amount is mandatory,Annaðhvort miða Magn eða miða upphæð er nauðsynlegur,
Either target qty or target amount is mandatory.,Annaðhvort miða Magn eða miða upphæð er nauðsynlegur.,
Electrical,Electrical,
Electronic Equipments,Rafræn útbúnaður,
Electronics,Electronics,
Eligible ITC,Gildur ITC,
Email Account,netfangs,
Email Address,Netfang,
"Email Address must be unique, already exists for {0}","Netfang verður að vera einstakt, þegar til fyrir {0}",
Email Digest: ,Sendu Digest:,
Email Reminders will be sent to all parties with email contacts,Email Áminningar verða sendar öllum aðilum með tengiliðum í tölvupósti,
Email Sent,Tölvupóstur sendur,
Email Template,Email Sniðmát,
Email not found in default contact,Tölvupóstur fannst ekki í vanrækslu sambandi,
Email sent to supplier {0},Tölvupóstur sendur á birgi {0},
Email sent to {0},Tölvupóstur sendur til {0},
Employee,Starfsmaður,
Employee A/C Number,A / C fjöldi starfsmanna,
Employee Advances,Framfarir starfsmanna,
Employee Benefits,starfskjör,
Employee Grade,Starfsmaður,
Employee ID,Auðkenni starfsmanna,
Employee Lifecycle,Starfsmaður lífeyri,
Employee Name,starfsmaður Name,
Employee Promotion cannot be submitted before Promotion Date ,Ekki er hægt að leggja fram starfsmannakynningu fyrir kynningardag,
Employee Referral,Tilvísun starfsmanna,
Employee Transfer cannot be submitted before Transfer Date ,Ekki er hægt að skila starfsmanni flytja fyrir flutningsdag,
Employee cannot report to himself.,Starfsmaður getur ekki skýrslu við sjálfan sig.,
Employee relieved on {0} must be set as 'Left',Starfsmaður létta á {0} skal stilla eins &#39;Vinstri&#39;,
Employee status cannot be set to 'Left' as following employees are currently reporting to this employee:&nbsp;,Ekki er hægt að stilla stöðu starfsmanna á „Vinstri“ þar sem eftirfarandi starfsmenn tilkynna þessa starfsmann sem stendur:,
Employee {0} already submited an apllication {1} for the payroll period {2},Starfsmaður {0} hefur nú þegar sent inn umsókn {1} fyrir launatímabilið {2},
Employee {0} has already applied for {1} between {2} and {3} : ,Starfsmaður {0} hefur þegar sótt um {1} á milli {2} og {3}:,
Employee {0} has already applied for {1} on {2} : ,Starfsmaður {0} hefur þegar sótt um {1} á {2}:,
Employee {0} has no maximum benefit amount,Starfsmaður {0} hefur ekki hámarksbætur,
Employee {0} is not active or does not exist,Starfsmaður {0} er ekki virkur eða er ekki til,
Employee {0} is on Leave on {1},Starfsmaður {0} er á leyfi á {1},
Employee {0} of grade {1} have no default leave policy,Starfsmaður {0} í einkunn {1} hefur ekki sjálfgefið eftirlitsstefnu,
Employee {0} on Half day on {1},Starfsmaður {0} á hálfan dag á {1},
Enable,Virkja,
Enable / disable currencies.,Virkja / slökkva á gjaldmiðla.,
Enabled,virkt,
"Enabling 'Use for Shopping Cart', as Shopping Cart is enabled and there should be at least one Tax Rule for Shopping Cart","Virkjun &#39;Nota fyrir Shopping Cart&#39;, eins og Shopping Cart er virkt og það ætti að vera að minnsta kosti einn Tax Rule fyrir Shopping Cart",
End Date,Lokadagur,
End Date can not be less than Start Date,Lokadagur getur ekki verið minna en upphafsdagur,
End Date cannot be before Start Date.,Lokadagur getur ekki verið fyrir upphafsdag.,
End Year,árslok,
End Year cannot be before Start Year,Árslok getur ekki verið áður Start Ár,
End on,Enda á,
End time cannot be before start time,Lokatími getur ekki verið fyrir upphafstíma,
Ends On date cannot be before Next Contact Date.,Endar Á dagsetning má ekki vera fyrir næsta tengiliðadag.,
Energy,Orka,
Engineer,Verkfræðingur,
Enough Parts to Build,Nóg Varahlutir til að byggja,
Enroll,innritast,
Enrolling student,innritast nemandi,
Enrolling students,Skráðu nemendur,
Enter depreciation details,Færðu inn upplýsingar um afskriftir,
Enter the Bank Guarantee Number before submittting.,Sláðu inn bankareikningsnúmerið áður en þú sendir það inn.,
Enter the name of the Beneficiary before submittting.,Sláðu inn heiti styrkþega áður en þú sendir inn.,
Enter the name of the bank or lending institution before submittting.,Sláðu inn nafn bankans eða útlánafyrirtækis áður en þú sendir það.,
Enter value betweeen {0} and {1},Sláðu inn gildi milli {0} og {1},
Enter value must be positive,Sláðu gildi verður að vera jákvæð,
Entertainment & Leisure,Skemmtun &amp; Leisure,
Entertainment Expenses,risnu,
Equity,Eigið fé,
Error Log,Villuannál,
Error evaluating the criteria formula,Villa við að meta viðmiðunarformúluna,
Error in formula or condition: {0},Villa í formúlu eða ástandi: {0},
Error while processing deferred accounting for {0},Villa við vinnslu frestaðs bókhalds fyrir {0},
Error: Not a valid id?,Villa: Ekki gild id?,
Estimated Cost,Áætlaður kostnaður,
Evaluation,Mat,
"Even if there are multiple Pricing Rules with highest priority, then following internal priorities are applied:","Jafnvel ef það eru margar Verðlagning Reglur með hæsta forgang, eru þá eftirfarandi innri forgangsmál beitt:",
Event,Event,
Event Location,Staðsetning viðburðar,
Event Name,Event Name,
Exchange Gain/Loss,Gengishagnaður / tap,
Exchange Rate Revaluation master.,Gjaldeyrismatsmeistari.,
Exchange Rate must be same as {0} {1} ({2}),Gengi að vera það sama og {0} {1} ({2}),
Excise Invoice,vörugjöld Invoice,
Execution,Framkvæmd,
Executive Search,Executive Search,
Expand All,Stækka All,
Expected Delivery Date,Áætlaðan fæðingardag,
Expected Delivery Date should be after Sales Order Date,Væntanlegur afhendingardagur ætti að vera eftir söluupphæðardagsetningu,
Expected End Date,Væntanlegur lokadagur,
Expected Hrs,Væntanlegur HRS,
Expected Start Date,Væntanlegur Start Date,
Expense,Expense,
Expense / Difference account ({0}) must be a 'Profit or Loss' account,Kostnað / Mismunur reikning ({0}) verður að vera &#39;rekstrarreikning &quot;reikning a,
Expense Account,Expense Reikningur,
Expense Claim,Expense Krafa,
Expense Claim for Vehicle Log {0},Kostnað Krafa um ökutæki Innskráning {0},
Expense Claim {0} already exists for the Vehicle Log,Kostnað Krafa {0} er þegar til fyrir Vehicle Innskráning,
Expense Claims,kostnaðarliðir Kröfur,
Expense account is mandatory for item {0},Kostnað reikningur er nauðsynlegur fyrir lið {0},
Expense or Difference account is mandatory for Item {0} as it impacts overall stock value,Kostnað eða Mismunur reikningur er nauðsynlegur fyrir lið {0} eins og það hefur áhrif á heildina birgðir gildi,
Expenses,Útgjöld,
Expenses Included In Asset Valuation,Útgjöld innifalinn í eignatryggingu,
Expenses Included In Valuation,Kostnaður í Verðmat,
Expired Batches,Útrunnið lotur,
Expires On,rennur út,
Expiring On,Rennur út á,
Expiry (In Days),Fyrning (í dögum),
Explore,Skoða,
Export E-Invoices,Flytja út reikninga,
Extra Large,Auka stór,
Extra Small,Extra Small,
Fail,Mistakast,
Failed,Mistókst,
Failed to create website,Mistókst að búa til vefsíðu,
Failed to install presets,Mistókst að setja upp forstillingar,
Failed to login,Mistókst að skrá þig inn,
Failed to setup company,Mistókst að setja upp fyrirtæki,
Failed to setup defaults,Ekki tókst að setja upp vanskil,
Failed to setup post company fixtures,Mistókst að skipuleggja póstfyrirtæki,
Fax,Fax,
Fee,Gjald,
Fee Created,Gjald búin,
Fee Creation Failed,Fee Creation mistókst,
Fee Creation Pending,Gjöld vegna verðtryggingar,
Fee Records Created - {0},Fee Records Búið - {0},
Feedback,athugasemdir,
Fees,Gjöld,
Female,female,
Fetch Data,Sækja gögn,
Fetch Subscription Updates,Fáðu áskriftaruppfærslur,
Fetch exploded BOM (including sub-assemblies),Ná sprakk BOM (þ.mt undireiningar),
Fetching records......,Sækir færslur ......,
Field Name,Field Name,
Fieldname,Fieldname,
Fields,Fields,
Fill the form and save it,Fylltu út formið og vista hana,
Filter Employees By (Optional),Sía starfsmenn eftir (valfrjálst),
"Filter Fields Row #{0}: Fieldname <b>{1}</b> must be of type ""Link"" or ""Table MultiSelect""",Sía reitir Röð # {0}: Reitnafn <b>{1}</b> verður að vera af gerðinni „Link“ eða „Tafla MultiSelect“,
Filter Total Zero Qty,Sía Samtals núll Magn,
Finance Book,Fjármálabók,
Financial / accounting year.,Financial / bókhald ári.,
Financial Services,Financial Services,
Financial Statements,Ársreikningur,
Financial Year,Fjárhagsár,
Finish,Ljúka,
Finished Good,Lokið vel,
Finished Good Item Code,Lokið góðum hlutakóða,
Finished Goods,fullunnum,
Finished Item {0} must be entered for Manufacture type entry,Lokið Item {0} verður inn fyrir Framleiðsla tegund færslu,
Finished product quantity <b>{0}</b> and For Quantity <b>{1}</b> cannot be different,Lokið vöru magn <b>{0}</b> og Fyrir magn <b>{1}</b> geta ekki verið mismunandi,
First Name,Fyrsta nafn,
"Fiscal Regime is mandatory, kindly set the fiscal regime in the company {0}","Ríkisfjármálastjórn er skylda, vinsamlegast stillið ríkisfjármálum í fyrirtækinu {0}",
Fiscal Year,Fiscal Year,
Fiscal Year End Date should be one year after Fiscal Year Start Date,Lokadagur reikningsárs ætti að vera ári eftir upphafsdag reikningsárs,
Fiscal Year Start Date and Fiscal Year End Date are already set in Fiscal Year {0},Reikningsár Start Date og Fiscal Year End Date eru nú þegar sett í Fiscal Year {0},
Fiscal Year Start Date should be one year earlier than Fiscal Year End Date,Upphafsdagur reikningsárs ætti að vera einu ári fyrr en lokadagur reikningsárs,
Fiscal Year {0} does not exist,Reikningsár {0} er ekki til,
Fiscal Year {0} is required,Reikningsár {0} er krafist,
Fiscal Year {0} not found,Reikningsár {0} fannst ekki,
Fiscal Year: {0} does not exists,Fiscal Year: {0} er ekki til,
Fixed Asset,fast Asset,
Fixed Asset Item must be a non-stock item.,Fast Asset Item verður a non-birgðir atriði.,
Fixed Assets,Fastafjármunir,
Following Material Requests have been raised automatically based on Item's re-order level,Eftirfarandi efni beiðnir hafa verið hækkaðir sjálfvirkt miðað aftur röð stigi atriðisins,
Following accounts might be selected in GST Settings:,Eftirfarandi reikningar gætu verið valin í GST stillingum:,
Following course schedules were created,Eftirfarandi námskeið voru búnar til,
Following item {0} is not marked as {1} item. You can enable them as {1} item from its Item master,Eftirfarandi atriði {0} er ekki merkt sem {1} atriði. Þú getur virkjað þau sem {1} atriði úr hlutastjóranum,
Following items {0} are not marked as {1} item. You can enable them as {1} item from its Item master,Eftirfarandi hlutir {0} eru ekki merktar sem {1} atriði. Þú getur virkjað þau sem {1} atriði úr hlutastjóranum,
Food,Matur,
"Food, Beverage & Tobacco","Matur, drykkir og Tobacco",
For,Fyrir,
"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.","Fyrir &quot;vara búnt &#39;atriði, Lager, Serial Nei og Batch No verður að teljast úr&#39; Pökkun lista &#39;töflunni. Ef Warehouse og Batch No eru sömu fyrir alla pökkun atriði fyrir hvaða &quot;vara búnt &#39;lið, sem gildin má færa í helstu atriði borðið, gildi verða afrituð á&#39; Pökkun lista &#39;borð.",
For Employee,Fyrir starfsmann,
For Quantity (Manufactured Qty) is mandatory,Fyrir Magn (Framleiðandi Magn) er nauðsynlegur,
For Supplier,Fyrir birgir,
For Warehouse,fyrir Warehouse,
For Warehouse is required before Submit,Fyrir Lager er krafist áður Senda,
"For an item {0}, quantity must be negative number",Fyrir hlut {0} skal magn vera neikvætt númer,
"For an item {0}, quantity must be positive number",Fyrir hlut {0} verður magn að vera jákvætt númer,
"For job card {0}, you can only make the 'Material Transfer for Manufacture' type stock entry",Að því er varðar starfskort {0} geturðu aðeins slegið inn „Efnisflutning til framleiðslu“,
"For row {0} in {1}. To include {2} in Item rate, rows {3} must also be included","Fyrir röð {0} í {1}. Til eru {2} í lið gengi, raðir {3} skal einnig",
For row {0}: Enter Planned Qty,Fyrir röð {0}: Sláðu inn skipulagt magn,
"For {0}, only credit accounts can be linked against another debit entry","Fyrir {0}, aðeins kredit reikninga er hægt að tengja við aðra gjaldfærslu",
"For {0}, only debit accounts can be linked against another credit entry","Fyrir {0}, aðeins debetkort reikninga er hægt að tengja við aðra tekjufærslu",
Form View,Eyðublað,
Forum Activity,Forum Activity,
Free item code is not selected,Ókeypis hlutakóði er ekki valinn,
Freight and Forwarding Charges,Frakt og Áframsending Gjöld,
Frequency,Tíðni,
Friday,Föstudagur,
From,Frá,
From Address 1,Frá Heimilisfang 1,
From Address 2,Frá Heimilisfang 2,
From Currency and To Currency cannot be same,Frá Gjaldmiðill og gjaldmiðla getur ekki verið það sama,
From Date and To Date lie in different Fiscal Year,Frá dagsetningu og dagsetningu liggja á mismunandi reikningsári,
From Date cannot be greater than To Date,Frá Dagsetning má ekki vera meiri en hingað til,
From Date must be before To Date,Frá Dagsetning verður að vera fyrir Lokadagurinn,
From Date should be within the Fiscal Year. Assuming From Date = {0},Frá Dagsetning ætti að vera innan fjárhagsársins. Að því gefnu Frá Dagsetning = {0},
From Date {0} cannot be after employee's relieving Date {1},Frá degi {0} er ekki hægt að losa starfsmanninn dagsetningu {1},
From Date {0} cannot be before employee's joining Date {1},Frá Dagsetning {0} getur ekki verið áður en starfsmaður er kominn með Dagsetning {1},
From Datetime,Frá Datetime,
From Delivery Note,Frá Delivery Note,
From Fiscal Year,Frá reikningsárinu,
From GSTIN,Frá GSTIN,
From Party Name,Frá nafn aðila,
From Pin Code,Frá PIN kóða,
From Place,Frá stað,
From Range has to be less than To Range,Frá Range þarf að vera minna en við úrval,
From State,Frá ríki,
From Time,frá Time,
From Time Should Be Less Than To Time,Frá tími ætti að vera minni en tími,
From Time cannot be greater than To Time.,Frá tími getur ekki verið meiri en tíma.,
"From a supplier under composition scheme, Exempt and Nil rated","Frá birgi samkvæmt kerfisskipulagi, undanþegin og Nil metin",
From and To dates required,Frá og Til dagsetningar krafist,
From date can not be less than employee's joining date,Frá dagsetningunni má ekki vera minna en tengingardagur starfsmanns,
From value must be less than to value in row {0},Frá gildi verður að vera minna en að verðmæti í röð {0},
From {0} | {1} {2},Frá {0} | {1} {2},
Fuel Price,eldsneyti verð,
Fuel Qty,eldsneyti Magn,
Fulfillment,fylling,
Full,Fullt,
Full Name,Fullt nafn,
Full-time,Fullt,
Fully Depreciated,Alveg afskrifaðar,
Furnitures and Fixtures,Húsgögnum og innréttingum,
"Further accounts can be made under Groups, but entries can be made against non-Groups","Frekari reikninga er hægt að gera undir Hópar, en færslur er hægt að gera á móti non-hópa",
Further cost centers can be made under Groups but entries can be made against non-Groups,Frekari stoðsviða er hægt að gera undir Hópar en færslur er hægt að gera á móti non-hópa,
Further nodes can be only created under 'Group' type nodes,Frekari hnútar geta verið aðeins búin undir &#39;group&#39; tegund hnúta,
Future dates not allowed,Framtíðardagar ekki leyfðar,
GSTIN,GSTIN,
GSTR3B-Form,GSTR3B-form,
Gain/Loss on Asset Disposal,Hagnaður / tap Asset förgun,
Gantt Chart,Gantt Mynd,
Gantt chart of all tasks.,Gantt graf af öllum verkefnum.,
Gender,Kyn,
General,Almennt,
General Ledger,General Ledger,
Generate Material Requests (MRP) and Work Orders.,Búðu til efnisbeiðnir (MRP) og vinnuskilaboð.,
Generate Secret,Búa til leyndarmál,
Get Details From Declaration,Fáðu upplýsingar frá yfirlýsingunni,
Get Employees,Fá starfsmenn,
Get Invocies,Fáðu ákalla,
Get Invoices,Fáðu reikninga,
Get Invoices based on Filters,Fáðu reikninga sem byggja á síum,
Get Items from BOM,Fá atriði úr BOM,
Get Items from Healthcare Services,Fáðu atriði úr heilbrigðisþjónustu,
Get Items from Prescriptions,Fáðu hluti úr lyfseðlum,
Get Items from Product Bundle,Fá atriði úr Vara Knippi,
Get Suppliers,Fáðu birgja,
Get Suppliers By,Fáðu birgja eftir,
Get Updates,fá uppfærslur,
Get customers from,Fáðu viðskiptavini frá,
Get from Patient Encounter,Komdu frá sjúklingaþingi,
Getting Started,Að byrja,
GitHub Sync ID,GitHub Sync ID,
Global settings for all manufacturing processes.,Global stillingar fyrir alla framleiðsluaðferðum.,
Go to the Desktop and start using ERPNext,Fara á Desktop og byrja að nota ERPNext,
GoCardless SEPA Mandate,GoCardless SEPA umboð,
GoCardless payment gateway settings,GoCardless greiðslu gátt stillingar,
Goal and Procedure,Markmið og málsmeðferð,
Goals cannot be empty,Markmið má ekki vera autt,
Goods In Transit,Vörur í flutningi,
Goods Transferred,Vörur fluttar,
Goods and Services Tax (GST India),Vörur og þjónusta Skattur (GST Indland),
Goods are already received against the outward entry {0},Vörur eru þegar mótteknar gegn útgönguskrá {0},
Government,Ríkisstjórn,
Grand Total,Grand Total,
Grant,Grant,
Grant Application,Grant Umsókn,
Grant Leaves,Grant Leaves,
Grant information.,Veita upplýsingar.,
Grocery,Matvöruverslun,
Gross Pay,Gross Pay,
Gross Profit,Framlegð,
Gross Profit %,Framlegð%,
Gross Profit / Loss,Gross Hagnaður / Tap,
Gross Purchase Amount,Gross Kaup Upphæð,
Gross Purchase Amount is mandatory,Gross Purchase Upphæð er nauðsynlegur,
Group by Account,Group eftir reikningi,
Group by Party,Hópur eftir flokk,
Group by Voucher,Group eftir Voucher,
Group by Voucher (Consolidated),Hópur eftir skírteini (samstæðu),
Group node warehouse is not allowed to select for transactions,Group hnút vöruhús er ekki leyft að velja fyrir viðskipti,
Group to Non-Group,Group Non-Group,
Group your students in batches,Hópur nemenda þín í lotur,
Groups,Hópar,
Guardian1 Email ID,Forráðamaður1 Netfang,
Guardian1 Mobile No,Guardian1 Mobile No,
Guardian1 Name,Guardian1 Name,
Guardian2 Email ID,Guardian2 Netfang,
Guardian2 Mobile No,Guardian2 Mobile No,
Guardian2 Name,Guardian2 Name,
Guest,Guest,
HR Manager,HR Manager,
HSN,HSN,
HSN/SAC,HSN / SAC,
Half Day,Hálfur dagur,
Half Day Date is mandatory,Half Day Dagsetning er nauðsynlegur,
Half Day Date should be between From Date and To Date,Half Day Date ætti að vera á milli Frá Dagsetning og hingað,
Half Day Date should be in between Work From Date and Work End Date,Hálft dagur Dagsetning ætti að vera á milli vinnu frá dagsetningu og vinnslutíma,
Half Yearly,Half Árlega,
Half day date should be in between from date and to date,Hálft dags dagsetning ætti að vera á milli frá dagsetningu og til dagsetning,
Half-Yearly,Hálfsárs,
Hardware,Vélbúnaður,
Head of Marketing and Sales,Forstöðumaður markaðssetning og sala,
Health Care,Heilbrigðisþjónusta,
Healthcare,Heilbrigðisþjónusta,
Healthcare (beta),Heilbrigðisþjónusta (beta),
Healthcare Practitioner,Heilbrigðisstarfsmaður,
Healthcare Practitioner not available on {0},Heilbrigðisstarfsmaður er ekki í boði á {0},
Healthcare Practitioner {0} not available on {1},Heilbrigðisstarfsmaður {0} er ekki í boði á {1},
Healthcare Service Unit,Heilbrigðisþjónustudeild,
Healthcare Service Unit Tree,Heilbrigðisþjónustudeild Tree,
Healthcare Service Unit Type,Heilbrigðisþjónusta,
Healthcare Services,Heilbrigðisþjónusta,
Healthcare Settings,Heilbrigðisstofnanir,
Hello,Halló,
Help Results for,Hjálparniðurstöður fyrir,
High,Hár,
High Sensitivity,Hár næmi,
Hold,haldið,
Hold Invoice,Haltu innheimtu,
Holiday,Holiday,
Holiday List,Holiday List,
Hotel Rooms of type {0} are unavailable on {1},Hótel Herbergi af tegund {0} eru ekki tiltækar á {1},
Hotels,Hótel,
Hourly,Klukkutíma,
Hours,Klukkustundir,
House rent paid days overlapping with {0},Húsaleiga greiddir dagar skarast við {0},
House rented dates required for exemption calculation,Hús leigt dagsetningar sem krafist er fyrir undanþágu útreikning,
House rented dates should be atleast 15 days apart,Hús leigð dagsetningar ætti að vera að minnsta kosti 15 daga í sundur,
How Pricing Rule is applied?,Hvernig Verðlagning Regla er beitt?,
Hub Category,Hub Flokkur,
Hub Sync ID,Hub Sync ID,
Human Resource,Mannauðs,
Human Resources,Mannauður,
IFSC Code,IFSC-kóði,
IGST Amount,IGST upphæð,
IP Address,IP-tölu,
ITC Available (whether in full op part),ITC í boði (hvort sem það er í heild hluta),
ITC Reversed,ITC snúið við,
Identifying Decision Makers,Þekkja ákvörðunarmenn,
"If Auto Opt In is checked, then the customers will be automatically linked with the concerned Loyalty Program (on save)",Ef sjálfvirkur valkostur er valinn verður viðskiptavinurinn sjálfkrafa tengdur við viðkomandi hollustuáætlun (við vistun),
"If multiple Pricing Rules continue to prevail, users are asked to set Priority manually to resolve conflict.","Ef margir Verðlagning Reglur halda áfram að sigra, eru notendur beðnir um að setja Forgangur höndunum til að leysa deiluna.",
"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.","Ef valin verðlagning er gerð fyrir &#39;Rate&#39; mun hún skrifa yfir Verðskrá. Verðlagning Regluhlutfall er endanlegt hlutfall, þannig að ekki skal nota frekari afslátt. Þess vegna, í viðskiptum eins og söluskilningi, innkaupapöntun o.þ.h., verður það sótt í &#39;Rate&#39; reitinn, frekar en &#39;Verðskrárhlutfall&#39; reitinn.",
"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.","Ef tveir eða fleiri Verðlagning Reglur finnast miðað við ofangreindar aðstæður, Forgangur er beitt. Forgangur er fjöldi milli 0 til 20 en Sjálfgefið gildi er núll (auður). Hærri tala þýðir að það mun hafa forgang ef það eru margar Verðlagning Reglur með sömu skilyrðum.",
"If unlimited expiry for the Loyalty Points, keep the Expiry Duration empty or 0.",Ef ótakmarkaður rennur út fyrir hollustustigið skaltu halda gildistíma gildistíma tómt eða 0.,
"If you have any questions, please get back to us.","Ef þú hefur einhverjar spurningar, vinsamlegast komast aftur til okkar.",
Ignore Existing Ordered Qty,Hunsa núverandi pöntuð magn,
Image,Mynd,
Image View,Mynd View,
Import Data,Flytja inn gögn,
Import Day Book Data,Flytja inn dagbókargögn,
Import Log,innflutningur Log,
Import Master Data,Flytja inn grunngögn,
Import Successfull,Flytja inn vel,
Import in Bulk,Innflutningur á lausu,
Import of goods,Innflutningur á vörum,
Import of services,Innflutningur þjónustu,
Importing Items and UOMs,Flytur inn hluti og UOM,
Importing Parties and Addresses,Flytur aðila og heimilisfang,
In Maintenance,Í viðhald,
In Production,Í framleiðslu,
In Qty,í Magn,
In Stock Qty,Á lager Magn,
In Stock: ,Á lager:,
In Value,Virði,
"In the case of multi-tier program, Customers will be auto assigned to the concerned tier as per their spent","Þegar um er að ræða fjölþættaráætlun, verða viðskiptavinir sjálfkrafa tengdir viðkomandi flokka eftir því sem þeir eru í",
Inactive,Óvirkt,
Incentives,Incentives,
Include Default Book Entries,Hafa sjálfgefnar bókarfærslur með,
Include Exploded Items,Inniheldur sprauta hluti,
Include POS Transactions,Innifalið POS-viðskipti,
Include UOM,Innifalið UOM,
Included in Gross Profit,Innifalið í brúttóhagnaði,
Income,Tekjur,
Income Account,tekjur Reikningur,
Income Tax,Tekjuskattur,
Incoming,Komandi,
Incoming Rate,Komandi Rate,
Incorrect number of General Ledger Entries found. You might have selected a wrong Account in the transaction.,Rangur fjöldi General Ledger færslur fundust. Þú gætir hafa valið rangt reikning í viðskiptum.,
Increment cannot be 0,Vöxtur getur ekki verið 0,
Increment for Attribute {0} cannot be 0,Vöxtur fyrir eigind {0} er ekki verið 0,
Indirect Expenses,óbeinum kostnaði,
Indirect Income,Óbein tekjur,
Individual,einstök,
Ineligible ITC,Óhæfur ITC,
Initiated,hafin,
Inpatient Record,Sjúkraskrá,
Insert,Setja inn,
Installation Note,uppsetning Note,
Installation Note {0} has already been submitted,Uppsetning Ath {0} hefur þegar verið lögð fram,
Installation date cannot be before delivery date for Item {0},Uppsetning dagsetning getur ekki verið áður fæðingardag fyrir lið {0},
Installing presets,Uppsetning forstillingar,
Institute Abbreviation,Institute Skammstöfun,
Institute Name,Institute Name,
Instructor,Kennari,
Insufficient Stock,ófullnægjandi Stock,
Insurance Start date should be less than Insurance End date,Tryggingar Start dagsetning ætti að vera minna en tryggingar lokadagsetning,
Integrated Tax,Samþættur skattur,
Inter-State Supplies,Ríkisbirgðir,
Interest Amount,vextir Upphæð,
Interests,Áhugasvið,
Intern,Intern,
Internet Publishing,internet Publishing,
Intra-State Supplies,Innanríkisbirgðir,
Introduction,Kynning,
Invalid Attribute,Ógilt Attribute,
Invalid Blanket Order for the selected Customer and Item,Ógildur sængurpöntun fyrir valda viðskiptavininn og hlutinn,
Invalid Company for Inter Company Transaction.,Ógilt fyrirtæki fyrir viðskipti milli fyrirtækja.,
Invalid GSTIN! A GSTIN must have 15 characters.,Ógilt GSTIN! GSTIN verður að hafa 15 stafi.,
Invalid GSTIN! First 2 digits of GSTIN should match with State number {0}.,Ógilt GSTIN! Fyrstu 2 tölustafir GSTIN ættu að passa við ríkið númer {0}.,
Invalid GSTIN! The input you've entered doesn't match the format of GSTIN.,Ógilt GSTIN! Inntakið sem þú slóst inn passar ekki við snið GSTIN.,
Invalid Posting Time,Ógildur póstur,
Invalid attribute {0} {1},Ógild eiginleiki {0} {1},
Invalid quantity specified for item {0}. Quantity should be greater than 0.,Ógild magn sem tilgreint er fyrir lið {0}. Magn ætti að vera hærri en 0.,
Invalid reference {0} {1},Ógild vísun {0} {1},
Invalid {0},Ógild {0},
Invalid {0} for Inter Company Transaction.,Ógilt {0} vegna viðskipta milli fyrirtækja.,
Invalid {0}: {1},Ógild {0}: {1},
Inventory,Skrá,
Investment Banking,Fyrirtækjaráðgjöf,
Investments,Fjárfestingar,
Invoice,Reikningur,
Invoice Created,Reikningur búin til,
Invoice Discounting,Reikningarafsláttur,
Invoice Patient Registration,Innheimtu sjúklingur skráning,
Invoice Posting Date,Reikningar Staða Date,
Invoice Type,Reikningar Type,
Invoice already created for all billing hours,Reikningur er þegar búinn til fyrir alla reikningstíma,
Invoice can't be made for zero billing hour,Reikningur er ekki hægt að gera í núll reikningstíma,
Invoice {0} no longer exists,Reikningur {0} er ekki lengur til,
Invoiced,Innheimt,
Invoiced Amount,Upphæð á reikningi,
Invoices,Reikningar,
Invoices for Costumers.,Reikningar fyrir viðskiptavini.,
Inward Supplies(liable to reverse charge,Birgðasali inn á við (hugsanlegt að snúa gjaldi),
Inward supplies from ISD,Innanbirgðir frá ISD,
Inward supplies liable to reverse charge (other than 1 & 2 above),"Innanbirgðir, sem geta verið gjaldfærðar til baka",
Is Active,er Active,
Is Default,er Default,
Is Existing Asset,Er núverandi eign,
Is Frozen,Er frosinn,
Is Group,Er hópur,
Issue,Mál,
Issue Material,Issue Efni,
Issued,Útgefið,
Issues,Vandamál,
It is needed to fetch Item Details.,Það er nauðsynlegt að ná Item upplýsingar.,
Item,Item,
Item 1,Atriði 1,
Item 2,Liður 2,
Item 3,Liður 3,
Item 4,Liður 4,
Item 5,Liður 5,
Item Cart,Atriði körfu,
Item Code,Item Code,
Item Code cannot be changed for Serial No.,Item Code er ekki hægt að breyta fyrir Raðnúmer,
Item Code required at Row No {0},Item Code þörf á Row nr {0},
Item Description,Lýsing á hlut,
Item Group,Liður Group,
Item Group Tree,Liður Group Tree,
Item Group not mentioned in item master for item {0},Item Group ekki getið í master lið fyrir lið {0},
Item Name,Nafn hlutar,
Item Price added for {0} in Price List {1},Atriði Verð bætt fyrir {0} í verðskrá {1},
"Item Price appears multiple times based on Price List, Supplier/Customer, Currency, Item, UOM, Qty and Dates.","Vara Verð birtist mörgum sinnum á grundvelli Verðlisti, Birgir / Viðskiptavinur, Gjaldmiðill, Liður, UOM, Magn og Dagsetningar.",
Item Price updated for {0} in Price List {1},Item Verð uppfærð fyrir {0} í verðskrá {1},
Item Row {0}: {1} {2} does not exist in above '{1}' table,Liður Rauða {0}: {1} {2} er ekki til í töflunni hér að framan &quot;{1}&quot;,
Item Tax Row {0} must have account of type Tax or Income or Expense or Chargeable,Liður Tax Row {0} verður að hafa hliðsjón af tegund skatta eða tekjur eða gjöld eða Skuldfæranlegar,
Item Template,Liður sniðmát,
Item Variant Settings,Variunarstillingar,
Item Variant {0} already exists with same attributes,Liður Variant {0} er þegar til staðar með sömu eiginleika,
Item Variants,Item Afbrigði,
Item Variants updated,Afbrigði atriða uppfært,
Item has variants.,Liður hefur afbrigði.,
Item must be added using 'Get Items from Purchase Receipts' button,Atriði verður að bæta með því að nota &quot;fá atriði úr greiðslukvittanir &#39;hnappinn,
Item or Warehouse for row {0} does not match Material Request,Liður eða Warehouse fyrir röð {0} passar ekki Material Beiðni,
Item valuation rate is recalculated considering landed cost voucher amount,Liður verðmat hlutfall er endurreiknuð miðað lenti kostnaður úttektarmiðans upphæð,
Item variant {0} exists with same attributes,Liður afbrigði {0} hendi með sömu eiginleika,
Item {0} does not exist,Liður {0} er ekki til,
Item {0} does not exist in the system or has expired,Liður {0} er ekki til í kerfinu eða er útrunnið,
Item {0} has already been returned,Liður {0} hefur þegar verið skilað,
Item {0} has been disabled,Liður {0} hefur verið gerð óvirk,
Item {0} has reached its end of life on {1},Liður {0} hefur náð enda sitt líf á {1},
Item {0} ignored since it is not a stock item,Liður {0} hunsuð þar sem það er ekki birgðir atriði,
"Item {0} is a template, please select one of its variants",Liður {0} er sniðmát skaltu velja einn af afbrigði hennar,
Item {0} is cancelled,Liður {0} er hætt,
Item {0} is disabled,Liður {0} er óvirk,
Item {0} is not a serialized Item,Liður {0} er ekki serialized Item,
Item {0} is not a stock Item,Liður {0} er ekki birgðir Item,
Item {0} is not active or end of life has been reached,Liður {0} er ekki virkur eða enda líf hefur verið náð,
Item {0} is not setup for Serial Nos. Check Item master,Liður {0} er ekki skipulag fyrir Serial Nos. Athuga Item meistara,
Item {0} is not setup for Serial Nos. Column must be blank,Liður {0} er ekki skipulag fyrir Serial Nos. Column verður auður,
Item {0} must be a Fixed Asset Item,Liður {0} verður að vera fast eign Item,
Item {0} must be a Sub-contracted Item,Liður {0} verður að vera Sub-dregist Item,
Item {0} must be a non-stock item,Liður {0} verður að a non-birgðir atriði,
Item {0} must be a stock Item,Liður {0} verður að vera birgðir Item,
Item {0} not found,Liður {0} fannst ekki,
Item {0} not found in 'Raw Materials Supplied' table in Purchase Order {1},Liður {0} fannst ekki í &#39;hráefnum Meðfylgjandi&#39; borð í Purchase Order {1},
Item {0}: Ordered qty {1} cannot be less than minimum order qty {2} (defined in Item).,Liður {0}: Pantaði Magn {1} má ekki vera minna en lágmarks röð Fjöldi {2} (sem skilgreindur er í lið).,
Item: {0} does not exist in the system,Item: {0} er ekki til í kerfinu,
Items,atriði,
Items Filter,Atriði Sía,
Items and Pricing,Atriði og verðlagning,
Items for Raw Material Request,Atriði fyrir hráefni,
Job Card,Atvinna kort,
Job Description,Starfslýsing,
Job Offer,Atvinnutilboð,
Job card {0} created,Atvinna kort {0} búið til,
Jobs,Störf,
Join,Join,
Journal Entries {0} are un-linked,Journal Entries {0} eru un-tengd,
Journal Entry,Dagbókarfærsla,
Journal Entry {0} does not have account {1} or already matched against other voucher,Journal Entry {0} hefur ekki reikning {1} eða þegar samsvarandi á móti öðrum skírteini,
Kanban Board,Kanban Board,
Key Reports,Lykilskýrslur,
LMS Activity,LMS virkni,
Lab Test,Lab Test,
Lab Test Prescriptions,Lab Test Prescriptions,
Lab Test Report,Lab Test Report,
Lab Test Sample,Lab Test Dæmi,
Lab Test Template,Lab Test Sniðmát,
Lab Test UOM,Lab Próf UOM,
Lab Tests and Vital Signs,Lab prófanir og lífskjör,
Lab result datetime cannot be before testing datetime,Lab niðurstaða datetime getur ekki verið fyrir prófunartíma,
Lab testing datetime cannot be before collection datetime,Lab prófunartímabil getur ekki verið fyrir dagsetningu söfnunartíma,
Label,Label,
Laboratory,Rannsóknarstofa,
Language Name,Tungumál Name,
Large,stór,
Last Communication,Síðasta samskipti,
Last Communication Date,Síðasti samskiptadagur,
Last Name,Eftirnafn,
Last Order Amount,Síðasta Order Magn,
Last Order Date,Síðasta Röð Dagsetning,
Last Purchase Price,Síðasta kaupverð,
Last Purchase Rate,Síðasta Kaup Rate,
Latest,Nýjustu,
Latest price updated in all BOMs,Nýjasta verð uppfært í öllum BOMs,
Lead,Lead,
Lead Count,Leiða Count,
Lead Owner,Lead Eigandi,
Lead Owner cannot be same as the Lead,Lead Eigandi getur ekki verið sama og Lead,
Lead Time Days,Lead Time Days,
Lead to Quotation,Leiða til tilvitnun,
"Leads help you get business, add all your contacts and more as your leads","Leiðir hjálpa þér að fá fyrirtæki, bæta alla tengiliði þína og fleiri sem leiðir þínar",
Learn,Frekari,
Leave Approval Notification,Skildu eftir samþykki tilkynningu,
Leave Blocked,Skildu Bannaður,
Leave Encashment,Skildu Encashment,
Leave Management,Skildu Stjórnun,
Leave Status Notification,Leyfi Tilkynning um leyfi,
Leave Type,Leave Type,
Leave Type is madatory,Leyfi Tegund er madatory,
Leave Type {0} cannot be allocated since it is leave without pay,Skildu Type {0} er ekki hægt að úthluta þar sem það er leyfi án launa,
Leave Type {0} cannot be carry-forwarded,Skildu Tegund {0} Ekki er hægt að bera-send,
Leave Type {0} is not encashable,Leyfi Type {0} er ekki encashable,
Leave Without Pay,Leyfi án launa,
Leave and Attendance,Leyfi og Mæting,
Leave application {0} already exists against the student {1},Leyfi umsókn {0} er nú þegar á móti nemandanum {1},
"Leave cannot be allocated before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}","Leyfi ekki hægt að skipta áður en {0}, sem orlof jafnvægi hefur þegar verið fært sendar í framtíðinni leyfi úthlutun met {1}",
"Leave cannot be applied/cancelled before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}","Skildu ekki hægt að beita / aflýst áður {0}, sem orlof jafnvægi hefur þegar verið fært sendar í framtíðinni leyfi úthlutun met {1}",
Leave of type {0} cannot be longer than {1},Leyfi af gerð {0} má ekki vera lengri en {1},
Leave the field empty to make purchase orders for all suppliers,Leyfa reitinn tóm til að gera kauppantanir fyrir alla birgja,
Leaves,Blöð,
Leaves Allocated Successfully for {0},Leaves Úthlutað Tókst fyrir {0},
Leaves has been granted sucessfully,Leaves hefur verið veitt með góðum árangri,
Leaves must be allocated in multiples of 0.5,"Leaves verður úthlutað margfeldi af 0,5",
Leaves per Year,Leaves á ári,
Ledger,Ledger,
Legal,Legal,
Legal Expenses,málskostnaðar,
Letter Head,Letter Head,
Letter Heads for print templates.,Bréf Heads fyrir prenta sniðmát.,
Level,Level,
Liability,Ábyrgð,
License,License,
Lifecycle,Líftíma,
Limit,Limit,
Limit Crossed,Limit Crossed,
Link to Material Request,Tengill við efnisbeiðni,
List of all share transactions,Listi yfir alla hlutafjáreignir,
List of available Shareholders with folio numbers,Listi yfir tiltæka hluthafa með folíumnúmerum,
Loading Payment System,Hleðsla greiðslukerfis,
Loan,Lán,
Loan Amount cannot exceed Maximum Loan Amount of {0},Lánið upphæð mega vera Hámarkslán af {0},
Loan Application,Lán umsókn,
Loan Management,Lánastjórnun,
Loan Repayment,Lán endurgreiðslu,
Loan Start Date and Loan Period are mandatory to save the Invoice Discounting,Upphafsdagur og lánstímabil lána er skylt að vista reikningsafslátt,
Loans (Liabilities),Lán (skulda),
Loans and Advances (Assets),Útlán og kröfur (inneign),
Local,Local,
"LocalStorage is full , did not save","LocalStorage er fullt, ekki spara",
"LocalStorage is full, did not save","LocalStorage er fullt, ekki spara",
Log,Log,
Logs for maintaining sms delivery status,Logs fyrir að viðhalda SMS-sendingar stöðu,
Lost,Lost,
Lost Reasons,Týndar ástæður,
Low,Low,
Low Sensitivity,Lágt næmi,
Lower Income,neðri Tekjur,
Loyalty Amount,Hollustuhæð,
Loyalty Point Entry,Hollusta Point innganga,
Loyalty Points,Hollusta stig,
"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.","Hollusta stig verður reiknað út frá því sem varið er (með sölureikningi), byggt á söfnunartölu sem getið er um.",
Loyalty Points: {0},Vildarkjör: {0},
Loyalty Program,Hollusta Program,
Main,Main,
Maintenance,Viðhald,
Maintenance Log,Viðhaldsskrá,
Maintenance Manager,viðhald Manager,
Maintenance Schedule,viðhald Dagskrá,
Maintenance Schedule is not generated for all the items. Please click on 'Generate Schedule',Viðhald Dagskrá er ekki mynda að öllum þeim atriðum. Vinsamlegast smelltu á &#39;Búa Stundaskrá&#39;,
Maintenance Schedule {0} exists against {1},Viðhaldsáætlun {0} er til staðar gegn {1},
Maintenance Schedule {0} must be cancelled before cancelling this Sales Order,Viðhald Dagskrá {0} verður lokað áður en hætta þessu Velta Order,
Maintenance Status has to be Cancelled or Completed to Submit,Viðhald Staða verður að vera Hætt eða lokið til að senda inn,
Maintenance User,viðhald User,
Maintenance Visit,viðhald Visit,
Maintenance Visit {0} must be cancelled before cancelling this Sales Order,Viðhald Visit {0} verður lokað áður en hætta þessu Velta Order,
Maintenance start date can not be before delivery date for Serial No {0},Viðhald Upphafsdagur getur ekki verið áður fæðingardag fyrir Raðnúmer {0},
Make,gera,
Make Payment,Greiða,
Make project from a template.,Búðu til verkefni úr sniðmáti.,
Making Stock Entries,Gerð lager færslur,
Male,male,
Manage Customer Group Tree.,Stjórna Viðskiptavinur Group Tree.,
Manage Sales Partners.,Stjórna Velta Partners.,
Manage Sales Person Tree.,Stjórna velta manneskja Tree.,
Manage Territory Tree.,Stjórna Territory Tree.,
Manage your orders,Stjórna pantanir,
Management,Stjórn,
Manager,Framkvæmdastjóri,
Managing Projects,Annast verkefni,
Managing Subcontracting,Annast undirverktöku,
Mandatory,nauðsynlegur,
Mandatory field - Academic Year,Skyldanlegt námskeið - námsár,
Mandatory field - Get Students From,Lögboðið reit - Fá nemendur frá,
Mandatory field - Program,Lögboðið reit - Program,
Manufacture,Framleiðsla,
Manufacturer,Framleiðandi,
Manufacturer Part Number,Framleiðandi Part Number,
Manufacturing,Framleiðsla,
Manufacturing Quantity is mandatory,Framleiðsla Magn er nauðsynlegur,
Mapping,Kortlagning,
Mapping Type,Kortlagningartegund,
Mark Absent,Mark Absent,
Mark Attendance,Mark Aðsókn,
Mark Half Day,Mark Half Day,
Mark Present,Mark Present,
Marketing,Markaðssetning,
Marketing Expenses,markaðskostnaður,
Marketplace,Marketplace,
Marketplace Error,Marketplace Villa,
"Master data syncing, it might take some time","Master gögn syncing, gæti það tekið smá tíma",
Masters,Masters,
Match Payments with Invoices,Passa Greiðslur með Reikningar,
Match non-linked Invoices and Payments.,Passa non-tengd og greiðslur.,
Material,Efni,
Material Consumption,Efni neysla,
Material Consumption is not set in Manufacturing Settings.,Efni neysla er ekki stillt í framleiðslustillingum.,
Material Receipt,Efni Kvittun,
Material Request,efni Beiðni,
Material Request Date,Efni Beiðni Dagsetning,
Material Request No,Efnisbeiðni nr,
"Material Request not created, as quantity for Raw Materials already available.","Efnisbeiðni ekki búin til, sem magn fyrir hráefni sem þegar er til.",
Material Request of maximum {0} can be made for Item {1} against Sales Order {2},Efni Beiðni um hámark {0} má gera ráð fyrir lið {1} gegn Velta Order {2},
Material Request to Purchase Order,Efni beiðni um innkaupapöntun,
Material Request {0} is cancelled or stopped,Efni Beiðni {0} er aflýst eða henni hætt,
Material Request {0} submitted.,Efnisbeiðni {0} lögð fram.,
Material Transfer,efni Transfer,
Material Transferred,Efni flutt,
Material to Supplier,Efni til Birgir,
Max Exemption Amount cannot be greater than maximum exemption amount {0} of Tax Exemption Category {1},Hámarksfrelsisupphæð má ekki vera hærri en hámarksfrávik {0} í skattfrelsisflokki {1},
Max benefits should be greater than zero to dispense benefits,Hámarks ávinningur ætti að vera meiri en núll til að skila ávinningi,
Max discount allowed for item: {0} is {1}%,Max afsláttur leyfð lið: {0} er {1}%,
Max: {0},Max: {0},
Maximum Samples - {0} can be retained for Batch {1} and Item {2}.,Hámarksýni - {0} er hægt að halda í lotu {1} og lið {2}.,
Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,Hámarksýni - {0} hafa þegar verið haldið fyrir lotu {1} og lið {2} í lotu {3}.,
Maximum amount eligible for the component {0} exceeds {1},Hámarksupphæð sem hæfur er fyrir hluti {0} fer yfir {1},
Maximum benefit amount of component {0} exceeds {1},Hámarks ávinningur magn af þáttur {0} fer yfir {1},
Maximum benefit amount of employee {0} exceeds {1},Hámarksframlagsþáttur starfsmanns {0} fer yfir {1},
Maximum discount for Item {0} is {1}%,Hámarks afsláttur fyrir lið {0} er {1}%,
Maximum leave allowed in the leave type {0} is {1},Hámarks leyfi sem leyfður er í tegund ferðarinnar {0} er {1},
Medical,Medical,
Medical Code,Læknisbók,
Medical Code Standard,Læknisfræðileg staðal,
Medical Department,Medical Department,
Medical Record,Læknisskýrsla,
Medium,Medium,
Meeting,Fundur,
Member Activity,Meðlimur Meðlimur,
Member ID,Lykilorð,
Member Name,Nafn Nafn,
Member information.,Upplýsingar um aðild.,
Membership,Aðild,
Membership Details,Upplýsingar um aðild,
Membership ID,Aðildarupplýsingar,
Membership Type,Aðildargerð,
Memebership Details,Uppljómun Upplýsingar,
Memebership Type Details,Upplýsingar um upplifunartegund,
Merge,Sameina,
Merge Account,Sameina reikning,
Merge with Existing Account,Sameina með núverandi reikningi,
"Merging is only possible if following properties are same in both records. Is Group, Root Type, Company","Samruni er aðeins mögulegt ef eftirfarandi eiginleikar eru sömu í báðum skrám. Er Group, Root Tegund, Company",
Message Examples,Skilaboða Dæmi,
Message Sent,Skilaboð send,
Method,Aðferð,
Middle Income,Middle Tekjur,
Middle Name,Millinafn,
Middle Name (Optional),Middle Name (Valfrjálst),
Min Amt can not be greater than Max Amt,Min Amt getur ekki verið meira en Max Amt,
Min Qty can not be greater than Max Qty,Min Magn má ekki vera meiri en Max Magn,
Minimum Lead Age (Days),Lágmarksstigleiki (dagar),
Miscellaneous Expenses,Ýmis útgjöld,
Missing Currency Exchange Rates for {0},Vantar gjaldeyri Verð fyrir {0},
Missing email template for dispatch. Please set one in Delivery Settings.,Vantar email sniðmát til sendingar. Vinsamlegast stilltu einn í Afhendingastillingar.,
"Missing value for Password, API Key or Shopify URL","Vantar gildi fyrir lykilorð, API lykil eða Shopify vefslóð",
Mode of Payment,Greiðslumáti,
Mode of Payments,Greiðslumáti,
Mode of Transport,Flutningsmáti,
Mode of Transportation,Samgöngustíll,
Mode of payment is required to make a payment,Háttur af greiðslu er krafist til að greiða,
Model,Model,
Moderate Sensitivity,Miðlungs næmi,
Monday,Mánudagur,
Monthly,Mánaðarleg,
Monthly Distribution,Mánaðarleg dreifing,
Monthly Repayment Amount cannot be greater than Loan Amount,Mánaðarlega endurgreiðslu Upphæð má ekki vera meiri en lánsfjárhæð,
More,Meira,
More Information,Meiri upplýsingar,
More than one selection for {0} not allowed,Fleiri en eitt val fyrir {0} er ekki leyfilegt,
More...,Meira ...,
Motion Picture & Video,Motion Picture &amp; Video,
Move,Ferðinni,
Move Item,færa Item,
Multi Currency,Multi Gjaldmiðill,
Multiple Item prices.,Margar Item verð.,
Multiple Loyalty Program found for the Customer. Please select manually.,Mörg hollusta forrit sem finnast fyrir viðskiptavininn. Vinsamlegast veldu handvirkt.,
"Multiple Price Rules exists with same criteria, please resolve conflict by assigning priority. Price Rules: {0}","Margar verð Reglur hendi með sömu forsendum, vinsamlegast leysa deiluna með því að úthluta forgang. Verð Reglur: {0}",
Multiple Variants,Margfeldi afbrigði,
Multiple default mode of payment is not allowed,Margfeldi sjálfgefið greiðslumáti er ekki leyfilegt,
Multiple fiscal years exist for the date {0}. Please set company in Fiscal Year,Margar reikningsárin til fyrir dagsetningu {0}. Vinsamlegast settu fyrirtæki í Fiscal Year,
Music,Tónlist,
My Account,Minn reikningur,
Name error: {0},Nafn villa: {0},
Name of new Account. Note: Please don't create accounts for Customers and Suppliers,Nafn nýja reikninginn. Ath: Vinsamlegast bý ekki reikninga fyrir viðskiptavini og birgja,
Name or Email is mandatory,Nafn eða netfang er nauðsynlegur,
Nature Of Supplies,Eðli birgða,
Navigating,siglingar,
Needs Analysis,Þarfir greining,
Negative Quantity is not allowed,Neikvætt Magn er ekki leyfð,
Negative Valuation Rate is not allowed,Neikvætt Verðmat Rate er ekki leyfð,
Negotiation/Review,Samningaviðræður / endurskoðun,
Net Asset value as on,Innra virði og á,
Net Cash from Financing,Handbært fé frá fjármögnun,
Net Cash from Investing,Handbært fé frá fjárfesta,
Net Cash from Operations,Handbært fé frá rekstri,
Net Change in Accounts Payable,Net Breyta í viðskiptaskuldum,
Net Change in Accounts Receivable,Net Breyta viðskiptakrafna,
Net Change in Cash,Net Breyting á Cash,
Net Change in Equity,Net breyting á eigin fé,
Net Change in Fixed Asset,Net Breyting á fast eign,
Net Change in Inventory,Net Breyting á Skrá,
Net ITC Available(A) - (B),Net ITC í boði (A) - (B),
Net Pay,Net Borga,
Net Pay cannot be less than 0,Net Borga má ekki vera minna en 0,
Net Profit,Hagnaður,
Net Salary Amount,Nettólaunaupphæð,
Net Total,Net Total,
Net pay cannot be negative,Net borga ekki vera neikvæð,
New Account Name,Nýtt nafn Account,
New Address,ný Address,
New BOM,ný BOM,
New Batch ID (Optional),Ný lotunúmer (valfrjálst),
New Batch Qty,Ný lotunúmer,
New Cart,nýtt körfu,
New Company,ný Company,
New Contact,nýtt samband við,
New Cost Center Name,Nýtt Kostnaður Center Name,
New Customer Revenue,Ný Tekjur Viðskiptavinur,
New Customers,ný Viðskiptavinir,
New Department,New Department,
New Employee,Ný starfsmaður,
New Location,Nýtt Staðsetning,
New Quality Procedure,Ný gæðaferli,
New Sales Invoice,Nýr reikningur,
New Sales Person Name,Nýtt Sales Person Name,
New Serial No cannot have Warehouse. Warehouse must be set by Stock Entry or Purchase Receipt,New Serial Nei getur ekki hafa Warehouse. Warehouse verður að setja af lager Entry eða kvittun,
New Warehouse Name,Nýtt Warehouse Name,
New credit limit is less than current outstanding amount for the customer. Credit limit has to be atleast {0},Ný hámarksupphæð er minna en núverandi útistandandi upphæð fyrir viðskiptavininn. Hámarksupphæð þarf að vera atleast {0},
New task,Nýtt verkefni,
New {0} pricing rules are created,Nýjar {0} verðlagningarreglur eru búnar til,
Newsletters,Fréttabréf,
Newspaper Publishers,dagblað Publishers,
Next,næsta,
Next Contact By cannot be same as the Lead Email Address,Næsta Samband með getur ekki verið sama og Lead netfanginu,
Next Contact Date cannot be in the past,Næsta Hafa Date getur ekki verið í fortíðinni,
Next Steps,Næstu skref,
No Action,Engin aðgerð,
No Customers yet!,Engar viðskiptavinir ennþá!,
No Data,Engin gögn,
No Delivery Note selected for Customer {},Engin afhendingartilkynning valin fyrir viðskiptavini {},
No Employee Found,Engin starfsmaður fannst,
No Item with Barcode {0},Ekkert atriði með Strikamerki {0},
No Item with Serial No {0},Ekkert atriði með Serial nr {0},
No Items added to cart,Engar atriði bætt við í körfu,
No Items available for transfer,Engar atriði í boði til að flytja,
No Items selected for transfer,Engar atriði valdir til flutnings,
No Items to pack,Engir hlutir í pakka,
No Items with Bill of Materials to Manufacture,Engar Verk með Bill of Materials að Manufacture,
No Items with Bill of Materials.,Engir hlutir með efnisyfirlit.,
No Lab Test created,Engin Lab próf búin til,
No Permission,Engin heimild,
No Quote,Engin tilvitnun,
No Remarks,Engar athugasemdir,
No Result to submit,Engar niðurstöður til að senda inn,
No Salary Structure assigned for Employee {0} on given date {1},Nei Launastyrkur úthlutað fyrir starfsmann {0} á tilteknum degi {1},
No Staffing Plans found for this Designation,Engar áætlanir um starfsmenntun fundust fyrir þessa tilnefningu,
No Student Groups created.,Engar Student Groups búin.,
No Students in,Engar nemendur í,
No Tax Withholding data found for the current Fiscal Year.,Engar skattgreiðslur sem fundust fyrir núverandi reikningsár.,
No Work Orders created,Engar vinnuskipanir búin til,
No accounting entries for the following warehouses,Engar bókhald færslur fyrir eftirfarandi vöruhús,
No active or default Salary Structure found for employee {0} for the given dates,Engin virk eða vanræksla Laun Uppbygging finna fyrir starfsmann {0} fyrir gefnar dagsetningar,
No address added yet.,Ekkert heimilisfang bætt við enn.,
No contacts added yet.,Engir tengiliðir bætt við enn.,
No contacts with email IDs found.,Engar tengiliðir við auðkenni tölvupósts fundust.,
No data for this period,Engin gögn fyrir þetta tímabil,
No description given,Engin lýsing gefin,
No employees for the mentioned criteria,Engar starfsmenn fyrir nefndar viðmiðanir,
No gain or loss in the exchange rate,Engin hagnaður eða tap á gengi krónunnar,
No items listed,Engin atriði skráð,
No items to be received are overdue,Engin atriði sem berast eru tímabært,
No material request created,Engin efnisbeiðni búin til,
No more updates,Ekki fleiri uppfærslur,
No of Interactions,Engar milliverkanir,
No of Shares,Fjöldi hlutabréfa,
No pending Material Requests found to link for the given items.,Engar biðröð Efnisbeiðnir fannst að tengjast fyrir tiltekna hluti.,
No products found,Engar vörur fundust,
No products found.,Engar vörur fundust.,
No record found,Ekkert fannst,
No records found in the Invoice table,Engar færslur finnast í Invoice töflunni,
No records found in the Payment table,Engar færslur finnast í Greiðsla töflunni,
No replies from,Engin svör frá,
No salary slip found to submit for the above selected criteria OR salary slip already submitted,Engin launaspjald fannst fyrir framangreindar valin skilyrði,
No tasks,Engin verkefni,
No time sheets,Enginn tími blöð,
No values,Engin gildi,
No {0} found for Inter Company Transactions.,Engin {0} fundust fyrir millifærsluviðskipti.,
Non GST Inward Supplies,Aðrar birgðir ekki GST,
Non Profit,non Profit,
Non Profit (beta),Hagnaður (beta),
Non-GST outward supplies,Aðrar birgðir utan GST,
Non-Group to Group,Non-Group til Group,
None,Enginn,
None of the items have any change in quantity or value.,Ekkert af þeim atriðum hafa allar breytingar á magni eða verðmæti.,
Nos,nos,
Not Available,Ekki í boði,
Not Marked,ekki Marked,
Not Paid and Not Delivered,Ekki greidd og ekki skilað,
Not Permitted,Ekki leyfilegt,
Not Started,ekki byrjað,
Not active,ekki virkur,
Not allow to set alternative item for the item {0},Ekki leyfa að setja aðra hluti fyrir hlutinn {0},
Not allowed to update stock transactions older than {0},Ekki leyft að uppfæra lager viðskipti eldri en {0},
Not authorized to edit frozen Account {0},Ekki heimild til að breyta frosinn reikning {0},
Not authroized since {0} exceeds limits,Ekki authroized síðan {0} umfram mörk,
Not eligible for the admission in this program as per DOB,Ekki hæfur til að taka þátt í þessu forriti samkvæmt DOB,
Not items found,Ekki atriði fundust,
Not permitted for {0},Ekki leyft {0},
"Not permitted, configure Lab Test Template as required","Ekki heimilt, stilla Lab Test Template eftir þörfum",
Not permitted. Please disable the Service Unit Type,Ekki leyfilegt. Vinsamlega slökkva á þjónustueiningartegundinni,
Note: Due / Reference Date exceeds allowed customer credit days by {0} day(s),Ath: Vegna / Frestdagur umfram leyfð viðskiptavina kredit dagar eftir {0} dag (s),
Note: Item {0} entered multiple times,Ath: Item {0} inn mörgum sinnum,
Note: Payment Entry will not be created since 'Cash or Bank Account' was not specified,Ath: Greiðsla Entry verður ekki búið síðan &#39;Cash eða Bank Account &quot;var ekki tilgreint,
Note: System will not check over-delivery and over-booking for Item {0} as quantity or amount is 0,Ath: Kerfi mun ekki stöðva yfir fæðingu og yfir-bókun fyrir lið {0} sem magn eða upphæð er 0,
Note: There is not enough leave balance for Leave Type {0},Athugið: Það er ekki nóg leyfi jafnvægi um leyfi Tegund {0},
Note: This Cost Center is a Group. Cannot make accounting entries against groups.,Ath: Þessi Kostnaður Center er Group. Get ekki gert bókhaldsfærslum gegn hópum.,
Note: {0},Ath: {0},
Notes,Skýringar,
Nothing is included in gross,Ekkert er innifalið í brúttó,
Nothing more to show.,Ekkert meira að sýna.,
Nothing to change,Ekkert að breyta,
Notice Period,uppsagnarfrestur,
Notify Customers via Email,Tilkynna viðskiptavinum með tölvupósti,
Number,Númer,
Number of Depreciations Booked cannot be greater than Total Number of Depreciations,Fjöldi Afskriftir bókað getur ekki verið meiri en heildarfjöldi Afskriftir,
Number of Interaction,Fjöldi samskipta,
Number of Order,Fjöldi Order,
"Number of new Account, it will be included in the account name as a prefix","Fjöldi nýrra reikninga, það verður innifalið í reikningsnafninu sem forskeyti",
"Number of new Cost Center, it will be included in the cost center name as a prefix","Fjöldi nýju kostnaðarstöðvarinnar, það verður innifalið í heiti kostnaðarmiðstöðvarinnar sem forskeyti",
Number of root accounts cannot be less than 4,Fjöldi rótareikninga má ekki vera minna en 4,
Odometer,kílómetramæli,
Office Equipments,Skrifstofa útbúnaður,
Office Maintenance Expenses,Skrifstofa viðhald kostnaður,
Office Rent,Skrifstofa leigu,
On Hold,Á bið,
On Net Total,Á Nettó,
One customer can be part of only single Loyalty Program.,Eitt viðskiptavinur getur verið hluti af einni hollustuáætlun.,
Online,Online,
Online Auctions,Online uppboð,
Only Leave Applications with status 'Approved' and 'Rejected' can be submitted,Aðeins Skildu Umsóknir með stöðu &quot;Samþykkt&quot; og &quot;Hafnað &#39;er hægt að skila,
"Only the Student Applicant with the status ""Approved"" will be selected in the table below.",Aðeins umsækjandi með staðalinn &quot;Samþykkt&quot; verður valinn í töflunni hér að neðan.,
Only users with {0} role can register on Marketplace,Aðeins notendur með {0} hlutverk geta skráð sig á Marketplace,
Only {0} in stock for item {1},Aðeins {0} á lager fyrir hlut {1},
Open BOM {0},Open BOM {0},
Open Item {0},Open Item {0},
Open Notifications,Opið Tilkynningar,
Open Orders,Opna pantanir,
Open a new ticket,Opnaðu nýjan miða,
Opening,Opnun,
Opening (Cr),Opening (Cr),
Opening (Dr),Opening (Dr),
Opening Accounting Balance,Opnun Bókhald Balance,
Opening Accumulated Depreciation,Opnun uppsöfnuðum afskriftum,
Opening Accumulated Depreciation must be less than equal to {0},Opnun uppsöfnuðum afskriftum verður að vera minna en eða jafnt og {0},
Opening Balance,Opnunarjöfnuður,
Opening Balance Equity,Opnun Balance Equity,
Opening Date and Closing Date should be within same Fiscal Year,Opnun Dagsetning og lokadagur ætti að vera innan sama reikningsár,
Opening Date should be before Closing Date,Opnun Date ætti að vera áður lokadegi,
Opening Entry Journal,Opnun dagbókar,
Opening Invoice Creation Tool,Opna reikningsskilatól,
Opening Invoice Item,Opnun Reikningsatriði,
Opening Invoices,Opnun Reikningar,
Opening Invoices Summary,Opna reikningsyfirlit,
Opening Qty,opnun Magn,
Opening Stock,opnun Stock,
Opening Stock Balance,Opnun Stock Balance,
Opening Value,opnun Value,
Opening {0} Invoice created,Opnun {0} Reikningur búin til,
Operation,Operation,
Operation Time must be greater than 0 for Operation {0},Operation Time verður að vera hærri en 0 fyrir notkun {0},
"Operation {0} longer than any available working hours in workstation {1}, break down the operation into multiple operations","Operation {0} lengur en öllum tiltækum vinnutíma í vinnustöð {1}, brjóta niður rekstur í mörgum aðgerðum",
Operations,Aðgerðir,
Operations cannot be left blank,Aðgerðir geta ekki vera autt,
Opp Count,Upp Count,
Opp/Lead %,Upp / Leið%,
Opportunities,Tækifæri,
Opportunities by lead source,Tækifæri eftir forystu,
Opportunity,Tækifæri,
Opportunity Amount,Tækifærsla,
Optional Holiday List not set for leave period {0},Valfrjálst frídagur listi ekki settur í leyfiartíma {0},
"Optional. Sets company's default currency, if not specified.","Valfrjálst. Leikmynd sjálfgefið mynt félagsins, ef ekki tilgreint.",
Optional. This setting will be used to filter in various transactions.,Valfrjálst. Þessi stilling verður notuð til að sía í ýmsum viðskiptum.,
Options,Valmöguleikar,
Order Count,Order Count,
Order Entry,Pöntunarnúmer,
Order Value,Panta gildi,
Order rescheduled for sync,Pöntun endurskipulögð fyrir samstillingu,
Order/Quot %,Order / Quot%,
Ordered,Pantaði,
Ordered Qty,Raðaður Magn,
"Ordered Qty: Quantity ordered for purchase, but not received.","Pantað magn: Magn pantað til kaupa, en ekki móttekið.",
Orders,Pantanir,
Orders released for production.,Pantanir út fyrir framleiðslu.,
Organization,Skipulag,
Organization Name,nafn samtaka,
Other,Annað,
Other Reports,Aðrar skýrslur,
"Other outward supplies(Nil rated,Exempted)","Aðrar birgðir út á við (ekki metnar, undanþegnar)",
Others,Aðrir,
Out Qty,Út magn,
Out Value,út Value,
Out of Order,Bilað,
Outgoing,Outgoing,
Outstanding,Framúrskarandi,
Outstanding Amount,útistandandi fjárhæð,
Outstanding Amt,Framúrskarandi Amt,
Outstanding Cheques and Deposits to clear,Framúrskarandi Tékkar og Innlán til að hreinsa,
Outstanding for {0} cannot be less than zero ({1}),Framúrskarandi fyrir {0} má ekki vera minna en núll ({1}),
Outward taxable supplies(zero rated),Skattskyldar birgðir út á við (núll metnar),
Overdue,Tímabært,
Overlap in scoring between {0} and {1},Skarast í skora á milli {0} og {1},
Overlapping conditions found between:,Skarast skilyrði fundust milli:,
Owner,Eigandi,
PAN,PAN,
PO already created for all sales order items,Póstur er þegar búinn til fyrir allar vörur til sölu,
POS,POS,
POS Closing Voucher alreday exists for {0} between date {1} and {2},POS Lokunarskírteini er frá og með deginum á {0} frá dagsetningu {1} og {2},
POS Profile,POS Profile,
POS Profile is required to use Point-of-Sale,POS Profile er nauðsynlegt til að nota Point-of-Sale,
POS Profile required to make POS Entry,POS Profile þarf að gera POS Entry,
POS Settings,POS stillingar,
Packed quantity must equal quantity for Item {0} in row {1},Pakkað magn verður að vera jafnt magn fyrir lið {0} í röð {1},
Packing Slip,pökkun Slip,
Packing Slip(s) cancelled,Pökkun Slip (s) Hætt,
Paid,Greiddur,
Paid Amount,Greiddur upphæð,
Paid Amount cannot be greater than total negative outstanding amount {0},Greiddur Upphæð má ekki vera meiri en heildar neikvæð útistandandi {0},
Paid amount + Write Off Amount can not be greater than Grand Total,Greiddur upphæð + afskrifa Upphæð má ekki vera meiri en Grand Total,
Paid and Not Delivered,Greitt og ekki afhent,
Parameter,Parameter,
Parent Item {0} must not be a Stock Item,Parent Item {0} mátt ekki vera Stock Item,
Parents Teacher Meeting Attendance,Foreldrar kennarasamkomu,
Part-time,Hluta,
Partially Depreciated,hluta afskrifaðar,
Partially Received,Móttekið að hluta,
Party,Party,
Party Name,Party Name,
Party Type,Party Type,
Party Type and Party is mandatory for {0} account,Samningsgerð og flokkur er nauðsynlegur fyrir {0} reikning,
Party Type is mandatory,Party Type er nauðsynlegur,
Party is mandatory,Party er nauðsynlegur,
Password,Lykilorð,
Password policy for Salary Slips is not set,Lykilorðastefna fyrir launaseðla er ekki stillt,
Past Due Date,Fyrri gjalddaga,
Patient,Sjúklingur,
Patient Appointment,Sjúklingaráð,
Patient Encounter,Sjúklingur Fundur,
Patient not found,Sjúklingur fannst ekki,
Pay Remaining,Borga áfram,
Pay {0} {1},Borga {0} {1},
Payable,greiðist,
Payable Account,greiðist Reikningur,
Payable Amount,Greiðslufjárhæð,
Payment,Greiðsla,
Payment Cancelled. Please check your GoCardless Account for more details,Greiðsla hætt. Vinsamlegast athugaðu GoCardless reikninginn þinn til að fá frekari upplýsingar,
Payment Confirmation,Greiðsla staðfestingar,
Payment Date,Greiðsludagur,
Payment Days,Greiðsla Days,
Payment Document,greiðsla Document,
Payment Due Date,Greiðsla Due Date,
Payment Entries {0} are un-linked,Greiðsla Færslur {0} eru un-tengd,
Payment Entry,greiðsla Entry,
Payment Entry already exists,Greiðsla Entry er þegar til,
Payment Entry has been modified after you pulled it. Please pull it again.,Greiðsla Entry hefur verið breytt eftir að þú draga það. Vinsamlegast rífa það aftur.,
Payment Entry is already created,Greiðsla Entry er þegar búið,
Payment Failed. Please check your GoCardless Account for more details,Greiðsla mistókst. Vinsamlegast athugaðu GoCardless reikninginn þinn til að fá frekari upplýsingar,
Payment Gateway,Greiðsla Gateway,
"Payment Gateway Account not created, please create one manually.",Greiðsla Gateway Reikningur ekki búin skaltu búa til einn höndunum.,
Payment Gateway Name,Greiðsla Gateway Nafn,
Payment Mode,Greiðslumáti,
"Payment Mode is not configured. Please check, whether account has been set on Mode of Payments or on POS Profile.",Greiðsla Mode er ekki stillt. Vinsamlegast athugaðu hvort reikningur hefur verið sett á Mode Greiðslur eða POS Profile.,
Payment Receipt Note,Greiðslukvittun Note,
Payment Request,greiðsla Beiðni,
Payment Request for {0},Greiðslubók um {0},
Payment Tems,Greiðslumark,
Payment Term,Greiðsluskilmálar,
Payment Terms,Greiðsluskilmála,
Payment Terms Template,Sniðmát greiðsluskilmála,
Payment Terms based on conditions,Greiðsluskilmálar byggjast á skilyrðum,
Payment Type,greiðsla Type,
"Payment Type must be one of Receive, Pay and Internal Transfer","Greiðsla Type verður að vera einn af fáum, Borga og Innri Transfer",
Payment against {0} {1} cannot be greater than Outstanding Amount {2},Greiðsla gegn {0} {1} getur ekki verið meiri en Kröfuvirði {2},
Payment of {0} from {1} to {2},Greiðsla {0} frá {1} til {2},
Payment request {0} created,Greiðslubeiðni {0} búið til,
Payments,Greiðslur,
Payroll,Launaskrá,
Payroll Number,Launanúmer,
Payroll Payable,launaskrá Greiðist,
Payroll date can not be less than employee's joining date,Launardagsetning getur ekki verið minni en tengingardagur starfsmanns,
Payslip,launaseðli,
Pending Activities,bið Starfsemi,
Pending Amount,Bíður Upphæð,
Pending Leaves,Bíður Leaves,
Pending Qty,Bíður Magn,
Pending Quantity,Bíður magn,
Pending Review,Bíður Review,
Pending activities for today,Bið starfsemi fyrir dag,
Pension Funds,Lífeyrissjóðir,
Percentage Allocation should be equal to 100%,Hlutfall Úthlutun skal vera jafnt og 100%,
Perception Analysis,Skynjun greining,
Period,Tímabil,
Period Closing Entry,Tímabil Lokar Entry,
Period Closing Voucher,Tímabil Lokar Voucher,
Periodicity,tíðni,
Personal Details,Persónulegar upplýsingar,
Pharmaceutical,Pharmaceutical,
Pharmaceuticals,Pharmaceuticals,
Physician,Læknir,
Piecework,ákvæðisvinnu,
Pin Code,PIN númer,
Pincode,PIN númer,
Place Of Supply (State/UT),Framboðsstaður (ríki / UT),
Place Order,Panta,
Plan Name,Áætlun Nafn,
Plan for maintenance visits.,Áætlun um heimsóknir viðhald.,
Planned Qty,Planned Magn,
"Planned Qty: Quantity, for which, Work Order has been raised, but is pending to be manufactured.","Fyrirhuguð magn: Magn, sem verkpöntun hefur verið hækkuð fyrir, en er í bið til framleiðslu.",
Planning,áætlanagerð,
Plants and Machineries,Plöntur og Machineries,
Please Set Supplier Group in Buying Settings.,Vinsamlegast settu birgirhóp í kaupstillingum.,
Please add a Temporary Opening account in Chart of Accounts,Vinsamlegast bættu við tímabundna opnunareikning í reikningsskýringu,
Please add the account to root level Company - ,Vinsamlegast bættu reikningnum við rótarstig fyrirtækisins -,
Please add the remaining benefits {0} to any of the existing component,Vinsamlegast bættu við eftirtalin kostir {0} við einhvern af núverandi hluti,
Please check Multi Currency option to allow accounts with other currency,Vinsamlegast athugaðu Multi Currency kost að leyfa reikninga með öðrum gjaldmiðli,
Please click on 'Generate Schedule',Vinsamlegast smelltu á &#39;Búa Stundaskrá&#39;,
Please click on 'Generate Schedule' to fetch Serial No added for Item {0},Vinsamlegast smelltu á &#39;Búa Stundaskrá&#39; að ná Serial Nei bætt við fyrir lið {0},
Please click on 'Generate Schedule' to get schedule,Vinsamlegast smelltu á &#39;Búa Stundaskrá&#39; til að fá áætlun,
Please confirm once you have completed your training,Vinsamlegast staðfestu þegar þú hefur lokið þjálfun þinni,
Please contact to the user who have Sales Master Manager {0} role,Vinsamlegast hafðu samband við til notanda sem hefur sala Master Manager {0} hlutverki,
Please create Customer from Lead {0},Vinsamlegast búa til viðskiptavina frá Lead {0},
Please create purchase receipt or purchase invoice for the item {0},Vinsamlegast búðu til kaup kvittun eða kaup reikning fyrir hlutinn {0},
Please define grade for Threshold 0%,Vinsamlegast tilgreindu einkunn fyrir Þröskuld 0%,
Please enable Applicable on Booking Actual Expenses,Vinsamlegast virkjaðu við Bókunarútgjöld,
Please enable Applicable on Purchase Order and Applicable on Booking Actual Expenses,Vinsamlegast virkjaðu Gildandi á innkaupapöntun og gilda um bókunarútgjöld,
Please enable default incoming account before creating Daily Work Summary Group,Vinsamlegast virkjaðu sjálfgefna komandi reikning áður en þú býrð til dagvinnuupplýsingahóp,
Please enable pop-ups,Vinsamlegast virkjaðu pop-ups,
Please enter 'Is Subcontracted' as Yes or No,Vinsamlegast sláðu inn &quot;Er undirverktöku&quot; eins já eða nei,
Please enter API Consumer Key,Vinsamlegast sláðu inn API neytenda lykil,
Please enter API Consumer Secret,Vinsamlegast sláðu inn API Consumer Secret,
Please enter Account for Change Amount,Vinsamlegast sláðu inn reikning fyrir Change Upphæð,
Please enter Approving Role or Approving User,Vinsamlegast sláðu inn Samþykkir hlutverki eða samþykkir notandi,
Please enter Cost Center,Vinsamlegast sláðu Kostnaður Center,
Please enter Delivery Date,Vinsamlegast sláðu inn afhendingardagsetningu,
Please enter Employee Id of this sales person,Vinsamlegast sláðu Starfsmaður Id þessarar velta manneskja,
Please enter Expense Account,Vinsamlegast sláðu inn kostnað reikning,
Please enter Item Code to get Batch Number,Vinsamlegast sláðu Item Code til að fá lotunúmer,
Please enter Item Code to get batch no,Vinsamlegast sláðu Item Code til að fá lotu nr,
Please enter Item first,Vinsamlegast sláðu inn Item fyrst,
Please enter Maintaince Details first,Vinsamlegast sláðu Maintaince Nánar fyrst,
Please enter Material Requests in the above table,Vinsamlegast sláðu Efni Beiðnir í töflunni hér að ofan,
Please enter Planned Qty for Item {0} at row {1},Vinsamlegast sláðu Planned Magn fyrir lið {0} á röð {1},
Please enter Preferred Contact Email,Vinsamlegast sláðu Valinn netfangi,
Please enter Production Item first,Vinsamlegast sláðu Production Item fyrst,
Please enter Purchase Receipt first,Vinsamlegast sláðu inn kvittun fyrst,
Please enter Receipt Document,Vinsamlegast sláðu inn Kvittun Skjal,
Please enter Reference date,Vinsamlegast sláðu viðmiðunardagur,
Please enter Repayment Periods,Vinsamlegast sláðu inn lánstíma,
Please enter Reqd by Date,Vinsamlegast sláðu inn Reqd eftir dagsetningu,
Please enter Sales Orders in the above table,Vinsamlegast sláðu sölu skipunum í töflunni hér að ofan,
Please enter Woocommerce Server URL,Vinsamlegast sláðu inn slóðina á Woocommerce Server,
Please enter Write Off Account,Vinsamlegast sláðu afskrifa reikning,
Please enter atleast 1 invoice in the table,Vinsamlegast sláðu inn atleast 1 reikning í töflunni,
Please enter company first,Vinsamlegast sláðu fyrirtæki fyrst,
Please enter company name first,Vinsamlegast sláðu inn nafn fyrirtækis fyrst,
Please enter default currency in Company Master,Vinsamlegast sláðu inn sjálfgefið mynt í félaginu Master,
Please enter message before sending,Vinsamlegast sláðu inn skilaboð áður en þú sendir,
Please enter parent cost center,Vinsamlegast sláðu foreldri kostnaðarstað,
Please enter quantity for Item {0},Vinsamlegast sláðu inn magn fyrir lið {0},
Please enter relieving date.,Vinsamlegast sláðu létta dagsetningu.,
Please enter repayment Amount,Vinsamlegast sláðu endurgreiðslu Upphæð,
Please enter valid Financial Year Start and End Dates,Vinsamlegast sláðu inn fjárhagsári upphafs- og lokadagsetningar,
Please enter valid email address,Vinsamlegast sláðu inn gilt netfang,
Please enter {0} first,Vinsamlegast sláðu inn {0} fyrst,
Please fill in all the details to generate Assessment Result.,Vinsamlegast fylltu út allar upplýsingar til að fá fram mat á árangri.,
Please identify/create Account (Group) for type - {0},Vinsamlegast auðkennið / stofnaðu reikning (hópur) fyrir gerðina - {0},
Please identify/create Account (Ledger) for type - {0},Vinsamlegast auðkennið / stofnaðu reikning (Ledger) fyrir gerðina - {0},
Please input all required Result Value(s),Vinsamlegast settu inn allar nauðsynlegar niðurstöður gildi (s),
Please login as another user to register on Marketplace,Vinsamlegast skráðu þig inn sem annar notandi til að skrá þig á markaðssvæði,
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.,Vinsamlegast vertu viss um að þú viljir virkilega að eyða öllum viðskiptum fyrir þetta fyrirtæki. stofngÃ¶gn haldast eins og það er. Þessi aðgerð er ekki hægt að afturkalla.,
Please mention Basic and HRA component in Company,Vinsamlegast nefnið Basic og HRA hluti í fyrirtækinu,
Please mention Round Off Account in Company,Vinsamlegast nefna umferð á reikning í félaginu,
Please mention Round Off Cost Center in Company,Vinsamlegast nefna Round Off Kostnaður Center í félaginu,
Please mention no of visits required,Vinsamlegast nefna engin heimsókna krafist,
Please mention the Lead Name in Lead {0},Vinsamlegast nefnt Lead Name í Lead {0},
Please pull items from Delivery Note,Vinsamlegast draga atriði úr afhendingarseðlinum,
Please re-type company name to confirm,Vinsamlega munið gerð nafn fyrirtækis til að staðfesta,
Please register the SIREN number in the company information file,Vinsamlegast skráðu SIREN númerið í upplýsingaskránni,
Please remove this Invoice {0} from C-Form {1},Vinsamlegast fjarlægðu þennan reikning {0} úr C-Form {1},
Please save the patient first,Vinsamlegast vista sjúklinginn fyrst,
Please save the report again to rebuild or update,Vinsamlegast vistaðu skýrsluna aftur til að endurbyggja eða uppfæra,
"Please select Allocated Amount, Invoice Type and Invoice Number in atleast one row","Vinsamlegast veldu úthlutað magn, tegundir innheimtuseðla og reikningsnúmerið í atleast einni röð",
Please select Apply Discount On,Vinsamlegast veldu Virkja afsláttur á,
Please select BOM against item {0},Vinsamlegast veldu BOM gegn hlut {0},
Please select BOM for Item in Row {0},Vinsamlegast veldu BOM fyrir lið í Row {0},
Please select BOM in BOM field for Item {0},Vinsamlegast veldu BOM á BOM sviði í lið {0},
Please select Category first,Vinsamlegast veldu Flokkur fyrst,
Please select Charge Type first,Vinsamlegast veldu Charge Tegund fyrst,
Please select Company,Vinsamlegast veldu Company,
Please select Company and Designation,Vinsamlegast veldu fyrirtæki og tilnefningu,
Please select Company and Party Type first,Vinsamlegast veldu Company og Party Gerð fyrst,
Please select Company and Posting Date to getting entries,Vinsamlegast veldu félags og póstsetningu til að fá færslur,
Please select Company first,Vinsamlegast veldu Company fyrst,
Please select Completion Date for Completed Asset Maintenance Log,Vinsamlegast veldu Lokadagsetning fyrir lokaðan rekstrarskrá,
Please select Completion Date for Completed Repair,Vinsamlegast veldu Lokadagsetning fyrir lokið viðgerð,
Please select Course,Vinsamlegast veldu Námskeið,
Please select Drug,Vinsamlegast veldu Drug,
Please select Employee,Vinsamlegast veldu Starfsmaður,
Please select Employee Record first.,Vinsamlegast veldu Starfsmaður Taka fyrst.,
Please select Existing Company for creating Chart of Accounts,Vinsamlegast veldu núverandi fyrirtæki til að búa til töflu yfir reikninga,
Please select Healthcare Service,Vinsamlegast veldu heilsugæsluþjónustu,
"Please select Item where ""Is Stock Item"" is ""No"" and ""Is Sales Item"" is ""Yes"" and there is no other Product Bundle",Vinsamlegast veldu Hlutir sem &quot;Er Stock Item&quot; er &quot;Nei&quot; og &quot;Er Velta Item&quot; er &quot;já&quot; og það er engin önnur vara Bundle,
Please select Maintenance Status as Completed or remove Completion Date,Vinsamlegast veldu Viðhaldsstaða sem Lokið eða fjarlægðu Lokadagsetning,
Please select Party Type first,Vinsamlegast veldu Party Tegund fyrst,
Please select Patient,Vinsamlegast veldu Sjúklingur,
Please select Patient to get Lab Tests,Vinsamlegast veldu Sjúklingur til að fá Lab Tests,
Please select Posting Date before selecting Party,Vinsamlegast veldu dagsetningu birtingar áður en þú velur Party,
Please select Posting Date first,Vinsamlegast veldu dagsetningu birtingar fyrst,
Please select Price List,Vinsamlegast veldu Verðskrá,
Please select Program,Vinsamlegast veldu Forrit,
Please select Qty against item {0},Vinsamlegast veldu Magn á hlut {0},
Please select Sample Retention Warehouse in Stock Settings first,Vinsamlegast veldu sýnishorn varðveisla vörugeymsla í lagerstillingum fyrst,
Please select Start Date and End Date for Item {0},Vinsamlegast veldu Ræsa og lokadag fyrir lið {0},
Please select Student Admission which is mandatory for the paid student applicant,Vinsamlegast veljið Student Entrance sem er skylt fyrir greiddan nemanda,
Please select a BOM,Vinsamlegast veldu BOM,
Please select a Batch for Item {0}. Unable to find a single batch that fulfills this requirement,Vinsamlegast veldu lotu fyrir hlut {0}. Ekki er hægt að finna eina lotu sem uppfyllir þessa kröfu,
Please select a Company,Vinsamlegast veldu Company,
Please select a batch,Vinsamlegast veldu lotu,
Please select a csv file,Vinsamlegast veldu CSV skrá,
Please select a customer,Vinsamlegast veldu viðskiptavin,
Please select a field to edit from numpad,Vinsamlegast veldu reit til að breyta úr numpad,
Please select a table,Vinsamlegast veldu töflu,
Please select a valid Date,Vinsamlegast veldu gild dagsetningu,
Please select a value for {0} quotation_to {1},Vinsamlegast veldu gildi fyrir {0} quotation_to {1},
Please select a warehouse,Vinsamlegast veldu vöruhús,
Please select an item in the cart,Vinsamlegast veldu hlut í körfu,
Please select at least one domain.,Vinsamlegast veldu að minnsta kosti eitt lén.,
Please select correct account,Vinsamlegast veldu réttan reikning,
Please select customer,Vinsamlegast veldu viðskiptavin,
Please select date,Vinsamlegast veldu dagsetningu,
Please select item code,Vinsamlegast veldu atriði kóða,
Please select month and year,Vinsamlegast veldu mánuði og ár,
Please select prefix first,Vinsamlegast veldu forskeyti fyrst,
Please select the Company,Vinsamlegast veldu félagið,
Please select the Company first,Vinsamlegast veldu félagið fyrst,
Please select the Multiple Tier Program type for more than one collection rules.,Vinsamlegast veldu margfeldi tier program tegund fyrir fleiri en eina safn reglur.,
Please select the assessment group other than 'All Assessment Groups',Vinsamlegast veldu matshópinn annað en &#39;Öll matshópa&#39;,
Please select the document type first,Vinsamlegast veldu tegund skjals fyrst,
Please select weekly off day,Vinsamlegast veldu viku burt daginn,
Please select {0},Vinsamlegast veldu {0},
Please select {0} first,Vinsamlegast veldu {0} fyrst,
Please set 'Apply Additional Discount On',Vinsamlegast settu &#39;Virkja Viðbótarupplýsingar afslátt&#39;,
Please set 'Asset Depreciation Cost Center' in Company {0},Vinsamlegast settu &quot;Asset Afskriftir Kostnaður Center&quot; í félaginu {0},
Please set 'Gain/Loss Account on Asset Disposal' in Company {0},Vinsamlegast settu &quot;hagnaður / tap reikning á Asset förgun&quot; í félaginu {0},
Please set Account in Warehouse {0} or Default Inventory Account in Company {1},Vinsamlegast settu reikning í vörugeymslu {0} eða Sjálfgefin birgðareikningur í félaginu {1},
Please set B2C Limit in GST Settings.,Vinsamlegast stilltu B2C takmörk í GST stillingum.,
Please set Company,Vinsamlegast settu fyrirtækið,
Please set Company filter blank if Group By is 'Company',Vinsamlegast stilltu Fyrirtæki sía eyða ef Group By er &#39;Company&#39;,
Please set Default Payroll Payable Account in Company {0},Vinsamlegast settu Default Launaskrá Greiðist reikning í félaginu {0},
Please set Depreciation related Accounts in Asset Category {0} or Company {1},Vinsamlegast settu Fyrningar tengjast Accounts í eignaflokki {0} eða félaginu {1},
Please set Email Address,Vinsamlegast setja netfangið,
Please set GST Accounts in GST Settings,Vinsamlegast settu GST reikninga í GST stillingum,
Please set Hotel Room Rate on {},Vinsamlegast settu herbergi fyrir herbergi á {},
Please set Number of Depreciations Booked,Vinsamlegast settu Fjöldi Afskriftir Bókað,
Please set Unrealized Exchange Gain/Loss Account in Company {0},Vinsamlegast settu óinnleyst kaupgjald / tap reiknings í félaginu {0},
Please set User ID field in an Employee record to set Employee Role,Vinsamlegast settu User ID reit í Starfsmannafélag met að setja Starfsmannafélag hlutverki,
Please set a default Holiday List for Employee {0} or Company {1},Vinsamlegast setja sjálfgefið Holiday lista fyrir Starfsmaður {0} eða fyrirtækis {1},
Please set account in Warehouse {0},Vinsamlegast settu inn reikning í vörugeymslu {0},
Please set an active menu for Restaurant {0},Vinsamlegast stilltu virkan matseðill fyrir Veitingahús {0},
Please set associated account in Tax Withholding Category {0} against Company {1},Vinsamlegast stilltu tengda reikning í skattgreiðsluskilmála {0} gegn félagi {1},
Please set at least one row in the Taxes and Charges Table,Vinsamlegast stilltu að minnsta kosti eina röð í töflunni Skattar og gjöld,
Please set default Cash or Bank account in Mode of Payment {0},Vinsamlegast settu sjálfgefinn Cash eða bankareikning í háttur á greiðslu {0},
Please set default account in Salary Component {0},Vinsamlegast settu sjálfgefin reikningur í laun Component {0},
Please set default customer group and territory in Selling Settings,Vinsamlegast stilltu sjálfgefinn viðskiptavinahóp og landsvæði í Sölustillingar,
Please set default customer in Restaurant Settings,Vinsamlegast stilltu sjálfgefinn viðskiptavin í veitingastaðnum,
Please set default template for Leave Approval Notification in HR Settings.,Vinsamlegast stilltu sjálfgefið sniðmát fyrir leyfi um leyfi fyrir leyfi í HR-stillingum.,
Please set default template for Leave Status Notification in HR Settings.,Vinsamlegast stilltu sjálfgefið sniðmát fyrir skilatilkynningar um leyfi í HR-stillingum.,
Please set default {0} in Company {1},Vinsamlegast settu sjálfgefið {0} í félaginu {1},
Please set filter based on Item or Warehouse,Vinsamlegast settu síuna miðað Item eða Warehouse,
Please set leave policy for employee {0} in Employee / Grade record,Vinsamlegast settu leyfi fyrir starfsmanninn {0} í Starfsmanni / Stigaskrá,
Please set recurring after saving,Vinsamlegast settu endurtekin eftir vistun,
Please set the Company,Vinsamlegast settu fyrirtækið,
Please set the Customer Address,Vinsamlegast stilltu heimilisfang viðskiptavinarins,
Please set the Date Of Joining for employee {0},Vinsamlegast settu Dagsetning Tengingar fyrir starfsmann {0},
Please set the Default Cost Center in {0} company.,Vinsamlega stilltu sjálfgefna kostnaðarmiðstöðina í {0} fyrirtæki.,
Please set the Email ID for the Student to send the Payment Request,Vinsamlegast stilltu netfangið fyrir nemandann til að senda greiðslubeiðni,
Please set the Item Code first,Vinsamlegast settu vörulistann fyrst,
Please set the Payment Schedule,Vinsamlegast stilltu greiðsluáætlunina,
Please set the series to be used.,Vinsamlegast stilltu röðina sem á að nota.,
Please set {0} for address {1},Vinsamlegast stilltu {0} fyrir heimilisfang {1},
Please setup Students under Student Groups,Vinsamlegast settu upp nemendur undir nemendahópum,
Please share your feedback to the training by clicking on 'Training Feedback' and then 'New',Vinsamlegast deildu viðbrögðunum þínum við þjálfunina með því að smella á &#39;Þjálfunarniðurstaða&#39; og síðan &#39;Nýtt&#39;,
Please specify Company,Vinsamlegast tilgreinið Company,
Please specify Company to proceed,Vinsamlegast tilgreinið Company til að halda áfram,
Please specify a valid 'From Case No.',Vinsamlegast tilgreinið gilt &quot;Frá máli nr &#39;,
Please specify a valid Row ID for row {0} in table {1},Vinsamlegast tilgreindu gilt Row skírteini fyrir röð {0} í töflunni {1},
Please specify at least one attribute in the Attributes table,Vinsamlegast tilgreindu að minnsta kosti einn eiginleiki í þeim einkennum töflunni,
Please specify currency in Company,Vinsamlegast tilgreinið gjaldmiðil í félaginu,
Please specify either Quantity or Valuation Rate or both,Vinsamlegast tilgreindu annaðhvort magni eða Verðmat Meta eða bæði,
Please specify from/to range,Vinsamlegast tilgreinið frá / til svið,
Please supply the specified items at the best possible rates,Gefðu tilgreind atriði í besta mögulega verð,
Please update your status for this training event,Vinsamlegast uppfærðu stöðu þína fyrir þennan þjálfunarviðburð,
Please wait 3 days before resending the reminder.,Vinsamlegast bíðið 3 dögum áður en áminningin er send aftur.,
Point of Sale,Sölustaður,
Point-of-Sale,Sölustaður,
Point-of-Sale Profile,Point-af-sölu Profile,
Portal,Portal,
Portal Settings,Portal Stillingar,
Possible Supplier,Möguleg birgir,
Postal Expenses,pósti Útgjöld,
Posting Date,staða Date,
Posting Date cannot be future date,Staða Dagsetning má ekki vera liðinn,
Posting Time,staða Time,
Posting date and posting time is mandatory,Staða dagsetningu og staða tími er nauðsynlegur,
Posting timestamp must be after {0},Staða timestamp verður að vera eftir {0},
Potential opportunities for selling.,Hugsanleg tækifæri til að selja.,
Practitioner Schedule,Practitioner Stundaskrá,
Pre Sales,Forsala,
Preference,Forgangur,
Prescribed Procedures,Fyrirframgreindar aðferðir,
Prescription,Ávísun,
Prescription Dosage,Ávísun Skammtar,
Prescription Duration,Ávísunartími,
Prescriptions,Ávísanir,
Present,Present,
Prev,Fyrri,
Preview,Preview,
Preview Salary Slip,Preview Laun Slip,
Previous Financial Year is not closed,Næstliðnu reikningsári er ekki lokað,
Price,Verð,
Price List,Verðskrá,
Price List Currency not selected,Verðlisti Gjaldmiðill ekki valinn,
Price List Rate,Verðskrá Rate,
Price List master.,Verðskrá húsbóndi.,
Price List must be applicable for Buying or Selling,Verðlisti verður að gilda fyrir að kaupa eða selja,
Price List not found or disabled,Verðlisti fannst ekki eða fatlaður,
Price List {0} is disabled or does not exist,Verðlisti {0} er óvirk eða er ekki til,
Price or product discount slabs are required,Verð eða vöruafsláttarplötur eru nauðsynlegar,
Pricing,verðlagning,
Pricing Rule,verðlagning Regla,
"Pricing Rule is first selected based on 'Apply On' field, which can be Item, Item Group or Brand.","Verðlagning Regla er fyrst valið byggist á &#39;Virkja Á&#39; sviði, sem getur verið Item, Item Group eða Brand.",
"Pricing Rule is made to overwrite Price List / define discount percentage, based on some criteria.","Verðlagning Regla er gert til að skrifa verðskrá / define afsláttur hlutfall, byggt á einhverjum forsendum.",
Pricing Rule {0} is updated,Verðlagsregla {0} er uppfærð,
Pricing Rules are further filtered based on quantity.,Verðlagning Reglurnar eru frekar síuð miðað við magn.,
Primary,Primary,
Primary Address Details,Aðalupplýsingaupplýsingar,
Primary Contact Details,Aðal upplýsingar um tengilið,
Principal Amount,höfuðstóll,
Print Format,Print Format,
Print IRS 1099 Forms,Prentaðu IRS 1099 eyðublöð,
Print Report Card,Prenta skýrslukort,
Print Settings,prentstillingar,
Print and Stationery,Prenta og ritföng,
Print settings updated in respective print format,Prenta uppfærðar í viðkomandi prenta sniði,
Print taxes with zero amount,Prenta skatta með núll upphæð,
Printing and Branding,Prentun og merkingu,
Private Equity,Private Equity,
Privilege Leave,Privilege Leave,
Probation,reynslulausn,
Probationary Period,Reynslutíma,
Procedure,Málsmeðferð,
Process Day Book Data,Afgreiða dagbókargögn,
Process Master Data,Vinnið aðalgögn,
Processing Chart of Accounts and Parties,Afgreiðsla yfir reikninga og aðila,
Processing Items and UOMs,Að vinna úr hlutum og UOMs,
Processing Party Addresses,Afgreiða heimilisföng,
Processing Vouchers,Afgreiðsla fylgiskjala,
Procurement,Öflun,
Produced Qty,Framleitt magn,
Product,Vara,
Product Bundle,vara Bundle,
Product Search,Vöruleit,
Production,Framleiðsla,
Production Item,framleiðsla Item,
Products,Vörur,
Profit and Loss,Hagnaður og tap,
Profit for the year,Hagnaður ársins,
Program,program,
Program in the Fee Structure and Student Group {0} are different.,Forrit í gjaldskrárbyggingu og nemendahópnum {0} eru mismunandi.,
Program {0} does not exist.,Forritið {0} er ekki til.,
Program: ,Forrit:,
Progress % for a task cannot be more than 100.,Progress% fyrir verkefni getur ekki verið meira en 100.,
Project Collaboration Invitation,Project Samvinna Boð,
Project Id,Project Id,
Project Manager,Verkefnastjóri,
Project Name,nafn verkefnis,
Project Start Date,Project Start Date,
Project Status,Project Status,
Project Summary for {0},Yfirlit verkefna fyrir {0},
Project Update.,Verkefnisuppfærsla.,
Project Value,Project Value,
Project activity / task.,Project virkni / verkefni.,
Project master.,Project húsbóndi.,
Project-wise data is not available for Quotation,Project-vitur gögn eru ekki í boði fyrir Tilvitnun,
Projected,Áætlaðar,
Projected Qty,Spáð magn,
Projected Quantity Formula,Reiknuð magnformúla,
Projects,Verkefni,
Property,Property,
Property already added,Eign er þegar bætt við,
Proposal Writing,Tillaga Ritun,
Proposal/Price Quote,Tillaga / Verðtilboð,
Prospecting,Horfur,
Provisional Profit / Loss (Credit),Bráðabirgða Hagnaður / Tap (Credit),
Publications,Rit,
Publish Items on Website,Birta Atriði á vefsvæðinu,
Published,Útgefið,
Publishing,Publishing,
Purchase,Kaup,
Purchase Amount,kaup Upphæð,
Purchase Date,kaupdegi,
Purchase Invoice,kaup Invoice,
Purchase Invoice {0} is already submitted,Purchase Invoice {0} er þegar lögð,
Purchase Manager,kaup Manager,
Purchase Master Manager,Kaup Master Manager,
Purchase Order,Pöntun,
Purchase Order Amount,Upphæð innkaupapöntunar,
Purchase Order Amount(Company Currency),Upphæð innkaupapöntunar (Gjaldmiðill fyrirtækisins),
Purchase Order Date,Dagsetning innkaupapöntunar,
Purchase Order Items not received on time,Innkaupapöntunartilboð sem ekki eru móttekin á réttum tíma,
Purchase Order number required for Item {0},Innkaupapöntunarnúmeri þarf fyrir lið {0},
Purchase Order to Payment,Purchase Order til greiðslu,
Purchase Order {0} is not submitted,Purchase Order {0} er ekki lögð,
Purchase Orders are not allowed for {0} due to a scorecard standing of {1}.,Innkaupapantanir eru ekki leyfðar fyrir {0} vegna punkta sem standa upp á {1}.,
Purchase Orders given to Suppliers.,Purchase Pantanir gefið birgja.,
Purchase Price List,Kaupverðið List,
Purchase Receipt,Kvittun,
Purchase Receipt {0} is not submitted,Kvittun {0} er ekki lögð,
Purchase Tax Template,Kaup Tax sniðmáti,
Purchase User,kaup User,
Purchase orders help you plan and follow up on your purchases,Kaup pantanir hjálpa þér að skipuleggja og fylgja eftir kaupum þínum,
Purchasing,Innkaupastjóri,
Purpose must be one of {0},Tilgangurinn verður að vera einn af {0},
Qty,Magn,
Qty To Manufacture,Magn To Framleiðsla,
Qty Total,Magn Samtals,
Qty for {0},Magn {0},
Qualification,HM,
Quality,Gæði,
Quality Action,Gæðaaðgerð,
Quality Goal.,Gæðamarkmið.,
Quality Inspection,Quality Inspection,
Quality Inspection: {0} is not submitted for the item: {1} in row {2},Gæðaeftirlit: {0} er ekki sent fyrir hlutinn: {1} í röð {2},
Quality Management,Gæðastjórnun,
Quality Meeting,Gæðafundur,
Quality Procedure,Gæðaferli,
Quality Procedure.,Gæðaferli.,
Quality Review,Gæðaúttekt,
Quantity,Magn,
Quantity for Item {0} must be less than {1},Magn í lið {0} verður að vera minna en {1},
Quantity in row {0} ({1}) must be same as manufactured quantity {2},Magn í röð {0} ({1}) verður að vera það sama og framleiddar magn {2},
Quantity must be less than or equal to {0},Magn verður að vera minna en eða jafnt og {0},
Quantity must be positive,Magn verður að vera jákvætt,
Quantity must not be more than {0},Magn má ekki vera meira en {0},
Quantity required for Item {0} in row {1},Magn krafist fyrir lið {0} í röð {1},
Quantity should be greater than 0,Magn ætti að vera meiri en 0,
Quantity to Make,Magn til að gera,
Quantity to Manufacture must be greater than 0.,Magn á Framleiðsla verður að vera hærri en 0.,
Quantity to Produce,Magn til að framleiða,
Quantity to Produce can not be less than Zero,Magn til að framleiða getur ekki verið minna en núll,
Query Options,fyrirspurn Options,
Queued for replacing the BOM. It may take a few minutes.,Í biðstöðu fyrir að skipta um BOM. Það getur tekið nokkrar mínútur.,
Queued for updating latest price in all Bill of Materials. It may take a few minutes.,Í biðstöðu fyrir að uppfæra nýjustu verð í öllum efnisskránni. Það getur tekið nokkrar mínútur.,
Quick Journal Entry,Quick Journal Entry,
Quot Count,Tilvitnun,
Quot/Lead %,Quot / Lead%,
Quotation,Tilvitnun,
Quotation {0} is cancelled,Tilvitnun {0} er hætt,
Quotation {0} not of type {1},Tilvitnun {0} ekki af tegund {1},
Quotations,Tilvitnun,
"Quotations are proposals, bids you have sent to your customers",Tilvitnanir eru tillögur tilboðum þú sendir til viðskiptavina þinna,
Quotations received from Suppliers.,Tilvitnanir berast frá birgja.,
Quotations: ,Tilvitnun:,
Quotes to Leads or Customers.,Quotes að leiðir eða viðskiptavini.,
RFQs are not allowed for {0} due to a scorecard standing of {1},RFQs eru ekki leyfð fyrir {0} vegna þess að stigatafla sem stendur fyrir {1},
Range,Range,
Rate,Gefa,
Rate:,Verð:,
Rating,Einkunn,
Raw Material,Hrátt efni,
Raw Materials,Hráefni,
Raw Materials cannot be blank.,Hráefni má ekki vera auður.,
Re-open,Re-opinn,
Read blog,Lestu blogg,
Read the ERPNext Manual,Lestu ERPNext Manual,
Reading Uploaded File,Lestur hlaðið skrá,
Real Estate,Fasteign,
Reason For Putting On Hold,Ástæða þess að setja í bið,
Reason for Hold,Ástæða bið,
Reason for hold: ,Ástæða bið:,
Receipt,Kvittun,
Receipt document must be submitted,Kvittun skjal skal skilað,
Receivable,viðskiptakröfur,
Receivable Account,viðskiptakröfur Reikningur,
Receive at Warehouse Entry,Móttaka í vörugeymslu,
Received,fékk,
Received On,fékk á,
Received Quantity,Móttekið magn,
Received Stock Entries,Mótteknar hlutabréfaskráningar,
Receiver List is empty. Please create Receiver List,Receiver List er tóm. Vinsamlegast búa Receiver Listi,
Recipients,Viðtakendur,
Reconcile,sætta,
"Record of all communications of type email, phone, chat, visit, etc.","Upptaka af öllum samskiptum sem gerð tölvupósti, síma, spjall, heimsókn o.fl.",
Records,Records,
Redirect URL,Framsendingarslóð,
Ref,Ref,
Ref Date,Ref Dagsetning,
Reference,Tilvísun,
Reference #{0} dated {1},Tilvísun # {0} dagsett {1},
Reference Date,viðmiðunardagur,
Reference Doctype must be one of {0},Tilvísun Doctype verður að vera einn af {0},
Reference Document,Tilvísun Document,
Reference Document Type,Tilvísun skjal tegund,
Reference No & Reference Date is required for {0},Tilvísunarnúmer &amp; Frestdagur er nauðsynlegt fyrir {0},
Reference No and Reference Date is mandatory for Bank transaction,Tilvísun Nei og Frestdagur er nauðsynlegur fyrir banka viðskiptin,
Reference No is mandatory if you entered Reference Date,Tilvísunarnúmer er nauðsynlegt ef þú færð viðmiðunardagur,
Reference No.,Tilvísunarnúmer,
Reference Number,Tilvísunarnúmer,
Reference Owner,Tilvísun eigandi,
Reference Type,Tilvísun Type,
"Reference: {0}, Item Code: {1} and Customer: {2}","Tilvísun: {0}, Liður: {1} og Viðskiptavinur: {2}",
References,Tilvísanir,
Refresh Token,Uppfæra Token,
Region,Region,
Register,Nýskráning,
Reject,Hafna,
Rejected,Hafnað,
Related,Tengdar,
Relation with Guardian1,Tengsl Guardian1,
Relation with Guardian2,Tengsl Guardian2,
Release Date,Útgáfudagur,
Reload Linked Analysis,Endurhlaða tengd greining,
Remaining,eftir,
Remaining Balance,Eftirstöðvar,
Remarks,Athugasemdir,
Reminder to update GSTIN Sent,Áminning um að uppfæra GSTIN Sent,
Remove item if charges is not applicable to that item,Fjarlægja hlut ef gjöld eru ekki við þann lið,
Removed items with no change in quantity or value.,Fjarlægðar atriði með engin breyting á magni eða verðmæti.,
Reopen,Enduropna,
Reorder Level,Uppröðun Level,
Reorder Qty,Uppröðun Magn,
Repeat Customer Revenue,Endurtaka Tekjur viðskiptavinar,
Repeat Customers,endurtaka Viðskiptavinir,
Replace BOM and update latest price in all BOMs,Skiptu um BOM og uppfærðu nýjustu verð í öllum BOMs,
Replied,svaraði,
Replies,Svar,
Report,Skýrsla,
Report Builder,skýrsla Builder,
Report Type,Tegund skýrslu,
Report Type is mandatory,Tegund skýrslu er nauðsynlegur,
Report an Issue,Tilkynna um vandamál,
Reports,Skýrslur,
Reqd By Date,Reqd By Date,
Reqd Qty,Reqd Magn,
Request for Quotation,Beiðni um tilvitnun,
"Request for Quotation is disabled to access from portal, for more check portal settings.","Beiðni um tilvitnun er óvirk til að fá aðgang frá vefsíðunni, fyrir meira Check vefgáttinni stillingar.",
Request for Quotations,Beiðni um tilvitnanir,
Request for Raw Materials,Beiðni um hráefni,
Request for purchase.,Beiðni um kaupin.,
Request for quotation.,Beiðni um tilvitnun.,
Requested Qty,Umbeðin Magn,
"Requested Qty: Quantity requested for purchase, but not ordered.","Umbeðin magn: Magn sem óskað er eftir að kaupa, en ekki pantað.",
Requesting Site,Biður um síðu,
Requesting payment against {0} {1} for amount {2},Biðum greiðslu gegn {0} {1} fyrir upphæð {2},
Requestor,Beiðni,
Required On,Required On,
Required Qty,Required Magn,
Required Quantity,Nauðsynlegt magn,
Reschedule,Skipuleggja,
Research,Rannsókn,
Research & Development,Rannsóknir og þróun,
Researcher,Rannsóknarmaður,
Resend Payment Email,Endursenda Greiðsla tölvupóst,
Reserve Warehouse,Reserve Vörugeymsla,
Reserved Qty,Frátekið magn,
Reserved Qty for Production,Frátekið Magn fyrir framleiðslu,
Reserved Qty for Production: Raw materials quantity to make manufacturing items.,Frátekið magn til framleiðslu: Magn hráefna til að framleiða hluti.,
"Reserved Qty: Quantity ordered for sale, but not delivered.","Frátekið magn: Magn pantað til sölu, en ekki afhent.",
Reserved Warehouse is mandatory for Item {0} in Raw Materials supplied,Frátekið vörugeymsla er skylt að skila vöru {0} í hráefni,
Reserved for manufacturing,Frátekið fyrir framleiðslu,
Reserved for sale,Frátekið til sölu,
Reserved for sub contracting,Fyrirvara fyrir undirverktaka,
Resistant,Þola,
Resolve error and upload again.,Leysa villu og hlaða aftur.,
Response,Svar,
Responsibilities,ábyrgð,
Rest Of The World,Rest of the World,
Restart Subscription,Endurræsa áskrift,
Restaurant,Veitingahús,
Result Date,Niðurstaða dagsetning,
Result already Submitted,Niðurstaða þegar send,
Resume,Halda áfram,
Retail,Smásala,
Retail & Wholesale,Retail &amp; Heildverslun,
Retail Operations,Verslunarrekstur,
Retained Earnings,Óráðstafað eigið fé,
Retention Stock Entry,Varðveisla birgða,
Retention Stock Entry already created or Sample Quantity not provided,Varðveislubréf þegar búið er til eða sýnishorn Magn ekki til staðar,
Return,Return,
Return / Credit Note,Return / Credit Note,
Return / Debit Note,Return / skuldfærslu Note,
Returns,Skil,
Reverse Journal Entry,Reverse Journal Entry,
Review Invitation Sent,Skoðaðu boðin sent,
Review and Action,Endurskoðun og aðgerðir,
Role,Hlutverk,
Rooms Booked,Herbergi bókað,
Root Company,Rótarýfélag,
Root Type,Root Type,
Root Type is mandatory,Root Type er nauðsynlegur,
Root cannot be edited.,Root ekki hægt að breyta.,
Root cannot have a parent cost center,Rót getur ekki hafa foreldri kostnaður miðstöð,
Round Off,umferð Off,
Rounded Total,Ávalur Total,
Route,Route,
Row # {0}: ,Row # {0}:,
Row # {0}: Batch No must be same as {1} {2},Row # {0}: Hópur Nei verður að vera það sama og {1} {2},
Row # {0}: Cannot return more than {1} for Item {2},Row # {0}: Get ekki skila meira en {1} fyrir lið {2},
Row # {0}: Rate cannot be greater than the rate used in {1} {2},Row # {0}: Gengi má ekki vera hærra en hlutfallið sem notað er í {1} {2},
Row # {0}: Returned Item {1} does not exists in {2} {3},Row # {0}: aftur hlut {1} er ekki til í {2} {3},
Row # {0}: Serial No is mandatory,Row # {0}: Serial Nei er nauðsynlegur,
Row # {0}: Serial No {1} does not match with {2} {3},Row # {0}: Serial No {1} passar ekki við {2} {3},
Row #{0} (Payment Table): Amount must be negative,Row # {0} (Greiðsluborð): Magn verður að vera neikvætt,
Row #{0} (Payment Table): Amount must be positive,Row # {0} (Greiðsluborð): Magn verður að vera jákvætt,
Row #{0}: Account {1} does not belong to company {2},Row # {0}: Reikningur {1} tilheyrir ekki fyrirtæki {2},
Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Row # {0}: Úthlutað Magn má ekki vera hærra en útistandandi upphæð.,
"Row #{0}: Asset {1} cannot be submitted, it is already {2}","Row # {0}: Asset {1} er ekki hægt að skila, það er þegar {2}",
Row #{0}: Cannot set Rate if amount is greater than billed amount for Item {1}.,Row # {0}: Ekki er hægt að stilla Rate ef upphæðin er hærri en reiknuð upphæð fyrir lið {1}.,
Row #{0}: Clearance date {1} cannot be before Cheque Date {2},Row # {0}: Úthreinsun dagsetning {1} er ekki hægt áður Ávísun Dagsetning {2},
Row #{0}: Duplicate entry in References {1} {2},Row # {0}: Afrita færslu í tilvísunum {1} {2},
Row #{0}: Expected Delivery Date cannot be before Purchase Order Date,Row # {0}: Væntanlegur Afhendingardagur getur ekki verið fyrir Purchase Order Date,
Row #{0}: Item added,Röð # {0}: Hluti bætt við,
Row #{0}: Journal Entry {1} does not have account {2} or already matched against another voucher,Row # {0}: Journal Entry {1} hefur ekki reikning {2} eða þegar samsvarandi gegn öðrum skírteini,
Row #{0}: Not allowed to change Supplier as Purchase Order already exists,Row # {0}: Ekki leyfilegt að breyta birgi Purchase Order er þegar til,
Row #{0}: Please set reorder quantity,Row # {0}: Vinsamlegast settu pöntunarmark magn,
Row #{0}: Please specify Serial No for Item {1},Row # {0}: Vinsamlegast tilgreinið Serial Nei fyrir lið {1},
Row #{0}: Qty increased by 1,Röð # {0}: Magn jókst um 1,
Row #{0}: Rate must be same as {1}: {2} ({3} / {4}) ,Row # {0}: Gefa skal vera það sama og {1}: {2} ({3} / {4}),
Row #{0}: Reference Document Type must be one of Expense Claim or Journal Entry,Row # {0}: Tilvísun Document Type verður að vera einn af kostnaðarkröfu eða dagbókarfærslu,
"Row #{0}: Reference Document Type must be one of Purchase Order, Purchase Invoice or Journal Entry","Row # {0}: Tilvísun Document Type verður að vera einn af Purchase Order, Purchase Invoice eða Journal Entry",
"Row #{0}: Reference Document Type must be one of Sales Order, Sales Invoice or Journal Entry","Row # {0}: Tilvísun Document Type verður að vera einn af Sales Order, Sales Invoice eða Journal Entry",
Row #{0}: Rejected Qty can not be entered in Purchase Return,Row # {0}: Hafnað Magn er ekki hægt að færa í Purchase aftur,
Row #{0}: Rejected Warehouse is mandatory against rejected Item {1},Row # {0}: Hafnað Warehouse er nauðsynlegur móti hafnað Item {1},
Row #{0}: Reqd by Date cannot be before Transaction Date,Row # {0}: Reqd eftir dagsetningu má ekki vera fyrir viðskiptadag,
Row #{0}: Set Supplier for item {1},Row # {0}: Setja Birgir fyrir lið {1},
Row #{0}: Status must be {1} for Invoice Discounting {2},Röð # {0}: Staðan verður að vera {1} til að fá reikningaafslátt {2},
"Row #{0}: The batch {1} has only {2} qty. Please select another batch which has {3} qty available or split the row into multiple rows, to deliver/issue from multiple batches",Row # {0}: Batch {1} hefur aðeins {2} magn. Vinsamlegast veldu annað lotu sem hefur {3} magn í boði eða skipt röðina í margar línur til að afhenda / gefa út úr mörgum lotum,
Row #{0}: Timings conflicts with row {1},Row # {0}: tímasetning átök með röð {1},
Row #{0}: {1} can not be negative for item {2},Row # {0}: {1} getur ekki verið neikvæð fyrir atriðið {2},
Row No {0}: Amount cannot be greater than Pending Amount against Expense Claim {1}. Pending Amount is {2},Row Engin {0}: Upphæð má ekki vera meiri en Bíður Upphæð á móti kostnað {1} kröfu. Bið Upphæð er {2},
Row {0} : Operation is required against the raw material item {1},Row {0}: Aðgerð er krafist gegn hráefnishlutanum {1},
Row {0}# Allocated amount {1} cannot be greater than unclaimed amount {2},Rú {0} # Úthlutað magn {1} getur ekki verið hærra en óunnið magn {2},
Row {0}# Item {1} cannot be transferred more than {2} against Purchase Order {3},Row {0} # Liður {1} er ekki hægt að flytja meira en {2} gegn innkaupapöntun {3},
Row {0}# Paid Amount cannot be greater than requested advance amount,Row {0} # Greiddur upphæð má ekki vera meiri en óskað eftir upphæð,
Row {0}: Activity Type is mandatory.,Row {0}: Activity Type er nauðsynlegur.,
Row {0}: Advance against Customer must be credit,Row {0}: Advance gegn Viðskiptavinur verður að vera trúnaður,
Row {0}: Advance against Supplier must be debit,Row {0}: Advance gegn Birgir skal gjaldfæra,
Row {0}: Allocated amount {1} must be less than or equals to Payment Entry amount {2},Row {0}: Reiknaðar upphæð {1} verður að vera minna en eða jafngildir Greiðsla Entry upphæð {2},
Row {0}: Allocated amount {1} must be less than or equals to invoice outstanding amount {2},Row {0}: Reiknaðar upphæð {1} verður að vera minna en eða jafnt og til reikning útistandandi upphæð {2},
Row {0}: An Reorder entry already exists for this warehouse {1},Row {0}: An Uppröðun færslu þegar til fyrir þessa vöruhús {1},
Row {0}: Bill of Materials not found for the Item {1},Row {0}: Efnislisti finnst ekki fyrir þar sem efnið {1},
Row {0}: Conversion Factor is mandatory,Row {0}: viðskipta Factor er nauðsynlegur,
Row {0}: Cost center is required for an item {1},Rú {0}: Kostnaðurarmiðstöð er krafist fyrir hlut {1},
Row {0}: Credit entry can not be linked with a {1},Row {0}: Credit færslu er ekki hægt að tengja með {1},
Row {0}: Currency of the BOM #{1} should be equal to the selected currency {2},Row {0}: Gjaldmiðill af BOM # {1} ætti að vera jafn völdu gjaldmiðil {2},
Row {0}: Debit entry can not be linked with a {1},Row {0}: gjaldfærslu ekki hægt að tengja með {1},
Row {0}: Depreciation Start Date is required,Row {0}: Afskriftir upphafsdagur er krafist,
Row {0}: Enter location for the asset item {1},Row {0}: Sláðu inn staðsetning fyrir eignarhlutinn {1},
Row {0}: Exchange Rate is mandatory,Row {0}: Exchange Rate er nauðsynlegur,
Row {0}: Expected Value After Useful Life must be less than Gross Purchase Amount,Row {0}: Vænt verð eftir gagnlegt líf verður að vera lægra en heildsöluverð,
Row {0}: For supplier {0} Email Address is required to send email,Row {0}: Fyrir birgja {0} Netfang þarf að senda tölvupóst,
Row {0}: From Time and To Time is mandatory.,Row {0}: Frá Time og til tími er nauðsynlegur.,
Row {0}: From Time and To Time of {1} is overlapping with {2},Row {0}: Frá tíma og tíma af {1} er skörun við {2},
Row {0}: From time must be less than to time,Röð {0}: Frá tíma verður að vera minna en til tíma,
Row {0}: Hours value must be greater than zero.,Row {0}: Hours verður að vera stærri en núll.,
Row {0}: Invalid reference {1},Row {0}: Ógild vísun {1},
Row {0}: Party / Account does not match with {1} / {2} in {3} {4},Row {0}: Party / Account passar ekki við {1} / {2} í {3} {4},
Row {0}: Party Type and Party is required for Receivable / Payable account {1},Row {0}: Party Gerð og Party er nauðsynlegt fyrir / viðskiptakröfur reikninginn {1},
Row {0}: Payment against Sales/Purchase Order should always be marked as advance,Row {0}: Greiðsla gegn sölu / Purchase Order ætti alltaf að vera merkt sem fyrirfram,
Row {0}: Please check 'Is Advance' against Account {1} if this is an advance entry.,Row {0}: Vinsamlegast athugaðu &#39;Er Advance&#39; gegn reikninginn {1} ef þetta er fyrirfram færslu.,
Row {0}: Please set at Tax Exemption Reason in Sales Taxes and Charges,Röð {0}: Vinsamlegast stillið á skattfrelsisástæða í söluskatti og gjöldum,
Row {0}: Please set the Mode of Payment in Payment Schedule,Röð {0}: Vinsamlegast stilltu greiðslumáta í greiðsluáætlun,
Row {0}: Please set the correct code on Mode of Payment {1},Röð {0}: Vinsamlegast stilltu réttan kóða á greiðslumáta {1},
Row {0}: Qty is mandatory,Row {0}: Magn er nauðsynlegur,
Row {0}: Quality Inspection rejected for item {1},Röð {0}: Gæðaeftirlit hafnað fyrir hlut {1},
Row {0}: UOM Conversion Factor is mandatory,Row {0}: UOM viðskipta Factor er nauðsynlegur,
Row {0}: select the workstation against the operation {1},Rú {0}: veldu vinnustöðina gegn aðgerðinni {1},
Row {0}: {1} Serial numbers required for Item {2}. You have provided {3}.,Row {0}: {1} Raðnúmer er nauðsynlegt fyrir lið {2}. Þú hefur veitt {3}.,
Row {0}: {1} is required to create the Opening {2} Invoices,Row {0}: {1} er nauðsynlegt til að búa til opnun {2} Reikningar,
Row {0}: {1} must be greater than 0,Rú {0}: {1} verður að vera meiri en 0,
Row {0}: {1} {2} does not match with {3},Row {0}: {1} {2} passar ekki við {3},
Row {0}:Start Date must be before End Date,Row {0}: Byrja Bætt verður fyrir lokadagsetningu,
Rows with duplicate due dates in other rows were found: {0},Röð með tvíhliða gjalddaga í öðrum röðum fundust: {0},
Rules for adding shipping costs.,Reglur til að bæta sendingarkostnað.,
Rules for applying pricing and discount.,Reglur um beitingu verðlagningu og afslátt.,
S.O. No.,SO nr,
SGST Amount,SGST upphæð,
SO Qty,SO Magn,
Safety Stock,Safety Stock,
Salary,Laun,
Salary Slip ID,Laun Slip ID,
Salary Slip of employee {0} already created for this period,Laun Slip starfsmanns {0} þegar búin á þessu tímabili,
Salary Slip of employee {0} already created for time sheet {1},Laun Slip starfsmanns {0} þegar búið fyrir tíma blaði {1},
Salary Slip submitted for period from {0} to {1},Launasala lögð fyrir tímabil frá {0} til {1},
Salary Structure Assignment for Employee already exists,Uppbygging launauppbyggingar fyrir starfsmann er þegar til,
Salary Structure Missing,Laun Uppbygging vantar,
Salary Structure must be submitted before submission of Tax Ememption Declaration,Skila þarf uppbyggingu launa áður en skattafrelsisyfirlýsing er lögð fram,
Salary Structure not found for employee {0} and date {1},Launauppbygging fannst ekki fyrir starfsmann {0} og dagsetningu {1},
Salary Structure should have flexible benefit component(s) to dispense benefit amount,Launastyrkur ætti að hafa sveigjanlegan ávinningshluta (hluti) til að afgreiða bætur,
"Salary already processed for period between {0} and {1}, Leave application period cannot be between this date range.","Laun þegar unnin fyrir tímabilið milli {0} og {1}, Skildu umsókn tímabil getur ekki verið á milli þessu tímabili.",
Sales,velta,
Sales Account,Sölureikningur,
Sales Expenses,Sölukostnaður,
Sales Funnel,velta trekt,
Sales Invoice,Reikningar,
Sales Invoice {0} has already been submitted,Velta Invoice {0} hefur þegar verið lögð,
Sales Invoice {0} must be cancelled before cancelling this Sales Order,Velta Invoice {0} verður aflýst áður en hætta þessu Velta Order,
Sales Manager,Sölufulltrúi,
Sales Master Manager,Velta Master Manager,
Sales Order,Sölupöntun,
Sales Order Item,Velta Order Item,
Sales Order required for Item {0},Velta Order krafist fyrir lið {0},
Sales Order to Payment,Velta Order til greiðslu,
Sales Order {0} is not submitted,Velta Order {0} er ekki lögð,
Sales Order {0} is not valid,Velta Order {0} er ekki gilt,
Sales Order {0} is {1},Velta Order {0} er {1},
Sales Orders,velta Pantanir,
Sales Partner,velta Partner,
Sales Pipeline,velta Pipeline,
Sales Price List,Velta Verðskrá,
Sales Return,velta Return,
Sales Summary,Sölusamantekt,
Sales Tax Template,Söluskattur Snið,
Sales Team,velta Team,
Sales User,velta User,
Sales and Returns,Sala og skilar,
Sales campaigns.,Velta herferðir.,
Sales orders are not available for production,Sölufyrirmæli eru ekki tiltæk til framleiðslu,
Salutation,Kveðjan,
Same Company is entered more than once,Sama fyrirtæki er slegið oftar en einu sinni,
Same item cannot be entered multiple times.,Sama atriði er ekki hægt inn mörgum sinnum.,
Same supplier has been entered multiple times,Sama birgir hefur verið slegið mörgum sinnum,
Sample,Dæmi um,
Sample Collection,Sýnishorn,
Sample quantity {0} cannot be more than received quantity {1},Sýni magn {0} getur ekki verið meira en móttekin magn {1},
Sanctioned,bundnar,
Sanctioned Amount,bundnar Upphæð,
Sanctioned Amount cannot be greater than Claim Amount in Row {0}.,Bundnar Upphæð má ekki vera meiri en bótafjárhæðir í Row {0}.,
Sand,Sandur,
Saturday,Laugardagur,
Saved,Vistað,
Saving {0},Vistar {0},
Scan Barcode,Skannaðu strikamerki,
Schedule,Dagskrá,
Schedule Admission,Stundaskrá Aðgangur,
Schedule Course,Dagskrá Námskeið,
Schedule Date,Dagskrá Dags,
Schedule Discharge,Áætlun losun,
Scheduled,áætlunarferðir,
Scheduled Upto,Áætlað Upto,
"Schedules for {0} overlaps, do you want to proceed after skiping overlaped slots ?","Tímaáætlanir fyrir {0} skarast, viltu halda áfram eftir að skipta yfirliða rifa?",
Score cannot be greater than Maximum Score,Score getur ekki verið meiri en hámarks stig,
Score must be less than or equal to 5,Score þarf að vera minna en eða jafnt og 5,
Scorecards,Stigatöflur,
Scrapped,rifið,
Search,leit,
Search Item,leit Item,
Search Item (Ctrl + i),Leitaratriði (Ctrl + i),
Search Results,leitarniðurstöður,
Search Sub Assemblies,Leit Sub þing,
"Search by item code, serial number, batch no or barcode","Leitaðu eftir hlutkóða, raðnúmeri, lotunúmeri eða strikamerki",
"Seasonality for setting budgets, targets etc.","Árstíðum til að setja fjárveitingar, markmið o.fl.",
Secret Key,Secret Key,
Secretary,Ritari,
Section Code,Kóðinn,
Secured Loans,Veðlán,
Securities & Commodity Exchanges,Verðbréf &amp; hrávöru ungmennaskipti,
Securities and Deposits,Verðbréfa,
See All Articles,Sjá allar greinar,
See all open tickets,Sjáðu alla opna miða,
See past orders,Sjá fyrri pantanir,
See past quotations,Sjá tilvitnanir í fortíðina,
Select,Veldu,
Select Alternate Item,Veldu Varahlutir,
Select Attribute Values,Veldu Eiginleikar,
Select BOM,Veldu BOM,
Select BOM and Qty for Production,Veldu BOM og Magn fyrir framleiðslu,
"Select BOM, Qty and For Warehouse","Veldu BOM, magn og vöruhús",
Select Batch,Veldu hópur,
Select Batch No,Veldu lotu nr,
Select Batch Numbers,Veldu hópnúmer,
Select Brand...,Veldu Brand ...,
Select Company,Veldu fyrirtæki,
Select Company...,Veldu Company ...,
Select Customer,Veldu viðskiptavini,
Select Days,Veldu daga,
Select Default Supplier,Veldu Default Birgir,
Select DocType,Veldu DocType,
Select Fiscal Year...,Veldu fjárhagsársins ...,
Select Item (optional),Veldu hlut (valfrjálst),
Select Items based on Delivery Date,Veldu Atriði byggt á Afhendingardagur,
Select Items to Manufacture,Veldu Hlutir til Manufacture,
Select Loyalty Program,Veldu hollusta program,
Select POS Profile,Veldu POS prófíl,
Select Patient,Veldu sjúkling,
Select Possible Supplier,Veldu Möguleg Birgir,
Select Property,Veldu eign,
Select Quantity,Select Magn,
Select Serial Numbers,Veldu raðnúmer,
Select Target Warehouse,Veldu Target Warehouse,
Select Warehouse...,Veldu Warehouse ...,
Select an account to print in account currency,Veldu reikning til að prenta í reiknings gjaldmiðli,
Select an employee to get the employee advance.,Veldu starfsmann til að fá starfsmanninn fyrirfram.,
Select at least one value from each of the attributes.,Veldu að minnsta kosti eitt gildi af hverju eiginleiki.,
Select change amount account,Veldu breyting upphæð reiknings,
Select company first,Veldu fyrirtæki fyrst,
Select items to save the invoice,Veldu atriði til að bjarga reikning,
Select or add new customer,Veldu eða bæta við nýjum viðskiptavin,
Select students manually for the Activity based Group,Veldu nemendur handvirkt fyrir hópinn sem byggir á starfsemi,
Select the customer or supplier.,Veldu viðskiptavininn eða birgirinn.,
Select the nature of your business.,Veldu eðli rekstrar þíns.,
Select the program first,Veldu forritið fyrst,
Select to add Serial Number.,Veldu að bæta við raðnúmeri.,
Select your Domains,Veldu lénin þín,
Selected Price List should have buying and selling fields checked.,Valin verðskrá ætti að hafa keypt og selt reiti skoðuð.,
Sell,Selja,
Selling,Selja,
Selling Amount,Selja upphæð,
Selling Price List,Selja verðskrá,
Selling Rate,Sala hlutfall,
"Selling must be checked, if Applicable For is selected as {0}","Selja verður að vera merkt, ef við á er valið sem {0}",
Selling rate for item {0} is lower than its {1}. Selling rate should be atleast {2},Salahlutfall fyrir atriði {0} er lægra en {1} þess. Sala ætti að vera að minnsta kosti {2},
Send Grant Review Email,Senda Grant Review Email,
Send Now,Senda Nú,
Send SMS,Senda SMS,
Send Supplier Emails,Senda Birgir póst,
Send mass SMS to your contacts,Senda massa SMS til þinn snerting,
Sensitivity,Viðkvæmni,
Sent,sendir,
Serial #,Serial #,
Serial No and Batch,Serial Nei og Batch,
Serial No is mandatory for Item {0},Serial Nei er nauðsynlegur fyrir lið {0},
Serial No {0} does not belong to Batch {1},Raðnúmer {0} tilheyrir ekki batch {1},
Serial No {0} does not belong to Delivery Note {1},Serial Nei {0} ekki tilheyra afhendingarseðlinum {1},
Serial No {0} does not belong to Item {1},Serial Nei {0} ekki tilheyra lið {1},
Serial No {0} does not belong to Warehouse {1},Serial Nei {0} ekki tilheyra Warehouse {1},
Serial No {0} does not belong to any Warehouse,Serial Nei {0} er ekki tilheyra neinum Warehouse,
Serial No {0} does not exist,Serial Nei {0} er ekki til,
Serial No {0} has already been received,Serial Nei {0} hefur þegar borist,
Serial No {0} is under maintenance contract upto {1},Serial Nei {0} er undir viðhald samning uppí {1},
Serial No {0} is under warranty upto {1},Serial Nei {0} er undir ábyrgð uppí {1},
Serial No {0} not found,Serial Nei {0} fannst ekki,
Serial No {0} not in stock,Serial Nei {0} ekki til á lager,
Serial No {0} quantity {1} cannot be a fraction,Serial Nei {0} magn {1} getur ekki verið brot,
Serial Nos Required for Serialized Item {0},Serial Nos Áskilið fyrir serialized lið {0},
Serial Number: {0} is already referenced in Sales Invoice: {1},Raðnúmer: {0} er nú þegar vísað í sölureikning: {1},
Serial Numbers,Raðnúmer,
Serial Numbers in row {0} does not match with Delivery Note,Raðnúmer í röð {0} samsvarar ekki við Afhendingartilkynningu,
Serial no item cannot be a fraction,Serial engin lið getur ekki verið brot,
Serial no {0} has been already returned,Raðnúmer {0} hefur þegar verið skilað,
Serial number {0} entered more than once,Raðnúmer {0} inn oftar en einu sinni,
Serialized Inventory,Serialized Inventory,
Series Updated,Series Uppfært,
Series Updated Successfully,Series Uppfært Tókst,
Series is mandatory,Series er nauðsynlegur,
Series {0} already used in {1},Series {0} nú þegar notuð í {1},
Service,Þjónusta,
Service Expense,þjónusta Expense,
Service Level Agreement,Þjónustustigssamningur,
Service Level Agreement.,Þjónustustigssamningur.,
Service Level.,Þjónustustig.,
Service Stop Date cannot be after Service End Date,Þjónustuskilyrði Dagsetning getur ekki verið eftir þjónustudagsetning,
Service Stop Date cannot be before Service Start Date,Þjónustuskilyrði Dagsetning má ekki vera fyrir þjónustudagsetning,
Services,Þjónusta,
"Set Default Values like Company, Currency, Current Fiscal Year, etc.","Set Default gildi eins Company, Gjaldmiðill, yfirstandandi reikningsári, o.fl.",
Set Details,Setja Upplýsingar,
Set New Release Date,Stilla nýjan útgáfudag,
Set Project and all Tasks to status {0}?,Stilla verkefnið og öll verkefni á stöðuna {0}?,
Set Status,Stilla stöðu,
Set Tax Rule for shopping cart,Setja Tax Regla fyrir körfunni,
Set as Closed,Setja sem lokað,
Set as Completed,Stillt sem lokið,
Set as Default,Setja sem sjálfgefið,
Set as Lost,Setja sem Lost,
Set as Open,Setja sem Open,
Set default inventory account for perpetual inventory,Stilltu sjálfgefinn birgðareikning fyrir varanlegan birgða,
Set default mode of payment,Stilltu sjálfgefið greiðsluaðferð,
Set this if the customer is a Public Administration company.,Stilltu þetta ef viðskiptavinurinn er fyrirtæki í opinberri stjórnsýslu.,
Set {0} in asset category {1} or company {2},Setjið {0} í eignaflokki {1} eða fyrirtæki {2},
"Setting Events to {0}, since the Employee attached to the below Sales Persons does not have a User ID{1}","Stilling viðburðir til {0}, þar sem Starfsmannafélag fylgir að neðan sölufólk er ekki með notendanafn {1}",
Setting defaults,Stillingar sjálfgefið,
Setting up Email,Setja upp tölvupóst,
Setting up Email Account,Setja upp Email Account,
Setting up Employees,Setja upp Starfsmenn,
Setting up Taxes,Setja upp Skattar,
Setting up company,Setur upp fyrirtæki,
Settings,Stillingar,
"Settings for online shopping cart such as shipping rules, price list etc.","Stillingar fyrir online innkaupakörfu ss reglur skipum, verðlista o.fl.",
Settings for website homepage,Stillingar fyrir heimasíðu heimasíðuna,
Settings for website product listing,Stillingar fyrir vöruupplýsingar vefsíðu,
Settled,Sátt,
Setup Gateway accounts.,Skipulag Gateway reikninga.,
Setup SMS gateway settings,Skipulag SMS Gateway stillingar,
Setup cheque dimensions for printing,Skipulag athuga mál fyrir prentun,
Setup default values for POS Invoices,Uppsetningar sjálfgefin gildi fyrir POS-reikninga,
Setup mode of POS (Online / Offline),Uppsetningarhamur POS (Online / Offline),
Setup your Institute in ERPNext,Setjið stofnunina þína í ERPNext,
Share Balance,Hlutabréfaviðskipti,
Share Ledger,Share Ledger,
Share Management,Hlutastýring,
Share Transfer,Hlutaflutningur,
Share Type,Deila Tegund,
Shareholder,Hluthafi,
Ship To State,Skip til ríkis,
Shipments,Sendingar,
Shipping,Sendingar,
Shipping Address,Sendingar Address,
"Shipping Address does not have country, which is required for this Shipping Rule","Sendingar Heimilisfang hefur ekki land, sem er krafist fyrir þessa Shipping Regla",
Shipping rule only applicable for Buying,Sendingarregla gildir aðeins um kaup,
Shipping rule only applicable for Selling,Sendingarregla gildir aðeins um sölu,
Shopify Supplier,Shopify Birgir,
Shopping Cart,Innkaupakerra,
Shopping Cart Settings,Shopping Cart Stillingar,
Short Name,Short Name,
Shortage Qty,skortur Magn,
Show Completed,Sýningu lokið,
Show Cumulative Amount,Sýna uppsöfnuð upphæð,
Show Employee,Sýna starfsmaður,
Show Open,sýna opinn,
Show Opening Entries,Sýna opnunargögn,
Show Payment Details,Sýna greiðsluupplýsingar,
Show Return Entries,Sýna afturfærslur,
Show Salary Slip,Sýna Laun Slip,
Show Variant Attributes,Sýna Variant Eiginleikar,
Show Variants,Sýna afbrigði,
Show closed,Sýna lokaðar,
Show exploded view,Sýna sprauta skjá,
Show only POS,Sýna aðeins POS,
Show unclosed fiscal year's P&L balances,Sýna P &amp; unclosed fjárhagsári er L jafnvægi,
Show zero values,Sýna núll gildi,
Sick Leave,Veikindaleyfi,
Silt,Silt,
Single Variant,Einn afbrigði,
Single unit of an Item.,Single eining hlut.,
"Skipping Leave Allocation for the following employees, as Leave Allocation records already exists against them. {0}","Skipting Leyfi úthlutun fyrir eftirfarandi starfsmenn, þar sem Leyfisúthlutunarskrár eru þegar til á móti þeim. {0}",
"Skipping Salary Structure Assignment for the following employees, as Salary Structure Assignment records already exists against them. {0}",Hoppa yfir verkefnavinnu fyrir eftirfarandi starfsmenn þar sem verkefnaupplýsingar um launauppbyggingu eru þegar til gagnvart þeim. {0},
Slideshow,Slideshow,
Slots for {0} are not added to the schedule,Slots fyrir {0} eru ekki bætt við áætlunina,
Small,Lítil,
Soap & Detergent,Sápa &amp; Þvottaefni,
Software,Hugbúnaður,
Software Developer,Forritari,
Softwares,Hugbúnaður,
Soil compositions do not add up to 100,Jarðvegssamsetningar bæta ekki upp að 100,
Sold,selt,
Some emails are invalid,Sumar tölvupóstar eru ógildar,
Some information is missing,Sumir upplýsingar vantar,
Something went wrong!,Eitthvað fór úrskeiðis!,
"Sorry, Serial Nos cannot be merged","Því miður, Serial Nos ekki hægt sameinuð",
Source,Source,
Source Name,Source Name,
Source Warehouse,Source Warehouse,
Source and Target Location cannot be same,Uppruni og miða á staðsetningu getur ekki verið sama,
Source and target warehouse cannot be same for row {0},Uppspretta og miða vöruhús getur ekki verið það sama fyrir röð {0},
Source and target warehouse must be different,Uppspretta og miða vöruhús verður að vera öðruvísi,
Source of Funds (Liabilities),Uppruni Funds (Skuldir),
Source warehouse is mandatory for row {0},Source vöruhús er nauðsynlegur fyrir röð {0},
Specified BOM {0} does not exist for Item {1},Tilgreint BOM {0} er ekki til fyrir lið {1},
Split,Skipta,
Split Batch,Skipta lotu,
Split Issue,Split Issue,
Sports,Íþróttir,
Staffing Plan {0} already exist for designation {1},Stuðningsáætlun {0} er þegar til tilnefningar {1},
Standard,Standard,
Standard Buying,Standard Buying,
Standard Selling,Standard Selja,
Standard contract terms for Sales or Purchase.,Stöðluð samningsskilyrði til sölu eða kaup.,
Start Date,Upphafsdagur,
Start Date of Agreement can't be greater than or equal to End Date.,Upphafsdagur samkomulags getur ekki verið meiri en eða jöfn lokadagur.,
Start Year,Start Ár,
"Start and end dates not in a valid Payroll Period, cannot calculate {0}","Upphafs- og lokadagsetningar sem eru ekki á gildum launatímabili, geta ekki reiknað {0}",
"Start and end dates not in a valid Payroll Period, cannot calculate {0}.","Upphafs- og lokadagar ekki í gildum launum, geta ekki reiknað út {0}.",
Start date should be less than end date for Item {0},Upphafsdagur ætti að vera minna en lokadagsetningu fyrir lið {0},
Start date should be less than end date for task {0},Upphafsdagur ætti að vera minni en lokadagur fyrir verkefni {0},
Start day is greater than end day in task '{0}',Upphafsdagur er meiri en lokadagur í verkefni &#39;{0}&#39;,
Start on,Byrjaðu á,
State,Ríki,
State/UT Tax,Ríki / UT skattur,
Statement of Account,Reikningsyfirlit,
Status must be one of {0},Staða verður að vera einn af {0},
Stock,Stock,
Stock Adjustment,Stock Leiðrétting,
Stock Analytics,lager Analytics,
Stock Assets,lager Eignir,
Stock Available,Tilboð í boði,
Stock Balance,Stock Balance,
Stock Entries already created for Work Order ,Verðbréfaskráningar sem þegar eru búnar til fyrir vinnuskilaboð,
Stock Entry,Stock Entry,
Stock Entry {0} created,Stock Entry {0} búin,
Stock Entry {0} is not submitted,Stock Entry {0} er ekki lögð,
Stock Expenses,lager Útgjöld,
Stock In Hand,Lager í hendi,
Stock Items,lager vörur,
Stock Ledger,Stock Ledger,
Stock Ledger Entries and GL Entries are reposted for the selected Purchase Receipts,Lager Ledger Entries og GL Færslur eru endurbirt fyrir valin Purchase Kvittanir,
Stock Levels,lager Levels,
Stock Liabilities,lager Skuldir,
Stock Options,Kaupréttir,
Stock Qty,Fjöldi hluta,
Stock Received But Not Billed,Stock mótteknar En ekki skuldfærður,
Stock Reports,lager Skýrslur,
Stock Summary,Stock Yfirlit,
Stock Transactions,lager Viðskipti,
Stock UOM,Stock UOM,
Stock Value,Stock Value,
Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},Stock jafnvægi í Batch {0} verður neikvætt {1} fyrir lið {2} í Warehouse {3},
Stock cannot be updated against Delivery Note {0},Stock Ekki er hægt að uppfæra móti afhendingarseðlinum {0},
Stock cannot be updated against Purchase Receipt {0},Stock Ekki er hægt að uppfæra á móti kvittun {0},
Stock cannot exist for Item {0} since has variants,Stock getur ekki til fyrir lið {0} síðan hefur afbrigði,
Stock transactions before {0} are frozen,Lager viðskipti fyrir {0} eru frystar,
Stop,Hættu,
Stopped,Tappi,
"Stopped Work Order cannot be cancelled, Unstop it first to cancel",Stöðvuð vinnuskilyrði er ekki hægt að hætta við. Stöðva það fyrst til að hætta við,
Stores,verslanir,
Structures have been assigned successfully,Skipulag hefur verið úthlutað með góðum árangri,
Student,Student,
Student Activity,Námsmat,
Student Address,Námsmaður Heimilisfang,
Student Admissions,Student Innlagnir,
Student Attendance,Student Aðsókn,
"Student Batches help you track attendance, assessments and fees for students","Námsmaður Lotur hjálpa þér að fylgjast með mætingu, mat og gjalda fyrir nemendur",
Student Email Address,Student Netfang,
Student Email ID,Student Email ID,
Student Group,Student Group,
Student Group Strength,Styrkur nemendahóps,
Student Group is already updated.,Nemendahópur er þegar uppfærð.,
Student Group or Course Schedule is mandatory,Nemandi hópur eða námskeiði er skylt,
Student Group: ,Nemendahópur:,
Student ID,Student ID,
Student ID: ,Námsmaður:,
Student LMS Activity,LMS virkni nemenda,
Student Mobile No.,Student Mobile No.,
Student Name,Student Name,
Student Name: ,Nafn nemanda:,
Student Report Card,Námsmatsskýrsla,
Student is already enrolled.,Nemandi er nú skráður.,
Student {0} - {1} appears Multiple times in row {2} & {3},Student {0} - {1} birtist mörgum sinnum á röð {2} &amp; {3},
Student {0} does not belong to group {1},Nemandi {0} tilheyrir ekki hópi {1},
Student {0} exist against student applicant {1},Student {0} hendi gegn kæranda nemandi {1},
"Students are at the heart of the system, add all your students","Nemendur eru í hjarta kerfisins, bæta við öllum nemendum",
Sub Assemblies,Sub þing,
Sub Type,Undirgerð,
Sub-contracting,Sub-samningagerð,
Subcontract,Undirverktaka,
Subject,Subject,
Submit,Senda,
Submit Proof,Leggja fram sönnun,
Submit Salary Slip,Senda Laun Slip,
Submit this Work Order for further processing.,Sendu inn þessa vinnu til að fá frekari vinnslu.,
Submit this to create the Employee record,Sendu inn þetta til að búa til starfsmannaskrá,
Submitted orders can not be deleted,Lagðar pantanir ekki hægt að eyða,
Submitting Salary Slips...,Sendi launakort ...,
Subscription,Áskrift,
Subscription Management,Áskriftarstefna,
Subscriptions,Áskriftir,
Subtotal,Samtals,
Successful,Árangursrík,
Successfully Reconciled,tókst Samræmd,
Successfully Set Supplier,Settu Birgðasali vel,
Successfully created payment entries,Búið til greiðslufærslur með góðum árangri,
Successfully deleted all transactions related to this company!,Eytt öll viðskipti sem tengjast þessu fyrirtæki!,
Sum of Scores of Assessment Criteria needs to be {0}.,Summa skora á mat Criteria þarf að vera {0}.,
Sum of points for all goals should be 100. It is {0},Summa stig fyrir allar markmiðum ætti að vera 100. Það er {0},
Summary,Yfirlit,
Summary for this month and pending activities,Samantekt fyrir þennan mánuð og bið starfsemi,
Summary for this week and pending activities,Samantekt fyrir þessa viku og bið starfsemi,
Sunday,Sunnudagur,
Suplier,Suplier,
Suplier Name,suplier Name,
Supplier,Birgir,
Supplier Group,Birgir Group,
Supplier Group master.,Birgir Group húsbóndi.,
Supplier Id,Birgir Id,
Supplier Invoice Date cannot be greater than Posting Date,Birgir Invoice Dagsetning má ekki vera meiri en Staða Dagsetning,
Supplier Invoice No,Birgir Reikningur nr,
Supplier Invoice No exists in Purchase Invoice {0},Birgir Invoice Nei er í kaupa Reikningar {0},
Supplier Name,Nafn birgja,
Supplier Part No,Birgir Part No,
Supplier Quotation,Birgir Tilvitnun,
Supplier Quotation {0} created,Birgir Tilvitnun {0} búin,
Supplier Scorecard,Birgiratafla,
Supplier Warehouse mandatory for sub-contracted Purchase Receipt,Birgir Warehouse nauðsynlegur fyrir undirverktaka Kvittun,
Supplier database.,Birgir gagnagrunni.,
Supplier {0} not found in {1},Birgir {0} fannst ekki í {1},
Supplier(s),Birgir (s),
Supplies made to UIN holders,Birgðir til UIN handhafa,
Supplies made to Unregistered Persons,Birgðasala til óskráðra einstaklinga,
Suppliies made to Composition Taxable Persons,Birgðasali til skattskyldra einstaklinga,
Supply Type,Framboð Tegund,
Support,Stuðningur,
Support Analytics,Stuðningur Analytics,
Support Settings,Stuðningur Stillingar,
Support Tickets,Stuðningur miða,
Support queries from customers.,Stuðningur fyrirspurnir frá viðskiptavinum.,
Susceptible,Viðkvæm,
Sync Master Data,Sync Master Data,
Sync Offline Invoices,Sync Offline Reikningar,
Sync has been temporarily disabled because maximum retries have been exceeded,Samstillingu hefur verið lokað fyrir tímabundið vegna þess að hámarksstraumur hefur verið farið yfir,
Syntax error in condition: {0},Setningafræði í skilningi: {0},
Syntax error in formula or condition: {0},Málskipanarvilla í formúlu eða ástandi: {0},
System Manager,System Manager,
TDS Rate %,TDS hlutfall%,
Tap items to add them here,Pikkaðu á atriði til að bæta þeim við hér,
Target,Target,
Target ({}),Skotmark ({}),
Target On,Target On,
Target Warehouse,Target Warehouse,
Target warehouse is mandatory for row {0},Target vöruhús er nauðsynlegur fyrir röð {0},
Task,Verkefni,
Tasks,Verkefni,
Tasks have been created for managing the {0} disease (on row {1}),Verkefni hafa verið búnar til til að stjórna {0} sjúkdómnum (í röð {1}),
Tax,Tax,
Tax Assets,skattinneign,
Tax Category,Skattaflokkur,
Tax Category for overriding tax rates.,Skattaflokkur fyrir framhjá skatthlutföllum.,
"Tax Category has been changed to ""Total"" because all the Items are non-stock items",Skattflokki hefur verið breytt í &quot;Samtals&quot; vegna þess að öll atriðin eru hlutir sem ekki eru hlutir,
Tax ID,Tax ID,
Tax Id: ,Skattur:,
Tax Rate,Skatthlutfall,
Tax Rule Conflicts with {0},Tax regla Árekstrar með {0},
Tax Rule for transactions.,Tax Regla fyrir viðskiptum.,
Tax Template is mandatory.,Tax Snið er nauðsynlegur.,
Tax Withholding rates to be applied on transactions.,Skattgreiðslur sem eiga við um viðskipti.,
Tax template for buying transactions.,Tax sniðmát fyrir að kaupa viðskiptum.,
Tax template for item tax rates.,Skatta sniðmát fyrir skatthlutföll hlutar.,
Tax template for selling transactions.,Tax sniðmát til að selja viðskiptum.,
Taxable Amount,Skattskyld fjárhæð,
Taxes,Skattar,
Team Updates,Team uppfærslur,
Technology,Tækni,
Telecommunications,Fjarskipti,
Telephone Expenses,Sími Útgjöld,
Television,Sjónvarp,
Template Name,Sniðmát Nafn,
Template of terms or contract.,Snið af skilmálum eða samningi.,
Templates of supplier scorecard criteria.,Sniðmát af forsendukortum.,
Templates of supplier scorecard variables.,Sniðmát af birgðatölumörkum.,
Templates of supplier standings.,Sniðmát af birgðastöðu.,
Temporarily on Hold,Tímabundið í bið,
Temporary,tímabundin,
Temporary Accounts,tímabundin reikningar,
Temporary Opening,tímabundin Opening,
Terms and Conditions,Skilmálar og skilyrði,
Terms and Conditions Template,Skilmálar og skilyrði Snið,
Territory,Territory,
Territory is Required in POS Profile,Svæði er nauðsynlegt í POS prófíl,
Test,Próf,
Thank you,Þakka þér,
Thank you for your business!,Takk fyrir viðskiptin!,
The 'From Package No.' field must neither be empty nor it's value less than 1.,&quot;Frá pakkningarnúmerinu&quot; sviði verður hvorki að vera tómt né það er minna en 1.,
The Brand,The Brand,
The Item {0} cannot have Batch,The Item {0} getur ekki Hópur,
The Loyalty Program isn't valid for the selected company,Hollusta Programið er ekki gild fyrir völdu fyrirtæki,
The Payment Term at row {0} is possibly a duplicate.,Greiðslutími í röð {0} er hugsanlega afrit.,
The Term End Date cannot be earlier than the Term Start Date. Please correct the dates and try again.,Hugtakið Lokadagur getur ekki verið fyrr en Term Start Date. Vinsamlega leiðréttu dagsetningar og reyndu aftur.,
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.,Hugtakið Lokadagur getur ekki verið síðar en árslok Dagsetning skólaárið sem hugtakið er tengt (skólaárið {}). Vinsamlega leiðréttu dagsetningar og reyndu aftur.,
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.,Hugtakið Start Date getur ekki verið fyrr en árið upphafsdagur skólaárið sem hugtakið er tengt (skólaárið {}). Vinsamlega leiðréttu dagsetningar og reyndu aftur.,
The Year End Date cannot be earlier than the Year Start Date. Please correct the dates and try again.,The Year End Date getur ekki verið fyrr en árið Start Date. Vinsamlega leiðréttu dagsetningar og reyndu aftur.,
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.,Upphæðin {0} í þessari greiðslubeiðni er frábrugðin reiknuðu upphæð allra greiðsluáætlana: {1}. Gakktu úr skugga um að þetta sé rétt áður en skjalið er sent.,
The day(s) on which you are applying for leave are holidays. You need not apply for leave.,Daginn (s) sem þú ert að sækja um leyfi eru frí. Þú þarft ekki að sækja um leyfi.,
The field From Shareholder cannot be blank,Svæðið frá Hluthafi getur ekki verið auður,
The field To Shareholder cannot be blank,Reitinn til hluthafa má ekki vera auður,
The fields From Shareholder and To Shareholder cannot be blank,Reitirnir frá hluthafa og hluthöfum geta ekki verið auður,
The folio numbers are not matching,Folio númerin passa ekki saman,
The holiday on {0} is not between From Date and To Date,The frídagur á {0} er ekki á milli Frá Dagsetning og hingað,
The name of the institute for which you are setting up this system.,The nafn af the Institute sem þú ert að setja upp þetta kerfi.,
The name of your company for which you are setting up this system.,Nafn fyrirtækis þíns sem þú ert að setja upp þetta kerfi.,
The number of shares and the share numbers are inconsistent,Fjöldi hluta og hlutanúmer eru ósamræmi,
The payment gateway account in plan {0} is different from the payment gateway account in this payment request,Greiðslugátt reikningsins í áætluninni {0} er frábrugðin greiðslugáttarkonto í þessari greiðslubeiðni,
The request for quotation can be accessed by clicking on the following link,Beiðni um tilvitnun er hægt að nálgast með því að smella á eftirfarandi tengil,
The selected BOMs are not for the same item,Völdu BOMs eru ekki fyrir sama hlut,
The selected item cannot have Batch,Valið atriði getur ekki Hópur,
The seller and the buyer cannot be the same,Seljandi og kaupandi geta ekki verið þau sömu,
The shareholder does not belong to this company,Hluthafi er ekki tilheyrandi þessum fyrirtækjum,
The shares already exist,Hlutin eru þegar til,
The shares don't exist with the {0},Hlutarnir eru ekki til með {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",Verkefnið hefur verið unnið sem bakgrunnsstarf. Ef eitthvað er um vinnslu í bakgrunni mun kerfið bæta við athugasemd um villuna við þessa hlutafjársátt og fara aftur í drög að stigi,
"Then Pricing Rules are filtered out based on Customer, Customer Group, Territory, Supplier, Supplier Type, Campaign, Sales Partner etc.","Þá Verðlagning Reglur eru síuð út byggðar á viðskiptavininn, viðskiptavini Group, Territory, Birgir, Birgir Tegund, Campaign, Sales Partner o.fl.",
"There are inconsistencies between the rate, no of shares and the amount calculated","Það eru ósamræmi á milli gengisins, hlutafjár og fjárhæð sem reiknað er út",
There are more holidays than working days this month.,Það eru fleiri frídagar en vinnudögum þessum mánuði.,
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.,Það getur verið margfeldi upphækkunarheimildarþáttur miðað við heildartekjur. En viðskiptatakan fyrir innlausn mun alltaf vera sú sama fyrir alla flokkaupplýsingar.,
There can only be 1 Account per Company in {0} {1},Það getur aðeins verið 1 Account á félaginu í {0} {1},
"There can only be one Shipping Rule Condition with 0 or blank value for ""To Value""",Það getur aðeins verið einn Shipping Rule Ástand með 0 eða autt gildi fyrir &quot;to Value&quot;,
There is no leave period in between {0} and {1},Engin leyfi er á milli {0} og {1},
There is not enough leave balance for Leave Type {0},Það er ekki nóg leyfi jafnvægi um leyfi Tegund {0},
There is nothing to edit.,Það er ekkert að breyta.,
There isn't any item variant for the selected item,Það er ekkert hlutarafbrigði fyrir valda hlutinn,
"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.","Það virðist vera vandamál með GoCardless stillingar miðlara. Ekki hafa áhyggjur, ef bilun verður, þá færðu upphæðin endurgreiðslu á reikninginn þinn.",
There were errors creating Course Schedule,Það voru villur að búa til námskeiði,
There were errors.,Það voru villur.,
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,Þetta atriði er sniðmát og ekki er hægt að nota í viðskiptum. Item eiginleika verður að afrita yfir í afbrigði nema &quot;Enginn Afrita&quot; er sett,
This Item is a Variant of {0} (Template).,Þetta atriði er afbrigði af {0} (sniðmát).,
This Month's Summary,Samantekt þessa mánaðar,
This Week's Summary,Samantekt Í þessari viku er,
This action will stop future billing. Are you sure you want to cancel this subscription?,Þessi aðgerð mun stöðva framtíð innheimtu. Ertu viss um að þú viljir hætta við þessa áskrift?,
This covers all scorecards tied to this Setup,Þetta nær yfir öll stigatöflur sem tengjast þessu skipulagi,
This document is over limit by {0} {1} for item {4}. Are you making another {3} against the same {2}?,Þetta skjal er yfir mörkum með {0} {1} fyrir lið {4}. Ert þú að gera annað {3} gegn sama {2}?,
This is a root account and cannot be edited.,Þetta er rót reikningur og ekki hægt að breyta.,
This is a root customer group and cannot be edited.,Þetta er rót viðskiptavinur hóp og ekki hægt að breyta.,
This is a root department and cannot be edited.,Þetta er rótdeild og er ekki hægt að breyta.,
This is a root healthcare service unit and cannot be edited.,Þetta er rót heilbrigðisþjónustudeild og er ekki hægt að breyta.,
This is a root item group and cannot be edited.,Þetta er rót atriði hóp og ekki hægt að breyta.,
This is a root sales person and cannot be edited.,Þetta er rót velta manneskja og ekki hægt að breyta.,
This is a root supplier group and cannot be edited.,Þetta er rót birgir hópur og er ekki hægt að breyta.,
This is a root territory and cannot be edited.,Þetta er rót landsvæði og ekki hægt að breyta.,
This is an example website auto-generated from ERPNext,Þetta er dæmi website sjálfvirkt mynda frá ERPNext,
This is based on logs against this Vehicle. See timeline below for details,Þetta er byggt á logs gegn þessu ökutæki. Sjá tímalínu hér fyrir nánari upplýsingar,
This is based on stock movement. See {0} for details,Þetta er byggt á lager hreyfingu. Sjá {0} for details,
This is based on the Time Sheets created against this project,Þetta er byggt á tímaskýrslum skapast gagnvart þessu verkefni,
This is based on the attendance of this Employee,Þetta er byggt á mætingu þessa starfsmanns,
This is based on the attendance of this Student,Þetta er byggt á mætingu þessa Student,
This is based on transactions against this Customer. See timeline below for details,Þetta er byggt á viðskiptum móti þessum viðskiptavinar. Sjá tímalínu hér fyrir nánari upplýsingar,
This is based on transactions against this Healthcare Practitioner.,Þetta byggist á viðskiptum gegn þessum heilbrigðisstarfsmanni.,
This is based on transactions against this Patient. See timeline below for details,Þetta byggist á viðskiptum gegn þessum sjúklingum. Sjá tímalínu fyrir neðan til að fá nánari upplýsingar,
This is based on transactions against this Sales Person. See timeline below for details,Þetta byggist á viðskiptum gegn þessum söluaðila. Sjá tímalínu fyrir neðan til að fá nánari upplýsingar,
This is based on transactions against this Supplier. See timeline below for details,Þetta er byggt á viðskiptum móti þessum Birgir. Sjá tímalínu hér fyrir nánari upplýsingar,
This will submit Salary Slips and create accrual Journal Entry. Do you want to proceed?,Þetta mun leggja inn launakostnað og búa til dagbókarfærslu. Viltu halda áfram?,
This {0} conflicts with {1} for {2} {3},Þessi {0} átök með {1} fyrir {2} {3},
Time Sheet for manufacturing.,Tími Sheet fyrir framleiðslu.,
Time Tracking,Tími mælingar,
"Time slot skiped, the slot {0} to {1} overlap exisiting slot {2} to {3}","Tímaspjald sleppt, raufinn {0} til {1} skarast á raufinn {2} í {3}",
Time slots added,Tími rifa bætt við,
Time(in mins),Tími (í mín),
Timer,Tímamælir,
Timer exceeded the given hours.,Niðurteljari fór yfir tiltekin klukkustund.,
Timesheet,Tímatafla,
Timesheet for tasks.,Timesheet fyrir verkefni.,
Timesheet {0} is already completed or cancelled,Timesheet {0} er þegar lokið eða hætt,
Timesheets,timesheets,
"Timesheets help keep track of time, cost and billing for activites done by your team","Timesheets að halda utan um tíma, kostnað og innheimtu fyrir athafnir gert með lið",
Titles for print templates e.g. Proforma Invoice.,Titlar til prenta sniðmát td Próformareikningur.,
To,Til,
To Address 1,Til að senda 1,
To Address 2,Til að senda 2,
To Bill,Bill,
To Date,Hingað til,
To Date cannot be before From Date,Hingað til er ekki hægt að áður frá dagsetningu,
To Date cannot be less than From Date,Til dagsetning má ekki vera minna en Frá Dagsetning,
To Date must be greater than From Date,Hingað til verður að vera meiri en frá dagsetningu,
To Date should be within the Fiscal Year. Assuming To Date = {0},Til Dagsetning ætti að vera innan fjárhagsársins. Að því gefnu að Dagsetning = {0},
To Datetime,Til Datetime,
To Deliver,til Bera,
To Deliver and Bill,Að skila og Bill,
To Fiscal Year,Til reikningsárs,
To GSTIN,Til GSTIN,
To Party Name,Til nafn aðila,
To Pin Code,Til að pinna kóða,
To Place,Að setja,
To Receive,Til að taka á móti,
To Receive and Bill,Að taka við og Bill,
To State,Að ríkja,
To Warehouse,til Warehouse,
To create a Payment Request reference document is required,Til að búa til greiðslubeiðni þarf viðmiðunarskjal,
To date can not be equal or less than from date,Hingað til er ekki hægt að jafna eða minna en frá þeim degi,
To date can not be less than from date,Hingað til getur ekki verið minna en frá þeim degi,
To date can not greater than employee's relieving date,Hingað til getur ekki verið meiri en lélegur dagsetning starfsmanns,
"To filter based on Party, select Party Type first","Að sía byggt á samningsaðila, velja Party Sláðu fyrst",
"To get the best out of ERPNext, we recommend that you take some time and watch these help videos.","Til að fá það besta út úr ERPNext, mælum við með að þú að taka nokkurn tíma og horfa á þessi hjálp vídeó.",
"To include tax in row {0} in Item rate, taxes in rows {1} must also be included","Til eru skatt í röð {0} í lið gengi, skatta í raðir {1} skal einnig",
To make Customer based incentive schemes.,Til að gera viðskiptavinir byggðar hvatningarkerfi.,
"To merge, following properties must be same for both items","Að sameinast, eftirfarandi eiginleika verða að vera það sama fyrir bæði atriði",
"To not apply Pricing Rule in a particular transaction, all applicable Pricing Rules should be disabled.","Að ekki um Verðlagning reglunni í tilteknu viðskiptum, öll viðeigandi Verðlagning Reglur ætti að vera óvirk.",
"To set this Fiscal Year as Default, click on 'Set as Default'","Til að stilla þessa rekstrarárs sem sjálfgefið, smelltu á &#39;Setja sem sjálfgefið&#39;",
To view logs of Loyalty Points assigned to a Customer.,Til að skoða skrár af hollustustöðum sem eru úthlutað til viðskiptavinar.,
To {0},Til {0},
To {0} | {1} {2},Til {0} | {1} {2},
Toggle Filters,Skiptu um síur,
Too many columns. Export the report and print it using a spreadsheet application.,Of margir dálkar. Flytja skýrslu og prenta það með töflureikni.,
Tools,Verkfæri,
Total (Credit),Alls (Credit),
Total (Without Tax),Samtals (án skatta),
Total Absent,alls Absent,
Total Achieved,alls Náð,
Total Actual,alls Raunveruleg,
Total Allocated Leaves,Samtals úthlutað blöð,
Total Amount,Heildarupphæð,
Total Amount Credited,Heildarfjárhæð innheimt,
Total Amount {0},Samtals upphæð {0},
Total Applicable Charges in Purchase Receipt Items table must be same as Total Taxes and Charges,Samtals greiðsla í kvittun atriðum borðið verður að vera það sama og Samtals skatta og gjöld,
Total Budget,Heildaráætlun,
Total Collected: {0},Samtals safnað: {0},
Total Commission,alls Commission,
Total Contribution Amount: {0},Samtals Framlagsmagn: {0},
Total Credit/ Debit Amount should be same as linked Journal Entry,Samtals lánsfé / skuldfærsla ætti að vera eins og tengt dagbókarfærsla,
Total Debit must be equal to Total Credit. The difference is {0},Alls skuldfærsla verður að vera jöfn Total Credit. Munurinn er {0},
Total Deduction,Samtals Frádráttur,
Total Invoiced Amount,Alls Upphæð á reikningi,
Total Leaves,Samtals Leaves,
Total Order Considered,Pöntunin Talin,
Total Order Value,Pöntunin Value,
Total Outgoing,alls Outgoing,
Total Outstanding,Samtals framúrskarandi,
Total Outstanding Amount,Heildarstöðu útistandandi,
Total Outstanding: {0},Samtals framúrskarandi: {0},
Total Paid Amount,Samtals greitt upphæð,
Total Payment Amount in Payment Schedule must be equal to Grand / Rounded Total,Samtals greiðslugjald í greiðsluáætlun verður að vera jafnt við Grand / Rounded Total,
Total Payments,Heildargreiðslur,
Total Present,alls Present,
Total Qty,Total Magn,
Total Quantity,Heildarfjöldi,
Total Revenue,heildartekjum,
Total Student,Samtals nemandi,
Total Target,alls Target,
Total Tax,Total Tax,
Total Taxable Amount,Heildarskattskyld fjárhæð,
Total Taxable Value,Heildar skattskyld gildi,
Total Unpaid: {0},Samtals Ógreitt: {0},
Total Variance,alls Dreifni,
Total Weightage of all Assessment Criteria must be 100%,Alls weightage allra Námsmat Criteria verður að vera 100%,
Total advance ({0}) against Order {1} cannot be greater than the Grand Total ({2}),Total fyrirfram ({0}) gegn Order {1} er ekki vera meiri en GRAND Samtals ({2}),
Total advance amount cannot be greater than total claimed amount,Samtals fyrirfram upphæð getur ekki verið hærri en heildarfjölda krafna,
Total advance amount cannot be greater than total sanctioned amount,Heildarfjöldi fyrirframgreiðslna má ekki vera hærri en heildarfjárhæðir,
Total allocated leaves are more days than maximum allocation of {0} leave type for employee {1} in the period,Samtals úthlutað lauf eru fleiri dagar en hámarks úthlutun {0} ferðaþáttur fyrir starfsmanninn {1} á tímabilinu,
Total allocated leaves are more than days in the period,Samtals úthlutað Blöðin eru fleiri en dagar á tímabilinu,
Total allocated percentage for sales team should be 100,Samtals úthlutað hlutfall fyrir Söluteymi ætti að vera 100,
Total cannot be zero,Alls má ekki vera núll,
Total contribution percentage should be equal to 100,Heildarframlagshlutfall ætti að vera jafnt og 100,
Total flexible benefit component amount {0} should not be less than max benefits {1},Heildarupphæð sveigjanlegs ávinningshluta {0} ætti ekki að vera minni en hámarksbætur {1},
Total hours: {0},Total hours: {0},
Total leaves allocated is mandatory for Leave Type {0},Heildarlaun úthlutað er nauðsynlegt fyrir Leyfi Type {0},
Total weightage assigned should be 100%. It is {0},Alls weightage úthlutað ætti að vera 100%. Það er {0},
Total working hours should not be greater than max working hours {0},Samtals vinnutími ætti ekki að vera meiri en max vinnutíma {0},
Total {0} ({1}),Alls {0} ({1}),
"Total {0} for all items is zero, may be you should change 'Distribute Charges Based On'","Alls {0} á öllum hlutum er núll, getur verið að þú ættir að breyta &#39;Úthluta Gjöld Byggt á&#39;",
Total(Amt),Alls (Amt),
Total(Qty),Alls (Magn),
Traceability,Rekjanleiki,
Traceback,Rekja aftur,
Track Leads by Lead Source.,Fylgjast með leiðsögn með leiðsögn.,
Training,Þjálfun,
Training Event,Þjálfun Event,
Training Events,Þjálfun viðburðir,
Training Feedback,Þjálfun Feedback,
Training Result,Þjálfun Niðurstaða,
Transaction,Færsla,
Transaction Date,Færsla Dagsetning,
Transaction Type,Tegund viðskipta,
Transaction currency must be same as Payment Gateway currency,Transaction gjaldmiðli skal vera það sama og Greiðsla Gateway gjaldmiðil,
Transaction not allowed against stopped Work Order {0},Viðskipti ekki leyfð gegn hætt Work Order {0},
Transaction reference no {0} dated {1},Tilvísunarnúmer viðskipta engin {0} dagsett {1},
Transactions,Viðskipti,
Transactions can only be deleted by the creator of the Company,Viðskipti er einungis hægt að eytt af skapara félagsins,
Transfer,Transfer,
Transfer Material,Transfer Efni,
Transfer Type,Flutningsgerð,
Transfer an asset from one warehouse to another,Flytja eign frá einu vöruhúsi til annars,
Transfered,framseldir,
Transferred Quantity,Yfirfærð magn,
Transport Receipt Date,Flutningsdagsetning,
Transport Receipt No,Flutningsskírteini nr,
Transportation,Samgöngur,
Transporter ID,Transporter ID,
Transporter Name,Flutningsaðili Nafn,
Travel,Ferðalög,
Travel Expenses,Ferðakostnaður,
Tree Type,Tree Tegund,
Tree of Bill of Materials,Tré Bill of Materials,
Tree of Item Groups.,Tré Item hópa.,
Tree of Procedures,Verklagstré,
Tree of Quality Procedures.,Tré gæðaaðferða.,
Tree of financial Cost Centers.,Tré fjárhagslegum stoðsviða.,
Tree of financial accounts.,Tré ársreikning.,
Treshold {0}% appears more than once,Treshold {0}% virðist oftar en einu sinni,
Trial Period End Date Cannot be before Trial Period Start Date,Prófunartímabil Lokadagur getur ekki verið fyrir upphafsdag Prófunartímabils,
Trialling,Skrímsli,
Type of Business,Tegund viðskipta,
Types of activities for Time Logs,Tegundir starfsemi fyrir Time Logs,
UOM,UOM,
UOM Conversion factor is required in row {0},UOM viðskipta þáttur er krafist í röð {0},
UOM coversion factor required for UOM: {0} in Item: {1},UOM coversion þáttur sem þarf til UOM: {0} í lið: {1},
URL,URL,
Unable to find DocType {0},Gat ekki fundið DocType {0},
Unable to find exchange rate for {0} to {1} for key date {2}. Please create a Currency Exchange record manually,Ekki er hægt að finna gengi fyrir {0} til {1} fyrir lykilatriði {2}. Vinsamlegast búðu til gjaldeyrisviðskipti handvirkt,
Unable to find score starting at {0}. You need to have standing scores covering 0 to 100,Ekki er hægt að finna stig sem byrjar á {0}. Þú þarft að standa frammistöðu sem nær yfir 0 til 100,
Unable to find variable: ,Ekki tókst að finna breytu:,
Unblock Invoice,Aflokkaðu innheimtu,
Uncheck all,Afhakaðu allt,
Unclosed Fiscal Years Profit / Loss (Credit),Unclosed Fiscal Years Hagnaður / Tap (Credit),
Unit,Unit,
Unit of Measure,Mælieining,
Unit of Measure {0} has been entered more than once in Conversion Factor Table,Mælieiningin {0} hefur verið slegið oftar en einu sinni í viðskipta Factor töflu,
Unknown,óþekkt,
Unpaid,ógreitt,
Unsecured Loans,Ótryggð lán,
Unsubscribe from this Email Digest,Segja upp áskrift að þessum tölvupósti Digest,
Unsubscribed,Afskráður,
Until,þangað,
Unverified Webhook Data,Óvirkt Webhook gögn,
Update Account Name / Number,Uppfæra reikningsnafn / númer,
Update Account Number / Name,Uppfæra reikningsnúmer / nafn,
Update Bank Transaction Dates,Update viðskipta banka Dagsetningar,
Update Cost,Uppfæra Kostnaður,
Update Cost Center Number,Uppfæra kostnaðarmiðstöðvarnúmer,
Update Email Group,Uppfæra Email Group,
Update Items,Uppfæra atriði,
Update Print Format,Uppfæra Prenta Format,
Update Response,Uppfæra svar,
Update bank payment dates with journals.,Uppfæra banka greiðslu dagsetningar með tímaritum.,
Update in progress. It might take a while.,Uppfærsla í gangi. Það gæti tekið smá stund.,
Update rate as per last purchase,Uppfærsla hlutfall eftir síðustu kaupum,
Update stock must be enable for the purchase invoice {0},Uppfæra hlutabréfa verður að vera virk fyrir kaupreikninginn {0},
Updating Variants...,Uppfærir afbrigði ...,
Upload your letter head and logo. (you can edit them later).,Hlaða bréf höfuðið og merki. (Þú getur breytt þeim síðar).,
Upper Income,Efri tekjur,
Use Sandbox,Nota Sandbox,
Used Leaves,Notaðar blöð,
User,Notandi,
User Forum,User Forum,
User ID,notandanafn,
User ID not set for Employee {0},User ID ekki sett fyrir Starfsmaður {0},
User Remark,Notandi Athugasemd,
User has not applied rule on the invoice {0},Notandi hefur ekki beitt reglu á reikninginn {0},
User {0} already exists,Notandi {0} er þegar til,
User {0} created,Notandi {0} búinn til,
User {0} does not exist,User {0} er ekki til,
User {0} doesn't have any default POS Profile. Check Default at Row {1} for this User.,Notandi {0} hefur engin sjálfgefin POS prófíl. Kannaðu sjálfgefið í röð {1} fyrir þennan notanda.,
User {0} is already assigned to Employee {1},User {0} er þegar úthlutað til starfsmanns {1},
User {0} is already assigned to Healthcare Practitioner {1},Notandi {0} er þegar úthlutað heilbrigðisstarfsmanni {1},
Users,Notendur,
Utility Expenses,gagnsemi Útgjöld,
Valid From Date must be lesser than Valid Upto Date.,Gildir frá Dagsetning verður að vera minni en Gildistími dagsetning.,
Valid Till,Gildir til,
Valid from and valid upto fields are mandatory for the cumulative,Gildir frá og gildir upp í reitir eru nauðsynlegir fyrir uppsafnaðan,
Valid from date must be less than valid upto date,Gildir frá dagsetningu verða að vera minni en gildir fram til dagsetninga,
Valid till date cannot be before transaction date,Gildir til dagsetning geta ekki verið fyrir viðskiptadag,
Validity,gildi,
Validity period of this quotation has ended.,Gildistími þessa tilvitnunar er lokið.,
Valuation Rate,verðmat Rate,
Valuation Rate is mandatory if Opening Stock entered,Verðmat Rate er nauðsynlegur ef Opnun Stock inn,
Valuation type charges can not marked as Inclusive,Verðmat gerð gjöld geta ekki merkt sem Inclusive,
Value Or Qty,Gildi eða magn,
Value Proposition,Verðmæti framsetning,
Value for Attribute {0} must be within the range of {1} to {2} in the increments of {3} for Item {4},Gildi fyrir eigind {0} verður að vera innan þeirra marka sem {1} til {2} í þrepum {3} fyrir lið {4},
Value missing,Gildi vantar,
Value must be between {0} and {1},Gildið verður að vera á milli {0} og {1},
"Values of exempt, nil rated and non-GST inward supplies","Gildi undanþeginna, óverðmætra birgða sem eru ekki metin og ekki GST",
Variable,Variable,
Variance,dreifni,
Variance ({}),Tilbrigði ({}),
Variant,Variant,
Variant Attributes,Variant Eiginleikar,
Variant Based On cannot be changed,Ekki er hægt að breyta afbrigði byggðum á,
Variant Details Report,Variant Details Report,
Variant creation has been queued.,Variant sköpun hefur verið í biðstöðu.,
Vehicle Expenses,ökutæki Útgjöld,
Vehicle No,ökutæki Nei,
Vehicle Type,Gerð ökutækis,
Vehicle/Bus Number,Ökutæki / rútu númer,
Venture Capital,Venture Capital,
View Chart of Accounts,Skoða töflu reikninga,
View Fees Records,Skoða gjaldskrár,
View Form,Skoða form,
View Lab Tests,Skoða Lab Próf,
View Leads,Skoða Vísbendingar,
View Ledger,Skoða Ledger,
View Now,skoða Now,
View a list of all the help videos,Skoða lista yfir öll hjálparefni myndbönd,
View in Cart,Skoða í körfu,
Visit report for maintenance call.,Heimsókn skýrslu fyrir símtal viðhald.,
Visit the forums,Heimsókn á umræðunum,
Vital Signs,Lífsmörk,
Volunteer,Sjálfboðaliði,
Volunteer Type information.,Upplýsingar um sjálfboðaliða.,
Volunteer information.,Sjálfboðaliðarupplýsingar.,
Voucher #,skírteini #,
Voucher No,skírteini nr,
Voucher Type,skírteini Type,
WIP Warehouse,WIP Warehouse,
Walk In,Ganga í,
Warehouse can not be deleted as stock ledger entry exists for this warehouse.,Warehouse ekki hægt að eyða eins birgðir höfuðbók færsla er til fyrir þetta vöruhús.,
Warehouse cannot be changed for Serial No.,Warehouse er ekki hægt að breyta fyrir Raðnúmer,
Warehouse is mandatory,Warehouse er nauðsynlegur,
Warehouse is mandatory for stock Item {0} in row {1},Warehouse er nauðsynlegur fyrir hlutabréfum lið {0} í röð {1},
Warehouse not found in the system,Warehouse fannst ekki í kerfinu,
"Warehouse required at Row No {0}, please set default warehouse for the item {1} for the company {2}","Vöruhús krafist á röð nr. {0}, vinsamlegast stilltu sjálfgefið vörugeymsla fyrir hlutinn {1} fyrir fyrirtækið {2}",
Warehouse required for stock Item {0},Warehouse krafist fyrir hlutabréfum lið {0},
Warehouse {0} can not be deleted as quantity exists for Item {1},Warehouse {0} Ekki er hægt að eyða eins magn er fyrir hendi tl {1},
Warehouse {0} does not belong to company {1},Warehouse {0} ekki tilheyra félaginu {1},
Warehouse {0} does not exist,Warehouse {0} er ekki til,
"Warehouse {0} is not linked to any account, please mention the account in  the warehouse record or set default inventory account in company {1}.","Vörugeymsla {0} er ekki tengt neinum reikningi, vinsamlegast tilgreinið reikninginn í vörugeymslunni eða settu sjálfgefið birgðareikning í félaginu {1}.",
Warehouses with child nodes cannot be converted to ledger,Vöruhús með hnúta barn er ekki hægt að breyta í höfuðbók,
Warehouses with existing transaction can not be converted to group.,Vöruhús með núverandi viðskipti er ekki hægt að breyta í hópinn.,
Warehouses with existing transaction can not be converted to ledger.,Vöruhús með núverandi viðskipti er ekki hægt að breyta í höfuðbók.,
Warning,Viðvörun,
Warning: Another {0} # {1} exists against stock entry {2},Viðvörun: Annar {0} # {1} er til gegn hlutabréfum færslu {2},
Warning: Invalid SSL certificate on attachment {0},Viðvörun: Ógild SSL vottorð á viðhengi {0},
Warning: Invalid attachment {0},Viðvörun: Ógild Attachment {0},
Warning: Leave application contains following block dates,Viðvörun: Leyfi umsókn inniheldur eftirfarandi block dagsetningar,
Warning: Material Requested Qty is less than Minimum Order Qty,Viðvörun: Efni Umbeðin Magn er minna en Minimum Order Magn,
Warning: Sales Order {0} already exists against Customer's Purchase Order {1},Viðvörun: Velta Order {0} er þegar til staðar á móti Purchase Order viðskiptavinar {1},
Warning: System will not check overbilling since amount for Item {0} in {1} is zero,Viðvörun: Kerfi mun ekki stöðva overbilling síðan upphæð fyrir lið {0} í {1} er núll,
Warranty,Ábyrgð í,
Warranty Claim,ábyrgð kröfu,
Warranty Claim against Serial No.,Ábyrgð kröfu gegn Raðnúmer,
Website,Vefsíða,
Website Image should be a public file or website URL,Vefsíða Image ætti að vera opinber skrá eða vefslóð,
Website Image {0} attached to Item {1} cannot be found,Vefsíða Image {0} fylgir tl {1} er ekki hægt að finna,
Website Listing,Website Skráning,
Website Manager,Vefsíða Manager,
Website Settings,Vefsíða Stillingar,
Wednesday,miðvikudagur,
Week,Vika,
Weekdays,Virka daga,
Weekly,Vikuleg,
"Weight is mentioned,\nPlease mention ""Weight UOM"" too","Þyngd er getið, \ nVinsamlega nefna &quot;Þyngd UOM&quot; of",
Welcome email sent,Velkomin sendur,
Welcome to ERPNext,Velkomið að ERPNext,
What do you need help with?,Hvað þarftu hjálp við?,
What does it do?,Hvað gerir það?,
Where manufacturing operations are carried.,Hvar framleiðslu aðgerðir eru gerðar.,
"While creating account for child Company {0}, parent account {1} not found. Please create the parent account in corresponding COA",Þegar stofnað var reikning fyrir barnafyrirtækið {0} fannst móðurreikningurinn {1} ekki. Vinsamlegast stofnaðu móðurreikninginn í samsvarandi COA,
White,White,
Wire Transfer,millifærsla,
WooCommerce Products,WooCommerce vörur,
Work In Progress,Verk í vinnslu,
Work Order,Vinna fyrirmæli,
Work Order already created for all items with BOM,Vinna Order þegar búið til fyrir alla hluti með BOM,
Work Order cannot be raised against a Item Template,Vinna Order er ekki hægt að hækka gegn hlutasniðmát,
Work Order has been {0},Vinna pöntun hefur verið {0},
Work Order not created,Vinna Order ekki búið til,
Work Order {0} must be cancelled before cancelling this Sales Order,Vinnuskilyrðin {0} verður að vera aflýst áður en þú hættir þessari sölupöntun,
Work Order {0} must be submitted,Vinnuskilyrði {0} verður að senda inn,
Work Orders Created: {0},Vinna Pantanir Búið til: {0},
Work Summary for {0},Vinna Yfirlit fyrir {0},
Work-in-Progress Warehouse is required before Submit,Work-í-gangi Warehouse er krafist áður Senda,
Workflow,Workflow,
Working,Vinna,
Working Hours,Vinnutími,
Workstation,Workstation,
Workstation is closed on the following dates as per Holiday List: {0},Vinnustöð er lokað á eftirfarandi dögum eins og á Holiday List: {0},
Wrapping up,Klára,
Wrong Password,Rangt lykilorð,
Year start date or end date is overlapping with {0}. To avoid please set company,Ár Upphafsdagur eða lokadagsetning er skörun við {0}. Til að forðast skaltu stilla fyrirtæki,
You are in offline mode. You will not be able to reload until you have network.,Þú ert í offline háttur. Þú munt ekki vera fær um að endurhlaða fyrr en þú hefur net.,
You are not authorized to add or update entries before {0},Þú hefur ekki heimild til að bæta við eða endurnýja færslum áður {0},
You are not authorized to approve leaves on Block Dates,Þú hefur ekki heimild til að samþykkja lauf á Block Dagsetningar,
You are not authorized to set Frozen value,Þú hefur ekki heimild til að setja Frozen gildi,
You are not present all day(s) between compensatory leave request days,Þú ert ekki til staðar allan daginn (s) á milli viðbótardagsbæta,
You can not change rate if BOM mentioned agianst any item,Þú getur ekki breytt hlutfall ef BOM getið agianst hvaða atriði,
You can not enter current voucher in 'Against Journal Entry' column,Þú getur ekki slá núverandi skírteini í &quot;Against dagbókarfærslu &#39;dálki,
You can only have Plans with the same billing cycle in a Subscription,Þú getur aðeins haft áætlanir með sömu innheimtuferli í áskrift,
You can only redeem max {0} points in this order.,Þú getur aðeins innleysað hámark {0} stig í þessari röð.,
You can only renew if your membership expires within 30 days,Þú getur aðeins endurnýjað ef aðild þín rennur út innan 30 daga,
You can only select a maximum of one option from the list of check boxes.,Þú getur aðeins valið hámark einn valkosta af listanum yfir kassa.,
You can only submit Leave Encashment for a valid encashment amount,Þú getur aðeins sent inn skiladæmi fyrir gildan skammtatölu,
You can't redeem Loyalty Points having more value than the Grand Total.,Þú getur ekki leyst inn hollusta stig sem hafa meira gildi en Grand Total.,
You cannot credit and debit same account at the same time,Þú getur ekki kredit-og debetkort sama reikning á sama tíma,
You cannot delete Fiscal Year {0}. Fiscal Year {0} is set as default in Global Settings,Þú getur ekki eytt Fiscal Year {0}. Reikningsár {0} er sett sem sjálfgefið í Global Settings,
You cannot delete Project Type 'External',Þú getur ekki eytt verkefnisgerðinni &#39;ytri&#39;,
You cannot edit root node.,Þú getur ekki breytt rótarkóði.,
You cannot restart a Subscription that is not cancelled.,Þú getur ekki endurræst áskrift sem ekki er lokað.,
You don't have enought Loyalty Points to redeem,Þú hefur ekki nóg hollusta stig til að innleysa,
You have already assessed for the assessment criteria {}.,Þú hefur nú þegar metið mat á viðmiðunum {}.,
You have already selected items from {0} {1},Þú hefur nú þegar valið hluti úr {0} {1},
You have been invited to collaborate on the project: {0},Þér hefur verið boðið að vinna að verkefninu: {0},
You have entered duplicate items. Please rectify and try again.,Þú hefur slegið afrit atriði. Vinsamlegast lagfæra og reyndu aftur.,
You need to be a user other than Administrator with System Manager and Item Manager roles to register on Marketplace.,Þú þarft að vera notandi annar en Stjórnandi með kerfisstjóra og hlutverkastjóra hlutverk til að skrá þig á markaðssvæði.,
You need to be a user with System Manager and Item Manager roles to add users to Marketplace.,Þú þarft að vera notandi með kerfisstjóra og hlutverkastjóra hlutverk til að bæta notendum við markaðssvæði.,
You need to be a user with System Manager and Item Manager roles to register on Marketplace.,Þú þarft að vera notandi með kerfisstjóra og hlutverkastjóra hlutverk til að skrá þig á markaðssvæðinu.,
You need to be logged in to access this page,Þú þarft að vera innskráður til að opna þessa síðu,
You need to enable Shopping Cart,Þú þarft að virkja Shopping Cart,
You will lose records of previously generated invoices. Are you sure you want to restart this subscription?,Þú munt missa skrár af áður búin reikningum. Ertu viss um að þú viljir endurræsa þessa áskrift?,
Your Organization,Stofnunin þín,
Your cart is Empty,Karfan þín er tóm,
Your email address...,Netfangið þitt...,
Your order is out for delivery!,Pöntunin þín er út fyrir afhendingu!,
Your tickets,Miða þinn,
ZIP Code,Póstnúmer,
[Error],[Villa],
[{0}](#Form/Item/{0}) is out of stock,[{0}] (# Form / Item / {0}) er út af lager,
`Freeze Stocks Older Than` should be smaller than %d days.,`Freeze Stocks Eldri Than` ætti að vera minni en% d daga.,
based_on,byggt á,
cannot be greater than 100,getur ekki verið meiri en 100,
disabled user,fatlaður notandi,
"e.g. ""Build tools for builders""",td &quot;Byggja verkfæri fyrir smiðirnir&quot;,
"e.g. ""Primary School"" or ""University""",td &quot;Primary School&quot; eða &quot;University&quot;,
"e.g. Bank, Cash, Credit Card","td Bank, Cash, Credit Card",
hidden,falinn,
modified,breytt,
old_parent,old_parent,
on,á,
{0} '{1}' is disabled,{0} &#39;{1}&#39; er óvirk,
{0} '{1}' not in Fiscal Year {2},{0} &#39;{1}&#39; ekki í Fiscal Year {2},
{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0} ({1}) getur ekki verið meiri en áætlað magn ({2}) í vinnuskilyrðingu {3},
{0} - {1} is inactive student,{0} - {1} er óvirkur nemandi,
{0} - {1} is not enrolled in the Batch {2},{0} - {1} er ekki skráður í lotuna {2},
{0} - {1} is not enrolled in the Course {2},{0} - {1} er ekki skráður í námskeiðið {2},
{0} Budget for Account {1} against {2} {3} is {4}. It will exceed by {5},{0} Fjárhagsáætlun fyrir reikning {1} gegn {2} {3} er {4}. Það mun fara yfir um {5},
{0} Digest,{0} Digest,
{0} Number {1} already used in account {2},{0} Númer {1} þegar notað í reikningi {2},
{0} Request for {1},{0} Beiðni um {1},
{0} Result submittted,{0} Niðurstöður sendar inn,
{0} Serial Numbers required for Item {1}. You have provided {2}.,{0} Serial Numbers krafist fyrir lið {1}. Þú hefur veitt {2}.,
{0} Student Groups created.,{0} Nemendahópar búin til.,
{0} Students have been enrolled,{0} Nemendur hafa verið skráðir,
{0} against Bill {1} dated {2},{0} gegn frumvarpinu {1} dags {2},
{0} against Purchase Order {1},{0} gegn Purchase Order {1},
{0} against Sales Invoice {1},{0} gegn sölureikningi {1},
{0} against Sales Order {1},{0} gegn Velta Order {1},
{0} already allocated for Employee {1} for period {2} to {3},{0} þegar úthlutað fyrir starfsmann {1} fyrir tímabilið {2} til {3},
{0} applicable after {1} working days,{0} gildir eftir {1} virka daga,
{0} asset cannot be transferred,{0} eign er ekki hægt að flytja,
{0} can not be negative,{0} er ekki hægt að neikvæð,
{0} created,{0} búin,
"{0} currently has a {1} Supplier Scorecard standing, and Purchase Orders to this supplier should be issued with caution.",{0} er nú með {1} Birgir Stuðningskort og kauptilboð til þessa birgis skulu gefin út með varúð.,
"{0} currently has a {1} Supplier Scorecard standing, and RFQs to this supplier should be issued with caution.",{0} er nú með {1} Birgir Stuðningskort og RFQs til þessa birgja skal gefa út með varúð.,
{0} does not belong to Company {1},{0} ekki tilheyra félaginu {1},
{0} does not have a Healthcare Practitioner Schedule. Add it in Healthcare Practitioner master,{0} hefur ekki heilbrigðisstarfsmannaskrá. Bættu því við í lækni í heilbrigðisstarfsmanni,
{0} entered twice in Item Tax,{0} slá inn tvisvar í lið Tax,
{0} for {1},{0} fyrir {1},
{0} has been submitted successfully,{0} hefur verið sent inn með góðum árangri,
{0} has fee validity till {1},{0} hefur gjaldgildi til {1},
{0} hours,{0} klukkustundir,
{0} in row {1},{0} í röð {1},
{0} is blocked so this transaction cannot proceed,{0} er læst þannig að þessi viðskipti geta ekki haldið áfram,
{0} is mandatory,{0} er nauðsynlegur,
{0} is mandatory for Item {1},{0} er nauðsynlegur fyrir lið {1},
{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2}.,{0} er nauðsynlegur. Kannski gjaldeyri færsla er ekki búin fyrir {1} til {2}.,
{0} is not a stock Item,{0} er ekki birgðir Item,
{0} is not a valid Batch Number for Item {1},{0} er ekki gild Batch Símanúmer fyrir lið {1},
{0} is not added in the table,{0} er ekki bætt við í töflunni,
{0} is not in Optional Holiday List,{0} er ekki í valfrjálsum frílista,
{0} is not in a valid Payroll Period,{0} er ekki í gildum launum,
{0} is now the default Fiscal Year. Please refresh your browser for the change to take effect.,{0} er nú sjálfgefið Fiscal Year. Vinsamlegast hressa vafrann til að breytingin taki gildi.,
{0} is on hold till {1},{0} er í bið til {1},
{0} item found.,{0} hlutur fannst.,
{0} items found.,{0} hlutir fundust.,
{0} items in progress,{0} atriði í gangi,
{0} items produced,{0} atriði framleitt,
{0} must appear only once,{0} verður að birtast aðeins einu sinni,
{0} must be negative in return document,{0} verður að vera neikvætt í staðinn skjal,
{0} must be submitted,{0} verður að senda inn,
{0} not allowed to transact with {1}. Please change the Company.,{0} Ekki leyft að eiga viðskipti við {1}. Vinsamlegast breyttu félaginu.,
{0} not found for item {1},{0} fannst ekki fyrir lið {1},
{0} parameter is invalid,{0} breytan er ógild,
{0} payment entries can not be filtered by {1},{0} greiðsla færslur er ekki hægt að sía eftir {1},
{0} should be a value between 0 and 100,{0} ætti að vera gildi á milli 0 og 100,
{0} units of [{1}](#Form/Item/{1}) found in [{2}](#Form/Warehouse/{2}),{0} einingar [{1}] (# Form / tl / {1}) fannst í [{2}] (# Form / Warehouse / {2}),
{0} units of {1} needed in {2} on {3} {4} for {5} to complete this transaction.,{0} einingar {1} þörf {2} á {3} {4} fyrir {5} að ljúka þessari færslu.,
{0} units of {1} needed in {2} to complete this transaction.,{0} einingar {1} þörf {2} að ljúka þessari færslu.,
{0} valid serial nos for Item {1},{0} gild raðnúmer nos fyrir lið {1},
{0} variants created.,{0} afbrigði búin til.,
{0} {1} created,{0} {1} búin,
{0} {1} does not exist,{0} {1} er ekki til,
{0} {1} does not exist.,{0} {1} er ekki til.,
{0} {1} has been modified. Please refresh.,{0} {1} hefur verið breytt. Vinsamlegast hressa.,
{0} {1} has not been submitted so the action cannot be completed,{0} {1} hefur ekki verið send inn þannig að aðgerðin er ekki hægt að ljúka,
"{0} {1} is associated with {2}, but Party Account is {3}",{0} {1} tengist {2} en samningsreikningur er {3},
{0} {1} is cancelled or closed,{0} {1} er aflýst eða lokaður,
{0} {1} is cancelled or stopped,{0} {1} er aflýst eða henni hætt,
{0} {1} is cancelled so the action cannot be completed,{0} {1} er lokað þannig að aðgerðin er ekki hægt að ljúka,
{0} {1} is closed,{0} {1} er lokað,
{0} {1} is disabled,{0} {1} er óvirk,
{0} {1} is frozen,{0} {1} er frosinn,
{0} {1} is fully billed,{0} {1} er að fullu innheimt,
{0} {1} is not active,{0} {1} er ekki virkur,
{0} {1} is not associated with {2} {3},{0} {1} tengist ekki {2} {3},
{0} {1} is not present in the parent company,{0} {1} er ekki til staðar í móðurfélaginu,
{0} {1} is not submitted,{0} {1} er ekki lögð,
{0} {1} is {2},{0} {1} er {2},
{0} {1} must be submitted,{0} {1} Leggja skal fram,
{0} {1} not in any active Fiscal Year.,{0} {1} ekki í hvaða virka Fiscal Year.,
{0} {1} status is {2},{0} {1} staðan er {2},
{0} {1}: 'Profit and Loss' type account {2} not allowed in Opening Entry,{0} {1}: &#39;Rekstrarreikningur &quot;tegund reiknings {2} ekki leyfð í Opnun Entry,
{0} {1}: Account {2} cannot be a Group,{0} {1}: Account {2} getur ekki verið Group,
{0} {1}: Account {2} does not belong to Company {3},{0} {1}: Account {2} ekki tilheyra félaginu {3},
{0} {1}: Account {2} is inactive,{0} {1}: Account {2} er óvirkur,
{0} {1}: Accounting Entry for {2} can only be made in currency: {3},{0} {1}: Bókhald Entry fyrir {2} Aðeins er hægt að gera í gjaldmiðli: {3},
{0} {1}: Cost Center is mandatory for Item {2},{0} {1}: Kostnaður Center er nauðsynlegur fyrir lið {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}: Kostnaður Center er nauðsynlegt fyrir &#39;RekstrarliÃ&#39; reikning {2}. Vinsamlegast setja upp sjálfgefið kostnaðarstað til félagsins.,
{0} {1}: Cost Center {2} does not belong to Company {3},{0} {1}: Kostnaður Center {2} ekki tilheyra félaginu {3},
{0} {1}: Customer is required against Receivable account {2},{0} {1}: Viðskiptavini er krafist móti óinnheimt reikninginn {2},
{0} {1}: Either debit or credit amount is required for {2},{0} {1}: Annaðhvort debet- eða kredit upphæð er nauðsynlegt fyrir {2},
{0} {1}: Supplier is required against Payable account {2},{0} {1}: Birgir þörf er á móti ber að greiða reikninginn {2},
{0}% Billed,{0}% Billed,
{0}% Delivered,{0}% Skilað,
"{0}: Employee email not found, hence email not sent","{0}: Starfsmaður tölvupósti fannst ekki, þess vegna email ekki sent",
{0}: From {0} of type {1},{0}: Frá {0} tegund {1},
{0}: From {1},{0}: Frá {1},
{0}: {1} does not exists,{0}: {1} er ekki til,
{0}: {1} not found in Invoice Details table,{0}: {1} fannst ekki í Reikningsupplýsingar töflu,
{} of {},{} af {},
Chat,Spjallaðu,
Completed By,Lokið við,
Conditions,Skilyrði,
County,County,
Day of Week,Vikudagur,
"Dear System Manager,","Kæri System Manager,",
Default Value,sjálfgefna gildið,
Email Group,Tölvupóstur Group,
Fieldtype,Fieldtype,
ID,ID,
Images,Myndir,
Import,innflutningur,
Office,Office,
Passive,Hlutlaus,
Percent,prósent,
Permanent,Varanleg,
Personal,Starfsfólk,
Plant,Plant,
Post,Post,
Postal,pósti,
Postal Code,póstnúmer,
Provider,Útgefandi,
Read Only,Lesið aðeins,
Recipient,Viðtakandi,
Reviews,Umsagnir,
Sender,sendanda,
Shop,Shop,
Subsidiary,Dótturfélag,
There is some problem with the file url: {0},Það er einhver vandamál með skrá url: {0},
Values Changed,Gildi breytt,
or,eða,
Ageing Range 4,Öldrunarsvið 4,
Allocated amount cannot be greater than unadjusted amount,Úthlutað magn getur ekki verið hærra en óleiðrétt fjárhæð,
Allocated amount cannot be negative,Úthlutað magn getur ekki verið neikvætt,
"Difference Account must be a Asset/Liability type account, since this Stock Entry is an Opening Entry",Mismunareikningur verður að vera eignareign / ábyrgðareikningur þar sem þessi hlutabréfafærsla er opnunarfærsla,
Error in some rows,Villa í sumum línum,
Import Successful,Innflutningur tókst,
Please save first,Vinsamlegast vistaðu fyrst,
Price not found for item {0} in price list {1},Verð fannst ekki fyrir hlutinn {0} í verðlistanum {1},
Warehouse Type,Vöruhúsagerð,
'Date' is required,„Dagsetning“ er krafist,
Benefit,Ávinningur,
Budgets,Fjárveitingar,
Bundle Qty,Magn búnt,
Company GSTIN,Fyrirtæki GSTIN,
Company field is required,Fyrirtækjasvið er krafist,
Creating Dimensions...,Býr til víddir ...,
Duplicate entry against the item code {0} and manufacturer {1},Afrit færslu gegn vörukóðanum {0} og framleiðanda {1},
Import Chart Of Accounts from CSV / Excel files,Flytja inn reikningskort úr CSV / Excel skrám,
Invalid GSTIN! The input you've entered doesn't match the GSTIN format for UIN Holders or Non-Resident OIDAR Service Providers,Ógilt GSTIN! Inntakið sem þú slóst inn passar ekki við GSTIN snið fyrir UIN handhafa eða OIDAR þjónustuaðila sem eru ekki búsettir,
Invoice Grand Total,Heildarfjárhæð reikninga,
Last carbon check date cannot be a future date,Síðasti dagsetning kolefnisrannsóknar getur ekki verið framtíðardagsetning,
Make Stock Entry,Gerðu hlutabréfafærslu,
Quality Feedback,Gæði endurgjöf,
Quality Feedback Template,Sniðmát fyrir gæði gæða,
Rules for applying different promotional schemes.,Reglur um beitingu mismunandi kynningarkerfa.,
Shift,Vakt,
Show {0},Sýna {0},
"Special Characters except ""-"", ""#"", ""."", ""/"", ""{"" and ""}"" not allowed in naming series","Sérstafir nema &quot;-&quot;, &quot;#&quot;, &quot;.&quot;, &quot;/&quot;, &quot;{&quot; Og &quot;}&quot; ekki leyfðar í nafngiftiröð",
Target Details,Upplýsingar um markmið,
{0} already has a Parent Procedure {1}.,{0} er þegar með foreldraferli {1}.,
API,API,
Annual,Árleg,
Approved,Samþykkt,
Change,Breyta,
Contact Email,Netfang tengiliðar,
From Date,frá Dagsetning,
Group By,Hópa eftir,
Importing {0} of {1},Flytur inn {0} af {1},
Last Sync On,Síðasta samstilling á,
Naming Series,nafngiftir Series,
No data to export,Engin gögn til útflutnings,
Print Heading,Print fyrirsögn,
Video,Myndband,
% Of Grand Total,% Af Grand Total,
'employee_field_value' and 'timestamp' are required.,Krafist er „starfsmannasviðs“ og „tímamóta“.,
<b>Company</b> is a mandatory filter.,<b>Fyrirtækið</b> er lögboðin sía.,
<b>From Date</b> is a mandatory filter.,<b>Frá Date</b> er lögboðin sía.,
<b>From Time</b> cannot be later than <b>To Time</b> for {0},<b>Frá tíma</b> má ekki vera seinna en <b>til tíma</b> fyrir {0},
<b>To Date</b> is a mandatory filter.,<b>Hingað til</b> er lögboðin sía.,
A new appointment has been created for you with {0},Ný stefna hefur verið búin til fyrir þig með {0},
Account Value,Reikningsgildi,
Account is mandatory to get payment entries,Reikningur er nauðsynlegur til að fá greiðslufærslur,
Account is not set for the dashboard chart {0},Reikningur er ekki stilltur fyrir stjórnborðið {0},
Account {0} does not belong to company {1},Reikningur {0} ekki tilheyra félaginu {1},
Account {0} does not exists in the dashboard chart {1},Reikningur {0} er ekki til í stjórnborði töflunnar {1},
Account: <b>{0}</b> is capital Work in progress and can not be updated by Journal Entry,Reikningur: <b>{0}</b> er höfuðborg Vinna í vinnslu og ekki er hægt að uppfæra hana með færslu dagbókar,
Account: {0} is not permitted under Payment Entry,Reikningur: {0} er ekki leyfður samkvæmt greiðslufærslu,
Accounting Dimension <b>{0}</b> is required for 'Balance Sheet' account {1}.,Bókhaldsvídd <b>{0}</b> er krafist fyrir reikning &#39;Efnahagsreikningur {1}.,
Accounting Dimension <b>{0}</b> is required for 'Profit and Loss' account {1}.,Bókhaldsvídd <b>{0}</b> er krafist fyrir reikninginn &#39;Hagnaður og tap&#39; {1}.,
Accounting Masters,Bókhaldsmeistarar,
Accounting Period overlaps with {0},Reikningstímabil skarast við {0},
Activity,virkni,
Add / Manage Email Accounts.,Bæta við / stjórna email reikningur.,
Add Child,Bæta Child,
Add Loan Security,Bættu við lánsöryggi,
Add Multiple,Bæta við mörgum,
Add Participants,Bæta við þátttakendum,
Add to Featured Item,Bæta við valinn hlut,
Add your review,Bættu við umsögninni þinni,
Add/Edit Coupon Conditions,Bæta við / breyta skilyrðum afsláttarmiða,
Added to Featured Items,Bætt við valin atriði,
Added {0} ({1}),Bætti {0} ({1}),
Address Line 1,Heimilisfang lína 1,
Addresses,Heimilisföng,
Admission End Date should be greater than Admission Start Date.,Lokadagsetning inntöku ætti að vera meiri en upphafsdagur inntöku.,
Against Loan,Gegn láni,
Against Loan:,Gegn láni:,
All,Allt,
All bank transactions have been created,Öll bankaviðskipti hafa verið búin til,
All the depreciations has been booked,Allar afskriftirnar hafa verið bókaðar,
Allocation Expired!,Úthlutun rann út!,
Allow Resetting Service Level Agreement from Support Settings.,Leyfa að endurstilla þjónustustigssamning frá stuðningsstillingum.,
Amount of {0} is required for Loan closure,Fjárhæð {0} er nauðsynleg vegna lokunar lána,
Amount paid cannot be zero,Upphæð greidd getur ekki verið núll,
Applied Coupon Code,Beitt afsláttarmiða kóða,
Apply Coupon Code,Notaðu afsláttarmiða kóða,
Appointment Booking,Ráðningabókun,
"As there are existing transactions against item {0}, you can not change the value of {1}",Eins og það eru núverandi reiðufé gegn færslu {0} er ekki hægt að breyta gildi {1},
Asset Id,Auðkenni eigna,
Asset Value,Eignamat,
Asset Value Adjustment cannot be posted before Asset's purchase date <b>{0}</b>.,Ekki er hægt að bókfæra leiðréttingu eigna fyrir kaupdag eigna <b>{0}</b> .,
Asset {0} does not belongs to the custodian {1},Eignir {0} tilheyra ekki vörsluaðilanum {1},
Asset {0} does not belongs to the location {1},Eignir {0} tilheyra ekki staðsetningunni {1},
At least one of the Applicable Modules should be selected,Að minnsta kosti einn af viðeigandi aðferðum skal valinn,
Atleast one asset has to be selected.,Velja þarf eina eign Atleast.,
Attendance Marked,Mæting merkt,
Attendance has been marked as per employee check-ins,Aðsókn hefur verið merkt samkvæmt innritun starfsmanna,
Authentication Failed,Auðkenning mistókst,
Automatic Reconciliation,Sjálfvirk sátt,
Available For Use Date,Laus til notkunar dagsetningar,
Available Stock,Laus lager,
"Available quantity is {0}, you need {1}","Laus magn er {0}, þú þarft {1}",
BOM 1,BOM 1,
BOM 2,BOM 2,
BOM Comparison Tool,BOM samanburðarverkfæri,
BOM recursion: {0} cannot be child of {1},Endurkoma BOM: {0} getur ekki verið barn af {1},
BOM recursion: {0} cannot be parent or child of {1},Endurkoma BOM: {0} getur ekki verið foreldri eða barn af {1},
Back to Home,Aftur heim,
Back to Messages,Aftur í skilaboð,
Bank Data mapper doesn't exist,Bankagagnagrunnur er ekki til,
Bank Details,Bankaupplýsingar,
Bank account '{0}' has been synchronized,Bankareikningur &#39;{0}&#39; hefur verið samstilltur,
Bank account {0} already exists and could not be created again,Bankareikningur {0} er þegar til og ekki var hægt að stofna hann aftur,
Bank accounts added,Bankareikningum bætt við,
Batch no is required for batched item {0},Lotu nr er krafist fyrir hluti sem er hluti {0},
Billing Date,Innheimtudagur,
Billing Interval Count cannot be less than 1,Greiðslumarkatala getur ekki verið minna en,
Blue,Blue,
Book,Bók,
Book Appointment,Ráðningartímabil,
Brand,vörumerki,
Browse,Vafra,
Call Connected,Hringdu í sambandi,
Call Disconnected,Hringt úr sambandi,
Call Missed,Hringt,
Call Summary,Samantekt símtala,
Call Summary Saved,Samantekt hringingar vistuð,
Cancelled,Hætt við,
Cannot Calculate Arrival Time as Driver Address is Missing.,Ekki hægt að reikna komutíma þar sem netfang ökumanns vantar.,
Cannot Optimize Route as Driver Address is Missing.,Ekki hægt að fínstilla leið þar sem heimilisfang ökumanns vantar.,
"Cannot Unpledge, loan security value is greater than the repaid amount","Ekki hægt að taka saman, öryggisgildi lána er hærra en endurgreidda upphæðin",
Cannot complete task {0} as its dependant task {1} are not ccompleted / cancelled.,Ekki hægt að ljúka verkefni {0} þar sem háð verkefni {1} þess eru ekki felld / hætt.,
Cannot create loan until application is approved,Get ekki stofnað lán fyrr en umsóknin hefur verið samþykkt,
Cannot find a matching Item. Please select some other value for {0}.,Get ekki fundið samsvörun hlut. Vinsamlegast veldu einhverja aðra verðmæti fyrir {0}.,
"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set allowance in Accounts Settings","Ekki hægt að of mikið af hlut {0} í röð {1} meira en {2}. Til að leyfa ofinnheimtu, vinsamlegast stilltu vasapeninga í reikningum",
Cannot unpledge more than {0} qty of {0},Ekki hægt að setja inn meira en {0} magn af {0},
"Capacity Planning Error, planned start time can not be same as end time","Villa við skipulagsgetu, áætlaður upphafstími getur ekki verið sá sami og lokatími",
Categories,Flokkar,
Changes in {0},Breytingar á {0},
Chart,Mynd,
Choose a corresponding payment,Veldu samsvarandi greiðslu,
Click on the link below to verify your email and confirm the appointment,Smelltu á hlekkinn hér að neðan til að staðfesta tölvupóstinn þinn og staðfesta stefnumótið,
Close,Loka,
Communication,Samskipti,
Compact Item Print,Compact Item Prenta,
Company,Fyrirtæki,
Company of asset {0} and purchase document {1} doesn't matches.,Fyrirtæki eignar {0} og kaupa skjal {1} er ekki passar.,
Compare BOMs for changes in Raw Materials and Operations,Berðu saman framleiðslueiningar fyrir breytingar á hráefnum og rekstri,
Compare List function takes on list arguments,Aðgerð bera saman lista tekur á rökrökum,
Complete,Complete,
Completed,Lokið,
Completed Quantity,Lokið magni,
Connect your Exotel Account to ERPNext and track call logs,Tengdu Exotel reikninginn þinn við ERPNext og fylgdu símtalaskrám,
Connect your bank accounts to ERPNext,Tengdu bankareikninga þína við ERPNext,
Contact Seller,Hafðu samband við seljanda,
Continue,Halda áfram,
Cost Center: {0} does not exist,Kostnaðarmiðstöð: {0} er ekki til,
Couldn't Set Service Level Agreement {0}.,Ekki var hægt að setja þjónustustigssamning {0}.,
Country,Land,
Country Code in File does not match with country code set up in the system,Landsnúmer í skrá passar ekki við landsnúmer sem er sett upp í kerfinu,
Create New Contact,Búðu til nýjan tengilið,
Create New Lead,Búðu til nýja blý,
Create Pick List,Búðu til vallista,
Create Quality Inspection for Item {0},Búðu til gæðaskoðun fyrir hlutinn {0},
Creating Accounts...,Býr til reikninga ...,
Creating bank entries...,Býr til bankafærslur ...,
Creating {0},Búa til {0},
Credit limit is already defined for the Company {0},Lánamörk eru þegar skilgreind fyrir fyrirtækið {0},
Ctrl + Enter to submit,Ctrl + Enter til að senda,
Ctrl+Enter to submit,Ctrl + Sláðu inn til að senda inn,
Currency,Gjaldmiðill,
Current Status,Núverandi staða,
Customer PO,Viðskiptavinur PO,
Customize,Sérsníða,
Daily,Daily,
Date,Dagsetning,
Date Range,Tímabil,
Date of Birth cannot be greater than Joining Date.,Fæðingardagur má ekki vera stærri en dagsetningardagur.,
Dear,Ágæti,
Default,Sjálfgefið,
Define coupon codes.,Tilgreindu afsláttarmiða kóða.,
Delayed Days,Seinkaðir dagar,
Delete,Eyða,
Delivered Quantity,Afhent magn,
Delivery Notes,Afhendingartilkynningar,
Depreciated Amount,Afskrifuð fjárhæð,
Description,Lýsing,
Designation,Tilnefning,
Difference Value,Mismunur gildi,
Dimension Filter,Mál sía,
Disabled,Fatlaðir,
Disbursed Amount cannot be greater than loan amount,Útborguð fjárhæð getur ekki verið hærri en lánsfjárhæð,
Disbursement and Repayment,Útborgun og endurgreiðsla,
Distance cannot be greater than 4000 kms,Fjarlægð getur ekki verið meiri en 4000 km,
Do you want to submit the material request,Viltu leggja fram efnisbeiðnina,
Doctype,DocType,
Document {0} successfully uncleared,Skjal {0} tókst ekki að hreinsa,
Download Template,Sækja Snið,
Dr,Dr,
Due Date,Skiladagur,
Duplicate,Afrit,
Duplicate Project with Tasks,Tvítekið verkefni með verkefnum,
Duplicate project has been created,Tvítekið verkefni hefur verið búið til,
E-Way Bill JSON can only be generated from a submitted document,E-Way Bill JSON er aðeins hægt að búa til úr innsendu skjali,
E-Way Bill JSON can only be generated from submitted document,E-Way Bill JSON er aðeins hægt að búa til úr innsendu skjali,
E-Way Bill JSON cannot be generated for Sales Return as of now,Ekki er hægt að búa til e-Way Bill JSON fyrir söluávöxtun frá og með,
ERPNext could not find any matching payment entry,ERPNext gat ekki fundið neina samsvarandi greiðslufærslu,
Earliest Age,Elstu aldur,
Edit Details,Breyta upplýsingum,
Edit Profile,Edit Profile,
Either GST Transporter ID or Vehicle No is required if Mode of Transport is Road,Annaðhvort er ID GST flutningsaðila eða ökutæki nr,
Email,Tölvupóstur,
Email Campaigns,Netfang herferðir,
Employee ID is linked with another instructor,Auðkenni starfsmanna er tengt við annan leiðbeinanda,
Employee Tax and Benefits,Starfsmannaskattur og ávinningur,
Employee is required while issuing Asset {0},Starfsmaður er krafist við útgáfu eigna {0},
Employee {0} does not belongs to the company {1},Starfsmaður {0} tilheyrir ekki fyrirtækinu {1},
Enable Auto Re-Order,Virkja sjálfvirka endurpöntun,
End Date of Agreement can't be less than today.,Lokadagur samnings má ekki vera minni en í dag.,
End Time,End Time,
Energy Point Leaderboard,Leaderboard fyrir orkupunkta,
Enter API key in Google Settings.,Sláðu inn API lykil í Google stillingum.,
Enter Supplier,Sláðu inn söluaðila,
Enter Value,Sláðu gildi,
Entity Type,Einingartegund,
Error,Villa,
Error in Exotel incoming call,Villa við innhringingu Exotel,
Error: {0} is mandatory field,Villa: {0} er skyldur reitur,
Event Link,Atburðartengill,
Exception occurred while reconciling {0},Undantekning átti sér stað við sátt {0},
Expected and Discharge dates cannot be less than Admission Schedule date,Reiknaðir dagsetningar og útskriftardagsetningar geta ekki verið minni en dagsetning inntökudags,
Expire Allocation,Úthluta úthlutun,
Expired,Útrunnið,
Export,Útflutningur,
Export not allowed. You need {0} role to export.,Export ekki leyfð. Þú þarft {0} hlutverki til útflutnings.,
Failed to add Domain,Mistókst að bæta við léninu,
Fetch Items from Warehouse,Sæktu hluti úr vöruhúsinu,
Fetching...,Sækir ...,
Field,Field,
File Manager,File Manager,
Filters,Síur,
Finding linked payments,Finndu tengdar greiðslur,
Finished Product,Lokin vara,
Finished Qty,Lokið magn,
Fleet Management,Lo Stjórn,
Following fields are mandatory to create address:,Eftirfarandi reiti er skylt að búa til heimilisfang:,
For Month,Fyrir mánuð,
"For item {0} at row {1}, count of serial numbers does not match with the picked quantity",Fyrir lið {0} í röð {1} passar fjöldi raðnúmera ekki við valið magn,
For operation {0}: Quantity ({1}) can not be greter than pending quantity({2}),Fyrir notkun {0}: Magn ({1}) getur ekki verið grettara en magn í bið ({2}),
For quantity {0} should not be greater than work order quantity {1},Fyrir magn {0} ætti ekki að vera stærra en magn vinnutilboðs {1},
Free item not set in the pricing rule {0},Ókeypis hlutur er ekki stilltur í verðlagsregluna {0},
From Date and To Date are Mandatory,Frá dagsetningu og til dagsetning er skylt,
From date can not be greater than than To date,Frá dagsetningu getur ekki verið meira en til þessa,
From employee is required while receiving Asset {0} to a target location,Frá starfsmanni er krafist meðan hann fær eign {0} á markstað,
Fuel Expense,Eldsneytisgjöld,
Future Payment Amount,Fjárhæð framtíðar,
Future Payment Ref,Framtíðargreiðsla ref,
Future Payments,Framtíðargreiðslur,
GST HSN Code does not exist for one or more items,GST HSN kóða er ekki til fyrir einn eða fleiri hluti,
Generate E-Way Bill JSON,Búðu til E-Way Bill JSON,
Get Items,fá atriði,
Get Outstanding Documents,Fá framúrskarandi skjöl,
Goal,Markmið,
Greater Than Amount,Meiri en upphæð,
Green,grænn,
Group,Group,
Group By Customer,Hópur eftir viðskiptavini,
Group By Supplier,Hópur eftir birgi,
Group Node,Group Node,
Group Warehouses cannot be used in transactions. Please change the value of {0},Hópgeymsluhús er ekki hægt að nota í viðskiptum. Vinsamlegast breyttu gildi {0},
Help,Hjálp,
Help Article,Hjálp gr,
"Helps you keep tracks of Contracts based on Supplier, Customer and Employee","Hjálpaðu þér að halda utan um samninga sem byggjast á birgi, viðskiptavini og starfsmanni",
Helps you manage appointments with your leads,Hjálpaðu þér að stjórna stefnumótum með leiðtogum þínum,
Home,Home,
IBAN is not valid,IBAN er ekki gilt,
Import Data from CSV / Excel files.,Flytja inn gögn úr CSV / Excel skrám.,
In Progress,Í vinnslu,
Incoming call from {0},Móttekið símtal frá {0},
Incorrect Warehouse,Röng vöruhús,
Interest Amount is mandatory,Vextir eru skyldur,
Intermediate,Intermediate,
Invalid Barcode. There is no Item attached to this barcode.,Ógild strikamerki. Það er enginn hlutur festur við þennan strikamerki.,
Invalid credentials,Ógild skilríki,
Invite as User,Bjóða eins Notandi,
Issue Priority.,Forgangsröð útgáfu.,
Issue Type.,Útgáfutegund.,
"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.",Það virðist sem það er vandamál með rétta stillingu miðlarans. Ef bilun er fyrir hendi verður fjárhæðin endurgreitt á reikninginn þinn.,
Item Reported,Liður tilkynntur,
Item listing removed,Atriðaskráning fjarlægð,
Item quantity can not be zero,Magn vöru getur ekki verið núll,
Item taxes updated,Atvinnuskattar uppfærðir,
Item {0}: {1} qty produced. ,Liður {0}: {1} fjöldi framleiddur.,
Items are required to pull the raw materials which is associated with it.,Atriði eru nauðsynleg til að draga hráefnin sem henni fylgja.,
Joining Date can not be greater than Leaving Date,Tengingardagur má ekki vera stærri en dagsetningardagur,
Lab Test Item {0} already exist,Liður í rannsóknarstofu {0} er þegar til,
Last Issue,Síðasta tölublað,
Latest Age,Síðasta aldur,
Leave application is linked with leave allocations {0}. Leave application cannot be set as leave without pay,Leyfisumsókn er tengd við úthlutunarheimildir {0}. Ekki er hægt að stilla leyfi umsókn sem leyfi án launa,
Leaves Taken,Blöð tekin,
Less Than Amount,Minna en upphæð,
Liabilities,Skuldir,
Loading...,Loading ...,
Loan Amount exceeds maximum loan amount of {0} as per proposed securities,Lánsfjárhæð er hærri en hámarks lánsfjárhæð {0} samkvæmt fyrirhuguðum verðbréfum,
Loan Applications from customers and employees.,Lánaforrit frá viðskiptavinum og starfsmönnum.,
Loan Disbursement,Útborgun lána,
Loan Processes,Lánaferli,
Loan Security,Lánöryggi,
Loan Security Pledge,Veðlán við lánsöryggi,
Loan Security Pledge Company and Loan Company must be same,Veðsetningarlánafyrirtæki og lánafyrirtæki verða að vera eins,
Loan Security Pledge Created : {0},Veðtryggingarlán til útlána búið til: {0},
Loan Security Pledge already pledged against loan {0},Veðtryggingarlán þegar veðsett gegn láni {0},
Loan Security Pledge is mandatory for secured loan,Veðlán við veðlán er skylt fyrir tryggt lán,
Loan Security Price,Lánaöryggisverð,
Loan Security Price overlapping with {0},Öryggisverð lána skarast við {0},
Loan Security Unpledge,Útilokun lánaöryggis,
Loan Security Value,Öryggisgildi lána,
Loan Type for interest and penalty rates,Lántegund fyrir vexti og dráttarvexti,
Loan amount cannot be greater than {0},Lánsfjárhæð getur ekki verið meiri en {0},
Loan is mandatory,Lán er skylt,
Loans,Lán,
Loans provided to customers and employees.,Lán veitt viðskiptavinum og starfsmönnum.,
Location,Staðsetning,
Log Type is required for check-ins falling in the shift: {0}.,Skráargerð er krafist fyrir innritanir sem falla í vaktina: {0}.,
Looks like someone sent you to an incomplete URL. Please ask them to look into it.,Lítur út eins og einhver sent þig til ófullnægjandi vefslóð. Vinsamlegast biðja þá að líta inn í það.,
Make Journal Entry,Gerðu dagbókarfærslu,
Make Purchase Invoice,Gerðu innkaupareikning,
Manufactured,Framleitt,
Mark Work From Home,Merktu vinnu heiman frá,
Master,Master,
Max strength cannot be less than zero.,Hámarksstyrkur getur ekki verið minni en núll.,
Maximum attempts for this quiz reached!,Hámarks tilraunir til þessarar spurningakeppni náðust!,
Message,Skilaboð,
Missing Values Required,Vantar gildi Áskilið,
Mobile No,Mobile Nei,
Mobile Number,Farsímanúmer,
Month,Mánuður,
Name,heiti,
Near you,Nálægt þér,
Net Profit/Loss,Hagnaður / tap,
New Expense,Ný útgjöld,
New Invoice,Nýr reikningur,
New Payment,Ný greiðsla,
New release date should be in the future,Nýr útgáfudagur ætti að vera í framtíðinni,
Newsletter,Fréttabréf,
No Account matched these filters: {},Enginn reikningur passaði við þessar síur: {},
No Employee found for the given employee field value. '{}': {},Enginn starfsmaður fannst fyrir tiltekið gildi starfsmanns. &#39;{}&#39;: {},
No Leaves Allocated to Employee: {0} for Leave Type: {1},Engum laufum úthlutað til starfsmanns: {0} fyrir leyfi Tegund: {1},
No communication found.,Engin samskipti fundust.,
No correct answer is set for {0},Ekkert rétt svar er stillt fyrir {0},
No description,engin lýsing,
No issue has been raised by the caller.,Ekkert mál hefur verið tekið upp af þeim sem hringir.,
No items to publish,Engin atriði til að birta,
No outstanding invoices found,Engir útistandandi reikningar fundust,
No outstanding invoices found for the {0} {1} which qualify the filters you have specified.,Engir útistandandi reikningar fundust fyrir {0} {1} sem fullgilda síurnar sem þú tilgreindir.,
No outstanding invoices require exchange rate revaluation,Engir útistandandi reikningar krefjast endurmats á gengi,
No reviews yet,Engar umsagnir ennþá,
No views yet,Engar skoðanir ennþá,
Non stock items,Hlutir sem ekki eru á lager,
Not Allowed,Ekki leyft,
Not allowed to create accounting dimension for {0},Ekki leyft að búa til bókhaldsvídd fyrir {0},
Not permitted. Please disable the Lab Test Template,Ekki leyfilegt. Vinsamlegast slökkva á Lab prófunar sniðmát,
Note,Note,
Notes: ,Skýringar:,
Offline,offline,
On Converting Opportunity,Um umbreytingu tækifærisins,
On Purchase Order Submission,Við afhendingu innkaupapöntunar,
On Sales Order Submission,Í afhendingu sölupöntunar,
On Task Completion,Í lok verkefnis,
On {0} Creation,Í {0} sköpun,
Only .csv and .xlsx files are supported currently,Aðeins .csv og .xlsx skrár eru studdar eins og er,
Only expired allocation can be cancelled,Aðeins er hægt að hætta við úthlutun,
Only users with the {0} role can create backdated leave applications,Aðeins notendur með {0} hlutverk geta búið til afturdagsleyfisforrit,
Open,Open,
Open Contact,Opinn tengiliður,
Open Lead,Opinn leiðtogi,
Opening and Closing,Opnun og lokun,
Operating Cost as per Work Order / BOM,Rekstrarkostnaður samkvæmt hverri vinnupöntun / BOM,
Order Amount,Panta upphæð,
Page {0} of {1},Page {0} af {1},
Paid amount cannot be less than {0},Greidd upphæð má ekki vera minna en {0},
Parent Company must be a group company,Móðurfélag verður að vera samstæðufyrirtæki,
Passing Score value should be between 0 and 100,Gildistigagildi ætti að vera á milli 0 og 100,
Password policy cannot contain spaces or simultaneous hyphens. The format will be restructured automatically,Lykilorðastefna getur ekki innihaldið bil eða bandstrik samtímis. Sniðið verður endurskipulagt sjálfkrafa,
Patient History,Saga sjúklinga,
Pause,Hlé,
Pay,Greitt,
Payment Document Type,Tegund greiðslu skjals,
Payment Name,Greiðsluheiti,
Penalty Amount,Vítaspyrna,
Pending,Bíður,
Performance,Frammistaða,
Period based On,Tímabil byggt á,
Perpetual inventory required for the company {0} to view this report.,Ævarandi birgða krafist fyrir fyrirtækið {0} til að skoða þessa skýrslu.,
Phone,Sími,
Pick List,Veldu lista,
Plaid authentication error,Villa í sannprófun á táknmynd,
Plaid public token error,Villa við almenna táknið,
Plaid transactions sync error,Villa við samstillingu Plaid viðskipti,
Please check the error log for details about the import errors,Vinsamlegast athugaðu villubókina til að fá upplýsingar um innflutningsvillurnar,
Please click on the following link to set your new password,Vinsamlegast smelltu á eftirfarandi tengil til að setja nýja lykilorðið þitt,
Please create <b>DATEV Settings</b> for Company <b>{}</b>.,Vinsamlegast búðu til <b>DATEV stillingar</b> fyrir fyrirtæki <b>{}</b> .,
Please create adjustment Journal Entry for amount {0} ,Vinsamlegast stofnaðu færslu dagbókar fyrir upphæð {0},
Please do not create more than 500 items at a time,Vinsamlegast ekki búa til meira en 500 hluti í einu,
Please enter <b>Difference Account</b> or set default <b>Stock Adjustment Account</b> for company {0},Vinsamlegast sláðu inn <b>mismunareikning</b> eða stilltu sjálfgefinn <b>lageraðlögunarreikning</b> fyrir fyrirtæki {0},
Please enter GSTIN and state for the Company Address {0},Vinsamlegast sláðu inn GSTIN og gefðu upp heimilisfang fyrirtækisins {0},
Please enter Item Code to get item taxes,Vinsamlegast sláðu inn vöruskóða til að fá vöruskatta,
Please enter Warehouse and Date,Vinsamlegast sláðu inn vöruhús og dagsetningu,
Please enter coupon code !!,Vinsamlegast sláðu inn afsláttarmiða kóða !!,
Please enter the designation,Vinsamlegast sláðu inn heiti,
Please enter valid coupon code !!,Vinsamlegast sláðu inn gildan afsláttarmiða kóða !!,
Please login as a Marketplace User to edit this item.,Vinsamlegast skráðu þig inn sem notandi Marketplace til að breyta þessu atriði.,
Please login as a Marketplace User to report this item.,Vinsamlegast skráðu þig inn sem notandi Marketplace til að tilkynna þetta.,
Please select <b>Template Type</b> to download template,Vinsamlegast veldu <b>sniðmát</b> til að hlaða niður sniðmáti,
Please select Applicant Type first,Vinsamlegast veldu gerð umsækjanda fyrst,
Please select Customer first,Vinsamlegast veldu viðskiptavin fyrst,
Please select Item Code first,Vinsamlegast veldu hlutakóða fyrst,
Please select Loan Type for company {0},Vinsamlegast veldu Lántegund fyrir fyrirtæki {0},
Please select a Delivery Note,Vinsamlegast veldu afhendingarskilaboð,
Please select a Sales Person for item: {0},Veldu söluaðila fyrir hlutinn: {0},
Please select another payment method. Stripe does not support transactions in currency '{0}',Vinsamlegast veldu annan greiðsluaðferð. Rönd styður ekki viðskipti í gjaldmiðli &#39;{0}&#39;,
Please select the customer.,Vinsamlegast veldu viðskiptavininn.,
Please set a Supplier against the Items to be considered in the Purchase Order.,Vinsamlegast stilltu söluaðila á hlutina sem koma til greina í innkaupapöntuninni.,
Please set account heads in GST Settings for Compnay {0},Vinsamlegast stilltu reikningshöfða í GST stillingar fyrir Compnay {0},
Please set an email id for the Lead {0},Vinsamlegast stilltu tölvupóstskilríki fyrir Lead {0},
Please set default UOM in Stock Settings,Vinsamlegast stilltu sjálfgefna UOM í lagerstillingum,
Please set filter based on Item or Warehouse due to a large amount of entries.,Vinsamlegast stilltu síu út frá hlut eða vöruhúsi vegna mikils fjölda færslna.,
Please set up the Campaign Schedule in the Campaign {0},Vinsamlegast settu upp herferðaráætlunina í herferðinni {0},
Please set valid GSTIN No. in Company Address for company {0},Vinsamlegast stillið gilt GSTIN-nr. Í heimilisfang fyrirtækis fyrir fyrirtæki {0},
Please set {0},Vinsamlegast stillið {0},customer
Please setup a default bank account for company {0},Settu upp sjálfgefinn bankareikning fyrir {0} fyrirtæki,
Please specify,Vinsamlegast tilgreindu,
Please specify a {0},Vinsamlegast tilgreindu {0},lead
Pledge Status,Veðréttarstaða,
Pledge Time,Veðsetningartími,
Printing,Prentun,
Priority,Forgangur,
Priority has been changed to {0}.,Forgangi hefur verið breytt í {0}.,
Priority {0} has been repeated.,Forgangsröð {0} hefur verið endurtekin.,
Processing XML Files,Vinnsla XML skrár,
Profitability,Arðsemi,
Project,Project,
Proposed Pledges are mandatory for secured Loans,Fyrirhugaðar veðsetningar eru skylda vegna tryggðra lána,
Provide the academic year and set the starting and ending date.,Veittu námsárið og stilltu upphafs- og lokadagsetningu.,
Public token is missing for this bank,Það vantar opinberan tákn fyrir þennan banka,
Publish,Birta,
Publish 1 Item,Birta 1 hlut,
Publish Items,Birta hluti,
Publish More Items,Birta fleiri hluti,
Publish Your First Items,Birta fyrstu hlutina þína,
Publish {0} Items,Birta {0} Atriði,
Published Items,Útgefin atriði,
Purchase Invoice cannot be made against an existing asset {0},Ekki er hægt að framkvæma innheimtuseðil á núverandi eign {0},
Purchase Invoices,Kaupið innheimtuseðla,
Purchase Orders,Kaup pantanir,
Purchase Receipt doesn't have any Item for which Retain Sample is enabled.,Innkaupakvittun er ekki með neinn hlut sem varðveita sýnishorn er virkt fyrir.,
Purchase Return,kaup Return,
Qty of Finished Goods Item,Magn fullunninna vara,
Qty or Amount is mandatroy for loan security,Magn eða fjárhæð er mandatroy fyrir lánsöryggi,
Quality Inspection required for Item {0} to submit,Gæðaskoðun þarf til að skila inn hlut {0},
Quantity to Manufacture,Magn til framleiðslu,
Quantity to Manufacture can not be zero for the operation {0},Magn til framleiðslu getur ekki verið núll fyrir aðgerðina {0},
Quarterly,Ársfjórðungslega,
Queued,biðröð,
Quick Entry,Quick Entry,
Quiz {0} does not exist,Skyndipróf {0} er ekki til,
Quotation Amount,Tilvitnunarfjárhæð,
Rate or Discount is required for the price discount.,Verð eða afsláttur er krafist fyrir verðafsláttinn.,
Reason,Ástæðan,
Reconcile Entries,Sættið færslur,
Reconcile this account,Samræma þennan reikning,
Reconciled,Sátt,
Recruitment,Ráðningar,
Red,Red,
Refreshing,Frískandi,
Release date must be in the future,Útgáfudagur verður að vera í framtíðinni,
Relieving Date must be greater than or equal to Date of Joining,Slökunardagur verður að vera meiri en eða jafn og dagsetningardagur,
Rename,Endurnefna,
Rename Not Allowed,Endurnefna ekki leyfilegt,
Repayment Method is mandatory for term loans,Endurgreiðsluaðferð er skylda fyrir tíma lán,
Repayment Start Date is mandatory for term loans,Upphafsdagur endurgreiðslu er skylda vegna lánstíma,
Report Item,Tilkynna hlut,
Report this Item,Tilkynna þetta atriði,
Reserved Qty for Subcontract: Raw materials quantity to make subcontracted items.,Frátekið magn fyrir undirverktaka: Magn hráefna til að búa til undirverktaka hluti.,
Reset,Endurstilla,
Reset Service Level Agreement,Endurstilla þjónustustigssamning,
Resetting Service Level Agreement.,Endurstilla þjónustustigssamning.,
Response Time for {0} at index {1} can't be greater than Resolution Time.,Viðbragðstími fyrir {0} við vísitölu {1} getur ekki verið meiri en upplausnartími.,
Return amount cannot be greater unclaimed amount,Skilafjárhæð getur ekki verið hærri án kröfu,
Review,Endurskoðun,
Room,Room,
Room Type,Herbergistegund,
Row # ,Row #,
Row #{0}: Accepted Warehouse and Supplier Warehouse cannot be same,Röð # {0}: Samþykkt vöruhús og birgðageymsla geta ekki verið eins,
Row #{0}: Cannot delete item {1} which has already been billed.,Lína # {0}: Get ekki eytt hlut {1} sem þegar hefur verið innheimtur.,
Row #{0}: Cannot delete item {1} which has already been delivered,Röð # {0}: Get ekki eytt hlut {1} sem þegar hefur verið afhentur,
Row #{0}: Cannot delete item {1} which has already been received,Lína # {0}: Get ekki eytt hlutnum {1} sem þegar hefur borist,
Row #{0}: Cannot delete item {1} which has work order assigned to it.,Röð # {0}: Get ekki eytt hlutnum {1} sem hefur verkunarröðinni úthlutað.,
Row #{0}: Cannot delete item {1} which is assigned to customer's purchase order.,Lína # {0}: Get ekki eytt hlut {1} sem er úthlutað í innkaupapöntun viðskiptavinarins.,
Row #{0}: Cannot select Supplier Warehouse while suppling raw materials to subcontractor,Röð # {0}: Get ekki valið birgðageymsla meðan hráefnum er veitt undirverktaka,
Row #{0}: Cost Center {1} does not belong to company {2},Röð # {0}: Kostnaðarmiðstöð {1} tilheyrir ekki fyrirtæki {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}.,Röð # {0}: Aðgerð {1} er ekki lokið fyrir {2} magn fullunnar vöru í vinnuskipan {3}. Vinsamlegast uppfærðu stöðu starfsins með Job Card {4}.,
Row #{0}: Payment document is required to complete the transaction,Lína # {0}: Greiðslu skjal er nauðsynlegt til að ljúka viðskiptunum,
Row #{0}: Serial No {1} does not belong to Batch {2},Röð # {0}: Raðnúmer {1} tilheyrir ekki hópi {2},
Row #{0}: Service End Date cannot be before Invoice Posting Date,Lína # {0}: Lokadagsetning þjónustu má ekki vera fyrir dagsetningu reiknings,
Row #{0}: Service Start Date cannot be greater than Service End Date,Röð # {0}: Upphafsdagsetning þjónustu má ekki vera meiri en lokadagur þjónustu,
Row #{0}: Service Start and End Date is required for deferred accounting,Röð # {0}: Upphafs- og lokadagsetning þjónustu er krafist fyrir frestað bókhald,
Row {0}: Invalid Item Tax Template for item {1},Röð {0}: Ógilt sniðmát fyrir hlutaskatt fyrir hlutinn {1},
Row {0}: Quantity not available for {4} in warehouse {1} at posting time of the entry ({2} {3}),Röð {0}: Magn er ekki fáanlegt fyrir {4} í vöruhúsi {1} á þeim tíma sem færslan birtist ({2} {3}),
Row {0}: user has not applied the rule {1} on the item {2},Röð {0}: notandi hefur ekki beitt reglunni {1} á hlutnum {2},
Row {0}:Sibling Date of Birth cannot be greater than today.,Röð {0}: Fæðingardagur systkina má ekki vera meiri en í dag.,
Row({0}): {1} is already discounted in {2},Röð ({0}): {1} er nú þegar afsláttur af {2},
Rows Added in {0},Raðir bætt við í {0},
Rows Removed in {0},Raðir fjarlægðar á {0},
Sanctioned Amount limit crossed for {0} {1},Viðurkennd fjárhæðarmörk yfir {0} {1},
Sanctioned Loan Amount already exists for {0} against company {1},Viðurkennd lánsfjárhæð er þegar til fyrir {0} gegn fyrirtæki {1},
Save,Vista,
Save Item,Vista hlut,
Saved Items,Vistaðir hlutir,
Scheduled and Admitted dates can not be less than today,Tímasettar og samþykktar dagsetningar geta ekki verið minni en í dag,
Search Items ...,Leitaðu að hlutum ...,
Search for a payment,Leitaðu að greiðslu,
Search for anything ...,Leitaðu að neinu ...,
Search results for,Leitarniðurstöður fyrir,
Select All,Velja allt,
Select Difference Account,Veldu mismunareikning,
Select a Default Priority.,Veldu sjálfgefið forgang.,
Select a Supplier from the Default Supplier List of the items below.,Veldu seljanda úr sjálfgefnum birgðalista yfir hlutina hér að neðan.,
Select a company,Veldu fyrirtæki,
Select finance book for the item {0} at row {1},Veldu fjármálabók fyrir hlutinn {0} í röð {1},
Select only one Priority as Default.,Veldu aðeins eitt forgang sem sjálfgefið.,
Seller Information,Upplýsingar um seljanda,
Send,Senda,
Send a message,Senda skilaboð,
Sending,Sendir,
Sends Mails to lead or contact based on a Campaign schedule,Sendir póst til að leiða eða hafa samband miðað við áætlun herferðar,
Serial Number Created,Raðnúmer búið til,
Serial Numbers Created,Raðnúmer búið til,
Serial no(s) required for serialized item {0},Raðnúmer (er) krafist fyrir raðtölu {0},
Series,Series,
Server Error,Server Villa,
Service Level Agreement has been changed to {0}.,Þjónustustigssamningi hefur verið breytt í {0}.,
Service Level Agreement tracking is not enabled.,Rekja þjónustustigssamning er ekki virk.,
Service Level Agreement was reset.,Þjónustustigssamningur var endurstilltur.,
Service Level Agreement with Entity Type {0} and Entity {1} already exists.,Samningur um þjónustustig með einingategund {0} og eining {1} er þegar til.,
Set,Setja,
Set Meta Tags,Setja Meta tags,
Set Response Time and Resolution for Priority {0} at index {1}.,Stilltu viðbragðstíma og upplausn fyrir forgang {0} við vísitölu {1}.,
Set {0} in company {1},Stilltu {0} í fyrirtæki {1},
Setup,Setja upp,
Setup Wizard,skipulag Wizard,
Shift Management,Shift Stjórnun,
Show Future Payments,Sýna framtíðargreiðslur,
Show Linked Delivery Notes,Sýna tengda afhendingarbréf,
Show Sales Person,Sýna sölumann,
Show Stock Ageing Data,Sýna gögn um öldrun hlutabréfa,
Show Warehouse-wise Stock,Sýna lager sem er vitur lager,
Size,Size,
Something went wrong while evaluating the quiz.,Eitthvað fór úrskeiðis við mat á spurningakeppninni.,
"Sorry,coupon code are exhausted","Því miður, afsláttarmiða kóða er búinn",
"Sorry,coupon code validity has expired","Því miður, gildistími afsláttarmiða er útrunninn",
"Sorry,coupon code validity has not started","Því miður, gildistími afsláttarmiða hefur ekki byrjað",
Sr,Sr,
Start,Start,
Start Date cannot be before the current date,Upphafsdagsetning má ekki vera fyrir núverandi dagsetningu,
Start Time,Byrjunartími,
Status,Staða,
Status must be Cancelled or Completed,Hætta verður við stöðuna eða henni er lokið,
Stock Balance Report,Hlutabréfaskýrsla,
Stock Entry has been already created against this Pick List,Hlutabréfafærsla er þegar búin til gegn þessum Pick List,
Stock Ledger ID,Auðkenni hlutafjárbókar,
Stock Value ({0}) and Account Balance ({1}) are out of sync for account {2} and it's linked warehouses.,Hlutabréfagildi ({0}) og reikningshald ({1}) eru ekki samstillt fyrir reikning {2} og tengd vöruhús.,
Stores - {0},Verslanir - {0},
Student with email {0} does not exist,Námsmaður með tölvupóst {0} er ekki til,
Submit Review,Sendu inn umsögn,
Submitted,lögð,
Supplier Addresses And Contacts,Birgir Heimilisföng og Tengiliðir,
Synchronize this account,Samstilla þennan reikning,
Tag,Merki,
Target Location is required while receiving Asset {0} from an employee,Miða staðsetningu er krafist meðan þú færð eign {0} frá starfsmanni,
Target Location is required while transferring Asset {0},Miða staðsetningu er krafist við flutning eigna {0},
Target Location or To Employee is required while receiving Asset {0},Markaðsstaðsetning eða starfsmaður er krafist meðan eign er veitt {0},
Task's {0} End Date cannot be after Project's End Date.,Lokadagsetning verkefnis {0} má ekki vera eftir lokadagsetningu verkefnisins.,
Task's {0} Start Date cannot be after Project's End Date.,Upphafsdagsetning verkefnis {0} getur ekki verið eftir lokadagsetningu verkefnis.,
Tax Account not specified for Shopify Tax {0},Skattareikningur ekki tilgreindur fyrir Shopify Tax {0},
Tax Total,Heildarskattur,
Template,Snið,
The Campaign '{0}' already exists for the {1} '{2}',Herferðin &#39;{0}&#39; er þegar til fyrir {1} &#39;{2}&#39;,
The difference between from time and To Time must be a multiple of Appointment,Munurinn á milli tíma og til tíma hlýtur að vera margfeldi af skipun,
The field Asset Account cannot be blank,Reiturinn Eignareikningur getur ekki verið auður,
The field Equity/Liability Account cannot be blank,Reiturinn Hlutabréf / Ábyrgð reikningur getur ekki verið auður,
The following serial numbers were created: <br><br> {0},Eftirfarandi raðnúmer voru búin til: <br><br> {0},
The parent account {0} does not exists in the uploaded template,Foreldrareikningurinn {0} er ekki til í sniðmátinu sem hlaðið var upp,
The question cannot be duplicate,Ekki er hægt að afrita spurninguna,
The selected payment entry should be linked with a creditor bank transaction,Valin greiðslufærsla ætti að vera tengd við kröfuhafa bankaviðskipti,
The selected payment entry should be linked with a debtor bank transaction,Valin greiðslufærsla ætti að vera tengd viðskiptum við skuldara,
The total allocated amount ({0}) is greated than the paid amount ({1}).,Heildarúthlutað upphæð ({0}) er hærri en greidd fjárhæð ({1}).,
The value {0} is already assigned to an exisiting Item {2}.,Gildið {0} er þegar úthlutað til núverandi vöru {2}.,
There are no vacancies under staffing plan {0},Engin laus störf eru samkvæmt starfsmannaplan {0},
This Service Level Agreement is specific to Customer {0},Þessi þjónustustigssamningur er sérstakur fyrir viðskiptavini {0},
This action will unlink this account from any external service integrating ERPNext with your bank accounts. It cannot be undone. Are you certain ?,Þessi aðgerð mun aftengja þennan reikning frá ytri þjónustu sem samþættir ERPNext við bankareikninga þína. Ekki er hægt að afturkalla það. Ertu viss?,
This bank account is already synchronized,Þessi bankareikningur er þegar samstilltur,
This bank transaction is already fully reconciled,Þessi bankaviðskipti eru nú þegar að fullu sátt,
This employee already has a log with the same timestamp.{0},Þessi starfsmaður er þegar með dagbók með sama tímamerki. {0},
This page keeps track of items you want to buy from sellers.,Þessi síða heldur utan um hluti sem þú vilt kaupa hjá seljendum.,
This page keeps track of your items in which buyers have showed some interest.,Þessi síða heldur utan um hluti sem kaupendur hafa sýnt áhuga á.,
Thursday,fimmtudagur,
Timing,Tímasetning,
Title,Title,
"To allow over billing, update ""Over Billing Allowance"" in Accounts Settings or the Item.","Til að leyfa innheimtu yfir, skaltu uppfæra „Yfir innheimtuheimild“ í reikningsstillingum eða hlutnum.",
"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.","Til að leyfa móttöku / afhendingu, skal uppfæra „Yfir móttöku / afhendingu“ í lager stillingum eða hlutnum.",
To date needs to be before from date,Hingað til þarf að vera fyrir frá dagsetningu,
Total,alls,
Total Early Exits,Heildar snemma útgönguleiðir,
Total Late Entries,Síðar færslur,
Total Payment Request amount cannot be greater than {0} amount,Heildarupphæð greiðslubeiðni má ekki vera hærri en {0} upphæð,
Total payments amount can't be greater than {},Heildargreiðslur geta ekki verið hærri en {},
Totals,Samtölur,
Training Event:,Þjálfunarþáttur:,
Transactions already retreived from the statement,Viðskipti hafa þegar verið endurheimt frá yfirlýsingunni,
Transfer Material to Supplier,Flytja efni til birgis,
Transport Receipt No and Date are mandatory for your chosen Mode of Transport,Flutningskvittun nr og dagsetning eru nauðsynleg fyrir valinn flutningsmáta,
Tuesday,þriðjudagur,
Type,Gerð,
Unable to find Salary Component {0},Ekki tókst að finna launahluta {0},
Unable to find the time slot in the next {0} days for the operation {1}.,Ekki tókst að finna tímaröðina á næstu {0} dögum fyrir aðgerðina {1}.,
Unable to update remote activity,Ekki tókst að uppfæra ytri virkni,
Unknown Caller,Óþekktur hringir,
Unlink external integrations,Aftengdu ytri samþættingar,
Unmarked Attendance for days,Ómerktur Mæting fyrir daga,
Unpublish Item,Aftengja hlut,
Unreconciled,Ósamræmd,
Unsupported GST Category for E-Way Bill JSON generation,Óstuddur GST flokkur fyrir E-Way Bill JSON kynslóð,
Update,Uppfæra,
Update Details,Uppfæra upplýsingar,
Update Taxes for Items,Uppfæra skatta fyrir hluti,
"Upload a bank statement, link or reconcile a bank account","Hladdu upp bankayfirliti, tengdu eða sættaðu bankareikning",
Upload a statement,Hladdu upp yfirlýsingu,
Use a name that is different from previous project name,Notaðu nafn sem er frábrugðið fyrri verkefnisheiti,
User {0} is disabled,User {0} er óvirk,
Users and Permissions,Notendur og heimildir,
Vacancies cannot be lower than the current openings,Laus störf geta ekki verið lægri en núverandi opnun,
Valid From Time must be lesser than Valid Upto Time.,Gildur frá tíma verður að vera minni en gildur fram að tíma.,
Valuation Rate required for Item {0} at row {1},Matshluti krafist fyrir lið {0} í röð {1},
"Valuation rate not found for the Item {0}, which is required to do accounting entries for {1} {2}. If the item is transacting as a zero valuation rate item in the {1}, please mention that in the {1} Item table. Otherwise, please create an incoming stock transaction for the item or mention valuation rate in the Item record, and then try submiting / cancelling this entry.","Matshlutfall fannst ekki fyrir hlutinn {0} sem þarf til að færa bókhald fyrir {1} {2}. Ef hluturinn er með viðskipti sem núll matshlutfall í {1}, vinsamlegast getið þess í {1} hlutatöflunni. Annars, vinsamlegast stofnaðu komandi hlutabréfaviðskipti fyrir hlutinn eða nefndu matshlutfall í hlutaskránni og reyndu síðan að senda inn / hætta við þessa færslu.",
Values Out Of Sync,Gildi utan samstillingar,
Vehicle Type is required if Mode of Transport is Road,Gerð ökutækis er krafist ef flutningsmáti er vegur,
Vendor Name,Nafn seljanda,
Verify Email,staðfesta tölvupóst,
View,Útsýni,
View all issues from {0},Skoða öll mál frá {0},
View call log,Skoða símtalaskrá,
Warehouse,Vöruhús,
Warehouse not found against the account {0},Vöruhús fannst ekki gegn reikningnum {0},
Welcome to {0},Að {0},
Why do think this Item should be removed?,Af hverju halda að þessi hluti eigi að fjarlægja?,
Work Order {0}: Job Card not found for the operation {1},Vinnipöntun {0}: starfskort fannst ekki fyrir aðgerðina {1},
Workday {0} has been repeated.,Virkur dagur {0} hefur verið endurtekinn.,
XML Files Processed,XML skrár unnar,
Year,Ár,
Yearly,Árlega,
You,Þú,
You are not allowed to enroll for this course,Þú hefur ekki leyfi til að skrá þig á þetta námskeið,
You are not enrolled in program {0},Þú ert ekki skráður í forritið {0},
You can Feature upto 8 items.,Þú getur haft allt að 8 atriði.,
You can also copy-paste this link in your browser,Þú getur líka afrita líma þennan tengil í vafranum þínum,
You can publish upto 200 items.,Þú getur birt allt að 200 atriði.,
You can't create accounting entries in the closed accounting period {0},Þú getur ekki búið til bókhaldsfærslur á lokuðu bókhaldstímabilinu {0},
You have to enable auto re-order in Stock Settings to maintain re-order levels.,Þú verður að virkja sjálfvirka pöntun í lagerstillingum til að viðhalda endurpöntunarstigum.,
You must be a registered supplier to generate e-Way Bill,Þú verður að vera skráður birgir til að búa til e-Way Bill,
You need to login as a Marketplace User before you can add any reviews.,Þú verður að skrá þig inn sem markaðsnotandi áður en þú getur bætt við umsögnum.,
Your Featured Items,Sérstakir hlutir þínir,
Your Items,Atriðin þín,
Your Profile,Prófílinn þinn,
Your rating:,Þín einkunn:,
Zero qty of {0} pledged against loan {0},Núll fjöldi {0} veðsettur gegn láni {0},
and,og,
e-Way Bill already exists for this document,E-Way Bill er þegar til fyrir þetta skjal,
woocommerce - {0},woocommerce - {0},
{0} Coupon used are {1}. Allowed quantity is exhausted,{0} afsláttarmiða notaður er {1}. Leyfilegt magn er uppurið,
{0} Name,{0} Heiti,
{0} Operations: {1},{0} Aðgerðir: {1},
{0} bank transaction(s) created,{0} bankaviðskipti stofnuð,
{0} bank transaction(s) created and {1} errors,{0} bankaviðskipti stofnuð og {1} villur,
{0} can not be greater than {1},{0} getur ekki verið stærra en {1},
{0} conversations,{0} samtöl,
{0} is not a company bank account,{0} er ekki bankareikningur fyrirtækisins,
{0} is not a group node. Please select a group node as parent cost center,{0} er ekki hópur hnút. Veldu hóp hnút sem kostnaðarmiðstöð foreldra,
{0} is not the default supplier for any items.,{0} er ekki sjálfgefinn birgir fyrir neina hluti.,
{0} is required,{0} er krafist,
{0} units of {1} is not available.,{0} einingar af {1} eru ekki tiltækar.,
{0}: {1} must be less than {2},{0}: {1} verður að vera minna en {2},
{} is an invalid Attendance Status.,{} er ógild aðsóknarstaða.,
{} is required to generate E-Way Bill JSON,{} er skylt að búa til e-Way Bill JSON,
"Invalid lost reason {0}, please create a new lost reason","Ógild glatað ástæða {0}, vinsamlegast stofnaðu nýja glataða ástæðu",
Profit This Year,Hagnaður í ár,
Total Expense,Heildarkostnaður,
Total Expense This Year,Heildarkostnaður í ár,
Total Income,Heildartekjur,
Total Income This Year,Heildartekjur í ár,
Barcode,Strikamerki,
Center,Center,
Clear,Tær,
Comment,Athugasemd,
Comments,Comments,
Download,Niðurhal,
Left,Vinstri,
Link,Hlekkur,
New,Nýtt,
Not Found,Ekki fundið,
Print,Prenta,
Reference Name,Tilvísunarnafn,
Refresh,Uppfæra,
Success,Árangur,
Time,Tími,
Value,Gildi,
Actual,Raunverulegur,
Add to Cart,Bæta í körfu,
Days Since Last Order,Dagar frá síðustu pöntun,
In Stock,Á lager,
Loan Amount is mandatory,Lánsfjárhæð er skylt,
Mode Of Payment,Háttur á greiðslu,
No students Found,Engir nemendur fundnir,
Not in Stock,Ekki til á lager,
Please select a Customer,Vinsamlegast veldu viðskiptavin,
Printed On,Prentað á,
Received From,fékk frá,
Sales Person,Sölufulltrúa,
To date cannot be before From date,Hingað til er ekki hægt að áður frá dagsetningu,
Write Off,Afskrifa,
{0} Created,{0} búin,
Email Id,Netfang,
No,engin,
Reference Doctype,Tilvísun DOCTYPE,
User Id,Notandanafn,
Yes,Já,
Actual ,Raunveruleg,
Add to cart,Bæta í körfu,
Budget,Budget,
Chart Of Accounts Importer,Yfirlit yfir innflutning reikninga,
Chart of Accounts,Yfirlit yfir reikninga,
Customer database.,Viðskiptavinur Gagnagrunnur.,
Days Since Last order,Dagar frá síðustu Order,
Download as JSON,Sæktu sem JSON,
End date can not be less than start date,Lokadagur getur ekki verið minna en upphafsdagur,
For Default Supplier (Optional),Fyrir Sjálfgefið Birgir (valfrjálst),
From date cannot be greater than To date,Frá Dagsetning má ekki vera meiri en Til Dagsetning,
Get items from,Fá atriði úr,
Group by,Hópa eftir,
In stock,Á lager,
Item name,Item Name,
Loan amount is mandatory,Lánsfjárhæð er skylt,
Minimum Qty,Lágmarksfjöldi,
More details,Nánari upplýsingar,
Nature of Supplies,Eðli birgða,
No Items found.,Engar vörur fundust.,
No employee found,Engin starfsmaður fannst,
No students found,Engir nemendur fundnir,
Not in stock,Ekki til á lager,
Not permitted,Ekki leyfilegt,
Open Issues ,Opið Issues,
Open Projects ,Opið Verkefni,
Open To Do ,Open Til Gera,
Operation Id,Operation ID,
Partially ordered,hluta Raðaður,
Please select company first,Vinsamlegast veldu Company fyrst,
Please select patient,Vinsamlegast veldu Sjúklingur,
Printed On ,Prentað á,
Projected qty,Spáð magn,
Sales person,Sölufulltrúa,
Serial No {0} Created,Serial Nei {0} búin,
Set as default,Setja sem sjálfgefið,
Source Location is required for the Asset {0},Heimild Staðsetning er krafist fyrir eignina {0},
Tax Id,Skattarauðkenni,
To Time,til Time,
To date cannot be before from date,Hingað til getur ekki verið fyrir frá dagsetningu,
Total Taxable value,Heildarskattverð,
Upcoming Calendar Events ,Næstu Dagbókaratriði,
Value or Qty,Gildi eða magn,
Variance ,Variance,
Variant of,Afbrigði af,
Write off,Afskrifa,
Write off Amount,Skrifaðu Off Upphæð,
hours,Klukkustundir,
received from,fékk frá,
to,Til,
Cards,Spil,
Percentage,Hlutfall,
Failed to setup defaults for country {0}. Please contact support@erpnext.com,Ekki tókst að setja upp vanskil fyrir land {0}. Vinsamlegast hafðu samband við support@erpnext.com,
Row #{0}: Item {1} is not a Serialized/Batched Item. It cannot have a Serial No/Batch No against it.,Röð # {0}: Liður {1} er ekki hlutur sem er raðskiptur / hópur. Það getur ekki haft raðnúmer / lotu nei á móti.,
Please set {0},Vinsamlegast settu {0},
Please set {0},Vinsamlegast stillið {0},supplier
Draft,Drög,"docstatus,=,0"
Cancelled,Hætt við,"docstatus,=,2"
Please setup Instructor Naming System in Education > Education Settings,Vinsamlegast settu upp kennslukerfi kennslukerfis í menntun&gt; Menntunarstillingar,
Please set Naming Series for {0} via Setup > Settings > Naming Series,Vinsamlegast stilltu Naming Series fyrir {0} með Setup&gt; Settings&gt; Naming Series,
UOM Conversion factor ({0} -> {1}) not found for item: {2},UOM viðskiptaþáttur ({0} -&gt; {1}) fannst ekki fyrir hlutinn: {2},
Item Code > Item Group > Brand,Atriðakóði&gt; Vöruflokkur&gt; Vörumerki,
Customer > Customer Group > Territory,Viðskiptavinur&gt; viðskiptavinahópur&gt; landsvæði,
Supplier > Supplier Type,Birgir&gt; Gerð birgis,
Please setup Employee Naming System in Human Resource > HR Settings,Vinsamlegast settu upp nafnakerfi starfsmanna í mannauð&gt; HR stillingar,
Please setup numbering series for Attendance via Setup > Numbering Series,Vinsamlegast settu upp númeraröð fyrir mætingu með uppsetningu&gt; Númeraröð,
Purchase Order Required,Purchase Order Required,
Purchase Receipt Required,Kvittun Áskilið,
Requested,Umbeðin,
YouTube,Youtube,
Vimeo,Vimeo,
Publish Date,Útgáfudagur,
Duration,Lengd,
Advanced Settings,Ítarlegar stillingar,
Path,Leið,
Components,Hluti,
Verified By,staðfest af,
Maintain Same Rate Throughout Sales Cycle,Halda Sama hlutfall á öllu söluferlið,
Must be Whole Number,Verður að vera heil tala,
GL Entry,GL Entry,
Fee Validity,Gjaldgildi,
Dosage Form,Skammtaform,
Patient Medical Record,Sjúkratryggingaskrá,
Total Completed Qty,Heildar lokið fjölda,
Qty to Manufacture,Magn To Framleiðsla,
Out Patient Consulting Charge Item,Out Patient Ráðgjöf Charge Item,
Inpatient Visit Charge Item,Göngudeild í sjúkrahúsum,
OP Consulting Charge,OP ráðgjöf gjald,
Inpatient Visit Charge,Sjúkraþjálfun,
Check Availability,Athuga framboð,
Heads (or groups) against which Accounting Entries are made and balances are maintained.,Höfuð (eða hópar) gegn sem bókhaldsfærslum eru gerðar og jafnvægi er viðhaldið.,
Account Name,Nafn reiknings,
Inter Company Account,Innri félagsreikningur,
Parent Account,Parent Reikningur,
Setting Account Type helps in selecting this Account in transactions.,Uppsetning reiknings Tegund hjálpar í því að velja þennan reikning í viðskiptum.,
Chargeable,ákæru,
Rate at which this tax is applied,Gengi sem þessi skattur er beitt,
Frozen,Frozen,
"If the account is frozen, entries are allowed to restricted users.","Ef reikningur er frosinn, eru færslur leyft að afmörkuðum notendum.",
Balance must be,Jafnvægi verður að vera,
Old Parent,Old Parent,
Include in gross,Hafa með í brúttó,
Auditor,endurskoðandi,
Accounting Dimension,Bókhaldsvídd,
Dimension Name,Víddarheiti,
Dimension Defaults,Vanskil víddar,
Accounting Dimension Detail,Smáatriði bókhaldsvíddar,
Default Dimension,Sjálfgefin vídd,
Mandatory For Balance Sheet,Skylda fyrir efnahagsreikning,
Mandatory For Profit and Loss Account,Skylda vegna rekstrarreiknings,
Accounting Period,Bókhaldstími,
Period Name,Nafn tímabils,
Closed Documents,Lokað skjöl,
Accounts Settings,reikninga Stillingar,
Settings for Accounts,Stillingar fyrir reikninga,
Make Accounting Entry For Every Stock Movement,Gera Bókhald færslu fyrir hvert Stock Hreyfing,
"If enabled, the system will post accounting entries for inventory automatically.","Ef þetta er virkt, mun kerfið birta bókhald færslur fyrir birgðum sjálfkrafa.",
Accounts Frozen Upto,Reikninga Frozen uppí,
"Accounting entry frozen up to this date, nobody can do / modify entry except role specified below.","Bókhald færsla fryst upp til þessa dagsetningu, enginn getur gert / breyta færslu, nema hlutverki sem tilgreindur er hér.",
Role Allowed to Set Frozen Accounts & Edit Frozen Entries,Hlutverk leyft að setja á frysta reikninga &amp; Sýsla Frozen færslur,
Users with this role are allowed to set frozen accounts and create / modify accounting entries against frozen accounts,Notendur með þetta hlutverk er leyft að setja á frysta reikninga og búa til / breyta bókhaldsfærslum gegn frysta reikninga,
Determine Address Tax Category From,Ákveðið heimilisfang skattaflokks frá,
Address used to determine Tax Category in transactions.,Heimilisfang notað til að ákvarða skattaflokk í viðskiptum.,
Over Billing Allowance (%),Yfir innheimtuheimild (%),
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 for $110.,"Hlutfall sem þú hefur heimild til að innheimta meira gegn upphæðinni sem pantað er. Til dæmis: Ef pöntunargildið er $ 100 fyrir hlut og vikmörk eru stillt sem 10%, þá hefurðu heimild til að gjaldfæra $ 110.",
Credit Controller,Credit Controller,
Role that is allowed to submit transactions that exceed credit limits set.,Hlutverk sem er leyft að leggja viðskiptum sem fara lánamörk sett.,
Check Supplier Invoice Number Uniqueness,Athuga Birgir Reikningur númer Sérstöðu,
Make Payment via Journal Entry,Greiða í gegnum dagbókarfærslu,
Unlink Payment on Cancellation of Invoice,Aftengja greiðsla á niðurfellingar Invoice,
Unlink Advance Payment on Cancelation of Order,Taktu úr sambandi fyrirframgreiðslu vegna niðurfellingar pöntunar,
Book Asset Depreciation Entry Automatically,Bókfært eignaaukning sjálfkrafa,
Allow Cost Center In Entry of Balance Sheet Account,Leyfa kostnaðarmiðstöð við birtingu reikningsreiknings,
Automatically Add Taxes and Charges from Item Tax Template,Bættu sjálfkrafa við sköttum og gjöldum af sniðmáti hlutarskatta,
Automatically Fetch Payment Terms,Sæktu sjálfkrafa greiðsluskilmála,
Show Inclusive Tax In Print,Sýna innifalið skatt í prenti,
Show Payment Schedule in Print,Sýna greiðsluáætlun í prenti,
Currency Exchange Settings,Valmöguleikar,
Allow Stale Exchange Rates,Leyfa óbreyttu gengi,
Stale Days,Gamall dagar,
Report Settings,Skýrslu Stillingar,
Use Custom Cash Flow Format,Notaðu Custom Cash Flow Format,
Only select if you have setup Cash Flow Mapper documents,Veldu aðeins ef þú hefur sett upp Cash Flow Mapper skjöl,
Allowed To Transact With,Leyfilegt að eiga viðskipti við,
Branch Code,Útibúarkóði,
Address and Contact,Heimilisfang og samband við,
Address HTML,Heimilisfang HTML,
Contact HTML,Viltu samband við HTML,
Data Import Configuration,Stillingar gagnainnflutnings,
Bank Transaction Mapping,Kortlagning bankaviðskipta,
Plaid Access Token,Tákn með aðgangi að tákni,
Company Account,Fyrirtækisreikningur,
Account Subtype,Undirgerð reiknings,
Is Default Account,Er sjálfgefinn reikningur,
Is Company Account,Er félagsreikningur,
Party Details,Upplýsingar um aðila,
Account Details,Reikningsupplýsingar,
IBAN,IBAN,
Bank Account No,Bankareikningur nr,
Integration Details,Upplýsingar um samþættingu,
Integration ID,Sameiningarkenni,
Last Integration Date,Síðasti samþættingardagur,
Change this date manually to setup the next synchronization start date,Skiptu um þessa dagsetningu handvirkt til að setja upp næsta upphafsdagsetningu samstillingar,
Mask,Gríma,
Bank Guarantee,Bankábyrgð,
Bank Guarantee Type,Bankareikningsgerð,
Receiving,Fá,
Providing,Veita,
Reference Document Name,Tilvísun skjal nafn,
Validity in Days,Gildi í dögum,
Bank Account Info,Bankareikningsupplýsingar,
Clauses and Conditions,Skilmálar og skilyrði,
Bank Guarantee Number,Bankareikningsnúmer,
Name of Beneficiary,Nafn bótaþega,
Margin Money,Framlegð peninga,
Charges Incurred,Gjöld felld,
Fixed Deposit Number,Fast innborgunarnúmer,
Account Currency,Reikningur Gjaldmiðill,
Select the Bank Account to reconcile.,Veldu bankareikninginn sem á að sætta.,
Include Reconciled Entries,Fela sáttir færslur,
Get Payment Entries,Fá greiðslu færslur,
Payment Entries,Greiðsla Entries,
Update Clearance Date,Uppfæra Úthreinsun Dagsetning,
Bank Reconciliation Detail,Bank Sættir Detail,
Cheque Number,ávísun Number,
Cheque Date,ávísun Dagsetning,
Statement Header Mapping,Yfirlit Header Kortlagning,
Statement Headers,Yfirlýsing Headers,
Transaction Data Mapping,Mapping viðskiptadags,
Mapped Items,Mapped Items,
Bank Statement Settings Item,Staða bankareiknings,
Mapped Header,Mapped Header,
Bank Header,Bankareikningur,
Bank Statement Transaction Entry,Viðskiptareikningur bankans,
Bank Transaction Entries,Viðskiptareikningar banka,
New Transactions,Nýjar færslur,
Match Transaction to Invoices,Samsvörun við reikninga,
Create New Payment/Journal Entry,Búðu til nýjan greiðslubréf / dagbókarfærslu,
Submit/Reconcile Payments,Sendu inn / afgreiðdu greiðslur,
Matching Invoices,Samsvörunargjöld,
Payment Invoice Items,Greiðslumiðlar,
Reconciled Transactions,Samræmd viðskipti,
Bank Statement Transaction Invoice Item,Bank Yfirlit Viðskiptareikning Atriði,
Payment Description,Greiðsla Lýsing,
Invoice Date,Dagsetning reiknings,
Bank Statement Transaction Payment Item,Viðskiptareikningur Greiðsluliður,
outstanding_amount,outstanding_amount,
Payment Reference,Greiðsla Tilvísun,
Bank Statement Transaction Settings Item,Yfirlit um viðskiptastilling bankans,
Bank Data,Bankagögn,
Mapped Data Type,Mapped Data Type,
Mapped Data,Mapped Data,
Bank Transaction,Bankaviðskipti,
ACC-BTN-.YYYY.-,ACC-BTN-.ÁÁÁÁ.-,
Transaction ID,Færsla ID,
Unallocated Amount,óráðstafað Upphæð,
Field in Bank Transaction,Reit í bankaviðskiptum,
Column in Bank File,Súla í bankaskrá,
Bank Transaction Payments,Greiðslur með bankaviðskiptum,
Control Action,Stjórna aðgerð,
Applicable on Material Request,Gildir á efnisbeiðni,
Action if Annual Budget Exceeded on MR,Aðgerð ef ársáætlun fór yfir MR,
Warn,Warn,
Ignore,Hunsa,
Action if Accumulated Monthly Budget Exceeded on MR,Aðgerð ef uppsafnað mánaðarlegt fjárhagsáætlun fór yfir MR,
Applicable on Purchase Order,Gildir á innkaupapöntun,
Action if Annual Budget Exceeded on PO,Aðgerð ef árleg fjárhagsáætlun er yfir PO,
Action if Accumulated Monthly Budget Exceeded on PO,Aðgerð ef uppsafnað mánaðarlegt fjárhagsáætlun fór fram á PO,
Applicable on booking actual expenses,Gildir á bókun raunkostnaði,
Action if Annual Budget Exceeded on Actual,Aðgerð ef ársáætlun fór yfir raunverulegt,
Action if Accumulated Monthly Budget Exceeded on Actual,Aðgerð ef uppsafnað mánaðarlegt fjárhagsáætlun fór yfir raunverulegt,
Budget Accounts,Budget reikningar,
Budget Account,Budget Account,
Budget Amount,Budget Upphæð,
C-Form,C-Form,
ACC-CF-.YYYY.-,ACC-CF-.YYYY.-,
C-Form No,C-Form Nei,
Received Date,fékk Date,
Quarter,Quarter,
I,ég,
II,II,
III,III,
IV,IV,
C-Form Invoice Detail,C-Form Reikningur Detail,
Invoice No,reikningur nr,
Cash Flow Mapper,Cash Flow Mapper,
Section Name,Section Name,
Section Header,Kaflaskipti,
Section Leader,Kafli Leader,
e.g Adjustments for:,td leiðréttingar fyrir:,
Section Subtotal,Hluti undirliða,
Section Footer,Section Footer,
Position,Staða,
Cash Flow Mapping,Cash Flow Kortlagning,
Select Maximum Of 1,Veldu hámark 1,
Is Finance Cost,Er fjármagnskostnaður,
Is Working Capital,Er vinnumarkaður,
Is Finance Cost Adjustment,Er fjármálakostnaður aðlögun,
Is Income Tax Liability,Er tekjuskattsskuldbinding,
Is Income Tax Expense,Er tekjuskattur kostnaður,
Cash Flow Mapping Accounts,Sjóðstreymisreikningar,
account,Reikningur,
Cash Flow Mapping Template,Sniðmát fyrir sjóðstreymi,
Cash Flow Mapping Template Details,Upplýsingar um sjóðstreymi fyrir sjóðstreymi,
POS-CLO-,POS-CLO-,
Custody,Forsjá,
Net Amount,Virði,
Cashier Closing Payments,Gjaldkeri greiðslur,
Import Chart of Accounts from a csv file,Flytja inn reikningskort úr csv skrá,
Attach custom Chart of Accounts file,Hengdu við sérsniðna skrá yfir reikninga,
Chart Preview,Forskoðun myndrits,
Chart Tree,Kortatré,
Cheque Print Template,Ávísun Prenta Snið,
Has Print Format,Hefur prenta sniði,
Primary Settings,Primary Stillingar,
Cheque Size,ávísun Size,
Regular,Venjulegur,
Starting position from top edge,Upphafsstöðu frá efstu brún,
Cheque Width,ávísun Breidd,
Cheque Height,ávísun Hæð,
Scanned Cheque,skönnuð ávísun,
Is Account Payable,Er reikningur Greiðist,
Distance from top edge,Fjarlægð frá efstu brún,
Distance from left edge,Fjarlægð frá vinstri kanti,
Message to show,Skilaboð til að sýna,
Date Settings,Dagsetning Stillingar,
Starting location from left edge,Byrjun stað frá vinstri kanti,
Payer Settings,greiðandi Stillingar,
Width of amount in word,Breidd upphæð í orði,
Line spacing for amount in words,Línubil fyrir fjárhæð í orðum,
Amount In Figure,Upphæð Á mynd,
Signatory Position,Undirritaður Staða,
Closed Document,Lokað skjal,
Track separate Income and Expense for product verticals or divisions.,Track sérstakt Vaxtatekjur og vaxtagjöld fyrir Þrep vöru eða deildum.,
Cost Center Name,Kostnaður Center Name,
Parent Cost Center,Parent Kostnaður Center,
lft,Lft,
rgt,rgt,
Coupon Code,afsláttarkóði,
Coupon Name,Afsláttarmiðaheiti,
"e.g. ""Summer Holiday 2019 Offer 20""",td „Sumarfrí 2019 tilboð 20“,
Coupon Type,Gerð afsláttarmiða,
Promotional,Kynningar,
Gift Card,Gjafakort,
unique e.g. SAVE20  To be used to get discount,einstakt td SAVE20 Til að nota til að fá afslátt,
Validity and Usage,Gildistími og notkun,
Maximum Use,Hámarksnotkun,
Used,Notað,
Coupon Description,Afsláttarmiða lýsing,
Discounted Invoice,Afsláttur reikninga,
Exchange Rate Revaluation,Gengisvísitala,
Get Entries,Fáðu færslur,
Exchange Rate Revaluation Account,Gengisvísitala endurskoðunar,
Total Gain/Loss,Heildargreiðsla / tap,
Balance In Account Currency,Jafnvægi í reiknings gjaldmiðli,
Current Exchange Rate,Núverandi gengi,
Balance In Base Currency,Jafnvægi í grunnvalmynd,
New Exchange Rate,Nýtt gengi,
New Balance In Base Currency,Nýtt jafnvægi í grunnvalmynd,
Gain/Loss,Hagnaður / tap,
**Fiscal Year** represents a Financial Year. All accounting entries and other major transactions are tracked against **Fiscal Year**.,** Fiscal Year ** táknar fjárhagsári. Öll bókhald færslur og aðrar helstu viðskipti eru raktar gegn ** Fiscal Year **.,
Year Name,ár Name,
"For e.g. 2012, 2012-13","Fyrir td 2012, 2012-13",
Year Start Date,Ár Start Date,
Year End Date,Ár Lokadagur,
Companies,Stofnanir,
Auto Created,Sjálfvirkt búið til,
Stock User,Stock User,
Fiscal Year Company,Reikningsár Company,
Debit Amount,debet Upphæð,
Credit Amount,Credit Upphæð,
Debit Amount in Account Currency,Debit Upphæð í Account Gjaldmiðill,
Credit Amount in Account Currency,Credit Upphæð í Account Gjaldmiðill,
Voucher Detail No,Skírteini Detail No,
Is Opening,er Opnun,
Is Advance,er Advance,
To Rename,Að endurnefna,
GST Account,GST reikning,
CGST Account,CGST reikningur,
SGST Account,SGST reikningur,
IGST Account,IGST reikningur,
CESS Account,CESS reikning,
Loan Start Date,Upphafsdagur lána,
Loan Period (Days),Lánstími (dagar),
Loan End Date,Lokadagur lána,
Bank Charges,Gjöld við banka,
Short Term Loan Account,Skammtímalánareikningur,
Bank Charges Account,Bankareikningsreikningur,
Accounts Receivable Credit Account,Viðskiptakröfur vegna viðskiptakrafna,
Accounts Receivable Discounted Account,Viðskiptakröfur Afsláttur reiknings,
Accounts Receivable Unpaid Account,Viðskiptakröfur Ógreiddur reikningur,
Item Tax Template,Sniðmát hlutar,
Tax Rates,Skattaverð,
Item Tax Template Detail,Upplýsingar um sniðmát hlutar,
Entry Type,Entry Type,
Inter Company Journal Entry,Inter Company Journal Entry,
Bank Entry,Bank Entry,
Cash Entry,Cash Entry,
Credit Card Entry,Credit Card Entry,
Contra Entry,contra Entry,
Excise Entry,vörugjöld Entry,
Write Off Entry,Skrifaðu Off færslu,
Opening Entry,opnun Entry,
ACC-JV-.YYYY.-,ACC-JV-.YYYY.-,
Accounting Entries,Bókhalds Færslur,
Total Debit,alls skuldfærsla,
Total Credit,alls Credit,
Difference (Dr - Cr),Munur (Dr - Cr),
Make Difference Entry,Gera Mismunur færslu,
Total Amount Currency,Heildarfjárhæð Gjaldmiðill,
Total Amount in Words,Heildarfjárhæð orðum,
Remark,athugasemd,
Paid Loan,Greiddur lán,
Inter Company Journal Entry Reference,Inter Company Journal Tilvísun Tilvísun,
Write Off Based On,Skrifaðu Off byggt á,
Get Outstanding Invoices,Fá útistandandi reikninga,
Printing Settings,prentun Stillingar,
Pay To / Recd From,Greiða til / Recd Frá,
Payment Order,Greiðslufyrirmæli,
Subscription Section,Áskriftarspurning,
Journal Entry Account,Journal Entry Reikningur,
Account Balance,Staða reiknings,
Party Balance,Party Balance,
If Income or Expense,Ef tekjur eða gjöld,
Exchange Rate,Exchange Rate,
Debit in Company Currency,Debet í félaginu Gjaldmiðill,
Credit in Company Currency,Credit í félaginu Gjaldmiðill,
Payroll Entry,Launaskrá,
Employee Advance,Starfsmaður,
Reference Due Date,Tilvísunardagsetning,
Loyalty Program Tier,Hollusta Program Tier,
Redeem Against,Innleysa gegn,
Expiry Date,Fyrningardagsetning,
Loyalty Point Entry Redemption,Innlán til hollustuháttar,
Redemption Date,Innlausnardagur,
Redeemed Points,Innleyst stig,
Loyalty Program Name,Hollusta Program Name,
Loyalty Program Type,Hollusta Program Tegund,
Single Tier Program,Single Tier Programme,
Multiple Tier Program,Margfeldi flokkaupplýsingar,
Customer Territory,Viðskiptavinur Territory,
Auto Opt In (For all customers),Sjálfkrafa valið (fyrir alla viðskiptavini),
Collection Tier,Collection Tier,
Collection Rules,Safneglur,
Redemption,Innlausn,
Conversion Factor,ummyndun Factor,
1 Loyalty Points = How much base currency?,1 hollusta stig = hversu mikið grunn gjaldmiðil?,
Expiry Duration (in days),Lengd gildistíma (í dögum),
Help Section,Hjálparsvið,
Loyalty Program Help,Hollusta Program Hjálp,
Loyalty Program Collection,Hollusta Program Collection,
Tier Name,Heiti heiti,
Minimum Total Spent,Lágmarks heildartekjur,
Collection Factor (=1 LP),Safnþáttur (= 1 LP),
For how much spent = 1 Loyalty Point,Fyrir hversu mikið eytt = 1 Hollusta,
Mode of Payment Account,Mode greiðslureikning,
Default Account,Sjálfgefið Reikningur,
Default account will be automatically updated in POS Invoice when this mode is selected.,Sjálfgefin reikningur verður sjálfkrafa uppfærð í POS Reikningur þegar þessi stilling er valin.,
**Monthly Distribution** helps you distribute the Budget/Target across months if you have seasonality in your business.,** Mánaðarleg dreifing ** hjálpar þér að dreifa fjárhagsáætlunar / Target yfir mánuði ef þú ert árstíðasveiflu í fyrirtæki þínu.,
Distribution Name,Dreifing Name,
Name of the Monthly Distribution,Heiti Monthly Distribution,
Monthly Distribution Percentages,Mánaðarleg Dreifing Prósentur,
Monthly Distribution Percentage,Mánaðarleg Dreifing Hlutfall,
Percentage Allocation,hlutfall Úthlutun,
Create Missing Party,Búðu til vantar aðila,
Create missing customer or supplier.,Búðu til vantar viðskiptavini eða birgi.,
Opening Invoice Creation Tool Item,Opnun Reikningur Verkfæri Tól,
Temporary Opening Account,Tímabundin opnunareikningur,
Party Account,Party Reikningur,
Type of Payment,Tegund greiðslu,
ACC-PAY-.YYYY.-,ACC-PAY-.YYYY.-,
Receive,fá,
Internal Transfer,innri Transfer,
Payment Order Status,Staða greiðslupöntunar,
Payment Ordered,Greiðsla pantað,
Payment From / To,Greiðsla Frá / Til,
Company Bank Account,Bankareikningur fyrirtækisins,
Party Bank Account,Bankareikningur aðila,
Account Paid From,Reikningur greitt frá,
Account Paid To,Reikningur Greiddur Til,
Paid Amount (Company Currency),Greiddur Magn (Company Gjaldmiðill),
Received Amount,fékk Upphæð,
Received Amount (Company Currency),Fékk Magn (Company Gjaldmiðill),
Get Outstanding Invoice,Fá framúrskarandi reikning,
Payment References,Greiðsla Tilvísanir,
Writeoff,Afskrifa,
Total Allocated Amount,Samtals úthlutað magn,
Total Allocated Amount (Company Currency),Total úthlutað magn (Company Gjaldmiðill),
Set Exchange Gain / Loss,Setja gengishagnaður / tap,
Difference Amount (Company Currency),Munurinn Magn (Company Gjaldmiðill),
Write Off Difference Amount,Skrifaðu Off Mismunur Upphæð,
Deductions or Loss,Frádráttur eða tap,
Payment Deductions or Loss,Greiðsla Frádráttur eða tap,
Cheque/Reference Date,Ávísun / Frestdagur,
Payment Entry Deduction,Greiðsla Entry Frádráttur,
Payment Entry Reference,Greiðsla Entry Tilvísun,
Allocated,úthlutað,
Payment Gateway Account,Greiðsla Gateway Reikningur,
Payment Account,greiðsla Reikningur,
Default Payment Request Message,Default Greiðsla Beiðni skilaboð,
PMO-,PMO-,
Payment Order Type,Tegund greiðslupöntunar,
Payment Order Reference,Greiðslumiðill,
Bank Account Details,Upplýsingar bankareiknings,
Payment Reconciliation,greiðsla Sættir,
Receivable / Payable Account,/ Viðskiptakröfur Account,
Bank / Cash Account,Bank / Cash Account,
From Invoice Date,Frá dagsetningu reiknings,
To Invoice Date,Til dagsetningu reiknings,
Minimum Invoice Amount,Lágmark Reikningsupphæð,
Maximum Invoice Amount,Hámarks Invoice Amount,
System will fetch all the entries if limit value is zero.,Kerfið sækir allar færslur ef viðmiðunarmörkin eru núll.,
Get Unreconciled Entries,Fá Unreconciled færslur,
Unreconciled Payment Details,Unreconciled Upplýsingar Greiðsla,
Invoice/Journal Entry Details,Invoice / Journal Entry Details,
Payment Reconciliation Invoice,Greiðsla Sættir Invoice,
Invoice Number,Reikningsnúmer,
Payment Reconciliation Payment,Greiðsla Sættir Greiðsla,
Reference Row,Tilvísun Row,
Allocated amount,úthlutað magn,
Payment Request Type,Greiðslubók Tegund,
Outward,Utan,
Inward,Innan,
ACC-PRQ-.YYYY.-,ACC-PRQ-.YYYY.-,
Transaction Details,Upplýsingar um viðskipti,
Amount in customer's currency,Upphæð í mynt viðskiptavinarins,
Is a Subscription,Er áskrift,
Transaction Currency,Færsla Gjaldmiðill,
Subscription Plans,Áskriftaráætlanir,
SWIFT Number,SWIFT númer,
Recipient Message And Payment Details,Viðtakandinn Message og greiðsluskilmálar,
Make Sales Invoice,Gera sölureikning,
Mute Email,Mute Email,
payment_url,payment_url,
Payment Gateway Details,Greiðsla Gateway Upplýsingar,
Payment Schedule,Greiðsluáætlun,
Invoice Portion,Reikningshluti,
Payment Amount,Greiðslu upphæð,
Payment Term Name,Nafn greiðsluheiti,
Due Date Based On,Gjalddagi Byggt á,
Day(s) after invoice date,Dagur / dagar eftir reikningsdag,
Day(s) after the end of the invoice month,Dagur / dagar eftir lok reiknings mánaðarins,
Month(s) after the end of the invoice month,Mánuður (s) eftir lok reiknings mánaðar,
Credit Days,Credit Days,
Credit Months,Lánshæfismat,
Payment Terms Template Detail,Greiðsluskilmálar Sniðmát smáatriði,
Closing Fiscal Year,Lokun fjárhagsársins,
Closing Account Head,Loka reikningi Head,
"The account head under Liability or Equity, in which Profit/Loss will be booked","Reikningurinn höfuð undir ábyrgð eða Equity, sem Hagnaður / Tap verður færður",
POS Customer Group,POS viðskiptavinar Group,
POS Field,POS sviði,
POS Item Group,POS Item Group,
[Select],[Veldu],
Company Address,Nafn fyrirtækis,
Update Stock,Uppfæra Stock,
Ignore Pricing Rule,Hunsa Verðlagning reglu,
Allow user to edit Rate,Leyfa notanda að breyta Meta,
Allow user to edit Discount,Leyfa notanda að breyta afslátt,
Allow Print Before Pay,Leyfa prentun áður en þú greiðir,
Display Items In Stock,Sýna vörur á lager,
Applicable for Users,Gildir fyrir notendur,
Sales Invoice Payment,Velta Invoice Greiðsla,
Item Groups,Item Hópar,
Only show Items from these Item Groups,Sýna aðeins hluti úr þessum vöruhópum,
Customer Groups,Hópar viðskiptavina,
Only show Customer of these Customer Groups,Sýna aðeins viðskiptavini þessara viðskiptavinahópa,
Print Format for Online,Prenta snið fyrir á netinu,
Offline POS Settings,POS stillingar án nettengingar,
Write Off Account,Skrifaðu Off reikning,
Write Off Cost Center,Skrifaðu Off Kostnaður Center,
Account for Change Amount,Reikningur fyrir Change Upphæð,
Taxes and Charges,Skattar og gjöld,
Apply Discount On,Gilda afsláttur á,
POS Profile User,POS prófíl notandi,
Use POS in Offline Mode,Notaðu POS í ótengdu ham,
Apply On,gilda um,
Price or Product Discount,Verð eða vöruafsláttur,
Apply Rule On Item Code,Notaðu reglu um hlutakóða,
Apply Rule On Item Group,Notaðu reglu um vöruhóp,
Apply Rule On Brand,Notaðu reglu um vörumerki,
Mixed Conditions,Blandaðar aðstæður,
Conditions will be applied on all the selected items combined. ,Skilyrðum verður beitt á alla valda hluti saman.,
Is Cumulative,Er uppsöfnuð,
Coupon Code Based,Byggt á afsláttarmiða kóða,
Discount on Other Item,Afsláttur af öðrum hlut,
Apply Rule On Other,Notaðu reglu um annað,
Party Information,Veisluupplýsingar,
Quantity and Amount,Magn og magn,
Min Qty,min Magn,
Max Qty,max Magn,
Min Amt,Min Amt,
Max Amt,Max Amt,
Period Settings,Tímabilstillingar,
Margin,spássía,
Margin Type,spássía Type,
Margin Rate or Amount,Framlegð hlutfall eða upphæð,
Price Discount Scheme,Verðafsláttarkerfi,
Rate or Discount,Verð eða afsláttur,
Discount Percentage,afsláttur Hlutfall,
Discount Amount,afsláttur Upphæð,
For Price List,Fyrir verðskrá,
Product Discount Scheme,Afsláttarkerfi vöru,
Same Item,Sami hlutur,
Free Item,Ókeypis hlutur,
Threshold for Suggestion,Þröskuldur fyrir tillögu,
System will notify to increase or decrease quantity or amount ,Kerfið mun láta vita um að auka eða minnka magn eða magn,
"Higher the number, higher the priority","Hærri sem talan, hærri forgang",
Apply Multiple Pricing Rules,Notaðu margar verðlagsreglur,
Apply Discount on Rate,Notaðu afslátt af gjaldi,
Validate Applied Rule,Staðfesta beitt reglu,
Rule Description,Reglulýsing,
Pricing Rule Help,Verðlagning Regla Hjálp,
Promotional Scheme Id,Kynningarfyrirkomulag kt,
Promotional Scheme,Kynningarkerfi,
Pricing Rule Brand,Verðlagsregla vörumerki,
Pricing Rule Detail,Upplýsingar um reglur um verðlagningu,
Child Docname,Barnalokanafn,
Rule Applied,Regla beitt,
Pricing Rule Item Code,Verðlagsregla atriðakóða,
Pricing Rule Item Group,Verðlagsregla hlutaflokks,
Price Discount Slabs,Verð afslátt plötum,
Promotional Scheme Price Discount,Kynningarverðsafsláttur,
Product Discount Slabs,Vara afslátt plötum,
Promotional Scheme Product Discount,Vöruafsláttur kynningar,
Min Amount,Lágmarks upphæð,
Max Amount,Hámarksfjöldi,
Discount Type,Tegund afsláttar,
ACC-PINV-.YYYY.-,ACC-PINV-.YYYY.-,
Tax Withholding Category,Skatthlutfall Flokkur,
Edit Posting Date and Time,Edit Staða Dagsetning og tími,
Is Paid,er greitt,
Is Return (Debit Note),Er skilað (skuldfærsla),
Apply Tax Withholding Amount,Sækja um skattframtal,
Accounting Dimensions ,Bókhaldsvíddir,
Supplier Invoice Details,Birgir Reikningsyfirlit,
Supplier Invoice Date,Birgir Dagsetning reiknings,
Return Against Purchase Invoice,Return Against kaupa Reikningar,
Select Supplier Address,Veldu Birgir Address,
Contact Person,Tengiliður,
Select Shipping Address,Veldu Shipping Address,
Currency and Price List,Gjaldmiðill og Verðskrá,
Price List Currency,Verðskrá Gjaldmiðill,
Price List Exchange Rate,Verðskrá Exchange Rate,
Set Accepted Warehouse,Setja samþykkt vöruhús,
Rejected Warehouse,hafnað Warehouse,
Warehouse where you are maintaining stock of rejected items,Warehouse þar sem þú ert að halda úttekt hafnað atriðum,
Raw Materials Supplied,Raw Materials Staðar,
Supplier Warehouse,birgir Warehouse,
Pricing Rules,Verðlagsreglur,
Supplied Items,Meðfylgjandi Items,
Total (Company Currency),Total (Company Gjaldmiðill),
Net Total (Company Currency),Net Total (Company Gjaldmiðill),
Total Net Weight,Samtals nettóþyngd,
Shipping Rule,Sendingar Regla,
Purchase Taxes and Charges Template,Purchase skatta og gjöld sniðmáti,
Purchase Taxes and Charges,Purchase skatta og gjöld,
Tax Breakup,Tax Breakup,
Taxes and Charges Calculation,Skattar og gjöld Útreikningur,
Taxes and Charges Added (Company Currency),Skattar og gjöld bætt (Company Gjaldmiðill),
Taxes and Charges Deducted (Company Currency),Skattar og gjöld FrÃ¡ (Company Gjaldmiðill),
Total Taxes and Charges (Company Currency),Samtals Skattar og gjöld (Company gjaldmiðli),
Taxes and Charges Added,Skattar og gjöld bætt,
Taxes and Charges Deducted,Skattar og gjöld FrÃ¡,
Total Taxes and Charges,Samtals Skattar og gjöld,
Additional Discount,Viðbótarupplýsingar Afsláttur,
Apply Additional Discount On,Berið Viðbótarupplýsingar afsláttur á,
Additional Discount Amount (Company Currency),Viðbótarupplýsingar Afsláttur Magn (Company Gjaldmiðill),
Grand Total (Company Currency),Grand Total (Company Gjaldmiðill),
Rounding Adjustment (Company Currency),Rounding Adjustment (Company Gjaldmiðill),
Rounded Total (Company Currency),Ávalur Total (Company Gjaldmiðill),
In Words (Company Currency),Í orðum (Company Gjaldmiðill),
Rounding Adjustment,Afrennslisbreyting,
In Words,í orðum,
Total Advance,alls Advance,
Disable Rounded Total,Slökkva á Ávalur Samtals,
Cash/Bank Account,Cash / Bank Account,
Write Off Amount (Company Currency),Skrifaðu Off Upphæð (Company Gjaldmiðill),
Set Advances and Allocate (FIFO),Setja framfarir og úthluta (FIFO),
Get Advances Paid,Fá Framfarir Greiddur,
Advances,framfarir,
Terms,Skilmálar,
Terms and Conditions1,Skilmálar og Conditions1,
Group same items,Group sömu atriði,
Print Language,Print Tungumál,
"Once set, this invoice will be on hold till the set date","Þegar sett er, verður þessi reikningur að vera í bið til upphafs dags",
Credit To,Credit Til,
Party Account Currency,Party Reikningur Gjaldmiðill,
Against Expense Account,Against kostnað reikning,
Inter Company Invoice Reference,Tilvísun í millifærslufyrirtæki,
Is Internal Supplier,Er innri birgir,
Start date of current invoice's period,Upphafsdagur tímabils núverandi reikningi er,
End date of current invoice's period,Lokadagur tímabils núverandi reikningi er,
Update Auto Repeat Reference,Uppfæra sjálfvirk endurtekið tilvísun,
Purchase Invoice Advance,Kaupa Reikningar Advance,
Purchase Invoice Item,Kaupa Reikningar Item,
Quantity and Rate,Magn og Rate,
Received Qty,fékk Magn,
Accepted Qty,Samþykkt magn,
Rejected Qty,hafnað Magn,
UOM Conversion Factor,UOM viðskipta Factor,
Discount on Price List Rate (%),Afsláttur á verðlista Rate (%),
Price List Rate (Company Currency),Verðlisti Rate (Company Gjaldmiðill),
Rate ,Gefa,
Rate (Company Currency),Hlutfall (Company Gjaldmiðill),
Amount (Company Currency),Upphæð (Company Gjaldmiðill),
Is Free Item,Er ókeypis hlutur,
Net Rate,Net Rate,
Net Rate (Company Currency),Net Rate (Company Gjaldmiðill),
Net Amount (Company Currency),Net Magn (Company Gjaldmiðill),
Item Tax Amount Included in Value,Fjárhæð skatta upphæð innifalin í verðmæti,
Landed Cost Voucher Amount,Landað Kostnaður skírteini Magn,
Raw Materials Supplied Cost,Raw Materials Staðar Kostnaður,
Accepted Warehouse,Samþykkt vöruhús,
Serial No,Raðnúmer,
Rejected Serial No,Hafnað Serial Nei,
Expense Head,Expense Head,
Is Fixed Asset,Er fast eign,
Asset Location,Eignastaða,
Deferred Expense,Frestað kostnað,
Deferred Expense Account,Frestað kostnaðarreikning,
Service Stop Date,Þjónustuskiladagsetning,
Enable Deferred Expense,Virkja frestaðan kostnað,
Service Start Date,Upphafsdagur þjónustunnar,
Service End Date,Þjónustudagsetning,
Allow Zero Valuation Rate,Leyfa núgildandi verðmæti,
Item Tax Rate,Liður Skatthlutfall,
Tax detail table fetched from item master as a string and stored in this field.\nUsed for Taxes and Charges,Tax smáatriði borð sóttu meistara lið sem streng og geyma á þessu sviði. Notað fyrir skatta og gjöld,
Purchase Order Item,Purchase Order Item,
Purchase Receipt Detail,Upplýsingar um kvittun kaupa,
Item Weight Details,Vara þyngd upplýsingar,
Weight Per Unit,Þyngd á hverja einingu,
Total Weight,Heildarþyngd,
Weight UOM,þyngd UOM,
Page Break,Page Break,
Consider Tax or Charge for,Íhuga skatta og álaga fyrir,
Valuation and Total,Verðmat og Total,
Valuation,verðmat,
Add or Deduct,Bæta eða draga,
Deduct,draga,
On Previous Row Amount,Á fyrri röð Upphæð,
On Previous Row Total,Á fyrri röð Total,
On Item Quantity,Um magn hlutar,
Reference Row #,Tilvísun Row #,
Is this Tax included in Basic Rate?,Er þetta Tax innifalinn í grunntaxta?,
"If checked, the tax amount will be considered as already included in the Print Rate / Print Amount",Ef hakað skattur upphæð verður að teljast þegar innifalið í Print Rate / Prenta Upphæð,
Account Head,Head Reikningur,
Tax Amount After Discount Amount,Skatthlutfall Eftir Afsláttur Upphæð,
"Standard tax template that can be applied to all Purchase Transactions. This template can contain list of tax heads and also other expense heads like ""Shipping"", ""Insurance"", ""Handling"" etc.\n\n#### Note\n\nThe tax rate you define here will be the standard tax rate for all **Items**. If there are **Items** that have different rates, they must be added in the **Item Tax** table in the **Item** master.\n\n#### Description of Columns\n\n1. Calculation Type: \n    - This can be on **Net Total** (that is the sum of basic amount).\n    - **On Previous Row Total / Amount** (for cumulative taxes or charges). If you select this option, the tax will be applied as a percentage of the previous row (in the tax table) amount or total.\n    - **Actual** (as mentioned).\n2. Account Head: The Account ledger under which this tax will be booked\n3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.\n4. Description: Description of the tax (that will be printed in invoices / quotes).\n5. Rate: Tax rate.\n6. Amount: Tax amount.\n7. Total: Cumulative total to this point.\n8. Enter Row: If based on ""Previous Row Total"" you can select the row number which will be taken as a base for this calculation (default is the previous row).\n9. Consider Tax or Charge for: In this section you can specify if the tax / charge is only for valuation (not a part of total) or only for total (does not add value to the item) or for both.\n10. Add or Deduct: Whether you want to add or deduct the tax.","Standard skatta sniðmát sem hægt er að beita öllum kaupfærslur. Þessi sniðmát geta innihaldið lista yfir skatta höfuð og einnig öðrum forstöðumönnum kostnaðarliði eins og &quot;Shipping&quot;, &quot;tryggingar&quot;, &quot;Meðhöndlun&quot; osfrv #### Athugið skatthlutfall þú velur hér verður staðallinn skatthlutfallið fyrir alla ** Items * *. Ef það eru ** Items ** sem hafa mismunandi verð, verður að bæta við í ** Item Tax ** borð í ** Liður ** meistara. #### Lýsing dálka 1. Útreikningur Type: - Þetta getur verið á ** Net Total ** (sem er summa grunnfjárhæð). - ** Á fyrri umf öllum / Upphæð ** (fyrir uppsöfnuð skatta eða gjöld). Ef þú velur þennan kost, að skattur verði beitt sem hlutfall af fyrri röðinni (í skatt töflu) fjárhæð eða samtals. - ** Raunveruleg ** (eins og getið). 2. Reikningur Head: The Account höfuðbók þar sem þessi skattur verður að bóka 3. Kostnaður Center: Ef skattur / gjald er tekjur (eins skipum) eða gjaldaliði það þarf að bóka á móti kostnaði sent. 4. Lýsing: Lýsing á skatta (sem verður prentað í reikningum / gæsalappa). 5. Gefa: Skatthlutfall. 6. Upphæð: Skatthlutfall. 7. Samtals: Uppsöfnuð alls að þessum tímapunkti. 8. Sláðu Row: Ef byggir á &quot;Fyrri Row Total&quot; getur þú valið línunúmeri sem verður tekið sem grunn fyrir þessum útreikningi (sjálfgefið er fyrri umf). 9. Íhuga skattur eða gjald fyrir: Í þessum kafla er hægt að tilgreina hvort skatturinn / gjald er aðeins fyrir mat (ekki hluti af öllum) eða aðeins fyrir samtals (ekki bæta gildi til hlutnum) eða bæði. 10. Bæta eða draga: Hvort sem þú vilt bæta við eða draga skatt.",
Salary Component Account,Laun Component Reikningur,
Default Bank / Cash account will be automatically updated in Salary Journal Entry when this mode is selected.,Default Bank / Cash reikningur verður sjálfkrafa uppfærð í laun dagbókarfærslu þegar þessi háttur er valinn.,
ACC-SINV-.YYYY.-,ACC-SINV-.YYYY.-,
Include Payment (POS),Fela Greiðsla (POS),
Offline POS Name,Offline POS Name,
Is Return (Credit Note),Er afturábak (lánshæfiseinkunn),
Return Against Sales Invoice,Return Against sölureikningi,
Update Billed Amount in Sales Order,Uppfærðu innheimta upphæð í sölupöntun,
Customer PO Details,Upplýsingar viðskiptavina,
Customer's Purchase Order,Viðskiptavinar Purchase Order,
Customer's Purchase Order Date,Viðskiptavinar Purchase Order Date,
Customer Address,viðskiptavinur Address,
Shipping Address Name,Sendingar Address Nafn,
Company Address Name,Nafn fyrirtækis fyrirtækis,
Rate at which Customer Currency is converted to customer's base currency,Gengi sem viðskiptavinir Gjaldmiðill er breytt til grunngj.miðil viðskiptavinarins,
Rate at which Price list currency is converted to customer's base currency,Gengi sem Verðskrá mynt er breytt í grunngj.miðil viðskiptavinarins,
Set Source Warehouse,Setja upprunavöruhús,
Packing List,Pökkunarlisti,
Packed Items,pakkað Items,
Product Bundle Help,Vara Knippi Hjálp,
Time Sheet List,Tími Sheet List,
Time Sheets,Tími Sheets,
Total Billing Amount,Alls innheimtu upphæð,
Sales Taxes and Charges Template,Velta Skattar og gjöld Sniðmátsmyndir,
Sales Taxes and Charges,Velta Skattar og gjöld,
Loyalty Points Redemption,Hollusta stig Innlausn,
Redeem Loyalty Points,Losaðu hollusta stig,
Redemption Account,Innlausnareikningur,
Redemption Cost Center,Innlausnarkostnaður,
In Words will be visible once you save the Sales Invoice.,Í orðum verður sýnileg þegar þú vistar sölureikningi.,
Allocate Advances Automatically (FIFO),Úthluta sjálfkrafa (FIFO),
Get Advances Received,Fá Framfarir móttekin,
Base Change Amount (Company Currency),Base Breyta Upphæð (Company Gjaldmiðill),
Write Off Outstanding Amount,Skrifaðu Off Útistandandi fjárhæð,
Terms and Conditions Details,Skilmálar og skilyrði Nánar,
Is Internal Customer,Er innri viðskiptavinur,
Is Discounted,Er afsláttur,
Unpaid and Discounted,Ógreiddur og afsláttur,
Overdue and Discounted,Forföll og afsláttur,
Accounting Details,Bókhalds Upplýsingar,
Debit To,debet Til,
Is Opening Entry,Er Opnun færslu,
C-Form Applicable,C-Form Gildir,
Commission Rate (%),Þóknun Rate (%),
Sales Team1,velta TEAM1,
Against Income Account,Against þáttatekjum,
Sales Invoice Advance,Velta Invoice Advance,
Advance amount,Advance Magn,
Sales Invoice Item,Velta Invoice Item,
Customer's Item Code,Liður viðskiptavinar Code,
Brand Name,Vörumerki,
Qty as per Stock UOM,Magn eins og á lager UOM,
Discount and Margin,Afsláttur og Framlegð,
Rate With Margin,Meta með skák,
Discount (%) on Price List Rate with Margin,Afsláttur (%) á Verðskrá Verð með Minni,
Rate With Margin (Company Currency),Meta með brún (Gjaldmiðill fyrirtækja),
Delivered By Supplier,Samþykkt með Birgir,
Deferred Revenue,Frestað tekjur,
Deferred Revenue Account,Frestað tekjuskattur,
Enable Deferred Revenue,Virkja frestað tekjur,
Stock Details,Stock Nánar,
Customer Warehouse (Optional),Viðskiptavinur Warehouse (Valfrjálst),
Available Batch Qty at Warehouse,Laus Hópur Magn á Lager,
Available Qty at Warehouse,Laus Magn á Lager,
Delivery Note Item,Afhending Note Item,
Base Amount (Company Currency),Base Magn (Company Gjaldmiðill),
Sales Invoice Timesheet,Velta Invoice Timesheet,
Time Sheet,Tímatafla,
Billing Hours,Billing Hours,
Timesheet Detail,timesheet Detail,
Tax Amount After Discount Amount (Company Currency),Skatthlutfall Eftir Afsláttur Upphæð (Company Gjaldmiðill),
Item Wise Tax Detail,Liður Wise Tax Nánar,
Parenttype,Parenttype,
"Standard tax template that can be applied to all Sales Transactions. This template can contain list of tax heads and also other expense / income heads like ""Shipping"", ""Insurance"", ""Handling"" etc.\n\n#### Note\n\nThe tax rate you define here will be the standard tax rate for all **Items**. If there are **Items** that have different rates, they must be added in the **Item Tax** table in the **Item** master.\n\n#### Description of Columns\n\n1. Calculation Type: \n    - This can be on **Net Total** (that is the sum of basic amount).\n    - **On Previous Row Total / Amount** (for cumulative taxes or charges). If you select this option, the tax will be applied as a percentage of the previous row (in the tax table) amount or total.\n    - **Actual** (as mentioned).\n2. Account Head: The Account ledger under which this tax will be booked\n3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.\n4. Description: Description of the tax (that will be printed in invoices / quotes).\n5. Rate: Tax rate.\n6. Amount: Tax amount.\n7. Total: Cumulative total to this point.\n8. Enter Row: If based on ""Previous Row Total"" you can select the row number which will be taken as a base for this calculation (default is the previous row).\n9. Is this Tax included in Basic Rate?: If you check this, it means that this tax will not be shown below the item table, but will be included in the Basic Rate in your main item table. This is useful where you want give a flat price (inclusive of all taxes) price to customers.","Standard skatta sniðmát sem hægt er að beita öllum sölu viðskiptum. Þessi sniðmát geta innihaldið lista yfir skatta höfuð og einnig öðrum höfuð kostnað / tekjur eins og &quot;Shipping&quot;, &quot;tryggingar&quot;, &quot;Meðhöndlun&quot; osfrv #### Athugið skatthlutfall þú velur hér verður staðallinn skatthlutfallið fyrir alla ** atriði **. Ef það eru ** Items ** sem hafa mismunandi verð, verður að bæta við í ** Item Tax ** borð í ** Liður ** meistara. #### Lýsing dálka 1. Útreikningur Type: - Þetta getur verið á ** Net Total ** (sem er summa grunnfjárhæð). - ** Á fyrri umf öllum / Upphæð ** (fyrir uppsöfnuð skatta eða gjöld). Ef þú velur þennan kost, að skattur verði beitt sem hlutfall af fyrri röðinni (í skatt töflu) fjárhæð eða samtals. - ** Raunveruleg ** (eins og getið). 2. Reikningur Head: The Account höfuðbók þar sem þessi skattur verður að bóka 3. Kostnaður Center: Ef skattur / gjald er tekjur (eins skipum) eða gjaldaliði það þarf að bóka á móti kostnaði sent. 4. Lýsing: Lýsing á skatta (sem verður prentað í reikningum / gæsalappa). 5. Gefa: Skatthlutfall. 6. Upphæð: Skatthlutfall. 7. Samtals: Uppsöfnuð alls að þessum tímapunkti. 8. Sláðu Row: Ef byggir á &quot;Fyrri Row Total&quot; getur þú valið línunúmeri sem verður tekið sem grunn fyrir þessum útreikningi (sjálfgefið er fyrri umf). 9. Er þetta Tax innifalinn í grunntaxta ?: Ef þú athuga þetta, þá þýðir það að þessi skattur verður ekki sýnd hér fyrir neðan hlutnum borð, en verður innifalið í grunntaxta í helstu atriði töflunni. Þetta er gagnlegt þar sem þú vilt gefa íbúð verð (að meðtöldum öllum sköttum) verð til viðskiptavina.",
* Will be calculated in the transaction.,* Verður að reikna í viðskiptunum.,
From No,Frá nr,
To No,Til nr,
Is Company,Er félagið,
Current State,Núverandi staða,
Purchased,Keypt,
From Shareholder,Frá hluthafa,
From Folio No,Frá Folio nr,
To Shareholder,Til hluthafa,
To Folio No,Til Folio nr,
Equity/Liability Account,Eigið / ábyrgðareikningur,
Asset Account,Eignareikningur,
(including),(þ.mt),
ACC-SH-.YYYY.-,ACC-SH-.YYYY.-,
Folio no.,Folio nr.,
Contact List,Tengiliðir,
Hidden list maintaining the list of contacts linked to Shareholder,Falinn listi heldur lista yfir tengiliði sem tengjast hluthafa,
Specify conditions to calculate shipping amount,Tilgreina skilyrði til að reikna sendingarkostnað upphæð,
Shipping Rule Label,Sendingar Regla Label,
example: Next Day Shipping,dæmi: Næsti dagur Shipping,
Shipping Rule Type,Sendingartegund Tegund,
Shipping Account,Sendingar Account,
Calculate Based On,Reikna miðað við,
Fixed,Fastur,
Net Weight,Net Weight,
Shipping Amount,Sendingar Upphæð,
Shipping Rule Conditions,Shipping regla Skilyrði,
Restrict to Countries,Takmarka við lönd,
Valid for Countries,Gildir fyrir löndum,
Shipping Rule Condition,Sendingar Regla Ástand,
A condition for a Shipping Rule,Skilyrði fyrir Shipping reglu,
From Value,frá Value,
To Value,til Value,
Shipping Rule Country,Sendingar Regla Country,
Subscription Period,Áskriftartímabil,
Subscription Start Date,Upphafsdagsetning,
Cancelation Date,Hætta við dagsetningu,
Trial Period Start Date,Upphafsdagur prófunartímabils,
Trial Period End Date,Prófunartímabil Lokadagur,
Current Invoice Start Date,Núverandi upphafsreikningur reiknings,
Current Invoice End Date,Núverandi reikningsskiladagur,
Days Until Due,Dagar til dags,
Number of days that the subscriber has to pay invoices generated by this subscription,Fjöldi daga sem áskrifandi þarf að greiða reikninga sem myndast með þessari áskrift,
Cancel At End Of Period,Hætta við lok tímabils,
Generate Invoice At Beginning Of Period,Búðu til reikning við upphaf tímabils,
Plans,Áætlanir,
Discounts,Afslættir,
Additional DIscount Percentage,Viðbótarupplýsingar Afsláttur Hlutfall,
Additional DIscount Amount,Viðbótarupplýsingar Afsláttur Upphæð,
Subscription Invoice,Áskriftargjald,
Subscription Plan,Áskriftaráætlun,
Price Determination,Verðsamanburður,
Fixed rate,Fast gjald,
Based on price list,Byggt á verðskrá,
Cost,Kostnaður,
Billing Interval,Innheimtuinterval,
Billing Interval Count,Greiðslumiðlunartala,
"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","Fjöldi millibils fyrir bilið, td ef bilið er &#39;dagar&#39; og innheimtugildi er 3, reikningar verða búnar til á 3 daga fresti",
Payment Plan,Greiðsluáætlun,
Subscription Plan Detail,Áskriftaráætlun smáatriði,
Plan,Áætlun,
Subscription Settings,Áskriftarstillingar,
Grace Period,Grace Period,
Number of days after invoice date has elapsed before canceling subscription or marking subscription as unpaid,Fjöldi daga eftir að reikningsdagur er liðinn áður en áskrift er felld niður eða áskriftarmerki ógreiddur,
Cancel Invoice After Grace Period,Hætta við innheimtu eftir náðartíma,
Prorate,Prorate,
Tax Rule,Tax Regla,
Tax Type,Tax Type,
Use for Shopping Cart,Nota fyrir Shopping Cart,
Billing City,Innheimta City,
Billing County,Innheimta County,
Billing State,Innheimta State,
Billing Zipcode,Innheimtu póstnúmer,
Billing Country,Innheimta Country,
Shipping City,Sendingar City,
Shipping County,Sendingar County,
Shipping State,Sendingar State,
Shipping Zipcode,Sendingarkóði,
Shipping Country,Sendingar Country,
Tax Withholding Account,Skattgreiðslureikningur,
Tax Withholding Rates,Skatthlutfall,
Rates,Verð,
Tax Withholding Rate,Skatthlutfall,
Single Transaction Threshold,Einstaklingsviðmiðunarmörk,
Cumulative Transaction Threshold,Uppsöfnuð viðskiptaþröskuldur,
Agriculture Analysis Criteria,Landbúnaður Greining Criteria,
Linked Doctype,Tengd Doctype,
Water Analysis,Vatnsgreining,
Soil Analysis,Jarðgreining,
Plant Analysis,Plant Greining,
Fertilizer,Áburður,
Soil Texture,Jarðvegur áferð,
Weather,Veður,
Agriculture Manager,Landbúnaðarstjóri,
Agriculture User,Landbúnaður Notandi,
Agriculture Task,Landbúnaður Verkefni,
Start Day,Byrjaðu daginn,
End Day,Lokadagur,
Holiday Management,Holiday Management,
Ignore holidays,Hunsa frí,
Previous Business Day,Fyrri viðskiptadagur,
Next Business Day,Næsta viðskiptadagur,
Urgent,Urgent,
Crop,Skera,
Crop Name,Skera nafn,
Scientific Name,Vísindalegt nafn,
"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.. ","Þú getur skilgreint öll þau verkefni sem þurfa að fara fram fyrir þessa ræktun hér. Dagurinn er notaður til að nefna þann dag sem verkefnið þarf að fara fram, 1 er fyrsta daginn, osfrv.",
Crop Spacing,Crop Spacing,
Crop Spacing UOM,Skera breiða UOM,
Row Spacing,Row Spacing,
Row Spacing UOM,Row Spacing UOM,
Perennial,Ævarandi,
Biennial,Biennial,
Planting UOM,Gróðursetning UOM,
Planting Area,Gróðursetningarsvæði,
Yield UOM,Afrakstur UOM,
Materials Required,Efni sem krafist er,
Produced Items,Framleiddir hlutir,
Produce,Framleiða,
Byproducts,Byproducts,
Linked Location,Tengd staðsetning,
A link to all the Locations in which the Crop is growing,Tengill til allra staða þar sem skógurinn er að vaxa,
This will be day 1 of the crop cycle,Þetta verður dagur 1 í ræktunarferlinu,
ISO 8601 standard,ISO 8601 staðall,
Cycle Type,Hringrásartegund,
Less than a year,Minna en ár,
The minimum length between each plant in the field for optimum growth,Lágmarkslengdin milli hvers plöntu á vettvangi fyrir bestu vöxt,
The minimum distance between rows of plants for optimum growth,Lágmarksfjarlægðin milli raða plantna fyrir bestu vöxt,
Detected Diseases,Uppgötvaðir sjúkdómar,
List of diseases detected on the field. When selected it'll automatically add a list of tasks to deal with the disease ,Listi yfir sjúkdóma sem finnast á þessu sviði. Þegar það er valið mun það bæta sjálfkrafa lista yfir verkefni til að takast á við sjúkdóminn,
Detected Disease,Uppgötvað sjúkdómur,
LInked Analysis,Linkað greining,
Disease,Sjúkdómur,
Tasks Created,Verkefni búin til,
Common Name,Algengt nafn,
Treatment Task,Meðferðarlisti,
Treatment Period,Meðferðartímabil,
Fertilizer Name,Áburður Nafn,
Density (if liquid),Density (ef vökvi),
Fertilizer Contents,Innihald áburðar,
Fertilizer Content,Áburður innihaldsefni,
Linked Plant Analysis,Tengd planta greining,
Linked Soil Analysis,Tengd jarðvegsgreining,
Linked Soil Texture,Tengd jarðvegur áferð,
Collection Datetime,Safn Datetime,
Laboratory Testing Datetime,Laboratory Testing Datetime,
Result Datetime,Niðurstaða Datetime,
Plant Analysis Criterias,Greiningarkerfi plantna,
Plant Analysis Criteria,Greiningarkerfi plantna,
Minimum Permissible Value,Lágmarks leyfilegt gildi,
Maximum Permissible Value,Hámarks leyfilegt gildi,
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,Jarðgreiningarkröfur,
Soil Analysis Criteria,Jarðgreiningarmörk,
Soil Type,Jarðvegsgerð,
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 (%),Leir Samsetning (%),
Sand Composition (%),Sand samsetning (%),
Silt Composition (%),Silt Samsetning (%),
Ternary Plot,Ternary plot,
Soil Texture Criteria,Jarðvegur Texture Criteria,
Type of Sample,Tegund sýni,
Container,Ílát,
Origin,Uppruni,
Collection Temperature ,Safn hitastig,
Storage Temperature,Geymslu hiti,
Appearance,Útlit,
Person Responsible,Persónuvernd,
Water Analysis Criteria,Vatn greining Criteria,
Weather Parameter,Veðurparameter,
ACC-ASS-.YYYY.-,ACC-ASS-.YYYY.-,
Asset Owner,Eigandi eigna,
Asset Owner Company,Eignarhaldsfélag,
Custodian,Vörsluaðili,
Disposal Date,förgun Dagsetning,
Journal Entry for Scrap,Journal Entry fyrir rusl,
Available-for-use Date,Dagsetning í boði fyrir notkun,
Calculate Depreciation,Reikna afskriftir,
Allow Monthly Depreciation,Leyfa afskriftir mánaðarlega,
Number of Depreciations Booked,Fjöldi Afskriftir Bókað,
Finance Books,Fjármálabækur,
Straight Line,Bein lína,
Double Declining Balance,Tvöfaldur Minnkandi Balance,
Manual,Manual,
Value After Depreciation,Gildi Eftir Afskriftir,
Total Number of Depreciations,Heildarfjöldi Afskriftir,
Frequency of Depreciation (Months),Tíðni Afskriftir (mánuðir),
Next Depreciation Date,Næsta Afskriftir Dagsetning,
Depreciation Schedule,Afskriftir Stundaskrá,
Depreciation Schedules,afskriftir Skrár,
Policy number,Lögreglu númer,
Insurer,Vátryggjandi,
Insured value,Vátryggð gildi,
Insurance Start Date,Tryggingar upphafsdagur,
Insurance End Date,Tryggingar lokadagur,
Comprehensive Insurance,Alhliða trygging,
Maintenance Required,Viðhald nauðsynlegt,
Check if Asset requires Preventive Maintenance or Calibration,Athugaðu hvort eignir krefjast fyrirbyggjandi viðhalds eða kvörðunar,
Booked Fixed Asset,Bókað fast eign,
Purchase Receipt Amount,Innheimtufjárhæð,
Default Finance Book,Sjálfgefið fjármálabók,
Quality Manager,gæðastjóri,
Asset Category Name,Asset Flokkur Nafn,
Depreciation Options,Afskriftir Valkostir,
Enable Capital Work in Progress Accounting,Virkja fjármagnsvinnu í vinnslu bókhald,
Finance Book Detail,Fjármálabók smáatriði,
Asset Category Account,Asset Flokkur Reikningur,
Fixed Asset Account,Fast Asset Reikningur,
Accumulated Depreciation Account,Uppsöfnuðum afskriftum Reikningur,
Depreciation Expense Account,Afskriftir kostnað reiknings,
Capital Work In Progress Account,Capital vinna í framfarir reikning,
Asset Finance Book,Eignarhaldsbók,
Written Down Value,Skrifað niður gildi,
Depreciation Start Date,Afskriftir upphafsdagur,
Expected Value After Useful Life,Væntanlegur Value Eftir gagnlegur líf,
Rate of Depreciation,Afskriftatíðni,
In Percentage,Í prósentu,
Select Serial No,Veldu raðnúmer,
Maintenance Team,Viðhaldsteymi,
Maintenance Manager Name,Nafn viðhaldsstjórans,
Maintenance Tasks,Viðhaldsverkefni,
Manufacturing User,framleiðsla User,
Asset Maintenance Log,Rekstrarleiki eigna,
ACC-AML-.YYYY.-,ACC-AML-.YYYY.-,
Maintenance Type,viðhald Type,
Maintenance Status,viðhald Staða,
Planned,Planað,
Actions performed,Aðgerðir gerðar,
Asset Maintenance Task,Viðhaldsverkefni eigna,
Maintenance Task,Viðhaldsviðskipti,
Preventive Maintenance,Fyrirbyggjandi viðhald,
Calibration,Kvörðun,
2 Yearly,2 árlega,
Certificate Required,Vottorð sem krafist er,
Next Due Date,Næsta gjalddagi,
Last Completion Date,Síðasti lokadagur,
Asset Maintenance Team,Eignastýringarteymi,
Maintenance Team Name,Viðhald Team Name,
Maintenance Team Members,Viðhaldsliðsmenn,
Purpose,Tilgangur,
Stock Manager,Stock Manager,
Asset Movement Item,Liður eignahreyfingar,
Source Location,Heimild Staðsetning,
From Employee,frá starfsmanni,
Target Location,Markmið staðsetningar,
To Employee,Til starfsmanns,
Asset Repair,Eignastýring,
ACC-ASR-.YYYY.-,ACC-ASR-.YYYY.-,
Failure Date,Bilunardagur,
Assign To Name,Úthluta til nafns,
Repair Status,Viðgerðarstaða,
Error Description,Villa lýsing,
Downtime,Niður í miðbæ,
Repair Cost,Viðgerðarkostnaður,
Manufacturing Manager,framleiðsla Manager,
Current Asset Value,Núverandi eignvirði,
New Asset Value,Nýr eignvirði,
Make Depreciation Entry,Gera Afskriftir færslu,
Finance Book Id,Fjármálabókin,
Location Name,Staðsetningarheiti,
Parent Location,Foreldri Location,
Is Container,Er ílát,
Check if it is a hydroponic unit,Athugaðu hvort það sé vatnsheld eining,
Location Details,Staðsetningarupplýsingar,
Latitude,Breidd,
Longitude,Lengdargráða,
Area,Svæði,
Area UOM,Svæði UOM,
Tree Details,Tree Upplýsingar,
Maintenance Team Member,Viðhaldsliðsmaður,
Team Member,Liðsfélagi,
Maintenance Role,Viðhald Hlutverk,
Buying Settings,Kaup Stillingar,
Settings for Buying Module,Stillingar fyrir Buying Module,
Supplier Naming By,Birgir Nafngift By,
Default Supplier Group,Sjálfgefið Birgir Group,
Default Buying Price List,Sjálfgefið Buying Verðskrá,
Maintain same rate throughout purchase cycle,Halda sama hlutfall allan kaup hringrás,
Allow Item to be added multiple times in a transaction,Leyfa Atriði til að bæta við mörgum sinnum í viðskiptum,
Backflush Raw Materials of Subcontract Based On,Backflush Raw Materials undirverktaka Byggt á,
Material Transferred for Subcontract,Efni flutt fyrir undirverktaka,
Over Transfer Allowance (%),Yfirfærsla vegna yfirfærslu (%),
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.,Hlutfall sem þú hefur leyfi til að flytja meira miðað við það magn sem pantað er. Til dæmis: Ef þú hefur pantað 100 einingar. og vasapeningurinn þinn er 10% þá hefurðu leyfi til að flytja 110 einingar.,
PUR-ORD-.YYYY.-,PUR-ORD-.YYYY.-,
Get Items from Open Material Requests,Fá atriði úr Open Efni Beiðnir,
Required By,krafist er í,
Order Confirmation No,Panta staðfestingar nr,
Order Confirmation Date,Panta staðfestingardag,
Customer Mobile No,Viðskiptavinur Mobile Nei,
Customer Contact Email,Viðskiptavinur samband við Tölvupóstur,
Set Target Warehouse,Setja miða vörugeymslu,
Supply Raw Materials,Supply Raw Materials,
Purchase Order Pricing Rule,Reglu um innkaupapöntun,
Set Reserve Warehouse,Setja varalager,
In Words will be visible once you save the Purchase Order.,Í orðum verður sýnileg þegar þú hefur vistað Purchase Order.,
Advance Paid,Advance Greiddur,
% Billed,% Billed,
% Received,% móttekin,
Ref SQ,Ref SQ,
Inter Company Order Reference,Tilvísun Inter fyrirtækisins,
Supplier Part Number,Birgir Part Number,
Billed Amt,billed Amt,
Warehouse and Reference,Warehouse og Tilvísun,
To be delivered to customer,Til að vera frelsari til viðskiptavina,
Material Request Item,Efni Beiðni Item,
Supplier Quotation Item,Birgir Tilvitnun Item,
Against Blanket Order,Gegn teppapöntun,
Blanket Order,Teppi panta,
Blanket Order Rate,Teppisverð fyrir teppi,
Returned Qty,Kominn Magn,
Purchase Order Item Supplied,Purchase Order Item Staðar,
BOM Detail No,BOM Detail No,
Stock Uom,Stock UOM,
Raw Material Item Code,Raw Material Item Code,
Supplied Qty,Staðar Magn,
Purchase Receipt Item Supplied,Kvittun Item Staðar,
Current Stock,Núverandi Stock,
PUR-RFQ-.YYYY.-,PUR-RFQ-.YYYY.-,
For individual supplier,Fyrir einstaka birgi,
Supplier Detail,birgir Detail,
Message for Supplier,Skilaboð til Birgir,
Request for Quotation Item,Beiðni um Tilvitnun Item,
Required Date,Áskilið Dagsetning,
Request for Quotation Supplier,Beiðni um Tilvitnun Birgir,
Send Email,Senda tölvupóst,
Quote Status,Tilvitnun Staða,
Download PDF,Sækja PDF,
Supplier of Goods or Services.,Seljandi vöru eða þjónustu.,
Name and Type,Nafn og tegund,
SUP-.YYYY.-,SUP-.YYYY.-,
Default Bank Account,Sjálfgefið Bank Account,
Is Transporter,Er flutningsaðili,
Represents Company,Táknar fyrirtæki,
Supplier Type,birgir Type,
Warn RFQs,Varða RFQs,
Warn POs,Varið PO,
Prevent RFQs,Hindra RFQs,
Prevent POs,Hindra POs,
Billing Currency,Innheimta Gjaldmiðill,
Default Payment Terms Template,Sjálfgefin greiðsluskilmálar sniðmát,
Block Supplier,Block Birgir,
Hold Type,Haltu tegund,
Leave blank if the Supplier is blocked indefinitely,Leyfi tómt ef birgir er lokað að eilífu,
Default Payable Accounts,Sjálfgefin greiðast reikningar,
Mention if non-standard payable account,Tilgreindu ef ekki staðlað greiðslureikningur,
Default Tax Withholding Config,Sjálfgefið skatthlutfall,
Supplier Details,birgir Upplýsingar,
Statutory info and other general information about your Supplier,Lögbundin upplýsingar og aðrar almennar upplýsingar um birgir,
PUR-SQTN-.YYYY.-,PUR-SQTN-.YYYY.-,
Supplier Address,birgir Address,
Link to material requests,Tengill á efni beiðna,
Rounding Adjustment (Company Currency,Afrennslisbreyting (Fyrirtæki Gjaldmiðill,
Auto Repeat Section,Sjálfvirk endurtekin þáttur,
Is Subcontracted,er undirverktöku,
Lead Time in days,Lead Time í dögum,
Supplier Score,Birgiratriði,
Indicator Color,Vísir Litur,
Evaluation Period,Matartímabil,
Per Week,Á viku,
Per Month,Á mánuði,
Per Year,Hvert ár,
Scoring Setup,Skora uppsetning,
Weighting Function,Vigtunarhlutverk,
"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","Nota má punktabreytur, svo og: {total_score} (heildarskoran frá því tímabili), {tímabil_númer} (fjöldi tímabila til dagsins í dag)",
Scoring Standings,Stigagjöf,
Criteria Setup,Viðmiðunarskipulag,
Load All Criteria,Hlaðið öll viðmið,
Scoring Criteria,Stigatöflu,
Scorecard Actions,Stigatafla,
Warn for new Request for Quotations,Varið við nýja beiðni um tilboðsyfirlit,
Warn for new Purchase Orders,Varið við nýjar innkaupapantanir,
Notify Supplier,Tilkynna birgir,
Notify Employee,Tilkynna starfsmann,
Supplier Scorecard Criteria,Birgir Scorecard Criteria,
Criteria Name,Viðmiðunarheiti,
Max Score,Hámarksstig,
Criteria Formula,Viðmiðunarformúla,
Criteria Weight,Viðmiðunarþyngd,
Supplier Scorecard Period,Birgir Tímabil,
PU-SSP-.YYYY.-,PU-SSP-.YYYY.-,
Period Score,Tímabilsstig,
Calculations,Útreikningar,
Criteria,Viðmiðanir,
Variables,Variables,
Supplier Scorecard Setup,Birgir Scorecard Skipulag,
Supplier Scorecard Scoring Criteria,Birgir Scorecard Scoring Criteria,
Score,Mark,
Supplier Scorecard Scoring Standing,Birgir Scorecard Scoring Standing,
Standing Name,Stöðugt nafn,
Min Grade,Min Grade,
Max Grade,Hámarksstig,
Warn Purchase Orders,Varið innkaupapantanir,
Prevent Purchase Orders,Hindra innkaupapantanir,
Employee ,Starfsmaður,
Supplier Scorecard Scoring Variable,Birgir Scorecard Scoring Variable,
Variable Name,Breytilegt nafn,
Parameter Name,Parameter Name,
Supplier Scorecard Standing,Birgir Stuðningskort Standandi,
Notify Other,Tilkynna Annað,
Supplier Scorecard Variable,Birgir Vottorð Variable,
Call Log,Símtala skrá,
Received By,Móttekið af,
Caller Information,Upplýsingar sem hringir í,
Contact Name,Nafn tengiliðar,
Lead Name,Lead Name,
Ringing,Hringit,
Missed,Saknað,
Call Duration in seconds,Lengd símtala í sekúndum,
Recording URL,Upptöku URL,
Communication Medium,Samskipti Medium,
Communication Medium Type,Samskiptamiðill tegund,
Voice,Rödd,
Catch All,Afli allra,
"If there is no assigned timeslot, then communication will be handled by this group","Ef það er enginn úthlutaður tímaröð, þá mun samskipti fara með þennan hóp",
Timeslots,Tímamót,
Communication Medium Timeslot,Samskipti miðlungs tímaröð,
Employee Group,Starfsmannahópur,
Appointment,Skipun,
Scheduled Time,Tímaáætlun,
Unverified,Óstaðfest,
Customer Details,Nánar viðskiptavina,
Phone Number,Símanúmer,
Skype ID,Skype ID,
Linked Documents,Tengd skjöl,
Appointment With,Ráðning með,
Calendar Event,Viðburður dagatalsins,
Appointment Booking Settings,Stillingar fyrir bókun stefnumóta,
Enable Appointment Scheduling,Virkja tímaáætlun,
Agent Details,Umboðsaðili,
Availability Of Slots,Framboð rifa,
Number of Concurrent Appointments,Fjöldi samráðs tíma,
Agents,Umboðsmenn,
Appointment Details,Upplýsingar um skipan,
Appointment Duration (In Minutes),Lengd stefnumóts (eftir nokkrar mínútur),
Notify Via Email,Látið vita með tölvupósti,
Notify customer and agent via email on the day of the appointment.,Láttu viðskiptavini og umboðsmann vita með tölvupósti á skipunardaginn.,
Number of days appointments can be booked in advance,Hægt er að bóka fjölda daga fyrirfram,
Success Settings,Árangursstillingar,
Success Redirect URL,Vefslóð til að beina árangri,
"Leave blank for home.\nThis is relative to site URL, for example ""about"" will redirect to ""https://yoursitename.com/about""","Skildu auðan heima. Þetta er miðað við vefslóð vefsins, til dæmis &quot;um&quot; vísar til &quot;https://yoursitename.com/about&quot;",
Appointment Booking Slots,Ráðning bókun rifa,
From Time ,frá Time,
Campaign Email Schedule,Netfang áætlunar herferðar,
Send After (days),Senda eftir (daga),
Signed,Undirritaður,
Party User,Party notandi,
Unsigned,Óskráð,
Fulfilment Status,Uppfyllingarstaða,
N/A,N / A,
Unfulfilled,Ófullnægjandi,
Partially Fulfilled,Að hluta til uppfyllt,
Fulfilled,Uppfyllt,
Lapsed,Horfið,
Contract Period,Samningstími,
Signee Details,Signee Upplýsingar,
Signee,Signee,
Signed On,Skráður á,
Contract Details,Samningsupplýsingar,
Contract Template,Samningur Sniðmát,
Contract Terms,Samningsskilmálar,
Fulfilment Details,Uppfyllingarupplýsingar,
Requires Fulfilment,Krefst uppfylla,
Fulfilment Deadline,Uppfyllingardagur,
Fulfilment Terms,Uppfyllingarskilmálar,
Contract Fulfilment Checklist,Samningur Uppfylling Checklist,
Requirement,Kröfu,
Contract Terms and Conditions,Samningsskilmálar og skilyrði,
Fulfilment Terms and Conditions,Uppfyllingarskilmálar og skilyrði,
Contract Template Fulfilment Terms,Samningsskilmál Skilgreining Skilmálar,
Email Campaign,Netfang herferð,
Email Campaign For ,Netfang herferð fyrir,
Lead is an Organization,Lead er stofnun,
CRM-LEAD-.YYYY.-,CRM-LEAD-.YYYY.-,
Person Name,Sá Name,
Lost Quotation,Lost Tilvitnun,
Interested,áhuga,
Converted,converted,
Do Not Contact,Ekki samband,
From Customer,frá viðskiptavinar,
Campaign Name,Heiti herferðar,
Follow Up,Fylgja eftir,
Next Contact By,Næsta Samband með,
Next Contact Date,Næsta samband við þann,
Address & Contact,Heimilisfang &amp; Hafa samband,
Mobile No.,Mobile No.,
Lead Type,Lead Tegund,
Channel Partner,Channel Partner,
Consultant,Ráðgjafi,
Market Segment,Market Segment,
Industry,Iðnaður,
Request Type,Beiðni Type,
Product Enquiry,vara Fyrirspurnir,
Request for Information,Beiðni um upplýsingar,
Suggestions,tillögur,
Blog Subscriber,Blog Notandanúmer,
Lost Reason Detail,Upplýsingar um glataða ástæðu,
Opportunity Lost Reason,Tækifærið misst ástæða,
Potential Sales Deal,Hugsanleg sala Deal,
CRM-OPP-.YYYY.-,CRM-OPP-.YYYY.-,
Opportunity From,tækifæri Frá,
Customer / Lead Name,Viðskiptavinur / Lead Name,
Opportunity Type,tækifæri Type,
Converted By,Umbreytt af,
Sales Stage,Sala stigi,
Lost Reason,Lost Ástæða,
To Discuss,Að ræða,
With Items,með atriði,
Probability (%),Líkur (%),
Contact Info,Contact Info,
Customer / Lead Address,Viðskiptavinur / Lead Address,
Contact Mobile No,Viltu samband við Mobile Nei,
Enter name of campaign if source of enquiry is campaign,Sláðu inn heiti herferðarinnar ef uppspretta rannsókn er herferð,
Opportunity Date,tækifæri Dagsetning,
Opportunity Item,tækifæri Item,
Basic Rate,Basic Rate,
Stage Name,Sviðsnafn,
Term Name,Term Name,
Term Start Date,Term Start Date,
Term End Date,Term Lokadagur,
Academics User,fræðimenn User,
Academic Year Name,Skólaárinu Name,
Article,Grein,
LMS User,LMS notandi,
Assessment Criteria Group,Námsmat Viðmið Group,
Assessment Group Name,Mat Group Name,
Parent Assessment Group,Parent Mat Group,
Assessment Name,mat Name,
Grading Scale,flokkun Scale,
Examiner,prófdómari,
Examiner Name,prófdómari Name,
Supervisor,Umsjón,
Supervisor Name,Umsjón Name,
Evaluate,Meta,
Maximum Assessment Score,Hámarks Mat Einkunn,
Assessment Plan Criteria,Mat Plan Viðmið,
Maximum Score,Hámarks Einkunn,
Total Score,Total Score,
Grade,bekk,
Assessment Result Detail,Mat Niðurstaða Detail,
Assessment Result Tool,Mat Niðurstaða Tool,
Result HTML,niðurstaða HTML,
Content Activity,Innihald virkni,
Last Activity ,Síðasta virkni,
Content Question,Efnisspurning,
Question Link,Spurningartengill,
Course Name,Auðvitað Name,
Topics,Efni,
Hero Image,Hetjuímynd,
Default Grading Scale,Sjálfgefið flokkun Scale,
Education Manager,Menntun Framkvæmdastjóri,
Course Activity,Virkni námskeiðsins,
Course Enrollment,Innritun námskeiðs,
Activity Date,Virkni dagsetning,
Course Assessment Criteria,Námsmat Viðmið,
Weightage,weightage,
Course Content,Innihald námskeiðsins,
Quiz,Skyndipróf,
Program Enrollment,program Innritun,
Enrollment Date,innritun Dagsetning,
Instructor Name,kennari Name,
EDU-CSH-.YYYY.-,EDU-CSH-.YYYY.-,
Course Scheduling Tool,Auðvitað Tímasetningar Tool,
Course Start Date,Auðvitað Start Date,
To TIme,til Time,
Course End Date,Auðvitað Lokadagur,
Course Topic,Málefni námskeiðsins,
Topic,Topic,
Topic Name,Topic Name,
Education Settings,Menntastillingar,
Current Academic Year,Núverandi námsár,
Current Academic Term,Núverandi námsbraut,
Attendance Freeze Date,Viðburður Frystingardagur,
Validate Batch for Students in Student Group,Staðfestu hópur fyrir nemendur í nemendahópi,
"For Batch based Student Group, the Student Batch will be validated for every Student from the Program Enrollment.","Fyrir hópur sem byggist á hópnum, verður námsmatið valið fyrir alla nemendum frá námsbrautinni.",
Validate Enrolled Course for Students in Student Group,Staðfestu skráð námskeið fyrir nemendur í nemendahópi,
"For Course based Student Group, the Course will be validated for every Student from the enrolled Courses in Program Enrollment.",Fyrir námsmiðaðan nemendahóp verður námskeiðið valið fyrir alla nemenda frá skráðum námskeiðum í námskrá.,
Make Academic Term Mandatory,Gerðu fræðilegan tíma skylt,
"If enabled, field Academic Term will be Mandatory in Program Enrollment Tool.","Ef slökkt er á, verður fræðasvið akur að vera skylt í forritaskráningartól.",
Instructor Records to be created by,Kennariaskrár til að búa til af,
Employee Number,starfsmaður Number,
LMS Settings,LMS stillingar,
Enable LMS,Virkja LMS,
LMS Title,LMS titill,
Fee Category,Fee Flokkur,
Fee Component,Fee Component,
Fees Category,Gjald Flokkur,
Fee Schedule,gjaldskrá,
Fee Structure,Gjald Uppbygging,
EDU-FSH-.YYYY.-,EDU-FSH-.YYYY.-,
Fee Creation Status,Gjaldeyrisréttindi,
In Process,Í ferli,
Send Payment Request Email,Sendu inn beiðni um greiðslubeiðni,
Student Category,Student Flokkur,
Fee Breakup for each student,Gjaldskrá fyrir hverja nemanda,
Total Amount per Student,Samtals upphæð á nemanda,
Institution,stofnun,
Fee Schedule Program,Gjaldskrá áætlun,
Student Batch,Student Hópur,
Total Students,Samtals nemendur,
Fee Schedule Student Group,Gjaldskrá Stúdentahópur,
EDU-FST-.YYYY.-,EDU-FST-.YYYY.-,
EDU-FEE-.YYYY.-,EDU-FEE-.YYYY.-,
Include Payment,Hafa greiðslu,
Send Payment Request,Senda greiðslubók,
Student Details,Nánari upplýsingar,
Student Email,Nemandi tölvupóstur,
Grading Scale Name,Flokkun Scale Name,
Grading Scale Intervals,Flokkun deilingargildi,
Intervals,millibili,
Grading Scale Interval,Flokkun deilingar,
Grade Code,bekk Code,
Threshold,þröskuldur,
Grade Description,gráðu Lýsing,
Guardian,Guardian,
Guardian Name,Guardian Name,
Alternate Number,varamaður Number,
Occupation,Atvinna,
Work Address,vinna Address,
Guardian Of ,Guardian Of,
Students,nemendur,
Guardian Interests,Guardian Áhugasvið,
Guardian Interest,Guardian Vextir,
Interest,vextir,
Guardian Student,Guardian Student,
EDU-INS-.YYYY.-,EDU-INS-.YYYY.-,
Instructor Log,Kennariaskrá,
Other details,aðrar upplýsingar,
Option,Valkostur,
Is Correct,Er rétt,
Program Name,program Name,
Program Abbreviation,program Skammstöfun,
Courses,námskeið,
Is Published,Er birt,
Allow Self Enroll,Leyfa sjálf innritun,
Is Featured,Er valinn,
Intro Video,Inngangsvideo,
Program Course,program Námskeið,
School House,School House,
Boarding Student,Stúdentsprófessor,
Check this if the Student is residing at the Institute's Hostel.,Kannaðu þetta ef nemandi er búsettur í gistihúsinu.,
Walking,Ganga,
Institute's Bus,Rútur stofnunarinnar,
Public Transport,Almenningssamgöngur,
Self-Driving Vehicle,Sjálfknúin ökutæki,
Pick/Drop by Guardian,Pick / Drop með forráðamanni,
Enrolled courses,Skráðir námskeið,
Program Enrollment Course,Forritunarnámskeið,
Program Enrollment Fee,Program innritunargjöld,
Program Enrollment Tool,Program Innritun Tool,
Get Students From,Fá nemendur frá,
Student Applicant,Student Umsækjandi,
Get Students,fá Nemendur,
Enrollment Details,Upplýsingar um innritun,
New Program,ný Program,
New Student Batch,Námsmaður Námsmaður,
Enroll Students,innritast Nemendur,
New Academic Year,Nýtt skólaár,
New Academic Term,Nýtt fræðasvið,
Program Enrollment Tool Student,Program Innritun Tool Student,
Student Batch Name,Student Hópur Name,
Program Fee,program Fee,
Question,Spurning,
Single Correct Answer,Eitt rétt svar,
Multiple Correct Answer,Margfalt rétt svar,
Quiz Configuration,Skyndipróf,
Passing Score,Brottför stig,
Score out of 100,Einkunn af 100,
Max Attempts,Max tilraunir,
Enter 0 to waive limit,Sláðu inn 0 til að falla frá takmörkun,
Grading Basis,Grunngrunnur,
Latest Highest Score,Nýjasta hæsta stigið,
Latest Attempt,Síðasta tilraun,
Quiz Activity,Spurningakeppni,
Enrollment,Innritun,
Pass,Pass,
Quiz Question,Spurningakeppni,
Quiz Result,Niðurstaða spurningakeppni,
Selected Option,Valinn kostur,
Correct,Rétt,
Wrong,Rangt,
Room Name,Room Name,
Room Number,Room Number,
Seating Capacity,sætafjölda,
House Name,House Name,
EDU-STU-.YYYY.-,EDU-STU-.YYYY.-,
Student Mobile Number,Student Mobile Number,
Joining Date,Tengja Dagsetning,
Blood Group,Blóðflokkur,
A+,A +,
A-,A-,
B+,B +,
B-,B-,
O+,O +,
O-,O-,
AB+,AB +,
AB-,vinnu í þrjá,
Nationality,Þjóðerni,
Home Address,Heimilisfangið,
Guardian Details,Guardian Upplýsingar,
Guardians,forráðamenn,
Sibling Details,systkini Upplýsingar,
Siblings,systkini,
Exit,Hætta,
Date of Leaving,Dagsetning Keyrsla,
Leaving Certificate Number,Lokaprófsskírteini Fjöldi,
Student Admission,Student Aðgangseyrir,
Application Form Route,Umsóknareyðublað Route,
Admission Start Date,Aðgangseyrir Start Date,
Admission End Date,Aðgangseyrir Lokadagur,
Publish on website,Birta á vefsíðu,
Eligibility and Details,Hæfi og upplýsingar,
Student Admission Program,Námsmenntun,
Minimum Age,Lágmarksaldur,
Maximum Age,Hámarksaldur,
Application Fee,Umsókn Fee,
Naming Series (for Student Applicant),Nafngiftir Series (fyrir námsmanna umsækjanda),
LMS Only,Aðeins LMS,
EDU-APP-.YYYY.-,EDU-APP-.YYYY.-,
Application Status,Umsókn Status,
Application Date,Umsókn Dagsetning,
Student Attendance Tool,Student Aðsókn Tool,
Students HTML,nemendur HTML,
Group Based on,Hópur byggt á,
Student Group Name,Student Group Name,
Max Strength,max Strength,
Set 0 for no limit,Setja 0. engin takmörk,
Instructors,leiðbeinendur,
Student Group Creation Tool,Student Group Creation Tool,
Leave blank if you make students groups per year,Skildu eftir ef þú gerir nemendur hópa á ári,
Get Courses,fá Námskeið,
Separate course based Group for every Batch,Aðskilja námskeið byggt fyrir hverja lotu,
Leave unchecked if you don't want to consider batch while making course based groups. ,Leyfi óskráð ef þú vilt ekki íhuga hópur meðan þú setur námskeið.,
Student Group Creation Tool Course,Student Group Creation Tool Course,
Course Code,Auðvitað Code,
Student Group Instructor,Nemandi hópur kennari,
Student Group Student,Student Group Student,
Group Roll Number,Group Roll Number,
Student Guardian,Student Guardian,
Relation,relation,
Mother,móðir,
Father,faðir,
Student Language,Student Tungumál,
Student Leave Application,Student Leave Umsókn,
Mark as Present,Merkja sem Present,
Will show the student as Present in Student Monthly Attendance Report,Mun sýna nemandann eins staðar í námsmanna Monthly Aðsókn Report,
Student Log,Student Log,
Academic,Academic,
Achievement,Achievement,
Student Report Generation Tool,Námsmatsskýrsla Generation Tool,
Include All Assessment Group,Inniheldur alla matshópa,
Show Marks,Sýna merki,
Add letterhead,Bættu við bréfinu,
Print Section,Prenta kafla,
Total Parents Teacher Meeting,Samtals foreldrar kennarasamkoma,
Attended by Parents,Sóttu foreldra,
Assessment Terms,Námsmat,
Student Sibling,Student systkini,
Studying in Same Institute,Nám í sömu Institute,
Student Siblings,Student Systkini,
Topic Content,Efni efnis,
Amazon MWS Settings,Amazon MWS Stillingar,
ERPNext Integrations,ERPNext Sameiningar,
Enable Amazon,Virkja Amazon,
MWS Credentials,MWS persónuskilríki,
Seller ID,Seljandi auðkenni,
AWS Access Key ID,AWS aðgangs lykilorð,
MWS Auth Token,MWS Auth Token,
Market Place ID,Markaðsfréttir ID,
AU,AU,
BR,BR,
CA,CA,
CN,CN,
DE,DE,
ES,ES,
FR,FR,
JP,JP,
IT,ÞAÐ,
UK,Bretland,
US,Bandaríkin,
Customer Type,Tegund viðskiptavina,
Market Place Account Group,Markaðsstaður reikningshóps,
After Date,Eftir dagsetningu,
Amazon will synch data updated after this date,Amazon mun synkja gögn uppfærð eftir þennan dag,
Get financial breakup of Taxes and charges data by Amazon ,Fá fjárhagslegt brot á skattar og gjöld gagna af Amazon,
Click this button to pull your Sales Order data from Amazon MWS.,Smelltu á þennan hnapp til að draga söluuppboðsgögnin þín frá Amazon MWS.,
Check this to enable a scheduled Daily synchronization routine via scheduler,Hakaðu við þetta til að virkja daglegt daglegt samstillingarferli með tímasetningu,
Max Retry Limit,Hámarksfjöldi endurheimta,
Exotel Settings,Stillingar Exotel,
Account SID,Reikningur SID,
API Token,API auðkenni,
GoCardless Mandate,GoCardless umboð,
Mandate,Umboð,
GoCardless Customer,GoCardless viðskiptavinur,
GoCardless Settings,GoCardless Stillingar,
Webhooks Secret,Webhooks Secret,
Plaid Settings,Stillingar plaða,
Synchronize all accounts every hour,Samstilltu alla reikninga á klukkutíma fresti,
Plaid Client ID,Auðkenni viðskiptavinarins,
Plaid Secret,Plaid Secret,
Plaid Public Key,Plaid Public Key,
Plaid Environment,Plaid umhverfi,
sandbox,sandkassi,
development,þróun,
QuickBooks Migrator,QuickBooks Migrator,
Application Settings,Umsókn Stillingar,
Token Endpoint,Tollpunktur endapunktar,
Scope,Umfang,
Authorization Settings,Leyfisstillingar,
Authorization Endpoint,Endapunktur leyfis,
Authorization URL,Leyfisveitandi URL,
Quickbooks Company ID,Quickbooks félagsauðkenni,
Company Settings,Fyrirtæki Stillingar,
Default Shipping Account,Sjálfgefið sendingarkostnaður,
Default Warehouse,Sjálfgefið Warehouse,
Default Cost Center,Sjálfgefið Kostnaður Center,
Undeposited Funds Account,Óheimilt sjóðsreikningur,
Shopify Log,Shopify Log,
Request Data,Beiðni gagna,
Shopify Settings,Shopify Stillingar,
status html,stöðu html,
Enable Shopify,Virkja Shopify,
App Type,App Tegund,
Last Sync Datetime,Síðast samstillt datatími,
Shop URL,Verslunarslóð,
eg: frappe.myshopify.com,td: frappe.myshopify.com,
Shared secret,Sameiginlegt leyndarmál,
Webhooks Details,Webhooks Upplýsingar,
Webhooks,Webhooks,
Customer Settings,Viðskiptavinur Stillingar,
Default Customer,Sjálfgefið viðskiptavinur,
"If Shopify not contains a customer in Order, then while syncing Orders, the system will consider default customer for order","Ef Shopify inniheldur ekki viðskiptavina í pöntunum, þá á meðan syncing Pantanir, kerfið mun íhuga vanræksla viðskiptavina fyrir pöntun",
Customer Group will set to selected group while syncing customers from Shopify,Viðskiptavinahópur mun setja á valda hóp meðan viðskiptavinir frá Shopify eru samstilltar,
For Company,Company,
Cash Account will used for Sales Invoice creation,Cash reikningur verður notaður fyrir stofnun sölureikninga,
Update Price from Shopify To ERPNext Price List,Uppfæra verð frá Shopify til ERPNext Verðskrá,
Default Warehouse to to create Sales Order and Delivery Note,Sjálfgefið vörugeymsla til að búa til sölupöntun og afhendingartilkynningu,
Sales Order Series,Sölu Order Series,
Import Delivery Notes from Shopify on Shipment,Flytja inn afhendibréf frá Shopify á sendingu,
Delivery Note Series,Afhendingarspjald Series,
Import Sales Invoice from Shopify if Payment is marked,Flytja inn sölureikning frá Shopify ef greiðsla er merkt,
Sales Invoice Series,Sala Reikningur Series,
Shopify Tax Account,Shopify Skattareikningur,
Shopify Tax/Shipping Title,Shopify Skatt / Shipping Title,
ERPNext Account,ERPNext reikningur,
Shopify Webhook Detail,Shopify Webhook Detail,
Webhook ID,Webhook ID,
Tally Migration,Flokksflutninga,
Master Data,Aðalgögn,
Is Master Data Processed,Er unnið með aðalgögn,
Is Master Data Imported,Er flutt inn aðalgögn,
Tally Creditors Account,Tally kröfuhafar reikningur,
Tally Debtors Account,Tally skuldara reikningur,
Tally Company,Tally Company,
ERPNext Company,ERPNext fyrirtæki,
Processed Files,Unnar skrár,
Parties,Teiti,
UOMs,UOMs,
Vouchers,Skírteini,
Round Off Account,Umferð Off reikning,
Day Book Data,Gögn um dagbók,
Is Day Book Data Processed,Er unnið úr dagbókargögnum,
Is Day Book Data Imported,Er dagbókargögn flutt inn,
Woocommerce Settings,Váskiptastillingar,
Enable Sync,Virkja samstillingu,
Woocommerce Server URL,Vefslóðir Woocommerce Server,
Secret,Leyndarmál,
API consumer key,API neytenda lykill,
API consumer secret,API neytenda leyndarmál,
Tax Account,Skattreikningur,
Freight and Forwarding Account,Fragt og áframsending reiknings,
Creation User,Notandi sköpunar,
"The user that will be used to create Customers, Items and Sales Orders. This user should have the relevant permissions.","Notandinn sem verður notaður til að búa til viðskiptavini, hluti og sölupantanir. Þessi notandi ætti að hafa viðeigandi heimildir.",
"This warehouse will be used to create Sales Orders. The fallback warehouse is ""Stores"".",Þetta lager verður notað til að búa til sölupantanir. Fallback vöruhúsið er „Birgðir“.,
"The fallback series is ""SO-WOO-"".",Fallback röðin er „SO-WOO-“.,
This company will be used to create Sales Orders.,Þetta fyrirtæki verður notað til að búa til sölupantanir.,
Delivery After (Days),Afhending eftir (daga),
This is the default offset (days) for the Delivery Date in Sales Orders. The fallback offset is 7 days from the order placement date.,Þetta er sjálfgefið móti (dagar) fyrir afhendingardag í sölupöntunum. Fallfallið er 7 dagar frá dagsetningu pöntunarinnar.,
"This is the default UOM used for items and Sales orders. The fallback UOM is ""Nos"".",Þetta er sjálfgefna UOM sem notuð er fyrir hluti og sölupantanir. Fallback UOM er „Nei“.,
Endpoints,Endapunktar,
Endpoint,Endapunktur,
Antibiotic Name,Name Sýklalyf,
Healthcare Administrator,Heilbrigðisstarfsmaður,
Laboratory User,Laboratory User,
Is Inpatient,Er sjúklingur,
HLC-CPR-.YYYY.-,HLC-CPR-.YYYY.-,
Procedure Template,Málsmeðferð máls,
Procedure Prescription,Verklagsregla,
Service Unit,Þjónustudeild,
Consumables,Rekstrarvörur,
Consume Stock,Neyta lager,
Nursing User,Hjúkrunarnotandi,
Clinical Procedure Item,Klínísk verklagsþáttur,
Invoice Separately as Consumables,Reikningur Sérstaklega sem neysluvörur,
Transfer Qty,Flytja magn,
Actual Qty (at source/target),Raunveruleg Magn (á uppspretta / miða),
Is Billable,Er gjaldfært,
Allow Stock Consumption,Leyfa vöruflokkun,
Collection Details,Safn Upplýsingar,
Codification Table,Codification Table,
Complaints,Kvartanir,
Dosage Strength,Skammtastyrkur,
Strength,Styrkur,
Drug Prescription,Lyfseðilsskyld lyf,
Dosage,Skammtar,
Dosage by Time Interval,Skammtur eftir tímabili,
Interval,Interval,
Interval UOM,Interval UOM,
Hour,klukkustund,
Update Schedule,Uppfæra áætlun,
Max number of visit,Hámarksfjöldi heimsókna,
Visited yet,Heimsóknir ennþá,
Mobile,Mobile,
Phone (R),Sími (R),
Phone (Office),Sími (Skrifstofa),
Hospital,Sjúkrahús,
Appointments,Ráðnir,
Practitioner Schedules,Hagnýtar áætlanir,
Charges,Gjöld,
Default Currency,sjálfgefið mynt,
Healthcare Schedule Time Slot,Heilsugæsluáætlunartímabil,
Parent Service Unit,Foreldraþjónustudeild,
Service Unit Type,Tegund þjónustunnar,
Allow Appointments,Leyfa skipan,
Allow Overlap,Leyfa skarast,
Inpatient Occupancy,Sjúkraþjálfun,
Occupancy Status,Staða umráðs,
Vacant,Laust,
Occupied,Upptekinn,
Item Details,Atriði í hlutanum,
UOM Conversion in Hours,UOM viðskipti í klukkustundum,
Rate / UOM,Rate / UOM,
Change in Item,Breyta í lið,
Out Patient Settings,Úthreinsun sjúklinga,
Patient Name By,Nafn sjúklinga eftir,
Patient Name,Nafn sjúklinga,
"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.","Ef athugað verður viðskiptavinur búinn til, kortlagður við sjúklinginn. Sjúkratryggingar verða búnar til gegn þessum viðskiptavini. Þú getur einnig valið núverandi viðskiptavin þegar þú býrð til sjúklinga.",
Default Medical Code Standard,Sjálfgefin Læknisfræðileg staðal,
Collect Fee for Patient Registration,Safna gjöld fyrir skráningu sjúklinga,
Registration Fee,Skráningargjald,
Manage Appointment Invoice submit and cancel automatically for Patient Encounter,Stjórna afgreiðslureikningi leggja inn og hætta sjálfkrafa fyrir sjúklingaþing,
Valid Number of Days,Gildir fjöldi daga,
Clinical Procedure Consumable Item,Klínísk verklagsvaranotkun,
Default income accounts to be used if not set in Healthcare Practitioner to book Appointment charges.,Sjálfgefnar tekjureikningar sem nota skal ef ekki er sett í heilbrigðisstarfsmann til að bóka ráðningargjöld.,
Out Patient SMS Alerts,Úthlutað þolinmæði fyrir sjúklinga,
Patient Registration,Sjúklingur skráning,
Registration Message,Skráningarnúmer,
Confirmation Message,Staðfestingarskilaboð,
Avoid Confirmation,Forðastu staðfestingu,
Do not confirm if appointment is created for the same day,Ekki staðfestu ef skipun er búin til fyrir sama dag,
Appointment Reminder,Tilnefning tilnefningar,
Reminder Message,Áminningarskilaboð,
Remind Before,Minna á áður,
Laboratory Settings,Laboratory Settings,
Employee name and designation in print,Starfsmaður nafn og tilnefningu í prenti,
Custom Signature in Print,Sérsniðin undirskrift í prenti,
Laboratory SMS Alerts,SMS tilkynningar fyrir rannsóknarstofu,
Check In,Innritun,
Check Out,Athuga,
HLC-INP-.YYYY.-,HLC-INP-.YYYY.-,
A Positive,A Jákvæð,
A Negative,Neikvætt,
AB Positive,AB Jákvæð,
AB Negative,AB neikvæð,
B Positive,B Jákvæð,
B Negative,B neikvæð,
O Positive,O Jákvæð,
O Negative,O neikvæð,
Date of birth,Fæðingardagur,
Admission Scheduled,Aðgangur áætlað,
Discharge Scheduled,Losun áætlað,
Discharged,Sleppt,
Admission Schedule Date,Aðgangur Dagskrá Dagsetning,
Admitted Datetime,Viðurkenndur Datetime,
Expected Discharge,Væntanlegur losun,
Discharge Date,Upphæðardagur,
Discharge Note,Athugasemd um losun,
Lab Prescription,Lab Prescription,
Test Created,Próf búin til,
LP-,LP-,
Submitted Date,Sendingardagur,
Approved Date,Samþykkt dagsetning,
Sample ID,Dæmi um auðkenni,
Lab Technician,Lab Tæknimaður,
Technician Name,Nafn tæknimanns,
Report Preference,Tilkynna ummæli,
Test Name,Próf Nafn,
Test Template,Próf sniðmát,
Test Group,Test Group,
Custom Result,Sérsniðin árangur,
LabTest Approver,LabTest Approver,
Lab Test Groups,Lab Test Groups,
Add Test,Bæta við prófun,
Add new line,Bæta við nýjum línu,
Normal Range,Venjulegt svið,
Result Format,Niðurstaða snið,
"Single for results which require only a single input, result UOM and normal value \n<br>\nCompound for results which require multiple input fields with corresponding event names, result UOMs and normal values\n<br>\nDescriptive for tests which have multiple result components and corresponding result entry fields. \n<br>\nGrouped for test templates which are a group of other test templates.\n<br>\nNo Result for tests with no results. Also, no Lab Test is created. e.g.. Sub Tests for Grouped results.","Einstök fyrir niðurstöður sem þurfa aðeins eitt inntak, veldu UOM og eðlilegt gildi <br> Samsett fyrir niðurstöður sem krefjast margra inntaksvettvanga með samsvarandi nöfn á viðburði, veldu UOM og eðlilegt gildi <br> Lýsandi fyrir prófanir sem eru með margvíslegar niðurstöður og samsvarandi innsláttarreitir. <br> Flokkað fyrir próf sniðmát sem eru hópur annarra próf sniðmát. <br> Ekkert niðurstaða fyrir prófanir án árangurs. Einnig er engin Lab Test búin til. td. Undirprófanir fyrir samnýttar niðurstöður.",
Single,Single,
Compound,Efnasamband,
Descriptive,Lýsandi,
Grouped,Flokkað,
No Result,engin Niðurstaða,
"If unchecked, the item wont be appear in Sales Invoice, but can be used in group test creation. ","Ef óskráð er, mun hluturinn ekki birtast í sölureikningi, en hægt er að nota í hópprófunarsköpun.",
This value is updated in the Default Sales Price List.,Þetta gildi er uppfært í Sjálfgefin söluverðalista.,
Lab Routine,Lab Routine,
Special,Sérstakur,
Normal Test Items,Venjuleg prófunaratriði,
Result Value,Niðurstaða gildi,
Require Result Value,Krefjast niðurstöður gildi,
Normal Test Template,Venjulegt próf sniðmát,
Patient Demographics,Lýðfræðilegar upplýsingar um sjúklinga,
HLC-PAT-.YYYY.-,HLC-PAT-.YYYY.-,
Inpatient Status,Staða sjúklings,
Personal and Social History,Persónuleg og félagsleg saga,
Marital Status,Hjúskaparstaða,
Married,giftur,
Divorced,skilin,
Widow,Ekkja,
Patient Relation,Sjúklingar Tengsl,
"Allergies, Medical and Surgical History","Ofnæmi, læknisfræði og skurðlækningar",
Allergies,Ofnæmi,
Medication,Lyfjagjöf,
Medical History,Sjúkrasaga,
Surgical History,Skurðaðgerðarsaga,
Risk Factors,Áhættuþættir,
Occupational Hazards and Environmental Factors,Starfsáhættu og umhverfisþættir,
Other Risk Factors,Aðrar áhættuþættir,
Patient Details,Sjúklingur Upplýsingar,
Additional information regarding the patient,Viðbótarupplýsingar um sjúklinginn,
Patient Age,Sjúklingur Aldur,
More Info,Meiri upplýsingar,
Referring Practitioner,Tilvísun sérfræðingur,
Reminded,Minntist á,
Parameters,Breytur,
HLC-ENC-.YYYY.-,HLC-ENC-.YYYY.-,
Encounter Date,Fundur Dagsetning,
Encounter Time,Fundur tími,
Encounter Impression,Fundur birtingar,
In print,Í prenti,
Medical Coding,Medical erfðaskrá,
Procedures,Málsmeðferð,
Review Details,Endurskoða upplýsingar,
HLC-PMR-.YYYY.-,HLC-PMR-.YYYY.-,
Spouse,Maki,
Family,Fjölskylda,
Schedule Name,Stundaskrá Nafn,
Time Slots,Tími rifa,
Practitioner Service Unit Schedule,Hagnýtar þjónustudeildaráætlun,
Procedure Name,Málsmeðferð,
Appointment Booked,Skipun Bókað,
Procedure Created,Málsmeðferð búin til,
HLC-SC-.YYYY.-,HLC-SC-.YYYY.-,
Collected By,Safnað með,
Collected Time,Safnað tíma,
No. of print,Fjöldi prenta,
Sensitivity Test Items,Næmi próf atriði,
Special Test Items,Sérstakar prófanir,
Particulars,Upplýsingar,
Special Test Template,Sérstök próf sniðmát,
Result Component,Niðurstaða hluti,
Body Temperature,Líkamshiti,
Presence of a fever (temp &gt; 38.5 °C/101.3 °F or sustained temp &gt; 38 °C/100.4 °F),"Hiti í kjölfarið (hitastig&gt; 38,5 ° C / viðvarandi hitastig&gt; 38 ° C / 100,4 ° F)",
Heart Rate / Pulse,Hjartsláttur / púls,
Adults' pulse rate is anywhere between 50 and 80 beats per minute.,Púls hlutfall fullorðinna er einhvers staðar á milli 50 og 80 slög á mínútu.,
Respiratory rate,Öndunarhraði,
Normal reference range for an adult is 16–20 breaths/minute (RCP 2012),Venjulegt viðmiðunarmörk fyrir fullorðna er 16-20 andardráttar / mínútur (RCP 2012),
Tongue,Tunga,
Coated,Húðað,
Very Coated,Mjög húðaður,
Normal,Venjulegt,
Furry,Furry,
Cuts,Skurður,
Abdomen,Kvið,
Bloated,Uppblásinn,
Fluid,Vökvi,
Constipated,Hægðatregða,
Reflexes,Viðbrögð,
Hyper,Hyper,
Very Hyper,Mjög há,
One Sided,Einhliða,
Blood Pressure (systolic),Blóðþrýstingur (slagbilsþrýstingur),
Blood Pressure (diastolic),Blóðþrýstingur (diastolic),
Blood Pressure,Blóðþrýstingur,
"Normal resting blood pressure in an adult is approximately 120 mmHg systolic, and 80 mmHg diastolic, abbreviated ""120/80 mmHg""","Venjulegur hvíldarþrýstingur hjá fullorðnum er u.þ.b. 120 mmHg slagbilsþrýstingur og 80 mmHg díastólskur, skammstafað &quot;120/80 mmHg&quot;",
Nutrition Values,Næringargildi,
Height (In Meter),Hæð (í metra),
Weight (In Kilogram),Þyngd (í kílógramm),
BMI,BMI,
Hotel Room,Hótelherbergi,
Hotel Room Type,Hótel Herbergi,
Capacity,Stærð,
Extra Bed Capacity,Auka rúmgetu,
Hotel Manager,Hótelstjórinn,
Hotel Room Amenity,Hótelið aðstaða,
Billable,reikningshæfur,
Hotel Room Package,Hótel herbergi pakki,
Amenities,Aðstaða,
Hotel Room Pricing,Hótel herbergi Verðlagning,
Hotel Room Pricing Item,Hotel Herbergi Verðlagning,
Hotel Room Pricing Package,Hotel Herbergi Verðlagning Pakki,
Hotel Room Reservation,Hótel herbergi fyrirvara,
Guest Name,Nafn gesta,
Late Checkin,Seint innritun,
Booked,Bókað,
Hotel Reservation User,Hotel Reservation User,
Hotel Room Reservation Item,Hotel Herbergi pöntunartilboð,
Hotel Settings,Hótelstillingar,
Default Taxes and Charges,Sjálfgefin skatta og gjöld,
Default Invoice Naming Series,Sjálfgefin innheimtuseðill,
Additional Salary,Viðbótarupplýsingar Laun,
HR,HR,
HR-ADS-.YY.-.MM.-,HR-ADS-.YY .-. MM.-,
Salary Component,laun Component,
Overwrite Salary Structure Amount,Yfirskrifa launauppbyggingarfjárhæð,
Deduct Full Tax on Selected Payroll Date,Draga frá fullum skatti á valinn launadag,
Payroll Date,Launardagsetning,
Date on which this component is applied,Dagsetning sem þessi hluti er notaður á,
Salary Slip,laun Slip,
Salary Component Type,Launaviðskiptategund,
HR User,HR User,
Appointment Letter,Ráðningarbréf,
Job Applicant,Atvinna umsækjanda,
Applicant Name,umsækjandi Nafn,
Appointment Date,Skipunardagur,
Appointment Letter Template,Skipunarsniðmát,
Body,Líkami,
Closing Notes,Loka skýringar,
Appointment Letter content,Innihald skipunarbréfs,
Appraisal,Úttekt,
HR-APR-.YY.-.MM.,HR-APR-.YY.-MM.,
Appraisal Template,Úttekt Snið,
For Employee Name,Fyrir Starfsmannafélag Nafn,
Goals,mörk,
Calculate Total Score,Reikna aðaleinkunn,
Total Score (Out of 5),Total Score (af 5),
"Any other remarks, noteworthy effort that should go in the records.","Allar aðrar athugasemdir, athyglisvert áreynsla sem ætti að fara í skrám.",
Appraisal Goal,Úttekt Goal,
Key Responsibility Area,Key Ábyrgð Area,
Weightage (%),Weightage (%),
Score (0-5),Score (0-5),
Score Earned,skora aflað,
Appraisal Template Title,Úttekt Snið Title,
Appraisal Template Goal,Úttekt Snið Goal,
KRA,KRA,
Key Performance Area,Key Performance Area,
HR-ATT-.YYYY.-,HR-ATT-.YYYY.-,
On Leave,Í leyfi,
Work From Home,Vinna heiman,
Leave Application,Leave Umsókn,
Attendance Date,Aðsókn Dagsetning,
Attendance Request,Dagsbeiðni,
Late Entry,Seint innganga,
Early Exit,Snemma útgönguleið,
Half Day Date,Half Day Date,
On Duty,Á vakt,
Explanation,Útskýring,
Compensatory Leave Request,Bótaábyrgð,
Leave Allocation,Skildu Úthlutun,
Worked On Holiday,Vinna í fríi,
Work From Date,Vinna frá degi,
Work End Date,Vinna lokadagsetning,
Select Users,Veldu Notendur,
Send Emails At,Senda póst At,
Reminder,Áminning,
Daily Work Summary Group User,Daglegur vinnusamningur hópur notandi,
Parent Department,Foreldradeild,
Leave Block List,Skildu Block List,
Days for which Holidays are blocked for this department.,Dagar sem Frídagar eru læst í þessari deild.,
Leave Approvers,Skildu Approvers,
Leave Approver,Skildu samþykkjari,
The first Leave Approver in the list will be set as the default Leave Approver.,Fyrsta leyfi samþykkis í listanum verður stillt sem sjálfgefið leyfi fyrir leyfi.,
Expense Approvers,Kostnaðarsamþykktir,
Expense Approver,Expense samþykkjari,
The first Expense Approver in the list will be set as the default Expense Approver.,Fyrsta kostnaðarákvörðunin á listanum verður stillt sem sjálfgefið kostnaðarákvörðun.,
Department Approver,Department Approver,
Approver,samþykkjari,
Required Skills,Nauðsynleg færni,
Skills,Færni,
Designation Skill,Tilnefningarhæfni,
Skill,Hæfni,
Driver,Ökumaður,
HR-DRI-.YYYY.-,HR-DRI-.YYYY.-,
Suspended,Hengdur,
Transporter,Flutningsaðili,
Applicable for external driver,Gildir fyrir utanaðkomandi ökumann,
Cellphone Number,gemsa númer,
License Details,Leyfisupplýsingar,
License Number,Leyfisnúmer,
Issuing Date,Útgáfudagur,
Driving License Categories,Ökuskírteini Flokkar,
Driving License Category,Ökuskírteini Flokkur,
Fleet Manager,Fleet Manager,
Driver licence class,Ökuskírteini,
HR-EMP-,HR-EMP-,
Employment Type,Atvinna Type,
Emergency Contact,Neyðar Tengiliður,
Emergency Contact Name,Neyðarnúmer tengiliða,
Emergency Phone,Neyðarnúmer Sími,
ERPNext User,ERPNext User,
"System User (login) ID. If set, it will become default for all HR forms.","System User (ur) ID. Ef sett, mun það verða sjálfgefið fyrir allar HR eyðublöð.",
Create User Permission,Búðu til notendaleyfi,
This will restrict user access to other employee records,Þetta mun takmarka notanda aðgang að öðrum starfsmönnum færslum,
Joining Details,Tengja upplýsingar,
Offer Date,Tilboð Dagsetning,
Confirmation Date,staðfesting Dagsetning,
Contract End Date,Samningur Lokadagur,
Notice (days),Tilkynning (dagar),
Date Of Retirement,Dagsetning starfsloka,
Department and Grade,Deild og bekk,
Reports to,skýrslur til,
Attendance and Leave Details,Upplýsingar um mætingu og leyfi,
Leave Policy,Leyfi stefnu,
Attendance Device ID (Biometric/RF tag ID),Auðkenni aðsóknartækja (líffræðileg tölfræðileg / RF merki),
Applicable Holiday List,Gildandi Holiday List,
Default Shift,Sjálfgefin vakt,
Salary Details,Laun Upplýsingar,
Salary Mode,laun Mode,
Bank A/C No.,Bank A / C nr,
Health Insurance,Sjúkratryggingar,
Health Insurance Provider,Sjúkratryggingafélag,
Health Insurance No,Sjúkratrygging nr,
Prefered Email,Ákjósanleg Email,
Personal Email,Starfsfólk Email,
Permanent Address Is,Varanleg Heimilisfang er,
Rented,leigt,
Owned,eigu,
Permanent Address,Heimilisfang,
Prefered Contact Email,Ákjósanleg Netfang tengiliðar,
Company Email,fyrirtæki Email,
Provide Email Address registered in company,Gefa upp netfang skráð í félaginu,
Current Address Is,Núverandi Heimilisfang er,
Current Address,Núverandi heimilisfang,
Personal Bio,Starfsfólk Bio,
Bio / Cover Letter,Bio / Cover Letter,
Short biography for website and other publications.,Stutt ævisaga um vefsíðu og öðrum ritum.,
Passport Number,Vegabréfs númer,
Date of Issue,Útgáfudagur,
Place of Issue,Útgáfustaður,
Widowed,Ekkja,
Family Background,Family Background,
"Here you can maintain family details like name and occupation of parent, spouse and children","Hér er hægt að halda upplýsingar fjölskyldu eins og nafn og starfsheiti foreldri, maka og börn",
Health Details,Heilsa Upplýsingar,
"Here you can maintain height, weight, allergies, medical concerns etc","Hér er hægt að halda hæð, þyngd, ofnæmi, læknis áhyggjum etc",
Educational Qualification,námsgráðu,
Previous Work Experience,Fyrri Starfsreynsla,
External Work History,Ytri Vinna Saga,
History In Company,Saga In Company,
Internal Work History,Innri Vinna Saga,
Resignation Letter Date,Störfum Letter Dagsetning,
Relieving Date,létta Dagsetning,
Reason for Leaving,Ástæða til að fara,
Leave Encashed?,Leyfi Encashed?,
Encashment Date,Encashment Dagsetning,
Exit Interview Details,Hætta Viðtal Upplýsingar,
Held On,Hélt í,
Reason for Resignation,Ástæðan fyrir úrsögn,
Better Prospects,betri horfur,
Health Concerns,Heilsa Áhyggjuefni,
New Workplace,ný Vinnustaðurinn,
HR-EAD-.YYYY.-,HR-EAD-.YYYY.-,
Due Advance Amount,Fyrirframgreiðslugjald,
Returned Amount,Skilað upphæð,
Claimed,Krafist,
Advance Account,Forgangsreikningur,
Employee Attendance Tool,Starfsmaður Aðsókn Tool,
Unmarked Attendance,ómerkt Aðsókn,
Employees HTML,starfsmenn HTML,
Marked Attendance,Marked Aðsókn,
Marked Attendance HTML,Marked Aðsókn HTML,
Employee Benefit Application,Umsóknarfrestur starfsmanna,
Max Benefits (Yearly),Max Hagur (Árlega),
Remaining Benefits (Yearly),Eftirstöðvar kostir (árlega),
Payroll Period,Launatímabil,
Benefits Applied,Kostirnir beittar,
Dispensed Amount (Pro-rated),Úthlutað magn (Pro-hlutfall),
Employee Benefit Application Detail,Starfsmannatengd umsóknareyðublað,
Earning Component,Earnings Component,
Pay Against Benefit Claim,Borga gegn hagur kröfu,
Max Benefit Amount,Hámarksbætur,
Employee Benefit Claim,Skaðabætur starfsmanns,
Claim Date,Dagsetning krafa,
Benefit Type and Amount,Tegund bóta og upphæð,
Claim Benefit For,Kröfuhagur fyrir,
Max Amount Eligible,Hámarksfjöldi hæfilegs,
Expense Proof,Kostnaðarsönnun,
Employee Boarding Activity,Starfsmannaþjónusta,
Activity Name,Nafn athafnasvæðis,
Task Weight,verkefni Þyngd,
Required for Employee Creation,Nauðsynlegt fyrir starfsmannasköpun,
Applicable in the case of Employee Onboarding,Gildandi ef um er að ræða Starfsmaður um borð,
Employee Checkin,Starfsmannaskoðun,
Log Type,Tegund annáls,
OUT,ÚT,
Location / Device ID,Staðsetning / tæki auðkenni,
Skip Auto Attendance,Slepptu sjálfvirkri aðsókn,
Shift Start,Shift Start,
Shift End,Shift End,
Shift Actual Start,Vaktu raunverulega byrjun,
Shift Actual End,Beygja raunverulegan endi,
Employee Education,starfsmaður Menntun,
School/University,Skóli / University,
Graduate,Útskrifast,
Post Graduate,Post Graduate,
Under Graduate,undir Graduate,
Year of Passing,Ár Passing,
Class / Percentage,Flokkur / Hlutfall,
Major/Optional Subjects,Major / valgreinum,
Employee External Work History,Starfsmaður Ytri Vinna Saga,
Total Experience,Samtals Experience,
Default Leave Policy,Sjálfgefin skiladagur,
Default Salary Structure,Sjálfgefið launauppbygging,
Employee Group Table,Tafla starfsmannahóps,
ERPNext User ID,ERPNext notandanafn,
Employee Health Insurance,Sjúkratrygging starfsmanna,
Health Insurance Name,Sjúkratryggingar Nafn,
Employee Incentive,Starfsmaður hvatningu,
Incentive Amount,Skuldbinding,
Employee Internal Work History,Starfsmaður Innri Vinna Saga,
Employee Onboarding,Starfsmaður um borð,
Notify users by email,Láttu notendur vita með tölvupósti,
Employee Onboarding Template,Starfsmaður Onboarding Sniðmát,
Activities,Starfsemi,
Employee Onboarding Activity,Starfsmaður um borð,
Employee Promotion,Starfsmaður kynningar,
Promotion Date,Kynningardagur,
Employee Promotion Details,Upplýsingar um starfsmannamál,
Employee Promotion Detail,Upplýsingar um starfsmenn í kynningu,
Employee Property History,Starfsmannasaga,
Employee Separation,Aðskilnaður starfsmanna,
Employee Separation Template,Aðskilnaðarsnið frá starfsmanni,
Exit Interview Summary,Hætta við viðtalssamantekt,
Employee Skill,Hæfni starfsmanna,
Proficiency,Hæfni,
Evaluation Date,Matsdagur,
Employee Skill Map,Hæfniskort starfsmanna,
Employee Skills,Hæfni starfsmanna,
Trainings,Æfingar,
Employee Tax Exemption Category,Skattfrjálsur flokkur starfsmanna,
Max Exemption Amount,Hámarksfjárhæð undanþágu,
Employee Tax Exemption Declaration,Skattfrelsisyfirlýsing starfsmanna,
Declarations,Yfirlýsingar,
Total Declared Amount,Heildaruppgefin fjárhæð,
Total Exemption Amount,Heildarfjöldi undanþága,
Employee Tax Exemption Declaration Category,Skattflokkun starfsmanna Skattlausn,
Exemption Sub Category,Undanþága undirflokkur,
Exemption Category,Undanþáguflokkur,
Maximum Exempted Amount,Hámarks undanþegin fjárhæð,
Declared Amount,Upplýst fjárhæð,
Employee Tax Exemption Proof Submission,Skattfrelsi frá starfsmanni,
Submission Date,Skiladagur,
Tax Exemption Proofs,Skattfrelsisskýrslur,
Total Actual Amount,Raunveruleg fjárhæð,
Employee Tax Exemption Proof Submission Detail,Skattfrjálsar upplýsingar um atvinnurekstur,
Maximum Exemption Amount,Hámarksfjárhæð undanþágu,
Type of Proof,Gerð sönnunargagna,
Actual Amount,Raunveruleg fjárhæð,
Employee Tax Exemption Sub Category,Undanþága frá starfsmanni skattfrelsis,
Tax Exemption Category,Skattlausn Flokkur,
Employee Training,Þjálfun starfsmanna,
Training Date,Þjálfunardagur,
Employee Transfer,Starfsmaður flytja,
Transfer Date,Flutnings Dagsetning,
Employee Transfer Details,Upplýsingar um starfsmannaskipti,
Employee Transfer Detail,Starfsmaður flytja smáatriði,
Re-allocate Leaves,Dreifa aftur leyfi,
Create New Employee Id,Búðu til nýjan starfsmannakenni,
New Employee ID,Nýtt starfsmannakenni,
Employee Transfer Property,Starfsmaður flytja eignir,
HR-EXP-.YYYY.-,HR-EXP-.YYYY.-,
Expense Taxes and Charges,Gjalda skatta og gjöld,
Total Sanctioned Amount,Alls bundnar Upphæð,
Total Advance Amount,Samtals framvirði,
Total Claimed Amount,Alls tilkalli Upphæð,
Total Amount Reimbursed,Heildarfjárhæð Endurgreiða,
Vehicle Log,ökutæki Log,
Employees Email Id,Starfsmenn Netfang Id,
Expense Claim Account,Expense Krafa Reikningur,
Expense Claim Advance,Kostnaðarkröfur Advance,
Unclaimed amount,Óhæfð upphæð,
Expense Claim Detail,Expense Krafa Detail,
Expense Date,Expense Dagsetning,
Expense Claim Type,Expense Gerð kröfu,
Holiday List Name,Holiday List Nafn,
Total Holidays,Samtals hátíðir,
Add Weekly Holidays,Bæta við vikulega frídaga,
Weekly Off,Vikuleg Off,
Add to Holidays,Bæta við hátíðir,
Holidays,Holidays,
Clear Table,Hreinsa Tafla,
HR Settings,HR Stillingar,
Employee Settings,Employee Stillingar,
Retirement Age,starfslok Age,
Enter retirement age in years,Sláðu eftirlaunaaldur í ár,
Employee Records to be created by,Starfskjör Records að vera búin með,
Employee record is created using selected field. ,Starfsmaður færsla er búin til með völdu sviði.,
Stop Birthday Reminders,Stop afmælisáminningar,
Don't send Employee Birthday Reminders,Ekki senda starfsmaður afmælisáminningar,
Expense Approver Mandatory In Expense Claim,Kostnaðarsamþykki Skylda á kostnaðarkröfu,
Payroll Settings,launaskrá Stillingar,
Max working hours against Timesheet,Max vinnutíma gegn Timesheet,
Include holidays in Total no. of Working Days,Fela frí í algjöru nr. vinnudaga,
"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Ef hakað Total nr. vinnudaga mun fela frí, og þetta mun draga úr gildi af launum fyrir dag",
"If checked, hides and disables Rounded Total field in Salary Slips","Ef hakað er við, felur og slekkur svæðið Rounded Total í launaseðlum",
Email Salary Slip to Employee,Sendu Laun Slip til starfsmanns,
Emails salary slip to employee based on preferred email selected in Employee,Póst laun miði að starfsmaður byggðar á völdum tölvupósti völdum í Launþegi,
Encrypt Salary Slips in Emails,Dulkóða launaseðla í tölvupósti,
"The salary slip emailed to the employee will be password protected, the password will be generated based on the password policy.","Launaseðillinn sem sendur er til starfsmannsins verður verndaður með lykilorði, lykilorðið verður búið til út frá lykilorðsstefnunni.",
Password Policy,Lykilorðastefna,
<b>Example:</b> SAL-{first_name}-{date_of_birth.year} <br>This will generate a password like SAL-Jane-1972,<b>Dæmi:</b> SAL- {first_name} - {date_of_birth.year} <br> Þetta mun búa til lykilorð eins og SAL-Jane-1972,
Leave Settings,Skildu Stillingar,
Leave Approval Notification Template,Skildu eftir skilmálaskilmálum,
Leave Status Notification Template,Leyfi Tilkynning Sniðmát,
Role Allowed to Create Backdated Leave Application,Hlutverki heimilt að búa til bakgrunnsdagsforrit,
Leave Approver Mandatory In Leave Application,Leyfi samþykki skylt í leyfi umsókn,
Show Leaves Of All Department Members In Calendar,Sýna blöð allra deildarmanna í dagatalinu,
Auto Leave Encashment,Sjálfkrafa leyfi,
Restrict Backdated Leave Application,Takmarka umsókn um dagsetning leyfis,
Hiring Settings,Ráðningarstillingar,
Check Vacancies On Job Offer Creation,Athugaðu laus störf við sköpun atvinnutilboða,
Identification Document Type,Skjalfestingartegund,
Standard Tax Exemption Amount,Venjulegt fjárhæð undanþágu skatts,
Taxable Salary Slabs,Skattskyld launakostnaður,
Applicant for a Job,Umsækjandi um starf,
Accepted,Samþykkt,
Job Opening,Atvinna Opnun,
Cover Letter,Kynningarbréf,
Resume Attachment,Halda áfram Attachment,
Job Applicant Source,Atvinnuleitandi Heimild,
Applicant Email Address,Netfang umsækjanda,
Awaiting Response,bíður svars,
Job Offer Terms,Atvinnutilboðsskilmálar,
Select Terms and Conditions,Valið Skilmálar og skilyrði,
Printing Details,Prentun Upplýsingar,
Job Offer Term,Atvinnutími,
Offer Term,Tilboð Term,
Value / Description,Gildi / Lýsing,
Description of a Job Opening,Lýsing á starf opnun,
Job Title,Starfsheiti,
Staffing Plan,Mönnun áætlun,
Planned number of Positions,Planned Fjöldi Staða,
"Job profile, qualifications required etc.","Job uppsetningu, hæfi sem krafist o.fl.",
HR-LAL-.YYYY.-,HR-LAL-.YYYY.-,
Allocation,Úthlutun,
New Leaves Allocated,Ný Leaves Úthlutað,
Add unused leaves from previous allocations,Bæta ónotuðum blöð frá fyrri úthlutanir,
Unused leaves,ónotuð leyfi,
Total Leaves Allocated,Samtals Leaves Úthlutað,
Total Leaves Encashed,Samtals Leaves Encashed,
Leave Period,Leyfi,
Carry Forwarded Leaves,Bera framsent lauf,
Apply / Approve Leaves,Beita / Samþykkja Leaves,
HR-LAP-.YYYY.-,HR-LAP-.YYYY.-,
Leave Balance Before Application,Skildu Balance Áður Umsókn,
Total Leave Days,Samtals leyfisdaga,
Leave Approver Name,Skildu samþykkjari Nafn,
Follow via Email,Fylgdu með tölvupósti,
Block Holidays on important days.,Block Holidays á mikilvægum dögum.,
Leave Block List Name,Skildu Block List Nafn,
Applies to Company,Gildir til félagsins,
"If not checked, the list will have to be added to each Department where it has to be applied.",Ef ekki hakað listi verður að vera bætt við hvorri deild þar sem það þarf að vera beitt.,
Block Days,blokk Days,
Stop users from making Leave Applications on following days.,Hættu notendur frá gerð yfirgefa Umsóknir um næstu dögum.,
Leave Block List Dates,Skildu Block Listi Dagsetningar,
Allow Users,leyfa notendum,
Allow the following users to approve Leave Applications for block days.,Leyfa eftirfarandi notendum að samþykkja yfirgefa Umsóknir um blokk daga.,
Leave Block List Allowed,Skildu Block List leyfðar,
Leave Block List Allow,Skildu Block List Leyfa,
Allow User,að leyfa notanda,
Leave Block List Date,Skildu Block List Dagsetning,
Block Date,Block Dagsetning,
Leave Control Panel,Skildu Control Panel,
Select Employees,Select Starfsmenn,
Employment Type (optional),Atvinnutegund (valfrjálst),
Branch (optional),Útibú (valfrjálst),
Department (optional),Deild (valfrjálst),
Designation (optional),Tilnefning (valfrjálst),
Employee Grade (optional),Starfsmannaeinkunn (valfrjálst),
Employee (optional),Starfsmaður (valfrjálst),
Allocate Leaves,Úthlutaðu laufum,
Carry Forward,Haltu áfram,
Please select Carry Forward if you also want to include previous fiscal year's balance leaves to this fiscal year,Vinsamlegast veldu Yfirfæranlegt ef þú vilt líka að fela jafnvægi fyrra reikningsári er fer að þessu fjárhagsári,
New Leaves Allocated (In Days),Ný Leaves Úthlutað (í dögum),
Allocate,úthluta,
Leave Balance,Skildu jafnvægi,
Encashable days,Skemmtilegir dagar,
Encashment Amount,Innheimtuhækkun,
Leave Ledger Entry,Skildu skráningu bókar,
Transaction Name,Nafn viðskipta,
Is Carry Forward,Er bera fram,
Is Expired,Er útrunninn,
Is Leave Without Pay,Er Leyfi án launa,
Holiday List for Optional Leave,Holiday List fyrir valfrjálst leyfi,
Leave Allocations,Leyfa úthlutun,
Leave Policy Details,Skildu eftir upplýsingum um stefnu,
Leave Policy Detail,Skildu eftir stefnu,
Annual Allocation,Árleg úthlutun,
Leave Type Name,Skildu Tegund Nafn,
Max Leaves Allowed,Hámark Leaves leyft,
Applicable After (Working Days),Gildir eftir (virka daga),
Maximum Continuous Days Applicable,Hámarks samfelldir dagar sem gilda,
Is Optional Leave,Er valfrjálst leyfi,
Allow Negative Balance,Leyfa neikvæða stöðu,
Include holidays within leaves as leaves,Fela frí í laufum sem fer,
Is Compensatory,Er þóknanlegt,
Maximum Carry Forwarded Leaves,Hámarks flutningssending lauf,
Expire Carry Forwarded Leaves (Days),Útrunnið framsend lauf (dagar),
Calculated in days,Reiknað í dögum,
Encashment,Encashment,
Allow Encashment,Leyfa Encashment,
Encashment Threshold Days,Skrímsluskammtardagar,
Earned Leave,Aflað Leyfi,
Is Earned Leave,Er unnið skilið,
Earned Leave Frequency,Aflað Leyfi Frequency,
Rounding,Afrennsli,
Payroll Employee Detail,Launaskrá Starfsmannaupplýsingar,
Payroll Frequency,launaskrá Tíðni,
Fortnightly,hálfsmánaðarlega,
Bimonthly,bimonthly,
Employees,starfsmenn,
Number Of Employees,Fjöldi starfsmanna,
Employee Details,Upplýsingar um starfsmenn,
Validate Attendance,Staðfesta staðfestingu,
Salary Slip Based on Timesheet,Laun Slip Byggt á tímaskráningar,
Select Payroll Period,Veldu Launaskrá Tímabil,
Deduct Tax For Unclaimed Employee Benefits,Dragðu skatt fyrir óinnheimta launþega,
Deduct Tax For Unsubmitted Tax Exemption Proof,Tregðu skatt vegna óskráðs skattfrelsis,
Select Payment Account to make Bank Entry,Veldu Greiðslureikningur að gera Bank Entry,
Salary Slips Created,Launasalar búin til,
Salary Slips Submitted,Launasamningar lögð fram,
Payroll Periods,Launatímabil,
Payroll Period Date,Launatímabil Dagsetning,
Purpose of Travel,Tilgangur ferðarinnar,
Retention Bonus,Varðveisla bónus,
Bonus Payment Date,Bónus greiðsludagur,
Bonus Amount,Bónus upphæð,
Abbr,skammst,
Depends on Payment Days,Fer eftir greiðsludögum,
Is Tax Applicable,Er skattur gilda,
Variable Based On Taxable Salary,Variable Byggt á skattskyldum launum,
Round to the Nearest Integer,Hringið að næsta heiltölu,
Statistical Component,Tölfræðilegur hluti,
"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. ","Ef valið er, mun gildi sem tilgreint eða reiknað er í þessum hluta ekki stuðla að tekjum eða frádráttum. Hins vegar er það gildi sem hægt er að vísa til af öðrum hlutum sem hægt er að bæta við eða draga frá.",
Flexible Benefits,Sveigjanlegan ávinning,
Is Flexible Benefit,Er sveigjanlegur hagur,
Max Benefit Amount (Yearly),Hámarksbætur (Árlega),
Only Tax Impact (Cannot Claim But Part of Taxable Income),Aðeins skattáhrif (getur ekki krafist en hluti af skattskyldum tekjum),
Create Separate Payment Entry Against Benefit Claim,Búðu til sérstakt greiðslubréf gegn ávinningi kröfu,
Condition and Formula,Ástand og formúla,
Amount based on formula,Upphæð byggist á formúlu,
Formula,Formula,
Salary Detail,laun Detail,
Component,Component,
Do not include in total,Ekki innifalið alls,
Default Amount,Sjálfgefið Upphæð,
Additional Amount,Viðbótarupphæð,
Tax on flexible benefit,Skattur á sveigjanlegum ávinningi,
Tax on additional salary,Skattur á viðbótarlaun,
Condition and Formula Help,Ástand og Formula Hjálp,
Salary Structure,laun Uppbygging,
Working Days,Vinnudagar,
Salary Slip Timesheet,Laun Slip Timesheet,
Total Working Hours,Samtals Vinnutíminn,
Hour Rate,Hour Rate,
Bank Account No.,Bankareikningur nr,
Earning & Deduction,Launin &amp; Frádráttur,
Earnings,Hagnaður,
Deductions,frádráttur,
Employee Loan,starfsmaður Lán,
Total Principal Amount,Samtals höfuðstóll,
Total Interest Amount,Samtals vextir,
Total Loan Repayment,Alls Loan Endurgreiðsla,
net pay info,nettó borga upplýsingar,
Gross Pay - Total Deduction - Loan Repayment,Gross Pay - Total Frádráttur - Lán Endurgreiðsla,
Total in words,Samtals í orðum,
Net Pay (in words) will be visible once you save the Salary Slip.,Net Borga (í orðum) verður sýnileg þegar þú hefur vistað Laun Slip.,
Salary Component for timesheet based payroll.,Laun Component fyrir timesheet byggt launaskrá.,
Leave Encashment Amount Per Day,Skildu innheimtuverð á dag,
Max Benefits (Amount),Max Hagur (upphæð),
Salary breakup based on Earning and Deduction.,Laun Breakup byggt á launin og frádráttur.,
Total Earning,alls earnings,
Salary Structure Assignment,Uppbygging verkefnis,
Shift Assignment,Skiptingarverkefni,
Shift Type,Shift Tegund,
Shift Request,Shift beiðni,
Enable Auto Attendance,Virkja sjálfvirk mæting,
Mark attendance based on 'Employee Checkin' for Employees assigned to this shift.,Merktu mætingu á grundvelli „Innritun starfsmanna“ fyrir starfsmenn sem úthlutað er til þessa vaktar.,
Auto Attendance Settings,Stillingar sjálfvirkrar mætingar,
Determine Check-in and Check-out,Ákveðið innritun og útritun,
Alternating entries as IN and OUT during the same shift,Skipt um færslur sem IN og OUT á sömu vakt,
Strictly based on Log Type in Employee Checkin,Byggt stranglega á innskráningargerð í innritun starfsmanna,
Working Hours Calculation Based On,Útreikningur vinnutíma byggður á,
First Check-in and Last Check-out,Fyrsta innritun og síðast útritun,
Every Valid Check-in and Check-out,Sérhver gilt innritun og útskráning,
Begin check-in before shift start time (in minutes),Byrjaðu innritun fyrir upphafstíma vakta (í mínútum),
The time before the shift start time during which Employee Check-in is considered for attendance.,Tíminn fyrir upphafstíma vakta þar sem innritun starfsmanna er talin til mætingar.,
Allow check-out after shift end time (in minutes),Leyfa útritun eftir lok vaktar (í mínútum),
Time after the end of shift during which check-out is considered for attendance.,Tími eftir lok vaktar þar sem úthlutun er talin til mætingar.,
Working Hours Threshold for Half Day,Vinnutími þröskuldur í hálfan dag,
Working hours below which Half Day is marked. (Zero to disable),Vinnutími þar sem hálfur dagur er merktur. (Núll til að slökkva á),
Working Hours Threshold for Absent,Vinnutími þröskuldur fyrir fjarverandi,
Working hours below which Absent is marked. (Zero to disable),Vinnutími undir þeim er fjarverandi er merktur. (Núll til að slökkva á),
Process Attendance After,Aðferð mæting á eftir,
Attendance will be marked automatically only after this date.,Aðsókn verður merkt sjálfkrafa aðeins eftir þennan dag.,
Last Sync of Checkin,Síðasta samstilling við innritun,
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.,Síðast þekktur árangursríkur samstilling á starfsmannaskoðun. Endurstilla þetta aðeins ef þú ert viss um að öll logs eru samstillt frá öllum stöðum. Vinsamlegast ekki breyta þessu ef þú ert ekki viss.,
Grace Period Settings For Auto Attendance,Náðastigstillingar fyrir sjálfvirka aðsókn,
Enable Entry Grace Period,Virkja inngöngutímabil,
Late Entry Grace Period,Náðartímabil fyrir seinagang,
The time after the shift start time when check-in is considered as late (in minutes).,Tíminn eftir upphafstíma vakta þegar innritun er talin seint (í mínútum).,
Enable Exit Grace Period,Virkja útgöngutímabil,
Early Exit Grace Period,Náðartímabil snemma útgöngu,
The time before the shift end time when check-out is considered as early (in minutes).,Tíminn fyrir lokatíma vaktar þegar brottför er álitinn eins snemma (í mínútum).,
Skill Name,Færnheiti,
Staffing Plan Details,Mönnun áætlun upplýsingar,
Staffing Plan Detail,Stúdentaráðsáætlun,
Total Estimated Budget,Heildaráætlað fjárhagsáætlun,
Vacancies,Laus störf,
Estimated Cost Per Position,Áætlaður kostnaður á hverja stöðu,
Total Estimated Cost,Heildar áætlaður kostnaður,
Current Count,Núverandi fjöldi,
Current Openings,Núverandi op,
Number Of Positions,Fjöldi staða,
Taxable Salary Slab,Skattskyld launakostnaður,
From Amount,Frá upphæð,
To Amount,Að upphæð,
Percent Deduction,Hlutfall frádráttar,
Training Program,Þjálfunaráætlun,
Event Status,Event Staða,
Has Certificate,Hefur vottorð,
Seminar,Seminar,
Theory,Theory,
Workshop,Workshop,
Conference,Ráðstefna,
Exam,Exam,
Internet,internet,
Self-Study,Sjálfsnám,
Advance,Advance,
Trainer Name,þjálfari Name,
Trainer Email,þjálfari Email,
Attendees,Fundarmenn,
Employee Emails,Tölvupóstur starfsmanns,
Training Event Employee,Þjálfun Event Starfsmaður,
Invited,boðið,
Feedback Submitted,athugasemdir Sent,
Optional,Valfrjálst,
Training Result Employee,Þjálfun Niðurstaða Starfsmaður,
Travel Itinerary,Ferðaáætlun,
Travel From,Ferðalög frá,
Travel To,Ferðast til,
Mode of Travel,Ferðalög,
Flight,Flug,
Train,Lest,
Taxi,Taxi,
Rented Car,Leigðu bíl,
Meal Preference,Máltíð,
Vegetarian,Grænmetisæta,
Non-Vegetarian,Non-Vegetarian,
Gluten Free,Glútenfrí,
Non Diary,Ekki dagbók,
Travel Advance Required,Ferðaframboð krafist,
Departure Datetime,Brottfaratímabil,
Arrival Datetime,Komutími,
Lodging Required,Gisting krafist,
Preferred Area for Lodging,Valinn svæði fyrir gistingu,
Check-in Date,Innritunardagur,
Check-out Date,Útskráningardagur,
Travel Request,Ferðaskilaboð,
Travel Type,Ferðalög,
Domestic,Innlendar,
International,International,
Travel Funding,Ferðasjóður,
Require Full Funding,Krefjast Fulls fjármögnunar,
Fully Sponsored,Fully Sponsored,
"Partially Sponsored, Require Partial Funding","Að hluta til styrkt, krefjast hluta fjármögnunar",
Copy of Invitation/Announcement,Afrit af boðskorti / tilkynningu,
"Details of Sponsor (Name, Location)","Upplýsingar um Sponsor (Nafn, Staðsetning)",
Identification Document Number,Kennitölu númer,
Any other details,Allar aðrar upplýsingar,
Costing Details,Kostnaðarupplýsingar,
Costing,kosta,
Event Details,Upplýsingar um viðburð,
Name of Organizer,Nafn skipuleggjanda,
Address of Organizer,Heimilisfang skipuleggjanda,
Travel Request Costing,Ferðaskilyrði Kostnaður,
Expense Type,Kostnaðartegund,
Sponsored Amount,Styrkt upphæð,
Funded Amount,Fjármögnuð upphæð,
Upload Attendance,Hlaða Aðsókn,
Attendance From Date,Aðsókn Frá Dagsetning,
Attendance To Date,Aðsókn að Dagsetning,
Get Template,fá sniðmát,
Import Attendance,innflutningur Aðsókn,
Upload HTML,Hlaða HTML,
Vehicle,ökutæki,
License Plate,Númeraplata,
Odometer Value (Last),Kílómetramæli Value (Last),
Acquisition Date,yfirtökudegi,
Chassis No,undirvagn Ekkert,
Vehicle Value,ökutæki Value,
Insurance Details,Tryggingar Upplýsingar,
Insurance Company,Tryggingafélag,
Policy No,stefna Nei,
Additional Details,Önnur Nánar,
Fuel Type,eldsneytistegund,
Petrol,Bensín,
Diesel,Diesel,
Natural Gas,Náttúru gas,
Electric,Electric,
Fuel UOM,eldsneyti UOM,
Last Carbon Check,Síðasta Carbon Athuga,
Wheels,hjól,
Doors,hurðir,
HR-VLOG-.YYYY.-,HR-VLOG-.YYYY.-,
Odometer Reading,kílómetramæli Reading,
Current Odometer value ,Núverandi gildi kílómetramæls,
last Odometer Value ,síðasta kílómetramæli,
Refuelling Details,Eldsneytisstöðvar Upplýsingar,
Invoice Ref,Invoice Ref,
Service Details,Upplýsingar um þjónustu,
Service Detail,þjónusta Detail,
Vehicle Service,Vehicle Service,
Service Item,þjónusta Item,
Brake Oil,Brake Oil,
Brake Pad,Bremsuklossi,
Clutch Plate,Clutch Plate,
Engine Oil,Vélarolía,
Oil Change,olía Breyta,
Inspection,skoðun,
Mileage,mílufjöldi,
Hub Tracked Item,Hub Tracked Item,
Hub Node,Hub Node,
Image List,Myndalisti,
Item Manager,Item Manager,
Hub User,Hub notandi,
Hub Password,Hub Lykilorð,
Hub Users,Hub notendur,
Marketplace Settings,Markaðsstillingar,
Disable Marketplace,Slökktu á markaðnum,
Marketplace URL (to hide and update label),Auglýsingamarkaður (til að fela og uppfæra merki),
Registered,Skráður,
Sync in Progress,Samstilling í framvindu,
Hub Seller Name,Hub seljanda nafn,
Custom Data,Sérsniðin gögn,
Member,Meðlimur,
Partially Disbursed,hluta ráðstafað,
Loan Closure Requested,Óskað er eftir lokun lána,
Repay From Salary,Endurgreiða frá Laun,
Loan Details,lán Nánar,
Loan Type,lán Type,
Loan Amount,lánsfjárhæð,
Is Secured Loan,Er tryggt lán,
Rate of Interest (%) / Year,Vextir (%) / Ár,
Disbursement Date,útgreiðsludagur,
Disbursed Amount,Útborgað magn,
Is Term Loan,Er tíma lán,
Repayment Method,endurgreiðsla Aðferð,
Repay Fixed Amount per Period,Endurgreiða Föst upphæð á hvern Tímabil,
Repay Over Number of Periods,Endurgreiða yfir fjölda tímum,
Repayment Period in Months,Lánstími í mánuði,
Monthly Repayment Amount,Mánaðarlega endurgreiðslu Upphæð,
Repayment Start Date,Endurgreiðsla upphafsdagur,
Loan Security Details,Upplýsingar um öryggi lána,
Maximum Loan Value,Hámarkslánagildi,
Account Info,Reikningur Upplýsingar,
Loan Account,Lánreikningur,
Interest Income Account,Vaxtatekjur Reikningur,
Penalty Income Account,Vítisreikning,
Repayment Schedule,endurgreiðsla Dagskrá,
Total Payable Amount,Alls Greiðist Upphæð,
Total Principal Paid,Heildargreiðsla greidd,
Total Interest Payable,Samtals vaxtagjöld,
Total Amount Paid,Heildarfjárhæð greitt,
Loan Manager,Lánastjóri,
Loan Info,lán Info,
Rate of Interest,Vöxtum,
Proposed Pledges,Fyrirhugaðar veðsetningar,
Maximum Loan Amount,Hámarkslán,
Repayment Info,endurgreiðsla Upplýsingar,
Total Payable Interest,Alls Greiðist Vextir,
Loan Interest Accrual,Uppsöfnun vaxtalána,
Amounts,Fjárhæðir,
Pending Principal Amount,Aðalupphæð í bið,
Payable Principal Amount,Greiðilegt aðalupphæð,
Process Loan Interest Accrual,Að vinna úr áföllum vaxtalána,
Regular Payment,Regluleg greiðsla,
Loan Closure,Lánalokun,
Payment Details,Greiðsluupplýsingar,
Interest Payable,Vextir sem greiða ber,
Amount Paid,Greidd upphæð,
Principal Amount Paid,Aðalupphæð greidd,
Loan Security Name,Öryggisheiti láns,
Loan Security Code,Öryggisnúmer lána,
Loan Security Type,Tegund öryggis,
Haircut %,Hárskera%,
Loan  Details,Upplýsingar um lán,
Unpledged,Óléttað,
Pledged,Veðsett,
Partially Pledged,Veðsett að hluta,
Securities,Verðbréf,
Total Security Value,Heildaröryggisgildi,
Loan Security Shortfall,Skortur á lánsöryggi,
Loan ,Lán,
Shortfall Time,Skortur tími,
America/New_York,Ameríka / New_York,
Shortfall Amount,Fjárhæð,
Security Value ,Öryggisgildi,
Process Loan Security Shortfall,Að vinna úr öryggisskorti,
Loan To Value Ratio,Hlutfall lána,
Unpledge Time,Tímasetning,
Unpledge Type,Unpedge gerð,
Loan Name,lán Name,
Rate of Interest (%) Yearly,Rate of Interest (%) Árleg,
Penalty Interest Rate (%) Per Day,Dráttarvextir (%) á dag,
Penalty Interest Rate is levied on the pending interest amount on a daily basis in case of delayed repayment ,Dráttarvextir eru lagðir á vaxtaupphæðina í bið daglega ef seinkað er um endurgreiðslu,
Grace Period in Days,Náðstímabil á dögum,
Pledge,Veð,
Post Haircut Amount,Fjárhæð hárskera,
Update Time,Uppfærslutími,
Proposed Pledge,Fyrirhugað veð,
Total Payment,Samtals greiðsla,
Balance Loan Amount,Balance lánsfjárhæð,
Is Accrued,Er safnað,
Salary Slip Loan,Launasala,
Loan Repayment Entry,Endurgreiðsla lána,
Sanctioned Loan Amount,Viðurkennt lánsfjárhæð,
Sanctioned Amount Limit,Viðurkennd fjárhæðarmörk,
Unpledge,Fjarlægja,
Against Pledge,Gegn veði,
Haircut,Hárskera,
MAT-MSH-.YYYY.-,MAT-MSH-.YYYY.-,
Generate Schedule,búa Stundaskrá,
Schedules,Skrár,
Maintenance Schedule Detail,Viðhald Dagskrá Detail,
Scheduled Date,áætlunarferðir Dagsetning,
Actual Date,Raunveruleg Dagsetning,
Maintenance Schedule Item,Viðhald Dagskrá Item,
No of Visits,Engin heimsókna,
MAT-MVS-.YYYY.-,MAT-MVS-.YYYY.-,
Maintenance Date,viðhald Dagsetning,
Maintenance Time,viðhald Time,
Completion Status,Gengið Staða,
Partially Completed,hluta Lokið,
Fully Completed,fullu lokið,
Unscheduled,unscheduled,
Breakdown,Brotna niður,
Purposes,tilgangi,
Customer Feedback,viðskiptavinur Feedback,
Maintenance Visit Purpose,Viðhald Visit Tilgangur,
Work Done,vinnu,
Against Document No,Against Document nr,
Against Document Detail No,Gegn Document Detail No,
MFG-BLR-.YYYY.-,MFG-BLR-.YYYY.-,
Order Type,Order Type,
Blanket Order Item,Teppi panta hlut,
Ordered Quantity,Raðaður Magn,
Item to be manufactured or repacked,Liður í að framleiða eða repacked,
Quantity of item obtained after manufacturing / repacking from given quantities of raw materials,Magn lið sem fæst eftir framleiðslu / endurpökkunarinnar úr gefin magni af hráefni,
Set rate of sub-assembly item based on BOM,Stilla hlutfall af undir-samkoma atriði byggt á BOM,
Allow Alternative Item,Leyfa öðru hluti,
Item UOM,Liður UOM,
Conversion Rate,Viðskiptahlutfallsbil,
Rate Of Materials Based On,Hlutfall af efni byggt á,
With Operations,með starfsemi,
Manage cost of operations,Stjórna kostnaði við rekstur,
Transfer Material Against,Flytja efni á móti,
Routing,Leiðbeiningar,
Materials,efni,
Quality Inspection Required,Gæðaeftirlit er krafist,
Quality Inspection Template,Gæðaskoðunar sniðmát,
Scrap,rusl,
Scrap Items,Rusl Items,
Operating Cost,Rekstrarkostnaður,
Raw Material Cost,Raw Material Kostnaður,
Scrap Material Cost,Rusl efniskostnaði,
Operating Cost (Company Currency),Rekstrarkostnaður (Company Gjaldmiðill),
Raw Material Cost (Company Currency),Hráefniskostnaður (Gjaldmiðill fyrirtækisins),
Scrap Material Cost(Company Currency),Rusl efniskostnaði (Company Gjaldmiðill),
Total Cost,Heildar kostnaður,
Total Cost (Company Currency),Heildarkostnaður (Gjaldmiðill fyrirtækisins),
Materials Required (Exploded),Efni sem þarf (Sprakk),
Exploded Items,Sprungið atriði,
Item Image (if not slideshow),Liður Image (ef ekki myndasýning),
Thumbnail,Smámynd,
Website Specifications,Vefsíða Upplýsingar,
Show Items,Sýna Items,
Show Operations,Sýna Aðgerðir,
Website Description,Vefsíða Lýsing,
BOM Explosion Item,BOM Sprenging Item,
Qty Consumed Per Unit,Magn neytt á Unit,
Include Item In Manufacturing,Hafa hlut í framleiðslu,
BOM Item,BOM Item,
Item operation,Liður aðgerð,
Rate & Amount,Röð og upphæð,
Basic Rate (Company Currency),Basic Rate (Company Gjaldmiðill),
Scrap %,rusl%,
Original Item,Upprunalegt atriði,
BOM Operation,BOM Operation,
Batch Size,Hópastærð,
Base Hour Rate(Company Currency),Base Hour Rate (Company Gjaldmiðill),
Operating Cost(Company Currency),Rekstrarkostnaður (Company Gjaldmiðill),
BOM Scrap Item,BOM Scrap Item,
Basic Amount (Company Currency),Basic Magn (Company Gjaldmiðill),
BOM Update Tool,BOM Update Tool,
"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.","Skiptu ákveðnu BOM í öllum öðrum BOM þar sem það er notað. Það mun skipta um gamla BOM tengilinn, uppfæra kostnað og endurnýja &quot;BOM Explosion Item&quot; töflunni eins og á nýjum BOM. Það uppfærir einnig nýjustu verð í öllum BOMs.",
Replace BOM,Skiptu um BOM,
Current BOM,Núverandi BOM,
The BOM which will be replaced,The BOM sem verður skipt út,
The new BOM after replacement,Hin nýja BOM eftir skipti,
Replace,Skipta,
Update latest price in all BOMs,Uppfæra nýjustu verð í öllum BOMs,
BOM Website Item,BOM Website Item,
BOM Website Operation,BOM Website Operation,
Operation Time,Operation Time,
PO-JOB.#####,PO-JOB. #####,
Timing Detail,Tímasetning smáatriði,
Time Logs,Tímaskrár,
Total Time in Mins,Heildartími í mín,
Transferred Qty,flutt Magn,
Job Started,Starf byrjað,
Started Time,Byrjaður tími,
Current Time,Núverandi tími,
Job Card Item,Atvinna kort atriði,
Job Card Time Log,Tímaskrá yfir starfskort,
Time In Mins,Tími í mín,
Completed Qty,lokið Magn,
Manufacturing Settings,framleiðsla Stillingar,
Raw Materials Consumption,Neyslu hráefna,
Allow Multiple Material Consumption,Leyfa mörgum efnisnotkun,
Allow multiple Material Consumption against a Work Order,Leyfa mörgum efni neyslu gegn vinnu pöntunar,
Backflush Raw Materials Based On,Backflush Raw Materials miðað við,
Material Transferred for Manufacture,Efni flutt til Framleiðendur,
Capacity Planning,getu Planning,
Disable Capacity Planning,Slökkva á getu skipulags,
Allow Overtime,leyfa yfirvinnu,
Plan time logs outside Workstation Working Hours.,Skipuleggja tíma logs utan Workstation vinnutíma.,
Allow Production on Holidays,Leyfa Framleiðsla á helgidögum,
Capacity Planning For (Days),Getu áætlanagerð fyrir (dagar),
Try planning operations for X days in advance.,Prófaðu að skipuleggja starfsemi fyrir X daga fyrirvara.,
Time Between Operations (in mins),Tími milli rekstrar (í mín),
Default 10 mins,Default 10 mínútur,
Default Warehouses for Production,Sjálfgefin vöruhús til framleiðslu,
Default Work In Progress Warehouse,Sjálfgefið Work In Progress Warehouse,
Default Finished Goods Warehouse,Sjálfgefin fullunnum Warehouse,
Default Scrap Warehouse,Sjálfgefið ruslvörugeymsla,
Over Production for Sales and Work Order,Yfirframleiðsla til sölu og vinnupöntunar,
Overproduction Percentage For Sales Order,Yfirvinnsla hlutfall fyrir sölu pöntunar,
Overproduction Percentage For Work Order,Yfirvinnsla hlutfall fyrir vinnu Order,
Other Settings,aðrar stillingar,
Update BOM Cost Automatically,Uppfæra BOM kostnað sjálfkrafa,
"Update BOM cost automatically via Scheduler, based on latest valuation rate / price list rate / last purchase rate of raw materials.","Uppfæra BOM kostnað sjálfkrafa með áætlun, byggt á nýjustu verðlagsgengi / verðskrárgengi / síðasta kaupgengi hráefna.",
Material Request Plan Item,Efnisyfirlit,
Material Request Type,Efni Beiðni Type,
Material Issue,efni Issue,
Customer Provided,Viðskiptavinur veittur,
Minimum Order Quantity,lágmarks magn pöntunar,
Default Workstation,Sjálfgefið Workstation,
Production Plan,Framleiðsluáætlun,
MFG-PP-.YYYY.-,MFG-PP-.YYYY.-,
Get Items From,Fá atriði úr,
Get Sales Orders,Fá sölu skipunum,
Material Request Detail,Efnisbeiðni Detail,
Get Material Request,Fá Material Beiðni,
Material Requests,efni Beiðnir,
Get Items For Work Order,Fáðu atriði fyrir vinnuskilyrði,
Material Request Planning,Efni beiðni um skipulagningu,
Include Non Stock Items,Inniheldur ekki hlutabréfaeign,
Include Subcontracted Items,Inniheldur undirverktaka,
Ignore Existing Projected Quantity,Hunsa núverandi áætlað magn,
"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>.","Til að vita meira um spáð magn, <a href=""https://erpnext.com/docs/user/manual/en/stock/projected-quantity"" style=""text-decoration: underline;"" target=""_blank"">smelltu hér</a> .",
Download Required Materials,Sæktu nauðsynleg efni,
Get Raw Materials For Production,Fáðu hráefni til framleiðslu,
Total Planned Qty,Samtals áætlað magn,
Total Produced Qty,Heildarframleiðsla,
Material Requested,Efni sem óskað er eftir,
Production Plan Item,Framleiðsla Plan Item,
Make Work Order for Sub Assembly Items,Gerðu vinnupöntun fyrir hluti undirþingsins,
"If enabled, system will create the work order for the exploded items against which BOM is available.",Ef þetta er virkt mun kerfið búa til vinnupöntunina fyrir sprungna hlutina sem BOM er í boði fyrir.,
Planned Start Date,Áætlaðir Start Date,
Quantity and Description,Magn og lýsing,
material_request_item,material_request_item,
Product Bundle Item,Vara Knippi Item,
Production Plan Material Request,Framleiðslu Plan Efni Beiðni,
Production Plan Sales Order,Framleiðslu Plan Velta Order,
Sales Order Date,Velta Order Dagsetning,
Routing Name,Leiðbeiningarheiti,
MFG-WO-.YYYY.-,MFG-WO-.YYYY.-,
Item To Manufacture,Atriði til að framleiða,
Material Transferred for Manufacturing,Efni flutt til framleiðslu,
Manufactured Qty,Framleiðandi Magn,
Use Multi-Level BOM,Notaðu Multi-Level BOM,
Plan material for sub-assemblies,Plan efni fyrir undireiningum,
Skip Material Transfer to WIP Warehouse,Slepptu efnisflutningi til WIP Warehouse,
Check if material transfer entry is not required,Athugaðu hvort efnisflutningsfærsla sé ekki krafist,
Backflush Raw Materials From Work-in-Progress Warehouse,Backflush hráefni úr vinnslu í vinnslu,
Update Consumed Material Cost In Project,Uppfærðu neyttan efniskostnað í verkefni,
Warehouses,Vöruhús,
This is a location where raw materials are available.,Þetta er staður þar sem hráefni er fáanlegt.,
Work-in-Progress Warehouse,Work-í-gangi Warehouse,
This is a location where operations are executed.,Þetta er staður þar sem aðgerðir eru framkvæmdar.,
This is a location where final product stored.,Þetta er staður þar sem endanleg vara er geymd.,
Scrap Warehouse,rusl Warehouse,
This is a location where scraped materials are stored.,Þetta er staður þar sem skafa efni eru geymd.,
Required Items,Nauðsynleg Items,
Actual Start Date,Raunbyrjunardagsetning,
Planned End Date,Áætlaðir Lokadagur,
Actual End Date,Raunveruleg Lokadagur,
Operation Cost,Operation Kostnaður,
Planned Operating Cost,Áætlaðir rekstrarkostnaður,
Actual Operating Cost,Raunveruleg rekstrarkostnaður,
Additional Operating Cost,Viðbótarupplýsingar rekstrarkostnaður,
Total Operating Cost,Samtals rekstrarkostnaður,
Manufacture against Material Request,Framleiðsla á móti Material Beiðni,
Work Order Item,Vinna pöntunarhlut,
Available Qty at Source Warehouse,Laus magn í Source Warehouse,
Available Qty at WIP Warehouse,Laus magn á WIP Warehouse,
Work Order Operation,Vinna fyrir aðgerðina,
Operation Description,Operation Lýsing,
Operation completed for how many finished goods?,Operation lokið fyrir hversu mörgum fullunnum vörum?,
Work in Progress,Verk í vinnslu,
Estimated Time and Cost,Áætlaður tími og kostnaður,
Planned Start Time,Planned Start Time,
Planned End Time,Planned Lokatími,
in Minutes,í mínútum,
Actual Time and Cost,Raunveruleg tíma og kostnað,
Actual Start Time,Raunveruleg Start Time,
Actual End Time,Raunveruleg Lokatími,
Updated via 'Time Log',Uppfært með &#39;Time Innskráning &quot;,
Actual Operation Time,Raunveruleg Operation Time,
in Minutes\nUpdated via 'Time Log',Fundargerðir Uppfært gegnum &#39;Time Innskráning &quot;,
(Hour Rate / 60) * Actual Operation Time,(Hour Rate / 60) * Raunveruleg Rekstur Time,
Workstation Name,Workstation Name,
Production Capacity,Framleiðslugeta,
Operating Costs,því að rekstrarkostnaðurinn,
Electricity Cost,rafmagn Kostnaður,
per hour,á klukkustund,
Consumable Cost,einnota Kostnaður,
Rent Cost,Rent Kostnaður,
Wages,laun,
Wages per hour,Laun á klukkustund,
Net Hour Rate,Net Hour Rate,
Workstation Working Hour,Workstation vinnustund,
Certification Application,Vottunarforrit,
Name of Applicant,Nafn umsækjanda,
Certification Status,Vottunarstaða,
Yet to appear,Samt að birtast,
Certified,Löggiltur,
Not Certified,Ekki staðfest,
USD,USD,
INR,INR,
Certified Consultant,Löggiltur ráðgjafi,
Name of Consultant,Nafn ráðgjafa,
Certification Validity,Vottun Gildistími,
Discuss ID,Ræddu ID,
GitHub ID,GitHub ID,
Non Profit Manager,Non Profit Manager,
Chapter Head,Kafli höfuð,
Meetup Embed HTML,Meetup Fella HTML inn,
chapters/chapter_name\nleave blank automatically set after saving chapter.,kaflar / kafli_nafn slepptu sjálfkrafa eftir að þú hefur vistað kafla.,
Chapter Members,Kafla meðlimir,
Members,Meðlimir,
Chapter Member,Kafli meðlimur,
Website URL,vefslóð,
Leave Reason,Skildu ástæðu,
Donor Name,Nafn gjafans,
Donor Type,Gerð gjafa,
Withdrawn,hætt við,
Grant Application Details ,Veita umsókn upplýsingar,
Grant Description,Grant Lýsing,
Requested Amount,Óskað eftir upphæð,
Has any past Grant Record,Hefur einhverjar fyrri styrkleikaskrár,
Show on Website,Sýna á heimasíðu,
Assessment  Mark (Out of 10),Námsmat (af 10),
Assessment  Manager,Matsstjóri,
Email Notification Sent,Email tilkynning send,
NPO-MEM-.YYYY.-,NPO-MEM-.YYYY.-,
Membership Expiry Date,Félagsdagur,
Non Profit Member,Non Profit Member,
Membership Status,Aðildarstaða,
Member Since,Meðlimur síðan,
Volunteer Name,Sjálfboðaliðanöfn,
Volunteer Type,Sjálfboðaliðar,
Availability and Skills,Framboð og hæfni,
Availability,Framboð,
Weekends,Helgar,
Availability Timeslot,Framboð tímabils,
Morning,Morgunn,
Afternoon,Að morgni,
Evening,Kvöld,
Anytime,Hvenær sem er,
Volunteer Skills,Sjálfboðaliða,
Volunteer Skill,Sjálfboðaliðastarf,
Homepage,heimasíða,
Hero Section Based On,Hetjuhluti byggður á,
Homepage Section,Heimasíða hluti,
Hero Section,Hetja hluti,
Tag Line,tag Line,
Company Tagline for website homepage,Fyrirtæki Yfirskrift fyrir vefsvæðið heimasíðuna,
Company Description for website homepage,Fyrirtæki Lýsing á heimasíðu heimasíðuna,
Homepage Slideshow,Heimasíða myndasýningar,
"URL for ""All Products""",URL fyrir &quot;Allar vörur&quot;,
Products to be shown on website homepage,Vörur birtist á heimasíðu heimasíðuna,
Homepage Featured Product,Heimasíðan Valin Vara,
Section Based On,Kafli byggður á,
Section Cards,Hlutakort,
Number of Columns,Fjöldi dálka,
Number of columns for this section. 3 cards will be shown per row if you select 3 columns.,Fjöldi dálka fyrir þennan hluta. 3 kort verða sýnd í hverri röð ef þú velur 3 dálka.,
Section HTML,Hluti HTML,
Use this field to render any custom HTML in the section.,Notaðu þennan reit til að birta sérsniðna HTML hluti.,
Section Order,Kafla röð,
"Order in which sections should appear. 0 is first, 1 is second and so on.","Röð í hvaða köflum ætti að birtast. 0 er fyrst, 1 er annað og svo framvegis.",
Homepage Section Card,Hlutasíðu heimasíðunnar,
Subtitle,Undirtitill,
Products Settings,Vörur Stillingar,
Home Page is Products,Home Page er vörur,
"If checked, the Home page will be the default Item Group for the website",Ef valið þá Heimasíða verður sjálfgefið Item Group fyrir vefsvæðið,
Show Availability Status,Sýna stöðu stöðu,
Product Page,Vörusíða,
Products per Page,Vörur á síðu,
Enable Field Filters,Virkja reitasíur,
Item Fields,Atriðisreitir,
Enable Attribute Filters,Virkja eigindasíur,
Attributes,Eigindir,
Hide Variants,Fela afbrigði,
Website Attribute,Eigind vefsíðna,
Attribute,eiginleiki,
Website Filter Field,Síusvið vefsíðunnar,
Activity Cost,virkni Kostnaður,
Billing Rate,Innheimta Rate,
Costing Rate,kosta Rate,
Projects User,verkefni User,
Default Costing Rate,Sjálfgefið Kosta Rate,
Default Billing Rate,Sjálfgefið Billing Rate,
Dependent Task,Dependent Task,
Project Type,Project Type,
% Complete Method,% Complete Aðferð,
Task Completion,verkefni Lokið,
Task Progress,verkefni Progress,
% Completed,% Lokið,
From Template,Frá sniðmáti,
Project will be accessible on the website to these users,Verkefnið verður aðgengilegur á vef þessara notenda,
Copied From,Afritað frá,
Start and End Dates,Upphafs- og lokadagsetningar,
Costing and Billing,Kosta og innheimtu,
Total Costing Amount (via Timesheets),Samtals kostnaðarverð (með tímariti),
Total Expense Claim (via Expense Claims),Total Expense Krafa (með kostnað kröfum),
Total Purchase Cost (via Purchase Invoice),Total Kaup Kostnaður (í gegnum kaupa Reikningar),
Total Sales Amount (via Sales Order),Samtals sölugjald (með sölupöntun),
Total Billable Amount (via Timesheets),Samtals reikningshæft magn (með tímariti),
Total Billed Amount (via Sales Invoices),Samtals innheimt upphæð (með sölutölum),
Total Consumed Material Cost  (via Stock Entry),Heildarkostnaður neyslukostnaðar (í gegnum vöruskipti),
Gross Margin,Heildarframlegð,
Gross Margin %,Heildarframlegð %,
Monitor Progress,Skjár framfarir,
Collect Progress,Safna framfarir,
Frequency To Collect Progress,Tíðni til að safna framfarir,
Twice Daily,Tvisvar á dag,
First Email,Fyrsta tölvupóstur,
Second Email,Second Email,
Time to send,Tími til að senda,
Day to Send,Dagur til að senda,
Projects Manager,Verkefnisstjóri,
Project Template,Verkefnasniðmát,
Project Template Task,Verkefni sniðmáts verkefnis,
Begin On (Days),Byrjaðu á (dagar),
Duration (Days),Lengd (dagar),
Project Update,Verkefnisuppfærsla,
Project User,Project User,
View attachments,Skoða viðhengi,
Projects Settings,Verkefni Stillingar,
Ignore Workstation Time Overlap,Hunsa vinnustöðartímann,
Ignore User Time Overlap,Hunsa User Time skarast,
Ignore Employee Time Overlap,Hunsa starfsmannatímabilið,
Weight,þyngd,
Parent Task,Foreldraverkefni,
Timeline,Tímalína,
Expected Time (in hours),Væntanlegur Time (í klst),
% Progress,% Progress,
Is Milestone,Er Milestone,
Task Description,Verkefnalýsing,
Dependencies,Ósjálfstæði,
Dependent Tasks,Ósjálfstætt verkefni,
Depends on Tasks,Fer á Verkefni,
Actual Start Date (via Time Sheet),Raunbyrjunardagsetning (með Time Sheet),
Actual Time (in hours),Tíminn (í klst),
Actual End Date (via Time Sheet),Raunveruleg End Date (með Time Sheet),
Total Costing Amount (via Time Sheet),Total kostnaðarútreikninga Magn (með Time Sheet),
Total Expense Claim (via Expense Claim),Total Expense Krafa (með kostnað kröfu),
Total Billing Amount (via Time Sheet),Total Billing Magn (með Time Sheet),
Review Date,Review Date,
Closing Date,lokadegi,
Task Depends On,Verkefni veltur á,
Task Type,Gerð verkefnis,
Employee Detail,starfsmaður Detail,
Billing Details,Billing Upplýsingar,
Total Billable Hours,Samtals vinnustunda,
Total Billed Hours,Samtals Greidd Hours,
Total Costing Amount,Alls Kosta Upphæð,
Total Billable Amount,Alls Reikningur Upphæð,
Total Billed Amount,Alls Billed Upphæð,
% Amount Billed,% Magn Billed,
Hrs,Hrs,
Costing Amount,kosta Upphæð,
Corrective/Preventive,Leiðréttandi / fyrirbyggjandi,
Corrective,Leiðrétting,
Preventive,Fyrirbyggjandi,
Resolution,upplausn,
Resolutions,Ályktanir,
Quality Action Resolution,Upplausn gæða,
Quality Feedback Parameter,Viðbrögð við gæðaeftirlit,
Quality Feedback Template Parameter,Breytitæki fyrir sniðmát gæða,
Quality Goal,Gæðamarkmið,
Monitoring Frequency,Vöktunartíðni,
Weekday,Vikudagur,
January-April-July-October,Janúar-apríl-júlí-október,
Revision and Revised On,Endurskoðun og endurskoðuð,
Revision,Endurskoðun,
Revised On,Endurskoðað þann,
Objectives,Markmið,
Quality Goal Objective,Gæðamarkmið,
Objective,Hlutlæg,
Agenda,Dagskrá,
Minutes,Fundargerð,
Quality Meeting Agenda,Dagskrá um gæði fundar,
Quality Meeting Minutes,Fundargerðir gæða fundar,
Minute,Minute,
Parent Procedure,Málsmeðferð foreldra,
Processes,Ferli,
Quality Procedure Process,Gæðaferli,
Process Description,Aðferðalýsing,
Link existing Quality Procedure.,Tengdu núverandi gæðaferli.,
Additional Information,Viðbótarupplýsingar,
Quality Review Objective,Markmið gæðaúttektar,
DATEV Settings,DATEV stillingar,
Regional,Regional,
Consultant ID,Ráðgjafaauðkenni,
GST HSN Code,GST HSN kóða,
HSN Code,HSN kóða,
GST Settings,GST Stillingar,
GST Summary,GST Yfirlit,
GSTIN Email Sent On,GSTIN Email Sent On,
GST Accounts,GST reikninga,
B2C Limit,B2C takmörk,
Set Invoice Value for B2C. B2CL and B2CS calculated based on this invoice value.,Stilltu reikningsgildi fyrir B2C. B2CL og B2CS reiknuð út frá þessum reikningsvirði.,
GSTR 3B Report,GSTR 3B skýrsla,
January,Janúar,
February,Febrúar,
March,Mars,
April,Apríl,
May,Maí,
June,Júní,
July,Júlí,
August,Ágúst,
September,September,
October,október,
November,Nóvember,
December,Desember,
JSON Output,JSON framleiðsla,
Invoices with no Place Of Supply,Reikningar án framboðs,
Import Supplier Invoice,Flytja inn reikning birgja,
Invoice Series,Reikningaröð,
Upload XML Invoices,Hladdu inn XML reikningum,
Zip File,Zip File,
Import Invoices,Flytja inn reikninga,
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.,Smelltu á hnappinn Flytja inn reikninga þegar zip-skráin hefur verið fest við skjalið. Allar villur sem tengjast vinnslu verða sýndar í Villa Log.,
Invoice Series Prefix,Reiknivél Reiknivél,
Active Menu,Virkur valmynd,
Restaurant Menu,Veitingahús Valmynd,
Price List (Auto created),Verðskrá (Sjálfvirk stofnaður),
Restaurant Manager,Veitingahússtjóri,
Restaurant Menu Item,Veitingahús Valmynd Item,
Restaurant Order Entry,Veitingahús Order Entry,
Restaurant Table,Veitingahús borðstofa,
Click Enter To Add,Smelltu á Enter til að bæta við,
Last Sales Invoice,Síðasta sala Reikningur,
Current Order,Núverandi röð,
Restaurant Order Entry Item,Veitingahús Order Entry Item,
Served,Served,
Restaurant Reservation,Veitingahús pöntun,
Waitlisted,Bíddu á lista,
No Show,Engin sýning,
No of People,Ekkert fólk,
Reservation Time,Afgreiðslutími,
Reservation End Time,Afgreiðslutími,
No of Seats,Nei sæti,
Minimum Seating,Lágmarksstofa,
"Keep Track of Sales Campaigns. Keep track of Leads, Quotations, Sales Order etc from Campaigns to gauge Return on Investment. ","Halda utan um sölu herferðir. Haldið utan um leiðir, tilvitnanir, Sales Order etc frá herferðir til að meta arðsemi fjárfestingarinnar.",
SAL-CAM-.YYYY.-,SAL-CAM-.YYYY.-,
Campaign Schedules,Dagskrá herferðar,
Buyer of Goods and Services.,Kaupandi vöru og þjónustu.,
CUST-.YYYY.-,CUST-.YYYY.-,
Default Company Bank Account,Sjálfgefinn bankareikningur fyrirtækisins,
From Lead,frá Lead,
Account Manager,Reikningsstjóri,
Default Price List,Sjálfgefið Verðskrá,
Primary Address and Contact Detail,Aðal heimilisfang og tengiliðaval,
"Select, to make the customer searchable with these fields","Veldu, til að gera viðskiptavininum kleift að leita að þessum reitum",
Customer Primary Contact,Tengiliður viðskiptavina,
"Reselect, if the chosen contact is edited after save","Veldu aftur, ef valinn tengiliður er breytt eftir að vista",
Customer Primary Address,Aðalnafn viðskiptavinar,
"Reselect, if the chosen address is edited after save","Veldu aftur, ef valið heimilisfang er breytt eftir að vista",
Primary Address,Aðal heimilisfang,
Mention if non-standard receivable account,Umtal ef non-staðall nái reikning,
Credit Limit and Payment Terms,Lánsfé og greiðsluskilmálar,
Additional information regarding the customer.,Viðbótarupplýsingar um viðskiptavininn.,
Sales Partner and Commission,Velta Partner og framkvæmdastjórnarinnar,
Commission Rate,Framkvæmdastjórnin Rate,
Sales Team Details,Upplýsingar Söluteymi,
Customer Credit Limit,Lánamörk viðskiptavina,
Bypass Credit Limit Check at Sales Order,Umframgreiðsla fyrir lánshæfiseinkunn í söluskilningi,
Industry Type,Iðnaður Type,
MAT-INS-.YYYY.-,MAT-INS-.YYYY.-,
Installation Date,uppsetning Dagsetning,
Installation Time,uppsetning Time,
Installation Note Item,Uppsetning Note Item,
Installed Qty,uppsett Magn,
Lead Source,Lead Source,
POS Closing Voucher,POS lokunarskírteini,
Period Start Date,Tímabil Upphafsdagur,
Period End Date,Tímabil Lokadagur,
Cashier,Gjaldkeri,
Expense Details,Upplýsingar um kostnað,
Expense Amount,Gjaldfjárhæð,
Amount in Custody,Upphæð í forsjá,
Total Collected Amount,Heildar safnað fjárhæð,
Difference,Mismunur,
Modes of Payment,Breytingar á greiðslu,
Linked Invoices,Tengdir reikningar,
Sales Invoices Summary,Sala reikninga Samantekt,
POS Closing Voucher Details,POS Loka Voucher Upplýsingar,
Collected Amount,Söfnuður upphæð,
Expected Amount,Væntanlegt magn,
POS Closing Voucher Invoices,POS Loka Voucher Reikningar,
Quantity of Items,Magn af hlutum,
POS Closing Voucher Taxes,POS Lokaskírteini Skattar,
"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","Samanlagðar hópur ** Items ** í annað ** Item **. Þetta er gagnlegt ef þú ert að samtvinnun ákveðnum ** Hlutir ** í pakka og þú halda lager af pakkað ** Items ** og ekki samanlagt ** Item **. The pakki ** Item ** mun hafa &quot;Er Stock Item&quot; sem &quot;Nei&quot; og &quot;Er Velta Item&quot; sem &quot;Já&quot;. Til dæmis: ef þú ert að selja Fartölvur og bakpoka sig og hafa sérstakt verð ef viðskiptavinur kaupir bæði, þá Laptop + Bakpoki verður ný vara Knippi Item. Ath: BOM = Bill of Materials",
Parent Item,Parent Item,
List items that form the package.,Listaatriði sem mynda pakka.,
SAL-QTN-.YYYY.-,SAL-QTN-.YYYY.-,
Quotation To,Tilvitnun Til,
Rate at which customer's currency is converted to company's base currency,Gengi sem viðskiptavinurinn er mynt er breytt í grunngj.miðil félagsins,
Rate at which Price list currency is converted to company's base currency,Gengi sem Verðskrá mynt er breytt í grunngj.miðil félagsins,
Additional Discount and Coupon Code,Viðbótarafsláttur og afsláttarmiða kóða,
Referral Sales Partner,Tilvísun söluaðila,
In Words will be visible once you save the Quotation.,Í orðum verður sýnileg þegar þú hefur vistað tilvitnun.,
Term Details,Term Upplýsingar,
Quotation Item,Tilvitnun Item,
Against Doctype,Against DOCTYPE,
Against Docname,Against DOCNAME,
Additional Notes,Viðbótarbréf,
SAL-ORD-.YYYY.-,SAL-ORD-.YYYY.-,
Skip Delivery Note,Sleppa afhendingu athugasemd,
In Words will be visible once you save the Sales Order.,Í orðum verður sýnileg þegar þú hefur vistað Velta Order.,
Track this Sales Order against any Project,Fylgjast með þessari sölu til gegn hvers Project,
Billing and Delivery Status,Innheimtu og skil Status,
Not Delivered,ekki Skilað,
Fully Delivered,Alveg Skilað,
Partly Delivered,hluta Skilað,
Not Applicable,Á ekki við,
%  Delivered,% Skilað,
% of materials delivered against this Sales Order,% Af efnum afhent gegn þessum Sales Order,
% of materials billed against this Sales Order,% Af efnum rukkaður gegn þessu Sales Order,
Not Billed,ekki borgað,
Fully Billed,Alveg Billed,
Partly Billed,hluta Billed,
Ensure Delivery Based on Produced Serial No,Tryggja afhendingu á grundvelli framleiddra raðnúmera,
Supplier delivers to Customer,Birgir skilar til viðskiptavinar,
Delivery Warehouse,Afhending Warehouse,
Planned Quantity,Áætlaðir Magn,
For Production,fyrir framleiðslu,
Work Order Qty,Vinnu Order Magn,
Produced Quantity,framleidd Magn,
Used for Production Plan,Notað fyrir framleiðslu áætlun,
Sales Partner Type,Sala samstarfsaðila,
Contact No.,Viltu samband við No.,
Contribution (%),Framlag (%),
Contribution to Net Total,Framlag til Nettó,
Selling Settings,selja Stillingar,
Settings for Selling Module,Stillingar fyrir Selja Module,
Customer Naming By,Viðskiptavinur Nafngift By,
Campaign Naming By,Herferð Nafngift By,
Default Customer Group,Sjálfgefið Group Viðskiptavinur,
Default Territory,Sjálfgefið Territory,
Close Opportunity After Days,Loka Tækifæri Eftir daga,
Auto close Opportunity after 15 days,Auto nálægt Tækifæri eftir 15 daga,
Default Quotation Validity Days,Sjálfgefið útboðsdagur,
Sales Order Required,Velta Order Required,
Delivery Note Required,Afhending Note Áskilið,
Sales Update Frequency,Sala Uppfæra Tíðni,
How often should project and company be updated based on Sales Transactions.,Hversu oft ætti verkefnið og fyrirtækið að uppfæra byggt á söluviðskiptum.,
Each Transaction,Hver viðskipti,
Allow user to edit Price List Rate in transactions,Leyfa notanda að breyta gjaldskránni Rate í viðskiptum,
Allow multiple Sales Orders against a Customer's Purchase Order,Leyfa mörgum sölu skipunum gegn Purchase Order viðskiptavinar,
Validate Selling Price for Item against Purchase Rate or Valuation Rate,Sannreyna söluverð lið gegn kaupgengi eða Verðmat Rate,
Hide Customer's Tax Id from Sales Transactions,Fela Tax Auðkenni viðskiptavinar frá sölu viðskiptum,
SMS Center,SMS Center,
Send To,Senda til,
All Contact,Allt samband við,
All Customer Contact,Allt Viðskiptavinur samband við,
All Supplier Contact,Allt Birgir samband við,
All Sales Partner Contact,Allt Sales Partner samband við,
All Lead (Open),Allt Lead (Open),
All Employee (Active),Allt Starfsmaður (Active),
All Sales Person,Allt Sales Person,
Create Receiver List,Búa Receiver lista,
Receiver List,Receiver List,
Messages greater than 160 characters will be split into multiple messages,Skilaboð meiri en 160 stafir verður skipt í marga skilaboð,
Total Characters,Samtals Stafir,
Total Message(s),Total Message (s),
Authorization Control,Heimildin Control,
Authorization Rule,Heimildin Regla,
Average Discount,Meðal Afsláttur,
Customerwise Discount,Customerwise Afsláttur,
Itemwise Discount,Itemwise Afsláttur,
Customer or Item,Viðskiptavinur eða Item,
Customer / Item Name,Viðskiptavinur / Item Name,
Authorized Value,Leyft Value,
Applicable To (Role),Gildir til (Hlutverk),
Applicable To (Employee),Gildir til (starfsmaður),
Applicable To (User),Gildir til (User),
Applicable To (Designation),Gildir til (Tilnefning),
Approving Role (above authorized value),Samþykkir hlutverk (að ofan er leyft gildi),
Approving User  (above authorized value),Samþykkir notandi (yfir viðurkennda gildi),
Brand Defaults,Vanski vörumerkis,
Legal Entity / Subsidiary with a separate Chart of Accounts belonging to the Organization.,Lögaðili / Dótturfélag með sérstakri Mynd af reikninga tilheyra stofnuninni.,
Change Abbreviation,Breyta Skammstöfun,
Parent Company,Móðurfélag,
Default Values,sjálfgefnar,
Default Holiday List,Sjálfgefin Holiday List,
Standard Working Hours,Venjulegur vinnutími,
Default Selling Terms,Sjálfgefin söluskilmálar,
Default Buying Terms,Sjálfgefnir kaupsskilmálar,
Default warehouse for Sales Return,Sjálfgefið lager fyrir söluávöxtun,
Create Chart Of Accounts Based On,Búa graf af reikningum miðað við,
Standard Template,Standard Template,
Chart Of Accounts Template,Mynd af reikningum sniðmáti,
Existing Company ,núverandi Company,
Date of Establishment,Stofnunardagur,
Sales Settings,Sölustillingar,
Monthly Sales Target,Mánaðarlegt sölumarkmið,
Sales Monthly History,Sala mánaðarlega sögu,
Transactions Annual History,Viðskipti ársferill,
Total Monthly Sales,Samtals mánaðarleg sala,
Default Cash Account,Sjálfgefið Cash Reikningur,
Default Receivable Account,Sjálfgefið Krafa Reikningur,
Round Off Cost Center,Umferð Off Kostnaður Center,
Discount Allowed Account,Afsláttur leyfður reikningur,
Discount Received Account,Móttekinn reikningur,
Exchange Gain / Loss Account,Gengishagnaður / Rekstrarreikningur,
Unrealized Exchange Gain/Loss Account,Óinnleystur Gengishagnaður / Tap reikningur,
Allow Account Creation Against Child Company,Leyfa stofnun reiknings gagnvart barnafyrirtæki,
Default Payable Account,Sjálfgefið Greiðist Reikningur,
Default Employee Advance Account,Sjálfstætt starfandi reikningsskil,
Default Cost of Goods Sold Account,Default Kostnaðarverð seldra vara reikning,
Default Income Account,Sjálfgefið Tekjur Reikningur,
Default Deferred Revenue Account,Sjálfgefið frestað tekjutekjur,
Default Deferred Expense Account,Sjálfgefið frestað kostnaðarreikningur,
Default Payroll Payable Account,Default Launaskrá Greiðist Reikningur,
Default Expense Claim Payable Account,Sjálfkrafa kostnaður krafa greiðanlegur reikningur,
Stock Settings,lager Stillingar,
Enable Perpetual Inventory,Virkja ævarandi birgða,
Default Inventory Account,Sjálfgefin birgðareikningur,
Stock Adjustment Account,Stock jöfnunarreikning,
Fixed Asset Depreciation Settings,Fast eign Afskriftir Stillingar,
Series for Asset Depreciation Entry (Journal Entry),Röð fyrir eignatekjur afskriftir (Journal Entry),
Gain/Loss Account on Asset Disposal,Hagnaður / tap reikning á Asset förgun,
Asset Depreciation Cost Center,Eignastýring Afskriftir Kostnaður Center,
Budget Detail,Fjárhagsáætlun smáatriði,
Exception Budget Approver Role,Undantekning fjárhagsáætlun samþykkis hlutverki,
Company Info,Upplýsingar um fyrirtæki,
For reference only.,Til viðmiðunar aðeins.,
Company Logo,Fyrirtæki Logo,
Date of Incorporation,Dagsetning samþættingar,
Date of Commencement,Dagsetning upphafs,
Phone No,Sími nei,
Company Description,Fyrirtæki Lýsing,
Registration Details,Skráning Details,
Company registration numbers for your reference. Tax numbers etc.,Fyrirtæki skráningarnúmer til viðmiðunar. Tax tölur o.fl.,
Delete Company Transactions,Eyða Transactions Fyrirtækið,
Currency Exchange,gjaldeyri,
Specify Exchange Rate to convert one currency into another,Tilgreina Exchange Rate að breyta einum gjaldmiðli í annan,
From Currency,frá Gjaldmiðill,
To Currency,til Gjaldmiðill,
For Buying,Til kaupa,
For Selling,Til sölu,
Customer Group Name,Viðskiptavinar Group Name,
Parent Customer Group,Parent Group Viðskiptavinur,
Only leaf nodes are allowed in transaction,Aðeins blaða hnútar mega í viðskiptum,
Mention if non-standard receivable account applicable,Umtal ef non-staðall nái reikning við,
Credit Limits,Lánamörk,
Email Digest,Tölvupóstur Digest,
Send regular summary reports via Email.,Senda reglulegar skýrslur yfirlit með tölvupósti.,
Email Digest Settings,Sendu Digest Stillingar,
How frequently?,Hversu oft?,
Next email will be sent on:,Næst verður send í tölvupósti á:,
Note: Email will not be sent to disabled users,Ath: Email verður ekki send til fatlaðra notenda,
Profit & Loss,Hagnaður &amp; Tap,
New Income,ný Tekjur,
New Expenses,ný Útgjöld,
Annual Income,Árleg innkoma,
Annual Expenses,Árleg útgjöld,
Bank Balance,Bank Balance,
Bank Credit Balance,Útlánajöfnuður bankans,
Receivables,Viðskiptakröfur,
Payables,skammtímaskuldir,
Sales Orders to Bill,Sölupantanir til Bill,
Purchase Orders to Bill,Kaup pantanir til Bill,
New Sales Orders,Ný Velta Pantanir,
New Purchase Orders,Ný Purchase Pantanir,
Sales Orders to Deliver,Sölutilboð til að skila,
Purchase Orders to Receive,Kaup pantanir til að fá,
New Purchase Invoice,Ný innheimtuseðill,
New Quotations,ný Tilvitnun,
Open Quotations,Opið Tilvitnanir,
Purchase Orders Items Overdue,Innkaupapantanir Atriði tímabært,
Add Quote,Bæta Quote,
Global Defaults,Global Vanskil,
Default Company,Sjálfgefið Company,
Current Fiscal Year,Yfirstandandi reikningsári,
Default Distance Unit,Sjálfgefin fjarlægðareining,
Hide Currency Symbol,Fela gjaldmiðilinn,
Do not show any symbol like $ etc next to currencies.,Ekki sýna tákn eins og $ etc hliðina gjaldmiðlum.,
"If disable, 'Rounded Total' field will not be visible in any transaction",Ef öryrkjar &#39;ávöl Samtals&#39; reitur verður ekki sýnilegt í öllum viðskiptum,
Disable In Words,Slökkva á í orðum,
"If disable, 'In Words' field will not be visible in any transaction",Ef öryrkjar &#39;í orðum&#39; sviði mun ekki vera sýnilegur í öllum viðskiptum,
Item Classification,Liður Flokkun,
General Settings,Almennar stillingar,
Item Group Name,Item Group Name,
Parent Item Group,Parent Item Group,
Item Group Defaults,Varahópur sjálfgefið,
Item Tax,Liður Tax,
Check this if you want to show in website,Hakaðu við þetta ef þú vilt sýna í viðbót,
Show this slideshow at the top of the page,Sýna þessa myndasýningu efst á síðunni,
HTML / Banner that will show on the top of product list.,HTML / Banner sem mun sýna á efst á listanum vöru.,
Set prefix for numbering series on your transactions,Setja forskeyti fyrir númerakerfi röð á viðskiptum þínum,
Setup Series,skipulag Series,
Select Transaction,Veldu Transaction,
Help HTML,Hjálp HTML,
Series List for this Transaction,Series List fyrir þessa færslu,
User must always select,Notandi verður alltaf að velja,
Check this if you want to force the user to select a series before saving. There will be no default if you check this.,Hakaðu við þetta ef þú vilt að þvinga notendur til að velja röð áður en þú vistar. Það verður ekkert sjálfgefið ef þú athuga þetta.,
Update Series,Uppfæra Series,
Change the starting / current sequence number of an existing series.,Breyta upphafsdegi / núverandi raðnúmer núverandi röð.,
Prefix,forskeyti,
Current Value,Núverandi Value,
This is the number of the last created transaction with this prefix,Þetta er fjöldi síðustu búin færslu með þessu forskeyti,
Update Series Number,Uppfæra Series Number,
Quotation Lost Reason,Tilvitnun Lost Ástæða,
A third party distributor / dealer / commission agent / affiliate / reseller who sells the companies products for a commission.,Þriðji aðili dreifingaraðila / söluaðila / umboðsmanns / tengja / sölumaður sem selur fyrirtæki vörur fyrir þóknun.,
Sales Partner Name,Heiti Sales Partner,
Partner Type,Gerð Partner,
Address & Contacts,Heimilisfang og Tengiliðir,
Address Desc,Heimilisfang karbósýklískan,
Contact Desc,Viltu samband við Ö,
Sales Partner Target,Velta Partner Target,
Targets,markmið,
Show In Website,Sýna í Vefsíða,
Referral Code,Tilvísunarkóði,
To Track inbound purchase,Til að fylgjast með innkaupum á heimleið,
Logo,logo,
Partner website,Vefsíða Partner,
All Sales Transactions can be tagged against multiple **Sales Persons** so that you can set and monitor targets.,Öll sala Viðskipti má tagged móti mörgum ** sölufólk ** þannig að þú getur sett og fylgjast markmið.,
Name and Employee ID,Nafn og Starfsmannafélag ID,
Sales Person Name,Velta Person Name,
Parent Sales Person,Móðurfélag Sales Person,
Select company name first.,Select nafn fyrirtækis fyrst.,
Sales Person Targets,Velta Person markmið,
Set targets Item Group-wise for this Sales Person.,Setja markmið Item Group-vitur fyrir þetta velta manneskja.,
Supplier Group Name,Nafn seljanda,
Parent Supplier Group,Móðir Birgir Group,
Target Detail,Target Detail,
Target Qty,Target Magn,
Target  Amount,Target Upphæð,
Target Distribution,Target Dreifing,
"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.","Staðlaðar Skilmálar og skilyrði sem hægt er að bæta við sölu og innkaup. Dæmi: 1. Gildi tilboðinu. 1. Greiðsluskilmálar (fyrirfram, á lánsfé, hluti fyrirfram etc). 1. Hvað er aukinn (eða ber að greiða viðskiptamanni). 1. Öryggi / notkun viðvörun. 1. Ábyrgð ef einhver er. 1. Skilareglur. 1. Skilmálar skipum, ef við á. 1. Leiðir sem fjallað deilur bætur, ábyrgð osfrv 1. Heimilisfang og Hafa fyrirtækisins.",
Applicable Modules,Gildandi mát,
Terms and Conditions Help,Skilmálar og skilyrði Hjálp,
Classification of Customers by region,Flokkun viðskiptavina eftir svæðum,
Territory Name,Territory Name,
Parent Territory,Parent Territory,
Territory Manager,Territory Manager,
For reference,til viðmiðunar,
Territory Targets,Territory markmið,
Set Item Group-wise budgets on this Territory. You can also include seasonality by setting the Distribution.,Setja Item Group-vitur fjárveitingar á þessum Territory. Þú getur einnig falið í sér árstíðasveiflu með því að setja dreifingu.,
UOM Name,UOM Name,
Check this to disallow fractions. (for Nos),Hakaðu við þetta til að banna broti. (NOS),
Website Item Group,Vefsíða Item Group,
Cross Listing of Item in multiple groups,Cross Skráning Liður í mörgum hópum,
Default settings for Shopping Cart,Sjálfgefnar stillingar fyrir Shopping Cart,
Enable Shopping Cart,Virkja Shopping Cart,
Display Settings,Sýna stillingar,
Show Public Attachments,Sýna opinberar viðhengi,
Show Price,Sýna verð,
Show Stock Availability,Sýna framboð á lager,
Show Configure Button,Sýna stillingarhnapp,
Show Contact Us Button,Sýna Hafðu samband hnappinn,
Show Stock Quantity,Sýna lager Magn,
Show Apply Coupon Code,Sýna Nota afsláttarmiða kóða,
Allow items not in stock to be added to cart,Leyfa að hlutum sem ekki eru til á lager sé bætt í körfuna,
Prices will not be shown if Price List is not set,Verð verður ekki sýnd ef verðskrá er ekki sett,
Quotation Series,Tilvitnun Series,
Checkout Settings,Checkout Stillingar,
Enable Checkout,Virkja Checkout,
Payment Success Url,Greiðsla Velgengni URL,
After payment completion redirect user to selected page.,Að lokinni greiðslu áframsenda notandann til valda síðu.,
Batch ID,hópur ID,
Parent Batch,Foreldri hópur,
Manufacturing Date,Framleiðslutími,
Source Document Type,Heimild skjal tegund,
Source Document Name,Heimild skjal Nafn,
Batch Description,hópur Lýsing,
Bin,Bin,
Reserved Quantity,frátekin Magn,
Actual Quantity,Raunveruleg Magn,
Requested Quantity,Umbeðin Magn,
Reserved Qty for sub contract,Frátekin fjöldi undirverktaka,
Moving Average Rate,Moving Average Meta,
FCFS Rate,FCFS Rate,
Customs Tariff Number,Tollskrá Number,
Tariff Number,gjaldskrá Number,
Delivery To,Afhending Til,
MAT-DN-.YYYY.-,MAT-DN-.YYYY.-,
Is Return,er aftur,
Issue Credit Note,Útgáfa lánshæfismats,
Return Against Delivery Note,Aftur gegn afhendingu Note,
Customer's Purchase Order No,Purchase Order No viðskiptavinar,
Billing Address Name,Billing Address Nafn,
Required only for sample item.,Aðeins nauðsynlegt fyrir sýnishorn hlut.,
"If you have created a standard template in Sales Taxes and Charges Template, select one and click on the button below.","Ef þú hefur búið til staðlaða sniðmát í sölu sköttum og gjöldum Snið, veldu einn og smelltu á hnappinn hér fyrir neðan.",
In Words will be visible once you save the Delivery Note.,Í orðum verður sýnileg þegar þú hefur vistað Afhending Ath.,
In Words (Export) will be visible once you save the Delivery Note.,Í orðum (Export) verður sýnileg þegar þú hefur vistað Afhending Ath.,
Transporter Info,Transporter Upplýsingar,
Driver Name,Nafn ökumanns,
Track this Delivery Note against any Project,Fylgjast með þessari Delivery Ath gegn hvers Project,
Inter Company Reference,Tilvísun Inter fyrirtækisins,
Print Without Amount,Prenta Án Upphæð,
% Installed,% Uppsett,
% of materials delivered against this Delivery Note,% Af efnum afhent gegn þessum Delivery Note,
Installation Status,uppsetning Staða,
Excise Page Number,Vörugjöld Page Number,
Instructions,leiðbeiningar,
From Warehouse,frá Warehouse,
Against Sales Order,Against Sales Order,
Against Sales Order Item,Gegn Sales Order Item,
Against Sales Invoice,Against sölureikningi,
Against Sales Invoice Item,Gegn sölureikningi Item,
Available Batch Qty at From Warehouse,Laus Hópur Magn á frá vöruhúsi,
Available Qty at From Warehouse,Laus Magn á frá vöruhúsi,
Delivery Settings,Afhendingastillingar,
Dispatch Settings,Sendingarstillingar,
Dispatch Notification Template,Tilkynningarsniðmát,
Dispatch Notification Attachment,Viðhengi Tilkynning Tilkynning,
Leave blank to use the standard Delivery Note format,Skildu eftir autt til að nota staðlaða sendingarskýringarmyndina,
Send with Attachment,Senda með viðhengi,
Delay between Delivery Stops,Tafir milli afhendingarstöðva,
Delivery Stop,Afhending Stöðva,
Visited,Heimsótt,
Order Information,Panta Upplýsingar,
Contact Information,Tengiliður Upplýsingar,
Email sent to,Tölvupóstur sendur til,
Dispatch Information,Sendingarupplýsingar,
Estimated Arrival,Áætlaður komudagur,
MAT-DT-.YYYY.-,MAT-DT-.YYYY.-,
Initial Email Notification Sent,Upphafleg póstskilaboð send,
Delivery Details,Afhending Upplýsingar,
Driver Email,Netfang ökumanns,
Driver Address,Heimilisfang ökumanns,
Total Estimated Distance,Samtals áætlað fjarlægð,
Distance UOM,Fjarlægð UOM,
Departure Time,Brottfaratími,
Delivery Stops,Afhending hættir,
Calculate Estimated Arrival Times,Reikna áætlaðan komutíma,
Use Google Maps Direction API to calculate estimated arrival times,Notaðu Google Maps Direction API til að reikna áætlaða komutíma,
Optimize Route,Bjartsýni leið,
Use Google Maps Direction API to optimize route,Notaðu Google Maps Direction API til að hámarka leið,
In Transit,Í flutningi,
Fulfillment User,Uppfylling Notandi,
"A Product or a Service that is bought, sold or kept in stock.","A vöru eða þjónustu sem er keypt, selt eða haldið á lager.",
STO-ITEM-.YYYY.-,STO-ITEM-.YYYY.-,
"If item is a variant of another item then description, image, pricing, taxes etc will be set from the template unless explicitly specified","Ef hluturinn er afbrigði af annað lið þá lýsingu, mynd, verðlagningu, skatta osfrv sett verður úr sniðmátinu nema skýrt tilgreint",
Is Item from Hub,Er hlutur frá miðstöð,
Default Unit of Measure,Default Mælieiningin,
Maintain Stock,halda lager,
Standard Selling Rate,Standard sölugengi,
Auto Create Assets on Purchase,Búa til sjálfvirkt Eignir um kaup,
Asset Naming Series,Eignaheiti,
Over Delivery/Receipt Allowance (%),Yfir afhending / kvittun (%),
Barcodes,Strikamerki,
Shelf Life In Days,Geymsluþol á dögum,
End of Life,End of Life,
Default Material Request Type,Default Efni Beiðni Type,
Valuation Method,Verðmatsaðferð,
FIFO,FIFO,
Moving Average,Moving Average,
Warranty Period (in days),Ábyrgðartímabilið (í dögum),
Auto re-order,Auto endurraða,
Reorder level based on Warehouse,Uppröðun stigi byggist á Lager,
Will also apply for variants unless overrridden,Mun einnig gilda um afbrigði nema overrridden,
Units of Measure,Mælieiningar,
Will also apply for variants,Mun einnig gilda fyrir afbrigði,
Serial Nos and Batches,Raðnúmer og lotur,
Has Batch No,Hefur Batch No,
Automatically Create New Batch,Búðu til nýjan hóp sjálfkrafa,
Batch Number Series,Batch Number Series,
"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.",Dæmi: ABCD. #####. Ef röð er stillt og lota nr er ekki getið í viðskiptum þá verður sjálfkrafa lotunúmer búið til byggt á þessari röð. Ef þú vilt alltaf nefna lotu nr. Fyrir þetta atriði skaltu láta þetta vera autt. Athugaðu: Þessi stilling mun taka forgang yfir forskeyti fyrir nafngiftaröð í lagerstillingum.,
Has Expiry Date,Hefur gildistími,
Retain Sample,Halda sýni,
Max Sample Quantity,Hámarksfjöldi sýnis,
Maximum sample quantity that can be retained,Hámarks sýni magn sem hægt er að halda,
Has Serial No,Hefur Serial Nei,
Serial Number Series,Serial Number Series,
"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.","Dæmi:. ABCD ##### Ef röð er sett og Serial Nei er ekki getið í viðskiptum, þá sjálfvirkur raðnúmer verður búin byggt á þessari röð. Ef þú vilt alltaf að beinlínis sé minnst Serial Nos fyrir þetta atriði. autt.",
Variants,afbrigði,
Has Variants,hefur Afbrigði,
"If this item has variants, then it cannot be selected in sales orders etc.","Ef þessi atriði eru afbrigði, þá getur það ekki verið valinn í sölu skipunum o.fl.",
Variant Based On,Variant miðað við,
Item Attribute,Liður Attribute,
"Sales, Purchase, Accounting Defaults","Sala, Kaup, Reikningsskil",
Item Defaults,Vara sjálfgefið,
"Purchase, Replenishment Details","Kaup, upplýsingar um endurnýjun",
Is Purchase Item,Er Purchase Item,
Default Purchase Unit of Measure,Sjálfgefin kaupareining,
Minimum Order Qty,Lágmark Order Magn,
Minimum quantity should be as per Stock UOM,Lágmarks magn ætti að vera eins og á lager UOM,
Average time taken by the supplier to deliver,Meðaltal tíma tekin af birgi að skila,
Is Customer Provided Item,Er viðskiptavini veitt hlut,
Delivered by Supplier (Drop Ship),Samþykkt með Birgir (Drop Ship),
Supplier Items,birgir Items,
Foreign Trade Details,Foreign Trade Upplýsingar,
Country of Origin,Upprunaland,
Sales Details,velta Upplýsingar,
Default Sales Unit of Measure,Sjálfgefin sölustuðull,
Is Sales Item,Er Sales Item,
Max Discount (%),Max Afsláttur (%),
No of Months,Fjöldi mánaða,
Customer Items,Atriði viðskiptavina,
Inspection Criteria,Skoðun Viðmið,
Inspection Required before Purchase,Skoðun Áskilið áður en kaupin,
Inspection Required before Delivery,Skoðun Áskilið fyrir fæðingu,
Default BOM,Sjálfgefið BOM,
Supply Raw Materials for Purchase,Framboð Raw Materials til kaups,
If subcontracted to a vendor,Ef undirverktaka til seljanda,
Customer Code,viðskiptavinur Code,
Show in Website (Variant),Sýna í Website (Variant),
Items with higher weightage will be shown higher,Verk með hærri weightage verður sýnt meiri,
Show a slideshow at the top of the page,Sýnið skyggnusýningu efst á síðunni,
Website Image,Mynd af vefsíðu,
Website Warehouse,Vefsíða Warehouse,
"Show ""In Stock"" or ""Not in Stock"" based on stock available in this warehouse.",Sýna &quot;Á lager&quot; eða &quot;ekki til á lager&quot; byggist á lager í boði í þessum vöruhúsi.,
Website Item Groups,Vefsíða Item Hópar,
List this Item in multiple groups on the website.,Listi þetta atriði í mörgum hópum á vefnum.,
Copy From Item Group,Afrita Frá Item Group,
Website Content,Innihald vefsíðu,
You can use any valid Bootstrap 4 markup in this field. It will be shown on your Item Page.,Þú getur notað hvaða gilda Bootstrap 4 merkingu sem er á þessum reit. Það verður sýnt á hlutar síðunni þinni.,
Total Projected Qty,Alls spáð Magn,
Hub Publishing Details,Hub Publishing Upplýsingar,
Publish in Hub,Birta á Hub,
Publish Item to hub.erpnext.com,Birta Item til hub.erpnext.com,
Hub Category to Publish,Hub Flokkur til birtingar,
Hub Warehouse,Hub Vörugeymsla,
"Publish ""In Stock"" or ""Not in Stock"" on Hub based on stock available in this warehouse.",Birta &quot;Í lager&quot; eða &quot;Ekki í lager&quot; á Hub byggt á lager sem er í boði á þessu vörugeymslu.,
Synced With Hub,Samstillt Með Hub,
Item Alternative,Item Alternative,
Alternative Item Code,Önnur vöruliður,
Two-way,Tveir-vegur,
Alternative Item Name,Annað heiti vöru,
Attribute Name,eigindi nafn,
Numeric Values,talnagildi,
From Range,frá Range,
Increment,vöxtur,
To Range,til Hóflegt,
Item Attribute Values,Liður eigindi gildi,
Item Attribute Value,Liður Attribute gildi,
Attribute Value,eigindi gildi,
Abbreviation,skammstöfun,
"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""","Þetta verður bætt við Item Code afbrigði. Til dæmis, ef skammstöfun er &quot;SM&quot;, og hluturinn kóða er &quot;T-bolur&quot;, hluturinn kóðann um afbrigði verður &quot;T-bolur-SM&quot;",
Item Barcode,Liður Strikamerki,
Barcode Type,Strikamerki,
EAN,EAN,
UPC-A,UPC-A,
Item Customer Detail,Liður Viðskiptavinur Detail,
"For the convenience of customers, these codes can be used in print formats like Invoices and Delivery Notes","Fyrir þægindi viðskiptavina, þessi númer er hægt að nota á prenti sniðum eins reikninga og sending minnismiða",
Ref Code,Ref Code,
Item Default,Atriði sjálfgefið,
Purchase Defaults,Kaup vanskil,
Default Buying Cost Center,Sjálfgefið Buying Kostnaður Center,
Default Supplier,Sjálfgefið Birgir,
Default Expense Account,Sjálfgefið kostnað reiknings,
Sales Defaults,Söluskilmálar,
Default Selling Cost Center,Sjálfgefið Selja Kostnaður Center,
Item Manufacturer,Atriði Framleiðandi,
Item Price,Item verð,
Packing Unit,Pökkunareining,
Quantity  that must be bought or sold per UOM,Magn sem þarf að kaupa eða selja á UOM,
Valid From ,Gildir frá,
Valid Upto ,gildir uppí,
Item Quality Inspection Parameter,Item Quality Inspection Parameter,
Acceptance Criteria,samþykktarviðmiðanir,
Item Reorder,Liður Uppröðun,
Check in (group),Innritun (hópur),
Request for,Beiðni um,
Re-order Level,Re-Order Level,
Re-order Qty,Re-Order Magn,
Item Supplier,Liður Birgir,
Item Variant,Liður Variant,
Item Variant Attribute,Liður Variant Attribute,
Do not update variants on save,Uppfæra ekki afbrigði við vistun,
Fields will be copied over only at time of creation.,Fields verður afritað aðeins á upphafinu.,
Allow Rename Attribute Value,Leyfa Endurnefna Eiginleikar,
Rename Attribute Value in Item Attribute.,Endurnefna eigindagildi í hlutdeild.,
Copy Fields to Variant,Afritaðu reiti í afbrigði,
Item Website Specification,Liður Website Specification,
Table for Item that will be shown in Web Site,Tafla fyrir lið sem verður sýnd í Web Site,
Landed Cost Item,Landað kostnaðarliðurinn,
Receipt Document Type,Kvittun Document Type,
Receipt Document,kvittun Document,
Applicable Charges,gildandi Gjöld,
Purchase Receipt Item,Kvittun Item,
Landed Cost Purchase Receipt,Landað Kostnaður Kvittun,
Landed Cost Taxes and Charges,Landað Kostnaður Skattar og gjöld,
Landed Cost Voucher,Landað Kostnaður Voucher,
MAT-LCV-.YYYY.-,MAT-LCV-.YYYY.-,
Purchase Receipts,Purchase Kvittanir,
Purchase Receipt Items,Kvittun Items,
Get Items From Purchase Receipts,Fá atriði úr Purchase Kvittanir,
Distribute Charges Based On,Dreifa Gjöld Byggt á,
Landed Cost Help,Landað Kostnaður Hjálp,
Manufacturers used in Items,Framleiðendur notað í liðum,
Limited to 12 characters,Takmarkast við 12 stafi,
MAT-MR-.YYYY.-,MAT-MR-.YYYY.-,
Requested For,Umbeðin Fyrir,
Transferred,Flutt,
% Ordered,% Pantaði,
Terms and Conditions Content,Skilmálar og skilyrði Content,
Quantity and Warehouse,Magn og Warehouse,
Lead Time Date,Lead Time Dagsetning,
Min Order Qty,Min Order Magn,
Packed Item,pakkað Item,
To Warehouse (Optional),Til Lager (Valfrjálst),
Actual Batch Quantity,Raunverulegt magn lotunnar,
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.","Mynda pökkun laumar fyrir pakka til að vera frelsari. Notað til að tilkynna pakka númer, Innihald pakkningar og þyngd sína.",
Indicates that the package is a part of this delivery (Only Draft),Gefur til kynna að pakki er hluti af þessari fæðingu (Only Draft),
MAT-PAC-.YYYY.-,MAT-PAC-.YYYY.-,
From Package No.,Frá pakkinn nr,
Identification of the package for the delivery (for print),Auðkenning pakka fyrir afhendingu (fyrir prentun),
To Package No.,Til spakki,
If more than one package of the same type (for print),Ef fleiri en einn pakka af sömu gerð (fyrir prentun),
Package Weight Details,Pakki Þyngd Upplýsingar,
The net weight of this package. (calculated automatically as sum of net weight of items),Nettóþyngd þessum pakka. (Reiknaðar sjálfkrafa sem summa nettó þyngd atriði),
Net Weight UOM,Net Weight UOM,
Gross Weight,Heildarþyngd,
The gross weight of the package. Usually net weight + packaging material weight. (for print),Framlegð þyngd pakkans. Venjulega nettóþyngd + umbúðir þyngd. (Til prentunar),
Gross Weight UOM,Gross Weight UOM,
Packing Slip Item,Pökkun Slip Item,
DN Detail,DN Detail,
STO-PICK-.YYYY.-,STO-PICK-.YYYY.-,
Material Transfer for Manufacture,Efni Transfer fyrir Framleiðsla,
Qty of raw materials will be decided based on the qty of the Finished Goods Item,Fjöldi hráefna verður ákvörðuð út frá magni fullunninnar vöru,
Parent Warehouse,Parent Warehouse,
Items under this warehouse will be suggested,Lagt verður til muna undir vöruhúsinu,
Get Item Locations,Fáðu staðsetningar hlutar,
Item Locations,Staðir hlutar,
Pick List Item,Veldu listalista,
Picked Qty,Valinn fjöldi,
Price List Master,Verðskrá Master,
Price List Name,Verðskrá Name,
Price Not UOM Dependent,Verð ekki UOM háður,
Applicable for Countries,Gildir fyrir löndum,
Price List Country,Verðskrá Country,
MAT-PRE-.YYYY.-,MAT-PRE-.YYYY.-,
Supplier Delivery Note,Birgir Afhending Ath,
Time at which materials were received,Tími þar sem efni bárust,
Return Against Purchase Receipt,Return Against kvittun,
Rate at which supplier's currency is converted to company's base currency,Gengi sem birgis mynt er breytt í grunngj.miðil félagsins,
Get Current Stock,Fá núverandi lager,
Add / Edit Taxes and Charges,Bæta við / breyta sköttum og gjöldum,
Auto Repeat Detail,Sjálfvirk endurtaka smáatriði,
Transporter Details,Transporter Upplýsingar,
Vehicle Number,ökutæki Number,
Vehicle Date,ökutæki Dagsetning,
Received and Accepted,Móttekið og samþykkt,
Accepted Quantity,Samþykkt Magn,
Rejected Quantity,hafnað Magn,
Sample Quantity,Dæmi Magn,
Rate and Amount,Hlutfall og Magn,
MAT-QA-.YYYY.-,MAT-QA-.YYYY.-,
Report Date,skýrsla Dagsetning,
Inspection Type,skoðun Type,
Item Serial No,Liður Serial Nei,
Sample Size,Prufustærð,
Inspected By,skoðað með,
Readings,Upplestur,
Quality Inspection Reading,Quality Inspection Reading,
Reading 1,lestur 1,
Reading 2,lestur 2,
Reading 3,lestur 3,
Reading 4,lestur 4,
Reading 5,lestur 5,
Reading 6,lestur 6,
Reading 7,lestur 7,
Reading 8,lestur 8,
Reading 9,lestur 9,
Reading 10,lestur 10,
Quality Inspection Template Name,Gæði Skoðun sniðmát Nafn,
Quick Stock Balance,Fljótur hlutafjárjöfnuður,
Available Quantity,Lauslegt magn,
Distinct unit of an Item,Greinilegur eining hlut,
Warehouse can only be changed via Stock Entry / Delivery Note / Purchase Receipt,Warehouse er einungis hægt að breyta í gegnum Kauphöll Entry / Afhending Note / Kvittun,
Purchase / Manufacture Details,Kaup / Framleiðsla Upplýsingar,
Creation Document Type,Creation Document Type,
Creation Document No,Creation Skjal nr,
Creation Date,Creation Date,
Creation Time,Creation Time,
Asset Details,Eignarupplýsingar,
Asset Status,Eignastaða,
Delivery Document Type,Afhending Document Type,
Delivery Document No,Afhending Skjal nr,
Delivery Time,Afhendingartími,
Invoice Details,Reikningsupplýsingar,
Warranty / AMC Details,Ábyrgð í / AMC Nánar,
Warranty Expiry Date,Ábyrgð í Fyrningardagsetning,
AMC Expiry Date,AMC Fyrningardagsetning,
Under Warranty,undir ábyrgð,
Out of Warranty,Út ábyrgðar,
Under AMC,undir AMC,
Out of AMC,Út af AMC,
Warranty Period (Days),Ábyrgðartímabilið (dagar),
Serial No Details,Serial Nei Nánar,
MAT-STE-.YYYY.-,MAT-STE-.YYYY.-,
Stock Entry Type,Gerð birgðir,
Stock Entry (Outward GIT),Hlutabréfafærsla (Outward GIT),
Material Consumption for Manufacture,Efni neysla til framleiðslu,
Repack,gera við,
Send to Subcontractor,Senda til undirverktaka,
Send to Warehouse,Senda á lager,
Receive at Warehouse,Móttaka í Warehouse,
Delivery Note No,Afhending Note Nei,
Sales Invoice No,Reiknings No.,
Purchase Receipt No,Kvittun Nei,
Inspection Required,skoðun Required,
From BOM,frá BOM,
For Quantity,fyrir Magn,
As per Stock UOM,Eins og á lager UOM,
Including items for sub assemblies,Þ.mt atriði fyrir undir þingum,
Default Source Warehouse,Sjálfgefið Source Warehouse,
Source Warehouse Address,Heimild Vörugeymsla Heimilisfang,
Default Target Warehouse,Sjálfgefið Target Warehouse,
Target Warehouse Address,Target Warehouse Heimilisfang,
Update Rate and Availability,Update Rate og Framboð,
Total Incoming Value,Alls Komandi Value,
Total Outgoing Value,Alls Outgoing Value,
Total Value Difference (Out - In),Heildarverðmæti Mismunur (Out - In),
Additional Costs,viðbótarkostnað,
Total Additional Costs,Samtals viðbótarkostnað,
Customer or Supplier Details,Viðskiptavina eða Birgir Upplýsingar,
Per Transferred,Per flutt,
Stock Entry Detail,Stock Entry Detail,
Basic Rate (as per Stock UOM),Basic Rate (eins og á lager UOM),
Basic Amount,grunnfjárhæð,
Additional Cost,aukakostnaðar,
Serial No / Batch,Serial Nei / Batch,
BOM No. for a Finished Good Item,BOM Nei fyrir Finished Good Item,
Material Request used to make this Stock Entry,Efni Beiðni notað til að gera þetta lager Entry,
Subcontracted Item,Undirverktaka,
Against Stock Entry,Gegn hlutabréfafærslu,
Stock Entry Child,Barnahlutabréf,
PO Supplied Item,PO fylgir hlutur,
Reference Purchase Receipt,Tilvísunarkvittun,
Stock Ledger Entry,Stock Ledger Entry,
Outgoing Rate,Outgoing Rate,
Actual Qty After Transaction,Raunveruleg Magn eftir viðskipti,
Stock Value Difference,Stock Value Mismunur,
Stock Queue (FIFO),Stock Biðröð (FIFO),
Is Cancelled,er Hætt,
Stock Reconciliation,Stock Sættir,
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.,Þetta tól hjálpar þér að uppfæra eða festa magn og mat á lager í kerfinu. Það er oftast notuð til að samstilla kerfið gildi og hvað raunverulega er til staðar í vöruhús þínum.,
MAT-RECO-.YYYY.-,MAT-RECO-.YYYY.-,
Reconciliation JSON,sættir JSON,
Stock Reconciliation Item,Stock Sættir Item,
Before reconciliation,áður sátta,
Current Serial No,Núverandi raðnúmer,
Current Valuation Rate,Núverandi Verðmat Rate,
Current Amount,Núverandi Upphæð,
Quantity Difference,magn Mismunur,
Amount Difference,upphæð Mismunur,
Item Naming By,Liður Nöfn By,
Default Item Group,Sjálfgefið Item Group,
Default Stock UOM,Sjálfgefið Stock UOM,
Sample Retention Warehouse,Sýnishorn vörugeymsla,
Default Valuation Method,Sjálfgefið Verðmatsaðferð,
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.,Hlutfall sem þú ert leyft að taka á móti eða afhenda fleiri gegn pantað magn. Til dæmis: Ef þú hefur pantað 100 einingar. og barnabætur er 10% þá er leyft að taka á móti 110 einingar.,
Action if Quality inspection is not submitted,Aðgerð ef gæðaskoðun er ekki lögð fram,
Show Barcode Field,Sýna Strikamerki Field,
Convert Item Description to Clean HTML,Breyta liður Lýsing til að hreinsa HTML,
Auto insert Price List rate if missing,Auto innskotið Verðlisti hlutfall ef vantar,
Allow Negative Stock,Leyfa Neikvæð lager,
Automatically Set Serial Nos based on FIFO,Sjálfkrafa Setja Serial Nos miðað FIFO,
Set Qty in Transactions based on Serial No Input,Setja magn í viðskiptum sem byggjast á raðnúmeri inntak,
Auto Material Request,Auto Efni Beiðni,
Raise Material Request when stock reaches re-order level,Hækka Material Beiðni þegar birgðir nær aftur röð stigi,
Notify by Email on creation of automatic Material Request,Tilkynna með tölvupósti á sköpun sjálfvirka Material Beiðni,
Freeze Stock Entries,Frysta lager Entries,
Stock Frozen Upto,Stock Frozen uppí,
Freeze Stocks Older Than [Days],Frysta Stocks eldri en [Days],
Role Allowed to edit frozen stock,Hlutverk Leyft að breyta fryst lager,
Batch Identification,Hópur auðkenni,
Use Naming Series,Notaðu nafngiftaröð,
Naming Series Prefix,Heiti forskeyti fyrir nöfn,
UOM Category,UOM Flokkur,
UOM Conversion Detail,UOM viðskipta Detail,
Variant Field,Variant Field,
A logical Warehouse against which stock entries are made.,A rökrétt Warehouse gegn sem stock færslur eru gerðar.,
Warehouse Detail,Warehouse Detail,
Warehouse Name,Warehouse Name,
"If blank, parent Warehouse Account or company default will be considered",Ef tómur verður tekinn í huga foreldrahúsareikningur eða sjálfgefið fyrirtæki,
Warehouse Contact Info,Warehouse Contact Info,
PIN,PIN,
Raised By (Email),Vakti By (Email),
Issue Type,Útgáfustegund,
Issue Split From,Útgáfa skipt frá,
Service Level,Þjónustustig,
Response By,Svar frá,
Response By Variance,Svar eftir breytileika,
Service Level Agreement Fulfilled,Þjónustustigssamningur uppfylltur,
Ongoing,Í gangi,
Resolution By,Upplausn með,
Resolution By Variance,Upplausn eftir breytileika,
Service Level Agreement Creation,Sköpun þjónustustigssamnings,
Mins to First Response,Mins to First Response,
First Responded On,Fyrst svöruðu,
Resolution Details,upplausn Upplýsingar,
Opening Date,opnun Date,
Opening Time,opnun Time,
Resolution Date,upplausn Dagsetning,
Via Customer Portal,Via Viðskiptavinur Portal,
Support Team,Stuðningur Team,
Issue Priority,Forgangsröð útgáfu,
Service Day,Þjónustudagur,
Workday,Vinnudagur,
Holiday List (ignored during SLA calculation),Hátíðarlisti (hunsuð við útreikning SLA),
Default Priority,Sjálfgefið forgang,
Response and Resoution Time,Svar og brottvikningartími,
Priorities,Forgangsröðun,
Support Hours,Stuðningstímar,
Support and Resolution,Stuðningur og ályktun,
Default Service Level Agreement,Sjálfgefinn þjónustustigssamningur,
Entity,Eining,
Agreement Details,Upplýsingar um samkomulag,
Response and Resolution Time,Svar og upplausnartími,
Service Level Priority,Forgang þjónustustigsins,
Response Time,Viðbragðstími,
Response Time Period,Svartímabil,
Resolution Time,Upplausnartími,
Resolution Time Period,Upplausnartímabil,
Support Search Source,Stuðningur Leita Heimild,
Source Type,Upprunategund,
Query Route String,Fyrirspurnarleiðsögn,
Search Term Param Name,Leita að heiti Param Nafn,
Response Options,Svörunarvalkostir,
Response Result Key Path,Svörunarleiðir lykillinn,
Post Route String,Birta leiðstreng,
Post Route Key List,Skráðu lykilslóð eftir leið,
Post Title Key,Post Titill lykill,
Post Description Key,Post Lýsing Lykill,
Link Options,Link Options,
Source DocType,Heimild DocType,
Result Title Field,Niðurstaða titils,
Result Preview Field,Úrslit Preview Field,
Result Route Field,Niðurstaða leiðsögn,
Service Level Agreements,Samningar um þjónustustig,
Track Service Level Agreement,Fylgdu þjónustustigssamningi,
Allow Resetting Service Level Agreement,Leyfa að endurstilla þjónustustigssamning,
Close Issue After Days,Loka Issue Eftir daga,
Auto close Issue after 7 days,Auto nálægt Issue eftir 7 daga,
Support Portal,Stuðningur Portal,
Get Started Sections,Byrjaðu kafla,
Show Latest Forum Posts,Sýna nýjustu spjallþræðir,
Forum Posts,Forum Posts,
Forum URL,Vefslóð spjallsins,
Get Latest Query,Fáðu nýjustu fyrirspurnina,
Response Key List,Svaralisti,
Post Route Key,Birta leiðarlykil,
Search APIs,Leitarforrit,
SER-WRN-.YYYY.-,SER-WRN-.YYYY.-,
Issue Date,Útgáfudagur,
Item and Warranty Details,Item og Ábyrgð Details,
Warranty / AMC Status,Ábyrgð í / AMC Staða,
Resolved By,leyst með,
Service Address,þjónusta Address,
If different than customer address,Ef öðruvísi en viðskiptavinur heimilisfangi,
Raised By,hækkaðir um,
From Company,frá Company,
Rename Tool,endurnefna Tól,
Utilities,Utilities,
Type of document to rename.,Tegund skjals til að endurnefna.,
File to Rename,Skrá til Endurnefna,
"Attach .csv file with two columns, one for the old name and one for the new name","Hengja .csv skrá með tveimur dálka, einn fyrir gamla nafn og einn fyrir nýju nafni",
Rename Log,endurnefna Innskráning,
SMS Log,SMS Log,
Sender Name,Sendandi Nafn,
Sent On,sendi á,
No of Requested SMS,Ekkert af Beðið um SMS,
Requested Numbers,umbeðin Numbers,
No of Sent SMS,Ekkert af Sendir SMS,
Sent To,send til,
Absent Student Report,Absent Student Report,
Assessment Plan Status,Mat á stöðu áætlunarinnar,
Asset Depreciation Ledger,Asset Afskriftir Ledger,
Asset Depreciations and Balances,Eignastýring Afskriftir og jafnvægi,
Available Stock for Packing Items,Laus Stock fyrir pökkun atriði,
Bank Clearance Summary,Bank Úthreinsun Yfirlit,
Bank Remittance,Endurgreiðsla banka,
Batch Item Expiry Status,Hópur Item Fyrning Staða,
Batch-Wise Balance History,Hópur-Wise Balance Saga,
BOM Explorer,BOM Explorer,
BOM Search,BOM leit,
BOM Stock Calculated,BOM Stock Reiknaður,
BOM Variance Report,BOM Variance Report,
Campaign Efficiency,Virkni herferðar,
Cash Flow,Peningaflæði,
Completed Work Orders,Lokið vinnutilboð,
To Produce,Að framleiða,
Produced,framleidd,
Consolidated Financial Statement,Samstæðuársreikningur,
Course wise Assessment Report,Námsmatsmatsskýrsla,
Customer Acquisition and Loyalty,Viðskiptavinur Kaup og Hollusta,
Customer Credit Balance,Viðskiptavinur Credit Balance,
Customer Ledger Summary,Yfirlit viðskiptavinarbókar,
Customer-wise Item Price,Viðskiptavænt vöruhlutur,
Customers Without Any Sales Transactions,Viðskiptavinir án söluviðskipta,
Daily Timesheet Summary,Daily Timesheet Yfirlit,
Daily Work Summary Replies,Dagleg vinnusamantekt Svar,
DATEV,DATEV,
Delayed Item Report,Seinkun hlutaskýrslu,
Delayed Order Report,Seinkun pöntunarskýrslu,
Delivered Items To Be Billed,Afhent Items verður innheimt,
Delivery Note Trends,Afhending Ath Trends,
Department Analytics,Department Analytics,
Electronic Invoice Register,Rafræn reikningaskrá,
Employee Advance Summary,Samantekt starfsmanna,
Employee Billing Summary,Yfirlit yfir greiðslur starfsmanna,
Employee Birthday,starfsmaður Afmæli,
Employee Information,starfsmaður Upplýsingar,
Employee Leave Balance,Starfsmaður Leave Balance,
Employee Leave Balance Summary,Yfirlit yfir jafnvægi starfsmanna leyfis,
Employees working on a holiday,Starfsmenn sem vinna í frí,
Eway Bill,Eway Bill,
Expiring Memberships,Lokandi félagsskapur,
Fichier des Ecritures Comptables [FEC],Fichier des Ecritures Comptables [FEC],
Final Assessment Grades,Lokamat,
Fixed Asset Register,Fast eignaskrá,
Gross and Net Profit Report,Hagnaður og hagnaður,
GST Itemised Purchase Register,GST greidd kaupaskrá,
GST Itemised Sales Register,GST hlutasala,
GST Purchase Register,GST Purchase Register,
GST Sales Register,GST söluskrá,
GSTR-1,GSTR-1,
GSTR-2,GSTR-2,
Hotel Room Occupancy,Hótel herbergi umráð,
HSN-wise-summary of outward supplies,HSN-vitur-samantekt á ytri birgðum,
Inactive Customers,óvirka viðskiptamenn,
Inactive Sales Items,Óvirkir söluhlutir,
IRS 1099,IRS 1099,
Issued Items Against Work Order,Útgefið atriði gegn vinnuskilningi,
Projected Quantity as Source,Áætlaðar Magn eins Source,
Item Balance (Simple),Varajöfnuður (Einföld),
Item Price Stock,Vörulisti Verð,
Item Prices,Item Verð,
Item Shortage Report,Liður Skortur Report,
Project Quantity,Project Magn,
Item Variant Details,Varahlutir Upplýsingar,
Item-wise Price List Rate,Item-vitur Verðskrá Rate,
Item-wise Purchase History,Item-vitur Purchase History,
Item-wise Purchase Register,Item-vitur Purchase Register,
Item-wise Sales History,Item-vitur Sales History,
Item-wise Sales Register,Item-vitur Sales Register,
Items To Be Requested,Hlutir til að biðja,
Reserved,frátekin,
Itemwise Recommended Reorder Level,Itemwise Mælt Uppröðun Level,
Lead Details,Lead Upplýsingar,
Lead Id,Lead Id,
Lead Owner Efficiency,Lead Owner Efficiency,
Loan Repayment and Closure,Endurgreiðsla og lokun lána,
Loan Security Status,Staða lánaöryggis,
Lost Opportunity,Týnt tækifæri,
Maintenance Schedules,viðhald Skrár,
Material Requests for which Supplier Quotations are not created,Efni Beiðnir sem Birgir tilvitnanir eru ekki stofnað,
Minutes to First Response for Issues,Mínútur til First Response fyrir málefni,
Minutes to First Response for Opportunity,Mínútur til First Response fyrir Tækifæri,
Monthly Attendance Sheet,Mánaðarleg Aðsókn Sheet,
Open Work Orders,Opna vinnu pantanir,
Ordered Items To Be Billed,Pantaði Items verður innheimt,
Ordered Items To Be Delivered,Pantaði Items til afhendingar,
Qty to Deliver,Magn í Bera,
Amount to Deliver,Nema Bera,
Item Delivery Date,Liður afhendingardags,
Delay Days,Frestur daga,
Payment Period Based On Invoice Date,Greiðsla Tímabil Byggt á reikningi Dagsetning,
Pending SO Items For Purchase Request,Bíður SO Hlutir til kaupa Beiðni,
Procurement Tracker,Rekja spor einhvers,
Product Bundle Balance,Vörujafnvægi,
Production Analytics,framleiðslu Analytics,
Profit and Loss Statement,Rekstrarreikningur yfirlýsing,
Profitability Analysis,arðsemi Greining,
Project Billing Summary,Yfirlit verkefnisgreiningar,
Project wise Stock Tracking ,Project vitur Stock mælingar,
Prospects Engaged But Not Converted,Horfur Engaged en ekki umbreytt,
Purchase Analytics,kaup Analytics,
Purchase Invoice Trends,Kaupa Reikningar Trends,
Purchase Order Items To Be Billed,Purchase Order Items verður innheimt,
Purchase Order Items To Be Received,Purchase Order Items að berast,
Qty to Receive,Magn til Fá,
Purchase Order Items To Be Received or Billed,Innkaupapöntunarhlutir sem berast eða innheimtir,
Base Amount,Grunnmagn,
Received Qty Amount,Móttekið magn fjárhæðar,
Amount to Receive,Upphæð til að fá,
Amount To Be Billed,Upphæð sem þarf að innheimta,
Billed Qty,Innheimt magn,
Qty To Be Billed,Magn sem þarf að greiða,
Purchase Order Trends,Purchase Order Trends,
Purchase Receipt Trends,Kvittun Trends,
Purchase Register,kaup Register,
Quotation Trends,Tilvitnun Trends,
Quoted Item Comparison,Vitnað Item Samanburður,
Received Items To Be Billed,Móttekin Items verður innheimt,
Requested Items To Be Ordered,Umbeðin Items til að panta,
Qty to Order,Magn til að panta,
Requested Items To Be Transferred,Umbeðin Items til að flytja,
Qty to Transfer,Magn á að flytja,
Salary Register,laun Register,
Sales Analytics,velta Analytics,
Sales Invoice Trends,Sölureikningi Trends,
Sales Order Trends,Velta Order Trends,
Sales Partner Commission Summary,Yfirlit yfir söluaðila,
Sales Partner Target Variance based on Item Group,Markmiðsafbrigði söluaðila miðað við vöruflokk,
Sales Partner Transaction Summary,Yfirlit yfir viðskipti með söluaðila,
Sales Partners Commission,Velta Partners Commission,
Average Commission Rate,Meðal framkvæmdastjórnarinnar Rate,
Sales Payment Summary,Sala Greiðsla Yfirlit,
Sales Person Commission Summary,Söluupplýsingar framkvæmdastjórnarinnar,
Sales Person Target Variance Based On Item Group,Markafbrigði söluaðila byggist á vöruflokki,
Sales Person-wise Transaction Summary,Sala Person-vitur Transaction Samantekt,
Sales Register,velta Nýskráning,
Serial No Service Contract Expiry,Serial Nei Service Contract gildir til,
Serial No Status,Serial Nei Staða,
Serial No Warranty Expiry,Serial Nei Ábyrgð gildir til,
Stock Ageing,Stock Ageing,
Stock and Account Value Comparison,Samanburður á hlutabréfum og reikningum,
Stock Projected Qty,Stock Áætlaðar Magn,
Student and Guardian Contact Details,Student og Guardian Tengiliðir Upplýsingar,
Student Batch-Wise Attendance,Student Hópur-Wise Aðsókn,
Student Fee Collection,Student Fee Collection,
Student Monthly Attendance Sheet,Student Monthly Aðsókn Sheet,
Subcontracted Item To Be Received,Hlutur undirverktaki sem berast,
Subcontracted Raw Materials To Be Transferred,Hráefni sem lagt er til í flutningi,
Supplier Ledger Summary,Yfirlit birgisbókar,
Supplier-Wise Sales Analytics,Birgir-Wise Sales Analytics,
Support Hour Distribution,Stuðningstími Dreifing,
TDS Computation Summary,TDS Útreikningur Samantekt,
TDS Payable Monthly,TDS greiðanleg mánaðarlega,
Territory Target Variance Based On Item Group,Markafbrigði landsvæðis byggð á vöruflokki,
Territory-wise Sales,Svæðisleg sala,
Total Stock Summary,Samtals yfirlit yfir lager,
Trial Balance,Trial Balance,
Trial Balance (Simple),Reynslujafnvægi (einfalt),
Trial Balance for Party,Trial Balance fyrir aðila,
Unpaid Expense Claim,Ógreitt Expense Krafa,
Warehouse wise Item Balance Age and Value,Vörugeymsla vitur Varajöfnuður Aldur og gildi,
Work Order Stock Report,Vinnu Order Stock Report,
Work Orders in Progress,Vinna Pantanir í gangi,
