DocType: Employee,Salary Mode,Lønn Mode
DocType: Employee,Divorced,Skilt
apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +96,Items already synced,Elementer allerede synkronisert
DocType: Buying Settings,Allow Item to be added multiple times in a transaction,Tillat Element som skal legges flere ganger i en transaksjon
apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +33,Cancel Material Visit {0} before cancelling this Warranty Claim,Avbryt Material Besøk {0} før den avbryter denne garantikrav
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +19,Consumer Products,Forbrukerprodukter
DocType: Item,Customer Items,Kunde Items
DocType: Project,Costing and Billing,Kalkulasjon og fakturering
apps/erpnext/erpnext/accounts/doctype/account/account.py +52,Account {0}: Parent account {1} can not be a ledger,Konto {0}: Parent konto {1} kan ikke være en hovedbok
DocType: Item,Publish Item to hub.erpnext.com,Publiser varen til hub.erpnext.com
apps/erpnext/erpnext/config/setup.py +88,Email Notifications,E-postvarsling
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +26,Evaluation,evaluering
DocType: Item,Default Unit of Measure,Standard måleenhet
DocType: SMS Center,All Sales Partner Contact,All Sales Partner Kontakt
DocType: Employee,Leave Approvers,La godkjennere
DocType: Sales Partner,Dealer,Dealer
DocType: Employee,Rented,Leide
DocType: Purchase Order,PO-,PO-
DocType: POS Profile,Applicable for User,Gjelder for User
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +196,"Stopped Production Order cannot be cancelled, Unstop it first to cancel","Stoppet produksjonsordre kan ikke avbestilles, Døves det første å avbryte"
DocType: Vehicle Service,Mileage,Kilometer
apps/erpnext/erpnext/accounts/doctype/asset/asset.js +231,Do you really want to scrap this asset?,Har du virkelig ønsker å hugge denne eiendelen?
apps/erpnext/erpnext/buying/report/quoted_item_comparison/quoted_item_comparison.js +44,Select Default Supplier,Velg Standard Leverandør
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +37,Currency is required for Price List {0},Valuta er nødvendig for Prisliste {0}
DocType: Sales Taxes and Charges Template,* Will be calculated in the transaction.,* Vil bli beregnet i transaksjonen.
DocType: Purchase Order,Customer Contact,Kundekontakt
DocType: Job Applicant,Job Applicant,Jobbsøker
apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py +6,This is based on transactions against this Supplier. See timeline below for details,Dette er basert på transaksjoner mot denne leverandøren. Se tidslinjen nedenfor for detaljer
apps/erpnext/erpnext/hub_node/page/hub/hub_body.html +18,No more results.,Ingen flere resultater.
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +34,Legal,Juridisk
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +174,Actual type tax cannot be included in Item rate in row {0},Faktiske typen skatt kan ikke inkluderes i Element rente i rad {0}
DocType: Bank Guarantee,Customer,Kunde
DocType: Purchase Receipt Item,Required By,Kreves av
DocType: Delivery Note,Return Against Delivery Note,Tilbake mot følgeseddel
DocType: Purchase Order,% Billed,% Fakturert
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +43,Exchange Rate must be same as {0} {1} ({2}),Exchange Rate må være samme som {0} {1} ({2})
DocType: Sales Invoice,Customer Name,Kundenavn
DocType: Vehicle,Natural Gas,Naturgass
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +132,Bank account cannot be named as {0},Bankkonto kan ikke bli navngitt som {0}
DocType: Account,Heads (or groups) against which Accounting Entries are made and balances are maintained.,Hoder (eller grupper) mot hvilke regnskapspostene er laget og balanserer opprettholdes.
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +196,Outstanding for {0} cannot be less than zero ({1}),Enestående for {0} kan ikke være mindre enn null ({1})
DocType: Manufacturing Settings,Default 10 mins,Standard 10 minutter
DocType: Leave Type,Leave Type Name,La Type Navn
apps/erpnext/erpnext/templates/pages/projects.js +62,Show open,Vis åpen
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +155,Series Updated Successfully,Serien er oppdatert
apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html +18,Checkout,Sjekk ut
apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +175,Accural Journal Entry Submitted,Accural Journal Entry Sendt inn
DocType: Pricing Rule,Apply On,Påfør på
DocType: Item Price,Multiple Item prices.,Flere varepriser.
,Purchase Order Items To Be Received,Purchase Order Elementer som skal mottas
DocType: SMS Center,All Supplier Contact,All Leverandør Kontakt
DocType: Support Settings,Support Settings,støtte~~POS=TRUNC Innstillinger
DocType: SMS Parameter,Parameter,Parameter
apps/erpnext/erpnext/projects/doctype/project/project.py +65,Expected End Date can not be less than Expected Start Date,Forventet Sluttdato kan ikke være mindre enn Tiltredelse
apps/erpnext/erpnext/utilities/transaction_base.py +110,Row #{0}: Rate must be same as {1}: {2} ({3} / {4}) ,Row # {0}: Pris må være samme som {1}: {2} ({3} / {4})
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +282,New Leave Application,New La Application
,Batch Item Expiry Status,Batch Element Utløps Status
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +153,Bank Draft,Bank Draft
DocType: Mode of Payment Account,Mode of Payment Account,Modus for betaling konto
apps/erpnext/erpnext/stock/doctype/item/item.js +56,Show Variants,Vis Varianter
DocType: Academic Term,Academic Term,semester
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py +14,Material,Materiale
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +670,Quantity,Antall
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +546,Accounts table cannot be blank.,Regnskap bordet kan ikke være tomt.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +154,Loans (Liabilities),Lån (gjeld)
DocType: Employee Education,Year of Passing,Year of Passing
DocType: Item,Country of Origin,Opprinnelsesland
apps/erpnext/erpnext/templates/includes/product_page.js +24,In Stock,På Lager
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +46,Open Issues,åpne spørsmål
DocType: Production Plan Item,Production Plan Item,Produksjonsplan Sak
apps/erpnext/erpnext/hr/doctype/employee/employee.py +144,User {0} is already assigned to Employee {1},Bruker {0} er allerede tildelt Employee {1}
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +31,Health Care,Helsevesen
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +65,Delay in payment (Days),Forsinket betaling (dager)
apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py +26,Service Expense,tjenesten Expense
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +860,Serial Number: {0} is already referenced in Sales Invoice: {1},Serienummer: {0} er allerede referert i salgsfaktura: {1}
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +809,Invoice,Faktura
DocType: Maintenance Schedule Item,Periodicity,Periodisitet
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +21,Fiscal Year {0} is required,Regnskapsår {0} er nødvendig
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +21,Defense,Forsvars
DocType: Salary Component,Abbr,Abbr
DocType: Appraisal Goal,Score (0-5),Score (0-5)
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +225,Row {0}: {1} {2} does not match with {3},Rad {0}: {1} {2} samsvarer ikke med {3}
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +75,Row # {0}:,Row # {0}:
DocType: Timesheet,Total Costing Amount,Total koster Beløp
DocType: Delivery Note,Vehicle No,Vehicle Nei
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +154,Please select Price List,Vennligst velg Prisliste
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +78,Row #{0}: Payment document is required to complete the trasaction,Row # {0}: Betaling dokumentet er nødvendig for å fullføre trasaction
DocType: Production Order Operation,Work In Progress,Arbeid På Går
apps/erpnext/erpnext/schools/report/absent_student_report/absent_student_report.py +13,Please select date,Vennligst velg dato
DocType: Employee,Holiday List,Holiday List
apps/erpnext/erpnext/public/js/setup_wizard.js +214,Accountant,Accountant
DocType: Cost Center,Stock User,Stock User
DocType: Company,Phone No,Telefonnr
apps/erpnext/erpnext/schools/doctype/course_scheduling_tool/course_scheduling_tool.py +50,Course Schedules created:,Kursrutetider opprettet:
apps/erpnext/erpnext/controllers/recurring_document.py +135,New {0}: #{1},New {0} # {1}
,Sales Partners Commission,Sales Partners Commission
apps/erpnext/erpnext/setup/doctype/company/company.py +45,Abbreviation cannot have more than 5 characters,Forkortelse kan ikke ha mer enn fem tegn
DocType: Payment Request,Payment Request,Betaling Request
DocType: Asset,Value After Depreciation,Verdi etter avskrivninger
DocType: Employee,O+,O +
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt_dashboard.py +17,Related,I slekt
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +43,Attendance date can not be less than employee's joining date,Oppmøte dato kan ikke være mindre enn ansattes bli dato
DocType: Grading Scale,Grading Scale Name,Grading Scale Name
apps/erpnext/erpnext/accounts/doctype/account/account.js +41,This is a root account and cannot be edited.,Dette er en rot konto og kan ikke redigeres.
DocType: Sales Invoice,Company Address,Firma adresse
DocType: BOM,Operations,Operasjoner
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +38,Cannot set authorization on basis of Discount for {0},Kan ikke sette autorisasjon på grunnlag av Rabatt for {0}
DocType: Rename Tool,"Attach .csv file with two columns, one for the old name and one for the new name","Fest CSV-fil med to kolonner, en for det gamle navnet og en for det nye navnet"
apps/erpnext/erpnext/accounts/utils.py +73,{0} {1} not in any active Fiscal Year.,{0} {1} ikke i noen aktiv regnskapsåret.
DocType: Packed Item,Parent Detail docname,Parent Detail docname
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +69,"Reference: {0}, Item Code: {1} and Customer: {2}","Henvisning: {0}, Varenummer: {1} og kunde: {2}"
apps/erpnext/erpnext/public/js/setup_wizard.js +308,Kg,Kg
DocType: Student Log,Log,Logg
apps/erpnext/erpnext/config/hr.py +45,Opening for a Job.,Åpning for en jobb.
DocType: Item Attribute,Increment,Tilvekst
apps/erpnext/erpnext/public/js/stock_analytics.js +61,Select Warehouse...,Velg Warehouse ...
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +6,Advertising,Annonsering
apps/erpnext/erpnext/accounts/doctype/mode_of_payment/mode_of_payment.py +22,Same Company is entered more than once,Samme firma er angitt mer enn én gang
DocType: Employee,Married,Gift
apps/erpnext/erpnext/accounts/party.py +43,Not permitted for {0},Ikke tillatt for {0}
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +568,Get items from,Få elementer fra
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +445,Stock cannot be updated against Delivery Note {0},Stock kan ikke oppdateres mot følgeseddel {0}
apps/erpnext/erpnext/templates/pages/home.py +25,Product {0},Produkt {0}
apps/erpnext/erpnext/templates/generators/item_group.html +43,No items listed,Ingen elementer oppført
DocType: Payment Reconciliation,Reconcile,Forsone
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +30,Grocery,Dagligvare
DocType: Quality Inspection Reading,Reading 1,Lesing 1
DocType: Process Payroll,Make Bank Entry,Gjør Bank Entry
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +40,Pension Funds,Pensjonsfondene
apps/erpnext/erpnext/accounts/doctype/asset/asset.py +88,Next Depreciation Date cannot be before Purchase Date,Neste Avskrivninger Datoen kan ikke være før Kjøpsdato
DocType: SMS Center,All Sales Person,All Sales Person
DocType: Monthly Distribution,**Monthly Distribution** helps you distribute the Budget/Target across months if you have seasonality in your business.,** Månedlig Distribusjon ** hjelper deg distribuere Budsjett / Target over måneder hvis du har sesongvariasjoner i din virksomhet.
apps/erpnext/erpnext/accounts/page/pos/pos.js +1672,Not items found,Ikke elementer funnet
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +178,Salary Structure Missing,Lønn Struktur Missing
DocType: Lead,Person Name,Person Name
DocType: Sales Invoice Item,Sales Invoice Item,Salg Faktura Element
DocType: Account,Credit,Credit
DocType: POS Profile,Write Off Cost Center,Skriv Av kostnadssted
apps/erpnext/erpnext/public/js/setup_wizard.js +97,"e.g. ""Primary School"" or ""University""",for eksempel &quot;Primary School&quot; eller &quot;University&quot;
apps/erpnext/erpnext/config/stock.py +32,Stock Reports,lager rapporter
DocType: Warehouse,Warehouse Detail,Warehouse Detalj
apps/erpnext/erpnext/selling/doctype/customer/customer.py +161,Credit limit has been crossed for customer {0} {1}/{2},Kredittgrense er krysset for kunde {0} {1} / {2}
apps/erpnext/erpnext/schools/doctype/academic_term/academic_term.py +33,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.,"Begrepet Sluttdato kan ikke være senere enn året sluttdato av studieåret som begrepet er knyttet (studieåret {}). Korriger datoene, og prøv igjen."
apps/erpnext/erpnext/stock/doctype/item/item.py +466,"""Is Fixed Asset"" cannot be unchecked, as Asset record exists against the item","&quot;Er Fixed Asset&quot; ikke kan være ukontrollert, som Asset post eksisterer mot elementet"
DocType: Vehicle Service,Brake Oil,bremse~~POS=TRUNC Oil
DocType: Tax Rule,Tax Type,Skatt Type
apps/erpnext/erpnext/controllers/taxes_and_totals.py +540,Taxable Amount,Skattepliktig beløp
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +160,You are not authorized to add or update entries before {0},Du er ikke autorisert til å legge til eller oppdatere bloggen før {0}
DocType: BOM,Item Image (if not slideshow),Sak Image (hvis ikke show)
apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.py +20,An Customer exists with same name,En Customer eksisterer med samme navn
DocType: Production Order Operation,(Hour Rate / 60) * Actual Operation Time,(Timepris / 60) * Faktisk Operation Tid
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +881,Select BOM,Velg BOM
DocType: SMS Log,SMS Log,SMS Log
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +27,Cost of Delivered Items,Kostnad for leverte varer
apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +38,The holiday on {0} is not between From Date and To Date,Ferien på {0} er ikke mellom Fra dato og Til dato
DocType: Student Log,Student Log,student Log
DocType: Quality Inspection,Get Specification Details,Få Spesifikasjon Detaljer
DocType: Lead,Interested,Interessert
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +171,Opening,Åpning
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +28,From {0} to {1},Fra {0} til {1}
DocType: Item,Copy From Item Group,Kopier fra varegruppe
DocType: Journal Entry,Opening Entry,Åpning Entry
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +25,Account Pay Only,Bare konto Pay
DocType: Employee Loan,Repay Over Number of Periods,Betale tilbake over antall perioder
DocType: Stock Entry,Additional Costs,Tilleggskostnader
apps/erpnext/erpnext/accounts/doctype/account/account.py +141,Account with existing transaction can not be converted to group.,Konto med eksisterende transaksjon kan ikke konverteres til gruppen.
DocType: Lead,Product Enquiry,Produkt Forespørsel
DocType: Academic Term,Schools,skoler
DocType: School Settings,Validate Batch for Students in Student Group,Valider batch for studenter i studentgruppen
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +35,No leave record found for employee {0} for {1},Ingen forlater plate funnet for ansatt {0} og {1}
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +23,Please enter company first,Skriv inn et selskap først
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +340,Please select Company first,Vennligst velg selskapet først
DocType: Employee Education,Under Graduate,Under Graduate
apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.js +27,Target On,Target På
DocType: BOM,Total Cost,Totalkostnad
DocType: Journal Entry Account,Employee Loan,Medarbeider Loan
apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.js +108,Activity Log:,Aktivitetsloggen:
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +234,Item {0} does not exist in the system or has expired,Element {0} finnes ikke i systemet eller er utløpt
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +44,Real Estate,Eiendom
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html +1,Statement of Account,Kontoutskrift
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +41,Pharmaceuticals,Farmasi
DocType: Purchase Invoice Item,Is Fixed Asset,Er Fast Asset
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +234,"Available qty is {0}, you need {1}","Tilgjengelig stk er {0}, må du {1}"
DocType: Expense Claim Detail,Claim Amount,Krav Beløp
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +49,Duplicate customer group found in the cutomer group table,Duplicate kundegruppen funnet i cutomer gruppetabellen
apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +31,Supplier Type / Supplier,Leverandør Type / leverandør
DocType: Naming Series,Prefix,Prefix
apps/erpnext/erpnext/public/js/setup_wizard.js +305,Consumable,Konsum
DocType: Employee,B-,B-
DocType: Upload Attendance,Import Log,Import Logg
DocType: Production Planning Tool,Pull Material Request of type Manufacture based on the above criteria,Trekk Material Request av typen Produksjon basert på de ovennevnte kriteriene
DocType: Training Result Employee,Grade,grade
DocType: Sales Invoice Item,Delivered By Supplier,Levert av Leverandør
DocType: SMS Center,All Contact,All kontakt
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +869,Production Order already created for all items with BOM,Produksjonsordre allerede opprettet for alle varer med BOM
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +189,Annual Salary,Årslønn
DocType: Daily Work Summary,Daily Work Summary,Daglig arbeid Oppsummering
DocType: Period Closing Voucher,Closing Fiscal Year,Lukke regnskapsår
apps/erpnext/erpnext/accounts/party.py +354,{0} {1} is frozen,{0} {1} er frosset
apps/erpnext/erpnext/setup/doctype/company/company.py +139,Please select Existing Company for creating Chart of Accounts,Velg eksisterende selskap for å skape Konto
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +80,Stock Expenses,Aksje Utgifter
apps/erpnext/erpnext/stock/doctype/batch/batch.js +91,Select Target Warehouse,Velg Target Warehouse
apps/erpnext/erpnext/stock/doctype/batch/batch.js +91,Select Target Warehouse,Velg Target Warehouse
apps/erpnext/erpnext/hr/doctype/employee/employee.js +80,Please enter Preferred Contact Email,Fyll inn foretrukne e-
DocType: Program Enrollment,School Bus,Skolebuss
DocType: Journal Entry,Contra Entry,Contra Entry
DocType: Journal Entry Account,Credit in Company Currency,Kreditt i selskapet Valuta
DocType: Delivery Note,Installation Status,Installasjon Status
apps/erpnext/erpnext/schools/doctype/student_attendance_tool/student_attendance_tool.js +135,"Do you want to update attendance?<br>Present: {0}\
					<br>Absent: {1}",Ønsker du å oppdatere oppmøte? <br> Present: {0} \ <br> Fraværende: {1}
apps/erpnext/erpnext/controllers/buying_controller.py +321,Accepted + Rejected Qty must be equal to Received quantity for Item {0},Akseptert + Avvist Antall må være lik mottatt kvantum for Element {0}
DocType: Request for Quotation,RFQ-,RFQ-
DocType: Item,Supply Raw Materials for Purchase,Leverer råvare til Purchase
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +147,At least one mode of payment is required for POS invoice.,I det minste én modus av betaling er nødvendig for POS faktura.
DocType: Products Settings,Show Products as a List,Vis produkter på en liste
DocType: Upload Attendance,"Download the Template, fill appropriate data and attach the modified file.
All dates and employee combination in the selected period will come in the template, with existing attendance records","Last ned mal, fyll riktige data og fest den endrede filen. Alle datoer og ansatt kombinasjon i den valgte perioden vil komme i malen, med eksisterende møteprotokoller"
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +482,Item {0} is not active or end of life has been reached,Element {0} er ikke aktiv eller slutten av livet er nådd
apps/erpnext/erpnext/public/js/setup_wizard.js +344,Example: Basic Mathematics,Eksempel: Grunnleggende matematikk
apps/erpnext/erpnext/controllers/accounts_controller.py +670,"To include tax in row {0} in Item rate, taxes in rows {1} must also be included","For å inkludere skatt i rad {0} i Element rente, skatt i rader {1} må også inkluderes"
apps/erpnext/erpnext/config/hr.py +214,Settings for HR Module,Innstillinger for HR Module
DocType: SMS Center,SMS Center,SMS-senter
DocType: Sales Invoice,Change Amount,endring Beløp
DocType: BOM Replace Tool,New BOM,New BOM
DocType: Depreciation Schedule,Make Depreciation Entry,Gjør Avskrivninger Entry
DocType: Appraisal Template Goal,KRA,KRA
DocType: Lead,Request Type,Forespørsel Type
apps/erpnext/erpnext/hr/doctype/offer_letter/offer_letter.js +17,Make Employee,Gjør Employee
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +14,Broadcasting,Kringkasting
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +160,Execution,Execution
apps/erpnext/erpnext/config/manufacturing.py +62,Details of the operations carried out.,Detaljene for operasjonen utføres.
DocType: Serial No,Maintenance Status,Vedlikehold Status
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +56,{0} {1}: Supplier is required against Payable account {2},{0} {1}: Leverandør er nødvendig mot Betales konto {2}
apps/erpnext/erpnext/config/selling.py +52,Items and Pricing,Elementer og priser
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +2,Total hours: {0},Antall timer: {0}
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +43,From Date should be within the Fiscal Year. Assuming From Date = {0},Fra dato bør være innenfor regnskapsåret. Antar Fra Date = {0}
DocType: Customer,Individual,Individuell
DocType: Interest,Academics User,akademikere Bruker
DocType: Cheque Print Template,Amount In Figure,Beløp I figur
DocType: Employee Loan Application,Loan Info,lån info
apps/erpnext/erpnext/config/maintenance.py +12,Plan for maintenance visits.,Plan for vedlikeholdsbesøk.
DocType: SMS Settings,Enter url parameter for message,Skriv inn url parameter for melding
DocType: POS Profile,Customer Groups,kunde~~POS=TRUNC grupper~~POS=HEADCOMP
apps/erpnext/erpnext/public/js/financial_statements.js +51,Financial Statements,Årsregnskap
DocType: Guardian,Students,studenter
apps/erpnext/erpnext/config/selling.py +91,Rules for applying pricing and discount.,Regler for bruk av prising og rabatt.
apps/erpnext/erpnext/stock/doctype/price_list/price_list.py +14,Price List must be applicable for Buying or Selling,Prisliste må være aktuelt for å kjøpe eller selge
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +79,Installation date cannot be before delivery date for Item {0},Installasjonsdato kan ikke være før leveringsdato for Element {0}
DocType: Pricing Rule,Discount on Price List Rate (%),Rabatt på Prisliste Rate (%)
DocType: Offer Letter,Select Terms and Conditions,Velg Vilkår
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +60,Out Value,ut Verdi
DocType: Production Planning Tool,Sales Orders,Salgsordrer
DocType: Purchase Taxes and Charges,Valuation,Verdivurdering
,Purchase Order Trends,Innkjøpsordre Trender
apps/erpnext/erpnext/templates/emails/request_for_quotation.html +7,The request for quotation can be accessed by clicking on the following link,Anmodningen om sitatet kan nås ved å klikke på følgende link
apps/erpnext/erpnext/config/hr.py +81,Allocate leaves for the year.,Bevilge blader for året.
DocType: SG Creation Tool Course,SG Creation Tool Course,SG Creation Tool Course
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +236,Insufficient Stock,utilstrekkelig Stock
DocType: Manufacturing Settings,Disable Capacity Planning and Time Tracking,Deaktiver kapasitetsplanlegging og Time Tracking
DocType: Email Digest,New Sales Orders,Nye salgsordrer
DocType: Bank Guarantee,Bank Account,Bankkonto
DocType: Leave Type,Allow Negative Balance,Tillat negativ saldo
DocType: Employee,Create User,Opprett bruker
DocType: Selling Settings,Default Territory,Standard Territory
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +53,Television,TV
DocType: Production Order Operation,Updated via 'Time Log',Oppdatert via &#39;Time Logg&#39;
apps/erpnext/erpnext/controllers/taxes_and_totals.py +420,Advance amount cannot be greater than {0} {1},Advance beløpet kan ikke være større enn {0} {1}
DocType: Naming Series,Series List for this Transaction,Serien Liste for denne transaksjonen
DocType: Company,Enable Perpetual Inventory,Aktiver evigvarende beholdning
DocType: Company,Default Payroll Payable Account,Standard Lønn betales konto
apps/erpnext/erpnext/schools/doctype/student_group/student_group.js +51,Update Email Group,Oppdater E-postgruppe
DocType: Sales Invoice,Is Opening Entry,Åpner Entry
DocType: Customer Group,Mention if non-standard receivable account applicable,Nevn hvis ikke-standard fordring konto aktuelt
DocType: Course Schedule,Instructor Name,instruktør Name
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +179,For Warehouse is required before Submit,For Warehouse er nødvendig før Send
apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +8,Received On,Mottatt On
DocType: Sales Partner,Reseller,Reseller
DocType: Production Planning Tool,"If checked, Will include non-stock items in the Material Requests.","Hvis det er merket, vil omfatte ikke-lager i materialet forespørsler."
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +24,Please enter Company,Skriv inn Firma
DocType: Delivery Note Item,Against Sales Invoice Item,Mot Salg Faktura Element
,Production Orders in Progress,Produksjonsordrer i Progress
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +39,Net Cash from Financing,Netto kontantstrøm fra finansierings
apps/erpnext/erpnext/accounts/page/pos/pos.js +2251,"LocalStorage is full , did not save","Localstorage er full, ikke spare"
DocType: Lead,Address & Contact,Adresse og kontakt
DocType: Leave Allocation,Add unused leaves from previous allocations,Legg ubrukte blader fra tidligere bevilgninger
apps/erpnext/erpnext/controllers/recurring_document.py +230,Next Recurring {0} will be created on {1},Neste Recurring {0} vil bli opprettet på {1}
DocType: Sales Partner,Partner website,partner nettstedet
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +105,Add Item,Legg til element
apps/erpnext/erpnext/public/js/setup_wizard.js +265,Contact Name,Kontakt Navn
DocType: Course Assessment Criteria,Course Assessment Criteria,Kursvurderingskriteriene
DocType: Process Payroll,Creates salary slip for above mentioned criteria.,Oppretter lønn slip for ovennevnte kriterier.
DocType: POS Customer Group,POS Customer Group,POS Kundegruppe
DocType: Cheque Print Template,Line spacing for amount in words,Linjeavstand for beløpet i ord
DocType: Vehicle,Additional Details,ekstra detaljer
apps/erpnext/erpnext/templates/generators/bom.html +85,No description given,Ingen beskrivelse gitt
apps/erpnext/erpnext/config/buying.py +13,Request for purchase.,Be for kjøp.
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py +6,This is based on the Time Sheets created against this project,Dette er basert på timelister som er opprettet mot dette prosjektet
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +382,Net Pay cannot be less than 0,Nettolønn kan ikke være mindre enn 0
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +224,Only the selected Leave Approver can submit this Leave Application,Bare den valgte La Godkjenner kan sende dette La Application
apps/erpnext/erpnext/hr/doctype/employee/employee.py +116,Relieving Date must be greater than Date of Joining,Lindrende Dato må være større enn tidspunktet for inntreden
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +197,Leaves per Year,Later per år
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +130,Row {0}: Please check 'Is Advance' against Account {1} if this is an advance entry.,Rad {0}: Vennligst sjekk &#39;Er Advance &quot;mot Account {1} hvis dette er et forskudd oppføring.
apps/erpnext/erpnext/stock/utils.py +212,Warehouse {0} does not belong to company {1},Warehouse {0} ikke tilhører selskapet {1}
DocType: Email Digest,Profit & Loss,Profitt tap
apps/erpnext/erpnext/public/js/setup_wizard.js +309,Litre,liter
DocType: Task,Total Costing Amount (via Time Sheet),Total Costing Beløp (via Timeregistrering)
DocType: Item Website Specification,Item Website Specification,Sak Nettsted Spesifikasjon
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +477,Leave Blocked,La Blokkert
apps/erpnext/erpnext/stock/doctype/item/item.py +672,Item {0} has reached its end of life on {1},Element {0} har nådd slutten av livet på {1}
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +107,Bank Entries,Bank Entries
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +119,Annual,Årlig
DocType: Stock Reconciliation Item,Stock Reconciliation Item,Stock Avstemming Element
DocType: Stock Entry,Sales Invoice No,Salg Faktura Nei
DocType: Material Request Item,Min Order Qty,Min Bestill Antall
DocType: Student Group Creation Tool Course,Student Group Creation Tool Course,Student Gruppe Creation Tool Course
DocType: Lead,Do Not Contact,Ikke kontakt
apps/erpnext/erpnext/public/js/setup_wizard.js +359,People who teach at your organisation,Folk som underviser i organisasjonen
DocType: Purchase Invoice,The unique id for tracking all recurring invoices. It is generated on submit.,Den unike id for sporing av alle løpende fakturaer. Det genereres på send.
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +104,Software Developer,Programvareutvikler
DocType: Item,Minimum Order Qty,Minimum Antall
DocType: Pricing Rule,Supplier Type,Leverandør Type
DocType: Course Scheduling Tool,Course Start Date,Kursstart
,Student Batch-Wise Attendance,Student Batch-Wise Oppmøte
DocType: POS Profile,Allow user to edit Rate,Tillater brukeren å redigere Ranger
DocType: Item,Publish in Hub,Publisere i Hub
DocType: Student Admission,Student Admission,student Entre
,Terretory,Terretory
apps/erpnext/erpnext/stock/doctype/item/item.py +692,Item {0} is cancelled,Element {0} er kansellert
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +883,Material Request,Materialet Request
DocType: Bank Reconciliation,Update Clearance Date,Oppdater Lagersalg Dato
DocType: Item,Purchase Details,Kjøps Detaljer
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +357,Item {0} not found in 'Raw Materials Supplied' table in Purchase Order {1},Element {0} ble ikke funnet i &#39;Råvare Leveres&#39; bord i innkjøpsordre {1}
DocType: Employee,Relation,Relasjon
DocType: Shipping Rule,Worldwide Shipping,Worldwide Shipping
DocType: Student Guardian,Mother,Mor
apps/erpnext/erpnext/config/selling.py +18,Confirmed orders from Customers.,Bekreftede bestillinger fra kunder.
DocType: Purchase Receipt Item,Rejected Quantity,Avvist Antall
DocType: SMS Settings,SMS Sender Name,SMS Sender Name
DocType: Notification Control,Notification Control,Varsling kontroll
DocType: Lead,Suggestions,Forslag
DocType: Territory,Set Item Group-wise budgets on this Territory. You can also include seasonality by setting the Distribution.,Set varegruppe-messig budsjetter på dette territoriet. Du kan også inkludere sesongvariasjoner ved å sette Distribution.
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +276,Payment against {0} {1} cannot be greater than Outstanding Amount {2},Betaling mot {0} {1} kan ikke være større enn utestående beløp {2}
DocType: Supplier,Address HTML,Adresse HTML
DocType: Lead,Mobile No.,Mobile No.
DocType: Maintenance Schedule,Generate Schedule,Generere Schedule
DocType: Purchase Invoice Item,Expense Head,Expense Leder
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +146,Please select Charge Type first,Vennligst velg Charge Type først
DocType: Student Group Student,Student Group Student,Student Gruppe Student
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41,Latest,Siste
DocType: Vehicle Service,Inspection,Undersøkelse
apps/erpnext/erpnext/utilities/page/leaderboard/leaderboard_row_head.html +1, List ,Liste
DocType: Email Digest,New Quotations,Nye Sitater
DocType: HR Settings,Emails salary slip to employee based on preferred email selected in Employee,E-poster lønn slip til ansatte basert på foretrukne e-post valgt i Employee
DocType: Employee,The first Leave Approver in the list will be set as the default Leave Approver,Den første La Godkjenner i listen vil bli definert som standard La Godkjenner
DocType: Tax Rule,Shipping County,Shipping fylke
apps/erpnext/erpnext/config/desktop.py +158,Learn,Lære
DocType: Asset,Next Depreciation Date,Neste Avskrivninger Dato
apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js +3,Activity Cost per Employee,Aktivitet Kostnad per Employee
DocType: Accounts Settings,Settings for Accounts,Innstillinger for kontoer
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +643,Supplier Invoice No exists in Purchase Invoice {0},Leverandør Faktura Ingen eksisterer i fakturaen {0}
apps/erpnext/erpnext/config/selling.py +118,Manage Sales Person Tree.,Administrer Sales Person treet.
DocType: Job Applicant,Cover Letter,Cover Letter
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +37,Outstanding Cheques and Deposits to clear,Utestående Sjekker og Innskudd å tømme
DocType: Item,Synced With Hub,Synkronisert Med Hub
DocType: Vehicle,Fleet Manager,Flåtesjef
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +517,Row #{0}: {1} can not be negative for item {2},Rad # {0}: {1} ikke kan være negativ for elementet {2}
apps/erpnext/erpnext/setup/doctype/company/company.js +70,Wrong Password,Feil Passord
DocType: Item,Variant Of,Variant av
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +367,Completed Qty can not be greater than 'Qty to Manufacture',Fullført Antall kan ikke være større enn &quot;Antall å Manufacture &#39;
DocType: Period Closing Voucher,Closing Account Head,Lukke konto Leder
DocType: Employee,External Work History,Ekstern Work History
apps/erpnext/erpnext/projects/doctype/task/task.py +99,Circular Reference Error,Rundskriv Reference Error
apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +55,Guardian1 Name,Guardian1 Name
DocType: Delivery Note,In Words (Export) will be visible once you save the Delivery Note.,I Words (eksport) vil være synlig når du lagrer følgeseddel.
DocType: Cheque Print Template,Distance from left edge,Avstand fra venstre kant
apps/erpnext/erpnext/utilities/bot.py +29,{0} units of [{1}](#Form/Item/{1}) found in [{2}](#Form/Warehouse/{2}),{0} enheter av [{1}] (# Form / post / {1}) finnes i [{2}] (# Form / Lager / {2})
DocType: Lead,Industry,Industry
DocType: Employee,Job Profile,Job Profile
apps/erpnext/erpnext/setup/doctype/company/company_dashboard.py +6,This is based on transactions against this Company. See timeline below for details,Dette er basert på transaksjoner mot dette selskapet. Se tidslinjen nedenfor for detaljer
DocType: Stock Settings,Notify by Email on creation of automatic Material Request,Varsle på e-post om opprettelse av automatisk Material Request
DocType: Journal Entry,Multi Currency,Multi Valuta
DocType: Payment Reconciliation Invoice,Invoice Type,Faktura Type
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +844,Delivery Note,Levering Note
apps/erpnext/erpnext/config/learn.py +82,Setting up Taxes,Sette opp skatter
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +131,Cost of Sold Asset,Cost of Selges Asset
apps/erpnext/erpnext/accounts/utils.py +351,Payment Entry has been modified after you pulled it. Please pull it again.,Betaling Entry har blitt endret etter at du trakk den. Kan trekke det igjen.
apps/erpnext/erpnext/stock/doctype/item/item.py +435,{0} entered twice in Item Tax,{0} registrert to ganger i pkt Skatte
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +114,Summary for this week and pending activities,Oppsummering for denne uken og ventende aktiviteter
DocType: Student Applicant,Admitted,innrømmet
DocType: Workstation,Rent Cost,Rent Cost
apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +81,Amount After Depreciation,Mengde etter avskrivninger
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +97,Upcoming Calendar Events,Kommende kalenderhendelser
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +75,Please select month and year,Velg måned og år
DocType: Employee,Company Email,Selskapet E-post
DocType: GL Entry,Debit Amount in Account Currency,Debet beløp på kontoen Valuta
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +21,Order Value,Bestillingsverdi
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +21,Order Value,Bestillingsverdi
apps/erpnext/erpnext/config/accounts.py +27,Bank/Cash transactions against party or for internal transfer,Bank / kontanter transaksjoner mot part eller for intern overføring
DocType: Shipping Rule,Valid for Countries,Gyldig for Land
apps/erpnext/erpnext/stock/doctype/item/item.js +55,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,"Denne varen er en mal, og kan ikke brukes i transaksjoner. Element attributter vil bli kopiert over i varianter med mindre &#39;No Copy&#39; er satt"
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +69,Total Order Considered,Total Bestill Regnes
apps/erpnext/erpnext/config/hr.py +234,"Employee designation (e.g. CEO, Director etc.).","Ansatt betegnelse (f.eks CEO, direktør etc.)."
apps/erpnext/erpnext/controllers/recurring_document.py +223,Please enter 'Repeat on Day of Month' field value,Skriv inn &#39;Gjenta på dag i måneden&#39; feltverdi
DocType: Sales Invoice,Rate at which Customer Currency is converted to customer's base currency,Hastigheten som Kunden Valuta omdannes til kundens basisvaluta
DocType: Course Scheduling Tool,Course Scheduling Tool,Kurs Planlegging Tool
apps/erpnext/erpnext/controllers/accounts_controller.py +571,Row #{0}: Purchase Invoice cannot be made against an existing asset {1},Row # {0}: Kjøp Faktura kan ikke gjøres mot en eksisterende eiendel {1}
DocType: Item Tax,Tax Rate,Skattesats
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +59,{0} already allocated for Employee {1} for period {2} to {3},{0} allerede bevilget for Employee {1} for perioden {2} til {3}
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +850,Select Item,Velg element
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +143,Purchase Invoice {0} is already submitted,Fakturaen {0} er allerede sendt
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +91,Row # {0}: Batch No must be same as {1} {2},Row # {0}: Batch No må være samme som {1} {2}
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +52,Convert to non-Group,Konverter til ikke-konsernet
apps/erpnext/erpnext/config/stock.py +122,Batch (lot) of an Item.,Batch (mye) av et element.
DocType: C-Form Invoice Detail,Invoice Date,Fakturadato
DocType: GL Entry,Debit Amount,Debet Beløp
apps/erpnext/erpnext/accounts/party.py +244,There can only be 1 Account per Company in {0} {1},Det kan bare være en konto per Company i {0} {1}
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +398,Please see attachment,Vennligst se vedlegg
DocType: Purchase Order,% Received,% Mottatt
apps/erpnext/erpnext/schools/doctype/student_group_creation_tool/student_group_creation_tool.js +3,Create Student Groups,Opprett studentgrupper
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +21,Setup Already Complete!!,Oppsett Allerede Komplett !!
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +24,Credit Note Amount,Kreditt Note Beløp
,Finished Goods,Ferdigvarer
DocType: Delivery Note,Instructions,Bruksanvisning
DocType: Quality Inspection,Inspected By,Inspisert av
DocType: Maintenance Visit,Maintenance Type,Vedlikehold Type
apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +40,{0} - {1} is not enrolled in the Course {2},{0} - {1} er ikke påmeldt kurset {2}
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +59,Serial No {0} does not belong to Delivery Note {1},Serial No {0} tilhører ikke følgeseddel {1}
apps/erpnext/erpnext/templates/pages/demo.html +47,ERPNext Demo,ERPNext Demo
apps/erpnext/erpnext/public/js/utils/item_selector.js +12,Add Items,Legg varer
DocType: Item Quality Inspection Parameter,Item Quality Inspection Parameter,Sak Quality Inspection Parameter
DocType: Leave Application,Leave Approver Name,La Godkjenner Name
DocType: Depreciation Schedule,Schedule Date,Schedule Date
apps/erpnext/erpnext/config/hr.py +116,"Earnings, Deductions and other Salary components","Inntjening, fradrag og andre Lønn komponenter"
DocType: Packed Item,Packed Item,Pakket Element
apps/erpnext/erpnext/config/buying.py +65,Default settings for buying transactions.,Standardinnstillingene for å kjøpe transaksjoner.
apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +29,Activity Cost exists for Employee {0} against Activity Type - {1},Aktivitet Kostnad finnes for Employee {0} mot Activity Type - {1}
apps/erpnext/erpnext/schools/doctype/program_enrollment_tool/program_enrollment_tool.py +14,Mandatory field - Get Students From,Obligatorisk felt - Få studenter fra
apps/erpnext/erpnext/schools/doctype/program_enrollment_tool/program_enrollment_tool.py +14,Mandatory field - Get Students From,Obligatorisk felt - Få studenter fra
DocType: Program Enrollment,Enrolled courses,Påmeldte kurs
DocType: Program Enrollment,Enrolled courses,Påmeldte kurs
DocType: Currency Exchange,Currency Exchange,Valutaveksling
DocType: Asset,Item Name,Navn
DocType: Authorization Rule,Approving User  (above authorized value),Godkjenne Bruker (ovenfor autorisert verdi)
DocType: Email Digest,Credit Balance,Credit Balance
DocType: Employee,Widowed,Enke
DocType: Request for Quotation,Request for Quotation,Forespørsel om kostnadsoverslag
DocType: Salary Slip Timesheet,Working Hours,Arbeidstid
DocType: Naming Series,Change the starting / current sequence number of an existing series.,Endre start / strøm sekvensnummer av en eksisterende serie.
apps/erpnext/erpnext/accounts/page/pos/pos.js +1455,Create a new Customer,Opprett en ny kunde
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +59,"If multiple Pricing Rules continue to prevail, users are asked to set Priority manually to resolve conflict.","Hvis flere Pris Regler fortsette å råde, blir brukerne bedt om å sette Priority manuelt for å løse konflikten."
apps/erpnext/erpnext/utilities/activation.py +88,Create Purchase Orders,Opprette innkjøpsordrer
,Purchase Register,Kjøp Register
DocType: Course Scheduling Tool,Rechedule,Rechedule
DocType: Landed Cost Item,Applicable Charges,Gjeldende avgifter
DocType: Workstation,Consumable Cost,Forbrukskostnads
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +220,{0} ({1}) must have role 'Leave Approver',{0} ({1}) må ha rollen «La Godkjenner &#39;
DocType: Purchase Receipt,Vehicle Date,Vehicle Dato
DocType: Student Log,Medical,Medisinsk
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +177,Reason for losing,Grunnen for å tape
apps/erpnext/erpnext/crm/doctype/lead/lead.py +41,Lead Owner cannot be same as the Lead,Bly Eier kan ikke være det samme som Lead
apps/erpnext/erpnext/accounts/utils.py +357,Allocated amount can not greater than unadjusted amount,Avsatt beløp kan ikke større enn ujustert beløp
DocType: Announcement,Receiver,mottaker
apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +83,Workstation is closed on the following dates as per Holiday List: {0},Workstation er stengt på følgende datoer som per Holiday Liste: {0}
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +32,Opportunities,Muligheter
DocType: Employee,Single,Enslig
DocType: Salary Slip,Total Loan Repayment,Total Loan Nedbetaling
DocType: Account,Cost of Goods Sold,Varekostnad
DocType: Purchase Invoice,Yearly,Årlig
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +228,Please enter Cost Center,Skriv inn kostnadssted
DocType: Journal Entry Account,Sales Order,Salgsordre
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +71,Avg. Selling Rate,Avg. Salgskurs
DocType: Assessment Plan,Examiner Name,Examiner Name
DocType: Purchase Invoice Item,Quantity and Rate,Kvantitet og Rate
DocType: Delivery Note,% Installed,% Installert
apps/erpnext/erpnext/public/js/setup_wizard.js +374,Classrooms/ Laboratories etc where lectures can be scheduled.,Klasserom / Laboratorier etc hvor forelesningene kan planlegges.
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +46,Please enter company name first,Skriv inn firmanavn først
DocType: Purchase Invoice,Supplier Name,Leverandør Name
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +25,Read the ERPNext Manual,Les ERPNext Manual
DocType: Account,Is Group,Is Gruppe
DocType: Email Digest,Pending Purchase Orders,Avventer innkjøpsordrer
DocType: Stock Settings,Automatically Set Serial Nos based on FIFO,Automatisk Sett Serial Nos basert på FIFO
DocType: Accounts Settings,Check Supplier Invoice Number Uniqueness,Sjekk Leverandør fakturanummer Unikhet
DocType: Vehicle Service,Oil Change,Oljeskift
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +57,'To Case No.' cannot be less than 'From Case No.',&#39;Til sak nr&#39; kan ikke være mindre enn &quot;From sak nr &#39;
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +115,Non Profit,Non Profit
DocType: Production Order,Not Started,Ikke i gang
DocType: Lead,Channel Partner,Channel Partner
DocType: Account,Old Parent,Gammel Parent
apps/erpnext/erpnext/schools/doctype/program_enrollment_tool/program_enrollment_tool.py +18,Mandatory field - Academic Year,Obligatorisk felt - akademisk år
apps/erpnext/erpnext/schools/doctype/program_enrollment_tool/program_enrollment_tool.py +18,Mandatory field - Academic Year,Obligatorisk felt - akademisk år
DocType: Notification Control,Customize the introductory text that goes as a part of that email. Each transaction has a separate introductory text.,Tilpass innledende tekst som går som en del av e-posten. Hver transaksjon har en egen innledende tekst.
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +153,Please set default payable account for the company {0},Vennligst angi standard betalbar konto for selskapet {0}
apps/erpnext/erpnext/config/manufacturing.py +84,Global settings for all manufacturing processes.,Globale innstillinger for alle produksjonsprosesser.
DocType: Accounts Settings,Accounts Frozen Upto,Regnskap Frozen Opp
DocType: SMS Log,Sent On,Sendte På
apps/erpnext/erpnext/stock/doctype/item/item.py +634,Attribute {0} selected multiple times in Attributes Table,Attributtet {0} valgt flere ganger i attributter Table
DocType: HR Settings,Employee record is created using selected field. ,Ansatt posten er opprettet ved hjelp av valgte feltet.
DocType: Sales Order,Not Applicable,Gjelder ikke
apps/erpnext/erpnext/config/hr.py +70,Holiday master.,Holiday mester.
DocType: Request for Quotation Item,Required Date,Nødvendig Dato
DocType: Delivery Note,Billing Address,Fakturaadresse
DocType: BOM,Costing,Costing
DocType: Tax Rule,Billing County,Billings County
DocType: Purchase Taxes and Charges,"If checked, the tax amount will be considered as already included in the Print Rate / Print Amount","Hvis det er merket, vil skattebeløpet betraktes som allerede er inkludert i Print Rate / Print Beløp"
DocType: Request for Quotation,Message for Supplier,Beskjed til Leverandør
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +48,Total Qty,Total Antall
apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +62,Guardian2 Email ID,Guardian2 Email ID
apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +62,Guardian2 Email ID,Guardian2 Email ID
DocType: Item,Show in Website (Variant),Vis i Website (Variant)
DocType: Employee,Health Concerns,Helse Bekymringer
DocType: Process Payroll,Select Payroll Period,Velg Lønn Periode
DocType: Purchase Invoice,Unpaid,Ubetalte
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +49,Reserved for sale,Reservert for salg
DocType: Packing Slip,From Package No.,Fra Package No.
DocType: Item Attribute,To Range,Range
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +29,Securities and Deposits,Verdipapirer og innskudd
apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +44,"Can't change valuation method, as there are transactions against some items which does not have it's own valuation method","Kan ikke endre verdsettelsesmetoden, da det er transaksjoner mot enkelte poster som ikke har egen verdsettelsesmetode"
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +82,Total leaves allocated is mandatory,Totalt blader tildelte er obligatorisk
DocType: Job Opening,Description of a Job Opening,Beskrivelse av en ledig jobb
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +111,Pending activities for today,Ventende aktiviteter for i dag
apps/erpnext/erpnext/config/hr.py +24,Attendance record.,Tilskuerrekord.
DocType: Salary Structure,Salary Component for timesheet based payroll.,Lønn Component for timebasert lønn.
DocType: Sales Order Item,Used for Production Plan,Brukes for Produksjonsplan
DocType: Employee Loan,Total Payment,totalt betaling
DocType: Manufacturing Settings,Time Between Operations (in mins),Time Between Operations (i minutter)
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +134,{0} {1} is cancelled so the action cannot be completed,"{0} {1} er kansellert, slik at handlingen ikke kan fullføres"
DocType: Customer,Buyer of Goods and Services.,Kjøper av varer og tjenester.
DocType: Journal Entry,Accounts Payable,Leverandørgjeld
apps/erpnext/erpnext/manufacturing/doctype/bom_replace_tool/bom_replace_tool.py +29,The selected BOMs are not for the same item,De valgte stykklister er ikke for den samme varen
DocType: Pricing Rule,Valid Upto,Gyldig Opp
DocType: Training Event,Workshop,Verksted
apps/erpnext/erpnext/public/js/setup_wizard.js +255,List a few of your customers. They could be organizations or individuals.,Liste noen av kundene dine. De kan være organisasjoner eller enkeltpersoner.
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py +21,Enough Parts to Build,Nok Deler bygge
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +128,Direct Income,Direkte Inntekt
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +36,"Can not filter based on Account, if grouped by Account","Kan ikke filtrere basert på konto, hvis gruppert etter konto"
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +99,Administrative Officer,Administrative Officer
apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +21,Please select Course,Vennligst velg Kurs
apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +21,Please select Course,Vennligst velg Kurs
DocType: Timesheet Detail,Hrs,timer
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +324,Please select Company,Vennligst velg selskapet
DocType: Stock Entry Detail,Difference Account,Forskjellen konto
DocType: Purchase Invoice,Supplier GSTIN,Leverandør GSTIN
apps/erpnext/erpnext/projects/doctype/task/task.py +46,Cannot close task as its dependant task {0} is not closed.,Kan ikke lukke oppgaven som sin avhengige oppgave {0} er ikke lukket.
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +433,Please enter Warehouse for which Material Request will be raised,Skriv inn Warehouse hvor Material Request vil bli hevet
DocType: Production Order,Additional Operating Cost,Ekstra driftskostnader
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +20,Cosmetics,Kosmetikk
apps/erpnext/erpnext/stock/doctype/item/item.py +530,"To merge, following properties must be same for both items","Å fusjonere, må følgende egenskaper være lik for begge elementene"
DocType: Shipping Rule,Net Weight,Netto Vekt
DocType: Employee,Emergency Phone,Emergency Phone
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +29,Buy,Kjøpe
,Serial No Warranty Expiry,Ingen garanti Utløpsserie
DocType: Sales Invoice,Offline POS Name,Offline POS Name
apps/erpnext/erpnext/schools/doctype/grading_scale/grading_scale.py +20,Please define grade for Threshold 0%,Vennligst definer karakter for Terskel 0%
apps/erpnext/erpnext/schools/doctype/grading_scale/grading_scale.py +20,Please define grade for Threshold 0%,Vennligst definer karakter for Terskel 0%
DocType: Sales Order,To Deliver,Å Levere
DocType: Purchase Invoice Item,Item,Sak
apps/erpnext/erpnext/accounts/page/pos/pos.js +2423,Serial no item cannot be a fraction,Serie ingen element kan ikke være en brøkdel
DocType: Journal Entry,Difference (Dr - Cr),Forskjellen (Dr - Cr)
DocType: Account,Profit and Loss,Gevinst og tap
apps/erpnext/erpnext/config/stock.py +325,Managing Subcontracting,Administrerende Underleverandører
DocType: Project,Project will be accessible on the website to these users,Prosjektet vil være tilgjengelig på nettstedet til disse brukerne
DocType: Quotation,Rate at which Price list currency is converted to company's base currency,Hastigheten som Prisliste valuta er konvertert til selskapets hovedvaluta
apps/erpnext/erpnext/setup/doctype/company/company.py +62,Account {0} does not belong to company: {1},Konto {0} tilhører ikke selskapet: {1}
apps/erpnext/erpnext/setup/doctype/company/company.py +51,Abbreviation already used for another company,Forkortelse allerede brukt for et annet selskap
DocType: Selling Settings,Default Customer Group,Standard Kundegruppe
DocType: Global Defaults,"If disable, 'Rounded Total' field will not be visible in any transaction","Hvis deaktivere, &#39;Rounded Total-feltet ikke vil være synlig i enhver transaksjon"
DocType: BOM,Operating Cost,Driftskostnader
DocType: Sales Order Item,Gross Profit,Bruttofortjeneste
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +49,Increment cannot be 0,Tilveksten kan ikke være 0
DocType: Production Planning Tool,Material Requirement,Material Requirement
DocType: Company,Delete Company Transactions,Slett transaksjoner
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +338,Reference No and Reference Date is mandatory for Bank transaction,Referansenummer og Reference Date er obligatorisk for Bank transaksjon
DocType: Purchase Receipt,Add / Edit Taxes and Charges,Legg til / Rediger skatter og avgifter
DocType: Purchase Invoice,Supplier Invoice No,Leverandør Faktura Nei
DocType: Territory,For reference,For referanse
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +158,"Cannot delete Serial No {0}, as it is used in stock transactions","Kan ikke slette Serial No {0}, slik det brukes i aksjetransaksjoner"
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +246,Closing (Cr),Lukking (Cr)
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +105,Move Item,Flytt element
DocType: Serial No,Warranty Period (Days),Garantiperioden (dager)
DocType: Installation Note Item,Installation Note Item,Installasjon Merk Element
DocType: Production Plan Item,Pending Qty,Venter Stk
DocType: Budget,Ignore,Ignorer
apps/erpnext/erpnext/accounts/party.py +358,{0} {1} is not active,{0} {1} er ikke aktiv
apps/erpnext/erpnext/setup/doctype/sms_settings/sms_settings.py +95,SMS sent to following numbers: {0},SMS sendt til følgende nummer: {0}
apps/erpnext/erpnext/config/accounts.py +279,Setup cheque dimensions for printing,Oppsett sjekk dimensjoner for utskrift
DocType: Salary Slip,Salary Slip Timesheet,Lønn Slip Timeregistrering
apps/erpnext/erpnext/controllers/buying_controller.py +153,Supplier Warehouse mandatory for sub-contracted Purchase Receipt,Leverandør Warehouse obligatorisk for underleverandør Kjøpskvittering
DocType: Pricing Rule,Valid From,Gyldig Fra
DocType: Sales Invoice,Total Commission,Total Commission
DocType: Pricing Rule,Sales Partner,Sales Partner
DocType: Buying Settings,Purchase Receipt Required,Kvitteringen Påkrevd
apps/erpnext/erpnext/stock/doctype/item/item.py +130,Valuation Rate is mandatory if Opening Stock entered,Verdsettelse Rate er obligatorisk hvis Åpning Stock oppgitt
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +142,No records found in the Invoice table,Ingen poster ble funnet i Faktura tabellen
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js +17,Please select Company and Party Type first,Vennligst velg først selskapet og Party Type
apps/erpnext/erpnext/config/accounts.py +295,Financial / accounting year.,Finansiell / regnskap år.
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.js +9,Accumulated Values,akkumulerte verdier
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +162,"Sorry, Serial Nos cannot be merged","Sorry, kan Serial Nos ikke bli slått sammen"
apps/erpnext/erpnext/selling/doctype/quotation/quotation.js +716,Make Sales Order,Gjør Salgsordre
DocType: Project Task,Project Task,Prosjektet Task
,Lead Id,Lead Id
DocType: C-Form Invoice Detail,Grand Total,Grand Total
DocType: Training Event,Course,Kurs
DocType: Timesheet,Payslip,payslip
apps/erpnext/erpnext/public/js/pos/pos.html +4,Item Cart,Sak Handlekurv
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +38,Fiscal Year Start Date should not be greater than Fiscal Year End Date,Regnskapsår Startdato bør ikke være større enn regnskapsåret Sluttdato
DocType: Issue,Resolution,Oppløsning
DocType: C-Form,IV,IV
apps/erpnext/erpnext/templates/pages/order.html +53,Delivered: {0},Levering: {0}
DocType: Expense Claim,Payable Account,Betales konto
DocType: Payment Entry,Type of Payment,Type Betaling
DocType: Sales Order,Billing and Delivery Status,Fakturering og levering Status
DocType: Job Applicant,Resume Attachment,Fortsett Vedlegg
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +58,Repeat Customers,Gjenta kunder
DocType: Leave Control Panel,Allocate,Bevilge
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +787,Sales Return,Sales Return
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +96,Note: Total allocated leaves {0} shouldn't be less than already approved leaves {1} for the period,Merk: Totalt tildelte blader {0} bør ikke være mindre enn allerede innvilgede permisjoner {1} for perioden
,Total Stock Summary,Totalt lageroppsummering
DocType: Announcement,Posted By,Postet av
DocType: Item,Delivered by Supplier (Drop Ship),Levert av Leverandør (Drop Ship)
apps/erpnext/erpnext/config/crm.py +12,Database of potential customers.,Database med potensielle kunder.
DocType: Authorization Rule,Customer or Item,Kunden eller Element
apps/erpnext/erpnext/config/selling.py +28,Customer database.,Kundedatabase.
DocType: Quotation,Quotation To,Sitat Å
DocType: Lead,Middle Income,Middle Income
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +218,Opening (Cr),Åpning (Cr)
apps/erpnext/erpnext/stock/doctype/item/item.py +798,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.,Standard Enhet for Element {0} kan ikke endres direkte fordi du allerede har gjort noen transaksjon (er) med en annen målenheter. Du må opprette et nytt element for å bruke et annet standardmålenheter.
apps/erpnext/erpnext/accounts/utils.py +355,Allocated amount can not be negative,Bevilget beløpet kan ikke være negativ
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +25,Please set the Company,Vennligst sett selskapet
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +25,Please set the Company,Vennligst sett selskapet
DocType: Purchase Order Item,Billed Amt,Billed Amt
DocType: Training Result Employee,Training Result Employee,Trening Resultat Medarbeider
DocType: Warehouse,A logical Warehouse against which stock entries are made.,En logisk Warehouse mot som lager oppføringer er gjort.
DocType: Repayment Schedule,Principal Amount,hovedstol
DocType: Employee Loan Application,Total Payable Interest,Total skyldige renter
DocType: Sales Invoice Timesheet,Sales Invoice Timesheet,Salg Faktura Timeregistrering
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +118,Reference No & Reference Date is required for {0},Referansenummer og Reference Date er nødvendig for {0}
DocType: Process Payroll,Select Payment Account to make Bank Entry,Velg betalingskonto å lage Bank Entry
apps/erpnext/erpnext/utilities/activation.py +134,"Create Employee records to manage leaves, expense claims and payroll","Lag personalregistre for å håndtere blader, refusjonskrav og lønn"
apps/erpnext/erpnext/support/doctype/issue/issue.js +24,Add to Knowledge Base,Legg til Knowledge Base
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +159,Proposal Writing,Forslaget Writing
DocType: Payment Entry Deduction,Payment Entry Deduction,Betaling Entry Fradrag
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +35,Another Sales Person {0} exists with the same Employee id,En annen Sales Person {0} finnes med samme Employee id
DocType: Production Planning Tool,"If checked, raw materials for items that are sub-contracted will be included in the Material Requests","Hvis det er merket, råvarer for elementer som er underleverandør vil bli inkludert i materialet Forespørsler"
apps/erpnext/erpnext/config/accounts.py +80,Masters,Masters
DocType: Assessment Plan,Maximum Assessment Score,Maksimal Assessment Score
apps/erpnext/erpnext/config/accounts.py +140,Update Bank Transaction Dates,Oppdater Banktransaksjons Datoer
apps/erpnext/erpnext/config/projects.py +30,Time Tracking,Time Tracking
DocType: Sales Invoice,DUPLICATE FOR TRANSPORTER,DUPLIKERER FOR TRANSPORTER
DocType: Fiscal Year Company,Fiscal Year Company,Regnskapsåret selskapet
DocType: Packing Slip Item,DN Detail,DN Detalj
DocType: Training Event,Conference,Konferanse
DocType: Timesheet,Billed,Fakturert
DocType: Batch,Batch Description,Batch Beskrivelse
apps/erpnext/erpnext/schools/doctype/student_group_creation_tool/student_group_creation_tool.js +12,Creating student groups,Opprette studentgrupper
apps/erpnext/erpnext/schools/doctype/student_group_creation_tool/student_group_creation_tool.js +12,Creating student groups,Opprette studentgrupper
apps/erpnext/erpnext/accounts/utils.py +722,"Payment Gateway Account not created, please create one manually.","Betaling Gateway konto ikke opprettet, kan du opprette en manuelt."
DocType: Sales Invoice,Sales Taxes and Charges,Salgs Skatter og avgifter
DocType: Employee,Organization Profile,Organisasjonsprofil
DocType: Student,Sibling Details,søsken Detaljer
DocType: Vehicle Service,Vehicle Service,Vehicle service
apps/erpnext/erpnext/config/setup.py +101,Automatically triggers the feedback request based on conditions.,Automatisk utløser tilbakemeldinger forespørsel basert på forholdene.
DocType: Employee,Reason for Resignation,Grunnen til Resignasjon
apps/erpnext/erpnext/config/hr.py +147,Template for performance appraisals.,Mal for medarbeidersamtaler.
DocType: Sales Invoice,Credit Note Issued,Kreditnota Utstedt
DocType: Project Task,Weight,Vekt
DocType: Payment Reconciliation,Invoice/Journal Entry Details,Faktura / Journal Entry Detaljer
apps/erpnext/erpnext/accounts/utils.py +83,{0} '{1}' not in Fiscal Year {2},{0} {1} ikke i regnskapsåret {2}
DocType: Buying Settings,Settings for Buying Module,Innstillinger for kjøp Module
apps/erpnext/erpnext/accounts/doctype/asset_movement/asset_movement.py +21,Asset {0} does not belong to company {1},Asset {0} tilhører ikke selskapet {1}
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +70,Please enter Purchase Receipt first,Skriv inn Kjøpskvittering først
DocType: Buying Settings,Supplier Naming By,Leverandør Naming Av
DocType: Activity Type,Default Costing Rate,Standard Koster Rate
DocType: Maintenance Schedule,Maintenance Schedule,Vedlikeholdsplan
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +36,"Then Pricing Rules are filtered out based on Customer, Customer Group, Territory, Supplier, Supplier Type, Campaign, Sales Partner etc.","Da reglene for prissetting filtreres ut basert på Kunden, Kundens Group, Territory, leverandør, leverandør Type, Kampanje, Sales Partner etc."
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +24,Net Change in Inventory,Netto endring i varelager
apps/erpnext/erpnext/config/hr.py +157,Employee Loan Management,Ansattes lån Ledelse
DocType: Employee,Passport Number,Passnummer
apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +60,Relation with Guardian2,Relasjon med Guardian2
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +93,Manager,Manager
DocType: Payment Entry,Payment From / To,Betaling fra / til
apps/erpnext/erpnext/selling/doctype/customer/customer.py +124,New credit limit is less than current outstanding amount for the customer. Credit limit has to be atleast {0},Ny kredittgrensen er mindre enn dagens utestående beløp for kunden. Kredittgrense må være atleast {0}
DocType: SMS Settings,Receiver Parameter,Mottaker Parameter
apps/erpnext/erpnext/controllers/trends.py +39,'Based On' and 'Group By' can not be same,&quot;Based On&quot; og &quot;Grupper etter&quot; ikke kan være det samme
DocType: Sales Person,Sales Person Targets,Sales Person Targets
DocType: Installation Note,IN-,I-
DocType: Production Order Operation,In minutes,I løpet av minutter
DocType: Issue,Resolution Date,Oppløsning Dato
DocType: Student Batch Name,Batch Name,batch Name
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +319,Timesheet created:,Timeregistrering opprettet:
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +880,Please set default Cash or Bank account in Mode of Payment {0},Vennligst angi standard kontanter eller bankkontoen i modus for betaling {0}
apps/erpnext/erpnext/schools/doctype/student_applicant/student_applicant.js +20,Enroll,Registrere
DocType: GST Settings,GST Settings,GST-innstillinger
DocType: Selling Settings,Customer Naming By,Kunden Naming Av
DocType: Student Leave Application,Will show the student as Present in Student Monthly Attendance Report,Vil vise studenten som Tilstede i Student Månedlig fremmøterapport
DocType: Depreciation Schedule,Depreciation Amount,avskrivninger Beløp
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +56,Convert to Group,Konverter til konsernet
DocType: Activity Cost,Activity Type,Aktivitetstype
DocType: Request for Quotation,For individual supplier,For enkelte leverandør
DocType: BOM Operation,Base Hour Rate(Company Currency),Base Hour Rate (Selskap Valuta)
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +47,Delivered Amount,Leveres Beløp
DocType: Supplier,Fixed Days,Faste Days
DocType: Quotation Item,Item Balance,Sak Balance
DocType: Sales Invoice,Packing List,Pakkeliste
apps/erpnext/erpnext/config/buying.py +28,Purchase Orders given to Suppliers.,Innkjøpsordrer gis til leverandører.
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +43,Publishing,Publisering
DocType: Activity Cost,Projects User,Prosjekter User
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41,Consumed,Forbrukes
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +157,{0}: {1} not found in Invoice Details table,{0}: {1} ble ikke funnet i Fakturadetaljer tabellen
DocType: Company,Round Off Cost Center,Rund av kostnadssted
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +227,Maintenance Visit {0} must be cancelled before cancelling this Sales Order,Vedlikehold Besøk {0} må avbestilles før den avbryter denne salgsordre
DocType: Item,Material Transfer,Material Transfer
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +211,Opening (Dr),Åpning (Dr)
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +39,Posting timestamp must be after {0},Oppslaget tidsstempel må være etter {0}
,GST Itemised Purchase Register,GST Artized Purchase Register
DocType: Employee Loan,Total Interest Payable,Total rentekostnader
DocType: Landed Cost Taxes and Charges,Landed Cost Taxes and Charges,Landed Cost skatter og avgifter
DocType: Production Order Operation,Actual Start Time,Faktisk Starttid
DocType: BOM Operation,Operation Time,Operation Tid
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +285,Finish,Bli ferdig
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +395,Base,Utgangspunkt
DocType: Timesheet,Total Billed Hours,Totalt fakturert timer
DocType: Journal Entry,Write Off Amount,Skriv Off Beløp
DocType: Journal Entry,Bill No,Bill Nei
DocType: Company,Gain/Loss Account on Asset Disposal,Gevinst / tap-konto på Asset Avhending
DocType: Vehicle Log,Service Details,Servicedetaljer
DocType: Vehicle Log,Service Details,Servicedetaljer
DocType: Purchase Invoice,Quarterly,Quarterly
DocType: Selling Settings,Delivery Note Required,Levering Note Påkrevd
DocType: Bank Guarantee,Bank Guarantee Number,Bankgaranti nummer
DocType: Bank Guarantee,Bank Guarantee Number,Bankgaranti nummer
DocType: Assessment Criteria,Assessment Criteria,Vurderingskriterier
DocType: BOM Item,Basic Rate (Company Currency),Basic Rate (Company Valuta)
DocType: Student Attendance,Student Attendance,student Oppmøte
DocType: Sales Invoice Timesheet,Time Sheet,Tids skjema
DocType: Manufacturing Settings,Backflush Raw Materials Based On,Spylings Råvare basert på
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +62,Please enter item details,Skriv inn elementdetaljer
DocType: Interest,Interest,Renter
apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +10,Pre Sales,Før salg
DocType: Purchase Receipt,Other Details,Andre detaljer
apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +18,Suplier,suplier
DocType: Account,Accounts,Kontoer
DocType: Vehicle,Odometer Value (Last),Kilometerstand (Siste)
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +78,Marketing,Markedsføring
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +282,Payment Entry is already created,Betaling Entry er allerede opprettet
DocType: Purchase Receipt Item Supplied,Current Stock,Nåværende Stock
apps/erpnext/erpnext/controllers/accounts_controller.py +558,Row #{0}: Asset {1} does not linked to Item {2},Row # {0}: Asset {1} ikke knyttet til Element {2}
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +377,Preview Salary Slip,Forhåndsvisning Lønn Slip
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +54,Account {0} has been entered multiple times,Konto {0} er angitt flere ganger
DocType: Account,Expenses Included In Valuation,Kostnader som inngår i verdivurderings
DocType: Hub Settings,Seller City,Selger by
,Absent Student Report,Fraværende Student Rapporter
DocType: Email Digest,Next email will be sent on:,Neste post vil bli sendt på:
DocType: Offer Letter Term,Offer Letter Term,Tilby Letter Term
apps/erpnext/erpnext/stock/doctype/item/item.py +613,Item has variants.,Elementet har varianter.
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +65,Item {0} not found,Element {0} ikke funnet
DocType: Bin,Stock Value,Stock Verdi
apps/erpnext/erpnext/accounts/doctype/account/account.py +26,Company {0} does not exist,Selskapet {0} finnes ikke
apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +82,Tree Type,Tre Type
DocType: BOM Explosion Item,Qty Consumed Per Unit,Antall som forbrukes per enhet
DocType: Serial No,Warranty Expiry Date,Garantiutløpsdato
DocType: Material Request Item,Quantity and Warehouse,Kvantitet og Warehouse
DocType: Sales Invoice,Commission Rate (%),Kommisjonen Rate (%)
apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +23,Please select Program,Vennligst velg Program
apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +23,Please select Program,Vennligst velg Program
DocType: Project,Estimated Cost,anslått pris
DocType: Purchase Order,Link to material requests,Lenke til materiale forespørsler
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +7,Aerospace,Aerospace
DocType: Journal Entry,Credit Card Entry,Kredittkort Entry
apps/erpnext/erpnext/config/accounts.py +51,Company and Accounts,Selskapet og regnskap
apps/erpnext/erpnext/config/stock.py +22,Goods received from Suppliers.,Mottatte varer fra leverandører.
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +58,In Value,i Verdi
DocType: Lead,Campaign Name,Kampanjenavn
DocType: Selling Settings,Close Opportunity After Days,Lukk mulighet da Days
,Reserved,Reservert
DocType: Purchase Order,Supply Raw Materials,Leverer råvare
DocType: Purchase Invoice,The date on which next invoice will be generated. It is generated on submit.,Datoen da neste faktura vil bli generert. Det genereres på send.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +10,Current Assets,Omløpsmidler
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +94,{0} is not a stock Item,{0} er ikke en lagervare
DocType: Mode of Payment Account,Default Account,Standard konto
DocType: Payment Entry,Received Amount (Company Currency),Mottatt beløp (Selskap Valuta)
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +166,Lead must be set if Opportunity is made from Lead,Lead må stilles inn hvis Opportunity er laget av Lead
apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +29,Please select weekly off day,Vennligst velg ukentlig off dag
DocType: Production Order Operation,Planned End Time,Planlagt Sluttid
,Sales Person Target Variance Item Group-Wise,Sales Person Target Avviks varegruppe-Wise
apps/erpnext/erpnext/accounts/doctype/account/account.py +96,Account with existing transaction cannot be converted to ledger,Konto med eksisterende transaksjon kan ikke konverteres til Ledger
DocType: Delivery Note,Customer's Purchase Order No,Kundens innkjøpsordre Nei
DocType: Budget,Budget Against,budsjett Against
DocType: Employee,Cell Number,Cell Number
apps/erpnext/erpnext/stock/reorder_item.py +177,Auto Material Requests Generated,Auto Materiell Forespørsler Generert
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js +7,Lost,Mistet
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +152,You can not enter current voucher in 'Against Journal Entry' column,Du kan ikke legge inn dagens kupong i &quot;Against Journal Entry-kolonnen
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +50,Reserved for manufacturing,Reservert for produksjon
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +25,Energy,Energy
DocType: Opportunity,Opportunity From,Opportunity Fra
apps/erpnext/erpnext/config/hr.py +98,Monthly salary statement.,Månedslønn uttalelse.
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +848,Row {0}: {1} Serial numbers required for Item {2}. You have provided {3}.,Row {0}: {1} Serienummer som kreves for element {2}. Du har oppgitt {3}.
DocType: BOM,Website Specifications,Nettstedet Spesifikasjoner
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +24,{0}: From {0} of type {1},{0}: Fra {0} av typen {1}
DocType: Warranty Claim,CI-,CI-
apps/erpnext/erpnext/controllers/buying_controller.py +287,Row {0}: Conversion Factor is mandatory,Rad {0}: Omregningsfaktor er obligatorisk
DocType: Employee,A+,A +
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +325,"Multiple Price Rules exists with same criteria, please resolve conflict by assigning priority. Price Rules: {0}","Flere Pris regler eksisterer med samme kriteriene, kan du løse konflikten ved å prioritere. Pris Regler: {0}"
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +468,Cannot deactivate or cancel BOM as it is linked with other BOMs,Kan ikke deaktivere eller kansellere BOM som det er forbundet med andre stykklister
DocType: Opportunity,Maintenance,Vedlikehold
DocType: Item Attribute Value,Item Attribute Value,Sak data Verdi
apps/erpnext/erpnext/config/selling.py +158,Sales campaigns.,Salgskampanjer.
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +109,Make Timesheet,Gjør Timeregistrering
DocType: Sales Taxes and Charges Template,"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.

#### Note

The 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.

#### Description of Columns

1. Calculation Type: 
    - This can be on **Net Total** (that is the sum of basic amount).
    - **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.
    - **Actual** (as mentioned).
2. Account Head: The Account ledger under which this tax will be booked
3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.
4. Description: Description of the tax (that will be printed in invoices / quotes).
5. Rate: Tax rate.
6. Amount: Tax amount.
7. Total: Cumulative total to this point.
8. 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).
9. 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 skatt mal som kan brukes på alle salgstransaksjoner. Denne malen kan inneholde liste over skatte hoder og også andre utgifter / inntekter hoder som &quot;Shipping&quot;, &quot;Forsikring&quot;, &quot;Håndtering&quot; osv #### Note Skattesatsen du definerer her vil være standard skattesats for alle ** Elementer **. Hvis det er ** Elementer ** som har forskjellige priser, må de legges i ** Sak Skatt ** bord i ** Sak ** mester. #### Beskrivelse av kolonner 1. Beregning Type: - Dette kan være på ** Net Total ** (som er summen av grunnbeløpet). - ** På Forrige Row Total / Beløp ** (for kumulative skatter eller avgifter). Hvis du velger dette alternativet, vil skatten bli brukt som en prosentandel av forrige rad (i skattetabellen) eller en total. - ** Faktisk ** (som nevnt). 2. Account Head: Konto hovedbok der denne skatten vil bli bokført 3. Cost Center: Hvis skatt / avgift er en inntekt (som frakt) eller utgifter det må bestilles mot et kostnadssted. 4. Beskrivelse: Beskrivelse av skatt (som vil bli skrevet ut i fakturaer / sitater). 5. Ranger: skattesats. 6. Beløp: Skatt beløp. 7. Totalt: Akkumulert total til dette punktet. 8. Angi Row: Dersom basert på &quot;Forrige Row Total&quot; du kan velge radnummeret som vil bli tatt som en base for denne beregningen (standard er den forrige rad). 9. Er dette inklusiv i Basic Rate ?: Hvis du sjekke dette, betyr det at denne avgiften ikke vil bli vist under elementet bordet, men vil inngå i grunnbeløpet i din viktigste elementet tabellen. Dette er nyttig når du vil gi en flat pris (inklusive alle avgifter) pris til kundene."
DocType: Employee,Bank A/C No.,Bank A / C No.
DocType: Bank Guarantee,Project,Prosjekt
DocType: Quality Inspection Reading,Reading 7,Reading 7
apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js +9,Partially Ordered,delvis Bestilt
DocType: Expense Claim Detail,Expense Claim Type,Expense krav Type
DocType: Shopping Cart Settings,Default settings for Shopping Cart,Standardinnstillingene for handlekurv
apps/erpnext/erpnext/accounts/doctype/asset/depreciation.py +132,Asset scrapped via Journal Entry {0},Asset kasserte via bilagsregistrering {0}
DocType: Employee Loan,Interest Income Account,Renteinntekter konto
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +13,Biotechnology,Bioteknologi
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +109,Office Maintenance Expenses,Kontor Vedlikehold Utgifter
apps/erpnext/erpnext/config/learn.py +47,Setting up Email Account,Sette opp e-postkonto
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.js +114,Please enter Item first,Skriv inn Sak først
DocType: Account,Liability,Ansvar
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +182,Sanctioned Amount cannot be greater than Claim Amount in Row {0}.,Sanksjonert Beløpet kan ikke være større enn krav Beløp i Rad {0}.
DocType: Company,Default Cost of Goods Sold Account,Standard varekostnader konto
apps/erpnext/erpnext/stock/get_item_details.py +309,Price List not selected,Prisliste ikke valgt
DocType: Employee,Family Background,Familiebakgrunn
DocType: Request for Quotation Supplier,Send Email,Send E-Post
apps/erpnext/erpnext/stock/doctype/item/item.py +203,Warning: Invalid Attachment {0},Advarsel: Ugyldig Vedlegg {0}
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +755,No Permission,Ingen tillatelse
DocType: Company,Default Bank Account,Standard Bank Account
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +50,"To filter based on Party, select Party Type first","Hvis du vil filtrere basert på partiet, velger partiet Skriv inn først"
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +48,'Update Stock' can not be checked because items are not delivered via {0},&#39;Oppdater Stock&#39; kan ikke kontrolleres fordi elementene ikke er levert via {0}
DocType: Vehicle,Acquisition Date,Innkjøpsdato
apps/erpnext/erpnext/public/js/setup_wizard.js +308,Nos,Nos
DocType: Item,Items with higher weightage will be shown higher,Elementer med høyere weightage vil bli vist høyere
DocType: Bank Reconciliation Detail,Bank Reconciliation Detail,Bankavstemming Detalj
apps/erpnext/erpnext/controllers/accounts_controller.py +562,Row #{0}: Asset {1} must be submitted,Row # {0}: Asset {1} må fremlegges
apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +40,No employee found,Ingen ansatte funnet
DocType: Supplier Quotation,Stopped,Stoppet
DocType: Item,If subcontracted to a vendor,Dersom underleverandør til en leverandør
apps/erpnext/erpnext/schools/doctype/student_group/student_group.js +111,Student Group is already updated.,Studentgruppen er allerede oppdatert.
apps/erpnext/erpnext/schools/doctype/student_group/student_group.js +111,Student Group is already updated.,Studentgruppen er allerede oppdatert.
DocType: SMS Center,All Customer Contact,All Kundekontakt
apps/erpnext/erpnext/config/stock.py +153,Upload stock balance via csv.,Last opp lagersaldo via csv.
DocType: Warehouse,Tree Details,Tree Informasjon
DocType: Training Event,Event Status,Hendelses Status
,Support Analytics,Støtte Analytics
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +344,"If you have any questions, please get back to us.","Hvis du har spørsmål, kan du komme tilbake til oss."
DocType: Item,Website Warehouse,Nettsted Warehouse
DocType: Payment Reconciliation,Minimum Invoice Amount,Minimum Fakturert beløp
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +111,{0} {1}: Cost Center {2} does not belong to Company {3},{0} {1}: Kostnadssted {2} ikke tilhører selskapet {3}
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +88,{0} {1}: Account {2} cannot be a Group,{0} {1}: Account {2} kan ikke være en gruppe
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +61,Item Row {idx}: {doctype} {docname} does not exist in above '{doctype}' table,Sak Row {idx}: {doctype} {DOCNAME} finnes ikke i oven {doctype} tabellen
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +278,Timesheet {0} is already completed or cancelled,Timeregistrering {0} er allerede gjennomført eller kansellert
apps/erpnext/erpnext/templates/pages/projects.html +42,No tasks,ingen oppgaver
DocType: Purchase Invoice,"The day of the month on which auto invoice will be generated e.g. 05, 28 etc","Dagen i måneden som auto faktura vil bli generert for eksempel 05, 28 osv"
DocType: Asset,Opening Accumulated Depreciation,Åpning akkumulerte avskrivninger
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.js +49,Score must be less than or equal to 5,Score må være mindre enn eller lik 5
DocType: Program Enrollment Tool,Program Enrollment Tool,Program Påmelding Tool
apps/erpnext/erpnext/config/accounts.py +332,C-Form records,C-Form poster
apps/erpnext/erpnext/config/selling.py +311,Customer and Supplier,Kunde og leverandør
DocType: Email Digest,Email Digest Settings,E-post Digest Innstillinger
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +346,Thank you for your business!,Takk for handelen!
apps/erpnext/erpnext/config/support.py +12,Support queries from customers.,Støtte henvendelser fra kunder.
,Production Order Stock Report,Produksjonsordre aksjerapport
DocType: HR Settings,Retirement Age,Pensjonsalder
DocType: Bin,Moving Average Rate,Moving Gjennomsnittlig pris
DocType: Production Planning Tool,Select Items,Velg Items
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +372,{0} against Bill {1} dated {2},{0} mot Bill {1} datert {2}
DocType: Program Enrollment,Vehicle/Bus Number,Kjøretøy / bussnummer
apps/erpnext/erpnext/schools/doctype/course/course.js +17,Course Schedule,Kursplan
DocType: Maintenance Visit,Completion Status,Completion Status
DocType: HR Settings,Enter retirement age in years,Skriv inn pensjonsalder i år
apps/erpnext/erpnext/accounts/doctype/asset/asset.js +263,Target Warehouse,Target Warehouse
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +102,Please select a warehouse,Vennligst velg et lager
DocType: Cheque Print Template,Starting location from left edge,Starter plassering fra venstre kant
DocType: Item,Allow over delivery or receipt upto this percent,Tillat løpet levering eller mottak opp denne prosent
DocType: Stock Entry,STE-,an- drogene
DocType: Upload Attendance,Import Attendance,Import Oppmøte
apps/erpnext/erpnext/public/js/pos/pos.html +115,All Item Groups,Alle varegrupper
DocType: Process Payroll,Activity Log,Aktivitetsloggen
apps/erpnext/erpnext/accounts/report/profit_and_loss_statement/profit_and_loss_statement.py +39,Net Profit / Loss,Netto gevinst / tap
apps/erpnext/erpnext/config/setup.py +89,Automatically compose message on submission of transactions.,Skriv melding automatisk ved innlevering av transaksjoner.
DocType: Production Order,Item To Manufacture,Element for å produsere
apps/erpnext/erpnext/buying/utils.py +80,{0} {1} status is {2},{0} {1} status er {2}
DocType: Employee,Provide Email Address registered in company,Gi e-postadresse som er registrert i selskapets
DocType: Shopping Cart Settings,Enable Checkout,aktiver kassen
apps/erpnext/erpnext/config/learn.py +202,Purchase Order to Payment,Bestilling til betaling
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +48,Projected Qty,Anslått Antall
DocType: Sales Invoice,Payment Due Date,Betalingsfrist
apps/erpnext/erpnext/stock/doctype/item/item.js +349,Item Variant {0} already exists with same attributes,Sak Variant {0} finnes allerede med samme attributtene
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +97,'Opening',&quot;Opening&quot;
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +130,Open To Do,Åpne for å gjøre
DocType: Notification Control,Delivery Note Message,Levering Note Message
DocType: Expense Claim,Expenses,Utgifter
DocType: Item Variant Attribute,Item Variant Attribute,Sak Variant Egenskap
,Purchase Receipt Trends,Kvitteringen Trender
DocType: Process Payroll,Bimonthly,annenhver måned
DocType: Vehicle Service,Brake Pad,Bremsekloss
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +88,Research & Development,Forskning Og Utvikling
apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py +20,Amount to Bill,Beløp til Bill
DocType: Company,Registration Details,Registrering Detaljer
DocType: Timesheet,Total Billed Amount,Total Fakturert beløp
DocType: Item Reorder,Re-Order Qty,Re-Order Antall
DocType: Leave Block List Date,Leave Block List Date,La Block List Dato
DocType: Pricing Rule,Price or Discount,Pris eller rabatt
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +86,Total Applicable Charges in Purchase Receipt Items table must be same as Total Taxes and Charges,Totalt gjeldende avgifter i kvitteringen Elementer tabellen må være det samme som total skatter og avgifter
DocType: Sales Team,Incentives,Motivasjon
DocType: SMS Log,Requested Numbers,Etterspør Numbers
DocType: Production Planning Tool,Only Obtain Raw Materials,Bare Skaffe råstoffer
apps/erpnext/erpnext/config/hr.py +142,Performance appraisal.,Medarbeidersamtaler.
apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +95,"Enabling 'Use for Shopping Cart', as Shopping Cart is enabled and there should be at least one Tax Rule for Shopping Cart","Aktivering av «Bruk for handlekurven&quot;, som Handlevogn er aktivert, og det bør være minst en skatteregel for Handlekurv"
apps/erpnext/erpnext/controllers/accounts_controller.py +360,"Payment Entry {0} is linked against Order {1}, check if it should be pulled as advance in this invoice.","Betaling Entry {0} er knyttet mot Bestill {1}, sjekk om det bør trekkes som forskudd i denne fakturaen."
DocType: Sales Invoice Item,Stock Details,Stock Detaljer
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +29,Project Value,Prosjektet Verdi
apps/erpnext/erpnext/config/selling.py +321,Point-of-Sale,Utsalgssted
DocType: Vehicle Log,Odometer Reading,Kilometerteller Reading
apps/erpnext/erpnext/accounts/doctype/account/account.py +119,"Account balance already in Credit, you are not allowed to set 'Balance Must Be' as 'Debit'","Saldo allerede i Credit, har du ikke lov til å sette &quot;Balance må være &#39;som&#39; debet &#39;"
DocType: Account,Balance must be,Balansen må være
DocType: Hub Settings,Publish Pricing,Publiser Priser
DocType: Notification Control,Expense Claim Rejected Message,Expense krav Avvist Message
,Available Qty,Tilgjengelig Antall
DocType: Purchase Taxes and Charges,On Previous Row Total,På Forrige Row Total
DocType: Purchase Invoice Item,Rejected Qty,avvist Antall
DocType: Salary Slip,Working Days,Arbeidsdager
DocType: Serial No,Incoming Rate,Innkommende Rate
DocType: Packing Slip,Gross Weight,Bruttovekt
apps/erpnext/erpnext/public/js/setup_wizard.js +90,The name of your company for which you are setting up this system.,Navnet på firmaet som du setter opp dette systemet.
DocType: HR Settings,Include holidays in Total no. of Working Days,Inkluder ferier i Total no. arbeidsdager
DocType: Job Applicant,Hold,Hold
DocType: Employee,Date of Joining,Dato for Delta
DocType: Naming Series,Update Series,Update-serien
DocType: Supplier Quotation,Is Subcontracted,Er underleverandør
DocType: Item Attribute,Item Attribute Values,Sak attributtverdier
DocType: Examination Result,Examination Result,Sensur
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +796,Purchase Receipt,Kvitteringen
,Received Items To Be Billed,Mottatte elementer å bli fakturert
apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +173,Submitted Salary Slips,Innsendte lønnsslipper
apps/erpnext/erpnext/config/accounts.py +305,Currency exchange rate master.,Valutakursen mester.
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +192,Reference Doctype must be one of {0},Referanse DOCTYPE må være en av {0}
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +302,Unable to find Time Slot in the next {0} days for Operation {1},Å finne tidsluke i de neste {0} dager for Operation klarer {1}
DocType: Production Order,Plan material for sub-assemblies,Plan materiale for sub-assemblies
apps/erpnext/erpnext/config/selling.py +97,Sales Partners and Territory,Salgs Partnere og Territory
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +547,BOM {0} must be active,BOM {0} må være aktiv
DocType: Journal Entry,Depreciation Entry,avskrivninger Entry
apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +36,Please select the document type first,Velg dokumenttypen først
apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py +65,Cancel Material Visits {0} before cancelling this Maintenance Visit,Avbryt Material Besøk {0} før den sletter denne Maintenance Visit
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +213,Serial No {0} does not belong to Item {1},Serial No {0} tilhører ikke Element {1}
DocType: Purchase Receipt Item Supplied,Required Qty,Påkrevd antall
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +123,Warehouses with existing transaction can not be converted to ledger.,Næringslokaler med eksisterende transaksjon kan ikke konverteres til hovedbok.
DocType: Bank Reconciliation,Total Amount,Totalbeløp
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +32,Internet Publishing,Internett Publisering
DocType: Production Planning Tool,Production Orders,Produksjonsordrer
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +62,Balance Value,Balanse Verdi
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +38,Sales Price List,Salg Prisliste
apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +69,Publish to sync items,Publisere synkronisere elementer
DocType: Bank Reconciliation,Account Currency,Account Valuta
apps/erpnext/erpnext/accounts/general_ledger.py +142,Please mention Round Off Account in Company,Vennligst oppgi Round Off-konto i selskapet
DocType: Purchase Receipt,Range,Område
DocType: Supplier,Default Payable Accounts,Standard Leverandørgjeld
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +49,Employee {0} is not active or does not exist,Ansatt {0} er ikke aktiv eller ikke eksisterer
DocType: Fee Structure,Components,komponenter
apps/erpnext/erpnext/accounts/doctype/asset/asset.py +250,Please enter Asset Category in Item {0},Fyll inn Asset kategori i Element {0}
DocType: Quality Inspection Reading,Reading 6,Reading 6
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +895,Cannot {0} {1} {2} without any negative outstanding invoice,Kan ikke {0} {1} {2} uten noen negativ utestående faktura
DocType: Purchase Invoice Advance,Purchase Invoice Advance,Fakturaen Advance
DocType: Hub Settings,Sync Now,Synkroniser nå
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +199,Row {0}: Credit entry can not be linked with a {1},Rad {0}: Credit oppføring kan ikke være knyttet til en {1}
apps/erpnext/erpnext/config/accounts.py +248,Define budget for a financial year.,Definer budsjett for et regnskapsår.
DocType: Mode of Payment Account,Default Bank / Cash account will be automatically updated in POS Invoice when this mode is selected.,Standard Bank / minibank konto vil automatisk bli oppdatert i POS faktura når denne modusen er valgt.
DocType: Lead,LEAD-,LEDE-
DocType: Employee,Permanent Address Is,Permanent Adresse Er
DocType: Production Order Operation,Operation completed for how many finished goods?,Operasjonen gjennomført for hvor mange ferdigvarer?
apps/erpnext/erpnext/public/js/setup_wizard.js +42,The Brand,The Brand
DocType: Employee,Exit Interview Details,Exit Intervju Detaljer
DocType: Item,Is Purchase Item,Er Purchase Element
DocType: Asset,Purchase Invoice,Fakturaen
DocType: Stock Ledger Entry,Voucher Detail No,Kupong Detail Ingen
apps/erpnext/erpnext/accounts/page/pos/pos.js +730,New Sales Invoice,Ny salgsfaktura
DocType: Stock Entry,Total Outgoing Value,Total Utgående verdi
apps/erpnext/erpnext/public/js/account_tree_grid.js +224,Opening Date and Closing Date should be within same Fiscal Year,Åpningsdato og sluttdato skal være innenfor samme regnskapsår
DocType: Lead,Request for Information,Spør etter informasjon
,LeaderBoard,Leaderboard
apps/erpnext/erpnext/accounts/page/pos/pos.js +743,Sync Offline Invoices,Synkroniser Offline Fakturaer
DocType: Payment Request,Paid,Betalt
DocType: Program Fee,Program Fee,program Fee
DocType: Salary Slip,Total in words,Totalt i ord
DocType: Material Request Item,Lead Time Date,Lead Tid Dato
DocType: Guardian,Guardian Name,Guardian navn
DocType: Cheque Print Template,Has Print Format,Har Print Format
DocType: Employee Loan,Sanctioned,sanksjonert
apps/erpnext/erpnext/accounts/page/pos/pos.js +71, is mandatory. Maybe Currency Exchange record is not created for ,er obligatorisk. Kanskje Valutaveksling posten ikke er skapt for
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +112,Row #{0}: Please specify Serial No for Item {1},Row # {0}: Vennligst oppgi serienummer for varen {1}
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +622,"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.","For &#39;Produkt Bundle&#39; elementer, Warehouse, serienummer og Batch Ingen vil bli vurdert fra &quot;Pakkeliste&quot; bord. Hvis Warehouse og Batch Ingen er lik for alle pakking elementer for noen &quot;Product Bundle &#39;elementet, kan disse verdiene legges inn i hoved Sak bordet, vil verdiene bli kopiert til&quot; Pakkeliste &quot;bord."
DocType: Job Opening,Publish on website,Publiser på nettstedet
apps/erpnext/erpnext/config/stock.py +17,Shipments to customers.,Forsendelser til kunder.
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +621,Supplier Invoice Date cannot be greater than Posting Date,Leverandør Fakturadato kan ikke være større enn konteringsdato
DocType: Purchase Invoice Item,Purchase Order Item,Innkjøpsordre Element
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +132,Indirect Income,Indirekte inntekt
DocType: Student Attendance Tool,Student Attendance Tool,Student Oppmøte Tool
DocType: Cheque Print Template,Date Settings,Dato Innstillinger
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +48,Variance,Varians
,Company Name,Selskapsnavn
DocType: SMS Center,Total Message(s),Total melding (er)
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +848,Select Item for Transfer,Velg elementet for Transfer
DocType: Purchase Invoice,Additional Discount Percentage,Ekstra rabatt Prosent
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +24,View a list of all the help videos,Vis en liste over alle hjelpevideoer
DocType: Bank Reconciliation,Select account head of the bank where cheque was deposited.,Velg kontoen leder av banken der sjekken ble avsatt.
DocType: Selling Settings,Allow user to edit Price List Rate in transactions,Tillater brukeren å redigere Prisliste Rate i transaksjoner
DocType: Pricing Rule,Max Qty,Max Antall
apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +30,"Row {0}: Invoice {1} is invalid, it might be cancelled / does not exist. \
						Please enter a valid Invoice","Rad {0}: Faktura {1} er ugyldig, kan det bli kansellert / finnes ikke. \ Vennligst skriv inn en gyldig faktura"
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +132,Row {0}: Payment against Sales/Purchase Order should always be marked as advance,Rad {0}: Betaling mot Salg / innkjøpsordre skal alltid merkes som forskudd
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +16,Chemical,Kjemisk
DocType: Salary Component Account,Default Bank / Cash account will be automatically updated in Salary Journal Entry when this mode is selected.,Standard Bank / minibank konto vil bli automatisk oppdatert i Lønn bilagsregistrering når denne modusen er valgt.
DocType: BOM,Raw Material Cost(Company Currency),Raw Material Cost (Selskap Valuta)
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +731,All items have already been transferred for this Production Order.,Alle elementene er allerede blitt overført til denne produksjonsordre.
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +87,Row # {0}: Rate cannot be greater than the rate used in {1} {2},Row # {0}: Prisen kan ikke være større enn frekvensen som brukes i {1} {2}
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +87,Row # {0}: Rate cannot be greater than the rate used in {1} {2},Row # {0}: Prisen kan ikke være større enn frekvensen som brukes i {1} {2}
apps/erpnext/erpnext/public/js/setup_wizard.js +309,Meter,Måler
DocType: Workstation,Electricity Cost,Elektrisitet Cost
DocType: HR Settings,Don't send Employee Birthday Reminders,Ikke send Employee bursdagspåminnelser
DocType: Item,Inspection Criteria,Inspeksjon Kriterier
apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js +14,Transfered,Overført
DocType: BOM Website Item,BOM Website Item,BOM Nettstedet Element
apps/erpnext/erpnext/public/js/setup_wizard.js +43,Upload your letter head and logo. (you can edit them later).,Last opp din brevhode og logo. (Du kan redigere dem senere).
DocType: Timesheet Detail,Bill,Regning
apps/erpnext/erpnext/accounts/doctype/asset/asset.py +85,Next Depreciation Date is entered as past date,Neste avskrivningsdato legges inn som siste dato
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +177,White,Hvit
DocType: SMS Center,All Lead (Open),All Lead (Open)
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +231,Row {0}: Qty not available for {4} in warehouse {1} at posting time of the entry ({2} {3}),Rad {0}: Antall ikke tilgjengelig for {4} i lageret {1} ved å legge tidspunktet for innreise ({2} {3})
DocType: Purchase Invoice,Get Advances Paid,Få utbetalt forskudd
DocType: Item,Automatically Create New Batch,Opprett automatisk ny batch automatisk
DocType: Item,Automatically Create New Batch,Opprett automatisk ny batch automatisk
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +767,Make ,Gjøre
DocType: Student Admission,Admission Start Date,Opptak Startdato
DocType: Journal Entry,Total Amount in Words,Totalbeløp i Words
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +7,There was an error. One probable reason could be that you haven't saved the form. Please contact support@erpnext.com if the problem persists.,Det var en feil. En mulig årsak kan være at du ikke har lagret skjemaet. Ta kontakt support@erpnext.com hvis problemet vedvarer.
apps/erpnext/erpnext/templates/pages/cart.html +5,My Cart,Handlekurv
apps/erpnext/erpnext/controllers/selling_controller.py +155,Order Type must be one of {0},Ordretype må være en av {0}
DocType: Lead,Next Contact Date,Neste Kontakt Dato
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +36,Opening Qty,Antall åpne
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +456,Please enter Account for Change Amount,Vennligst oppgi konto for Change Beløp
DocType: Student Batch Name,Student Batch Name,Student Batch Name
DocType: Holiday List,Holiday List Name,Holiday Listenavn
DocType: Repayment Schedule,Balance Loan Amount,Balanse Lånebeløp
apps/erpnext/erpnext/schools/doctype/course_scheduling_tool/course_scheduling_tool.js +13,Schedule Course,Schedule Course
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +193,Stock Options,Aksjeopsjoner
DocType: Journal Entry Account,Expense Claim,Expense krav
apps/erpnext/erpnext/accounts/doctype/asset/asset.js +245,Do you really want to restore this scrapped asset?,Har du virkelig ønsker å gjenopprette dette skrotet ressurs?
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +349,Qty for {0},Antall for {0}
DocType: Leave Application,Leave Application,La Application
apps/erpnext/erpnext/config/hr.py +80,Leave Allocation Tool,La Allocation Tool
DocType: Leave Block List,Leave Block List Dates,La Block List Datoer
DocType: Workstation,Net Hour Rate,Netto timepris
DocType: Landed Cost Purchase Receipt,Landed Cost Purchase Receipt,Landed Cost Kjøpskvittering
DocType: Company,Default Terms,Standard Terms
DocType: Packing Slip Item,Packing Slip Item,Pakking Slip Element
DocType: Purchase Invoice,Cash/Bank Account,Cash / Bank Account
apps/erpnext/erpnext/public/js/queries.js +96,Please specify a {0},Vennligst oppgi en {0}
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +71,Removed items with no change in quantity or value.,Fjernet elementer med ingen endring i mengde eller verdi.
DocType: Delivery Note,Delivery To,Levering Å
apps/erpnext/erpnext/stock/doctype/item/item.py +631,Attribute table is mandatory,Attributt tabellen er obligatorisk
DocType: Production Planning Tool,Get Sales Orders,Få salgsordrer
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +67,{0} can not be negative,{0} kan ikke være negativ
apps/erpnext/erpnext/public/js/pos/pos_selected_item.html +11,Discount,Rabatt
DocType: Asset,Total Number of Depreciations,Totalt antall Avskrivninger
DocType: Sales Invoice Item,Rate With Margin,Vurder med margin
DocType: Sales Invoice Item,Rate With Margin,Vurder med margin
DocType: Workstation,Wages,Lønn
DocType: Project,Internal,Intern
DocType: Task,Urgent,Haster
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +157,Please specify a valid Row ID for row {0} in table {1},Vennligst oppgi en gyldig Row ID for rad {0} i tabellen {1}
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +23,Go to the Desktop and start using ERPNext,Gå til skrivebordet og begynne å bruke ERPNext
DocType: Item,Manufacturer,Produsent
DocType: Landed Cost Item,Purchase Receipt Item,Kvitteringen Element
DocType: Purchase Receipt,PREC-RET-,PREC-RET-
DocType: POS Profile,Sales Invoice Payment,Salg Faktura Betaling
DocType: Production Plan Item,Reserved Warehouse in Sales Order / Finished Goods Warehouse,Reservert Industribygg i salgsordre / ferdigvarelageret
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +73,Selling Amount,Selge Beløp
DocType: Repayment Schedule,Interest Amount,rente~~POS=TRUNC
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +128,You are the Expense Approver for this record. Please Update the 'Status' and Save,Du er den Expense Godkjenner denne posten. Oppdater &quot;Status&quot; og Lagre
DocType: Serial No,Creation Document No,Creation Dokument nr
DocType: Issue,Issue,Problem
DocType: Asset,Scrapped,skrotet
apps/erpnext/erpnext/config/stock.py +195,"Attributes for Item Variants. e.g Size, Color etc.","Attributter for varen Varianter. f.eks størrelse, farge etc."
DocType: Purchase Invoice,Returns,returer
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order_calendar.js +42,WIP Warehouse,WIP Warehouse
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +195,Serial No {0} is under maintenance contract upto {1},Serial No {0} er under vedlikeholdskontrakt opp {1}
apps/erpnext/erpnext/config/hr.py +35,Recruitment,Rekruttering
DocType: Lead,Organization Name,Organization Name
DocType: Tax Rule,Shipping State,Shipping State
,Projected Quantity as Source,Anslått Antall som kilde
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +59,Item must be added using 'Get Items from Purchase Receipts' button,Elementet må legges til med &quot;Get Elementer fra innkjøps Receipts &#39;knappen
DocType: Employee,A-,EN-
DocType: Production Planning Tool,Include non-stock items,Inkluder ikke-lager
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +117,Sales Expenses,Salgs Utgifter
apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py +18,Standard Buying,Standard Kjøpe
DocType: GL Entry,Against,Against
DocType: Item,Default Selling Cost Center,Standard Selling kostnadssted
DocType: Sales Partner,Implementation Partner,Gjennomføring Partner
apps/erpnext/erpnext/accounts/page/pos/pos.js +1545,ZIP Code,Post kode
apps/erpnext/erpnext/controllers/selling_controller.py +265,Sales Order {0} is {1},Salgsordre {0} er {1}
DocType: Opportunity,Contact Info,Kontaktinfo
apps/erpnext/erpnext/config/stock.py +310,Making Stock Entries,Making Stock Entries
DocType: Packing Slip,Net Weight UOM,Vekt målenheter
apps/erpnext/erpnext/hr/doctype/training_result/training_result.py +20,{0} Results,{0} resultater
DocType: Item,Default Supplier,Standard Leverandør
DocType: Manufacturing Settings,Over Production Allowance Percentage,Over Produksjon Fradrag Prosent
DocType: Employee Loan,Repayment Schedule,tilbakebetaling Schedule
DocType: Shipping Rule Condition,Shipping Rule Condition,Shipping Rule Tilstand
DocType: Holiday List,Get Weekly Off Dates,Få Ukentlig Off Datoer
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +33,End Date can not be less than Start Date,Sluttdato kan ikke være mindre enn startdato
DocType: Sales Person,Select company name first.,Velg firmanavn først.
apps/erpnext/erpnext/config/buying.py +23,Quotations received from Suppliers.,Sitater mottatt fra leverandører.
apps/erpnext/erpnext/controllers/selling_controller.py +22,To {0} | {1} {2},Til {0} | {1} {2}
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +40,Average Age,Gjennomsnittsalder
DocType: School Settings,Attendance Freeze Date,Deltagelsesfrysedato
DocType: School Settings,Attendance Freeze Date,Deltagelsesfrysedato
DocType: Opportunity,Your sales person who will contact the customer in future,Din selger som vil ta kontakt med kunden i fremtiden
apps/erpnext/erpnext/public/js/setup_wizard.js +275,List a few of your suppliers. They could be organizations or individuals.,Liste noen av dine leverandører. De kan være organisasjoner eller enkeltpersoner.
apps/erpnext/erpnext/templates/pages/home.html +31,View All Products,Se alle produkter
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +20,Minimum Lead Age (Days),Minimum levealder (dager)
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +20,Minimum Lead Age (Days),Minimum levealder (dager)
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +61,All BOMs,alle stykklister
DocType: Company,Default Currency,Standard Valuta
DocType: Expense Claim,From Employee,Fra Employee
apps/erpnext/erpnext/controllers/accounts_controller.py +420,Warning: System will not check overbilling since amount for Item {0} in {1} is zero,Advarsel: System vil ikke sjekke billing siden beløpet for varen {0} i {1} er null
DocType: Journal Entry,Make Difference Entry,Gjør forskjell Entry
DocType: Upload Attendance,Attendance From Date,Oppmøte Fra dato
DocType: Appraisal Template Goal,Key Performance Area,Key Performance-området
DocType: Program Enrollment,Transportation,Transport
apps/erpnext/erpnext/controllers/item_variant.py +92,Invalid Attribute,Ugyldig Egenskap
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +216,{0} {1} must be submitted,{0} {1} må sendes
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +146,Quantity must be less than or equal to {0},Antall må være mindre enn eller lik {0}
DocType: SMS Center,Total Characters,Totalt tegn
apps/erpnext/erpnext/controllers/buying_controller.py +157,Please select BOM in BOM field for Item {0},Vennligst velg BOM i BOM felt for Element {0}
DocType: C-Form Invoice Detail,C-Form Invoice Detail,C-Form Faktura Detalj
DocType: Payment Reconciliation Invoice,Payment Reconciliation Invoice,Betaling Avstemming Faktura
apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +42,Contribution %,Bidrag%
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +208,"As per the Buying Settings if Purchase Order Required == 'YES', then for creating Purchase Invoice, user need to create Purchase Order first for item {0}","I henhold til kjøpsinnstillingene hvis innkjøpsordre er påkrevd == &#39;JA&#39; og deretter for å opprette Kjøpfaktura, må brukeren opprette innkjøpsordre først for element {0}"
DocType: Company,Company registration numbers for your reference. Tax numbers etc.,Firmaregistreringsnumre som referanse. Skatte tall osv
DocType: Sales Partner,Distributor,Distributør
DocType: Shopping Cart Shipping Rule,Shopping Cart Shipping Rule,Handlevogn Shipping Rule
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +233,Production Order {0} must be cancelled before cancelling this Sales Order,Produksjonsordre {0} må avbestilles før den avbryter denne salgsordre
apps/erpnext/erpnext/public/js/controllers/transaction.js +67,Please set 'Apply Additional Discount On',Vennligst sett &#39;Apply Ytterligere rabatt på&#39;
,Ordered Items To Be Billed,Bestilte varer til å bli fakturert
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +46,From Range has to be less than To Range,Fra Range må være mindre enn til kolleksjonen
DocType: Global Defaults,Global Defaults,Global Defaults
apps/erpnext/erpnext/projects/doctype/project/project.py +210,Project Collaboration Invitation,Prosjekt Samarbeid Invitasjon
DocType: Salary Slip,Deductions,Fradrag
DocType: Leave Allocation,LAL/,LAL /
apps/erpnext/erpnext/public/js/financial_statements.js +75,Start Year,start-år
apps/erpnext/erpnext/regional/india/utils.py +24,First 2 digits of GSTIN should match with State number {0},De to første sifrene i GSTIN skal samsvare med statens nummer {0}
DocType: Purchase Invoice,Start date of current invoice's period,Startdato for nåværende fakturaperiode
DocType: Salary Slip,Leave Without Pay,La Uten Pay
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +346,Capacity Planning Error,Kapasitetsplanlegging Error
,Trial Balance for Party,Trial Balance for partiet
DocType: Lead,Consultant,Konsulent
DocType: Salary Slip,Earnings,Inntjeningen
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +391,Finished Item {0} must be entered for Manufacture type entry,Ferdig Element {0} må angis for Produksjon typen oppføring
apps/erpnext/erpnext/config/learn.py +87,Opening Accounting Balance,Åpning Regnskap Balanse
,GST Sales Register,GST salgsregistrering
DocType: Sales Invoice Advance,Sales Invoice Advance,Salg Faktura Advance
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +548,Nothing to request,Ingenting å be om
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +34,Another Budget record '{0}' already exists against {1} '{2}' for fiscal year {3},En annen Budsjett record &#39;{0} finnes allerede mot {1} {2} for regnskapsåret {3}
apps/erpnext/erpnext/projects/doctype/task/task.py +40,'Actual Start Date' can not be greater than 'Actual End Date',&#39;Faktisk startdato&#39; ikke kan være større enn &quot;Actual End Date &#39;
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +86,Management,Ledelse
DocType: Cheque Print Template,Payer Settings,Payer Innstillinger
DocType: Item Attribute Value,"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""","Dette vil bli lagt til Element Code of varianten. For eksempel, hvis din forkortelsen er &quot;SM&quot;, og elementet kode er &quot;T-SHIRT&quot;, elementet koden til variant vil være &quot;T-SHIRT-SM&quot;"
DocType: Salary Slip,Net Pay (in words) will be visible once you save the Salary Slip.,Nettolønn (i ord) vil være synlig når du lagrer Lønn Slip.
DocType: Purchase Invoice,Is Return,Er Return
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +772,Return / Debit Note,Retur / debitnota
DocType: Price List Country,Price List Country,Prisliste Land
DocType: Item,UOMs,UOMs
apps/erpnext/erpnext/stock/utils.py +205,{0} valid serial nos for Item {1},{0} gyldig serie nos for Element {1}
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +57,Item Code cannot be changed for Serial No.,Elementkode kan ikke endres for Serial No.
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +24,POS Profile {0} already created for user: {1} and company {2},POS profil {0} allerede opprettet for user: {1} og selskapet {2}
DocType: Sales Invoice Item,UOM Conversion Factor,Målenheter Omregningsfaktor
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +23,Please enter Item Code to get Batch Number,Fyll inn Element kode for å få Batch Number
DocType: Stock Settings,Default Item Group,Standard varegruppe
DocType: Employee Loan,Partially Disbursed,delvis Utbetalt
apps/erpnext/erpnext/config/buying.py +38,Supplier database.,Leverandør database.
DocType: Account,Balance Sheet,Balanse
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +684,Cost Center For Item with Item Code ',Koste Center For Element med Element kode &#39;
apps/erpnext/erpnext/accounts/page/pos/pos.js +2384,"Payment Mode is not configured. Please check, whether account has been set on Mode of Payments or on POS Profile.","Betaling Mode er ikke konfigurert. Kontroller, om kontoen er satt på modus for betalinger eller på POS-profil."
DocType: Opportunity,Your sales person will get a reminder on this date to contact the customer,Din selger vil få en påminnelse på denne datoen for å kontakte kunden
apps/erpnext/erpnext/buying/utils.py +74,Same item cannot be entered multiple times.,Samme elementet kan ikke legges inn flere ganger.
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +28,"Further accounts can be made under Groups, but entries can be made against non-Groups","Ytterligere kontoer kan gjøres under grupper, men oppføringene kan gjøres mot ikke-grupper"
DocType: Lead,Lead,Lead
DocType: Email Digest,Payables,Gjeld
DocType: Course,Course Intro,kurs Intro
apps/erpnext/erpnext/stock/doctype/batch/batch.js +85,Stock Entry {0} created,Stock Entry {0} er opprettet
apps/erpnext/erpnext/controllers/buying_controller.py +293,Row #{0}: Rejected Qty can not be entered in Purchase Return,Row # {0}: Avvist Antall kan ikke legges inn i innkjøpsliste
,Purchase Order Items To Be Billed,Purchase Order Elementer som skal faktureres
DocType: Purchase Invoice Item,Net Rate,Net Rate
DocType: Purchase Invoice Item,Purchase Invoice Item,Fakturaen Element
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +58,Stock Ledger Entries and GL Entries are reposted for the selected Purchase Receipts,Arkiv Ledger Oppføringer og GL Oppføringer repostes for de valgte Kjøps Receipts
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +8,Item 1,Sak 1
DocType: Holiday,Holiday,Ferie
DocType: Support Settings,Close Issue After Days,Lukk Issue Etter dager
DocType: Leave Control Panel,Leave blank if considered for all branches,La stå tom hvis vurderes for alle grener
DocType: Bank Guarantee,Validity in Days,Gyldighet i dager
DocType: Bank Guarantee,Validity in Days,Gyldighet i dager
apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +21,C-form is not applicable for Invoice: {0},C-skjemaet er ikke aktuelt for faktura: {0}
DocType: Payment Reconciliation,Unreconciled Payment Details,Avstemte Betalingsopplysninger
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +20,Order Count,Ordre Count
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +20,Order Count,Ordre Count
DocType: Global Defaults,Current Fiscal Year,Værende regnskapsår
DocType: Purchase Order,Group same items,Gruppe samme elementene
DocType: Global Defaults,Disable Rounded Total,Deaktiver Avrundet Total
DocType: Employee Loan Application,Repayment Info,tilbakebetaling info
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +448,'Entries' cannot be empty,&#39;Innlegg&#39; kan ikke være tomt
apps/erpnext/erpnext/utilities/transaction_base.py +81,Duplicate row {0} with same {1},Duplicate rad {0} med samme {1}
,Trial Balance,Balanse Trial
apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +432,Fiscal Year {0} not found,Regnskapsåret {0} ikke funnet
apps/erpnext/erpnext/config/hr.py +296,Setting up Employees,Sette opp ansatte
DocType: Sales Order,SO-,SÅ-
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +157,Please select prefix first,Vennligst velg først prefiks
DocType: Employee,O-,O-
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +158,Research,Forskning
DocType: Maintenance Visit Purpose,Work Done,Arbeidet Som Er Gjort
apps/erpnext/erpnext/controllers/item_variant.py +33,Please specify at least one attribute in the Attributes table,Vennligst oppgi minst ett attributt i Attributter tabellen
DocType: Announcement,All Students,alle studenter
apps/erpnext/erpnext/accounts/doctype/asset/asset.py +45,Item {0} must be a non-stock item,Element {0} må være et ikke-lagervare
apps/erpnext/erpnext/stock/doctype/batch/batch.js +18,View Ledger,Vis Ledger
DocType: Grading Scale,Intervals,intervaller
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41,Earliest,Tidligste
apps/erpnext/erpnext/stock/doctype/item/item.py +504,"An Item Group exists with same name, please change the item name or rename the item group","En varegruppe eksisterer med samme navn, må du endre elementnavnet eller endre navn varegruppen"
apps/erpnext/erpnext/schools/report/absent_student_report/absent_student_report.py +52,Student Mobile No.,Student Mobile No.
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +487,Rest Of The World,Resten Av Verden
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +81,The Item {0} cannot have Batch,Element {0} kan ikke ha Batch
,Budget Variance Report,Budsjett Avvik Rapporter
DocType: Salary Slip,Gross Pay,Brutto Lønn
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +114,Row {0}: Activity Type is mandatory.,Rad {0}: Aktivitetstype er obligatorisk.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +166,Dividends Paid,Utbytte betalt
apps/erpnext/erpnext/buying/doctype/supplier/supplier.js +36,Accounting Ledger,Regnskap Ledger
DocType: Stock Reconciliation,Difference Amount,Forskjellen Beløp
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +172,Retained Earnings,Opptjent egenkapital
DocType: Vehicle Log,Service Detail,tjenesten Detalj
DocType: BOM,Item Description,Element Beskrivelse
DocType: Student Sibling,Student Sibling,student Søsken
DocType: Purchase Invoice,Is Recurring,Er Recurring
DocType: Purchase Invoice,Supplied Items,Leveringen
DocType: Student,STUD.,STUD.
DocType: Production Order,Qty To Manufacture,Antall å produsere
DocType: Email Digest,New Income,New Inntekt
DocType: School Settings,School Settings,Skoleinnstillinger
DocType: School Settings,School Settings,Skoleinnstillinger
DocType: Buying Settings,Maintain same rate throughout purchase cycle,Opprettholde samme tempo gjennom hele kjøpssyklusen
DocType: Opportunity Item,Opportunity Item,Opportunity Element
,Student and Guardian Contact Details,Student og Guardian Kontaktdetaljer
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +39,Row {0}: For supplier {0} Email Address is required to send email,Rad {0}: For Leverandøren pålegges {0} e-postadresse for å sende e-post
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +72,Temporary Opening,Midlertidig Åpning
,Employee Leave Balance,Ansatt La Balance
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +147,Balance for Account {0} must always be {1},Balanse for konto {0} må alltid være {1}
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +178,Valuation Rate required for Item in row {0},Verdsettelse Rate kreves for varen i rad {0}
apps/erpnext/erpnext/public/js/setup_wizard.js +329,Example: Masters in Computer Science,Eksempel: Masters i informatikk
DocType: Purchase Invoice,Rejected Warehouse,Avvist Warehouse
DocType: GL Entry,Against Voucher,Mot Voucher
DocType: Item,Default Buying Cost Center,Standard Kjøpe kostnadssted
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +6,"To get the best out of ERPNext, we recommend that you take some time and watch these help videos.","For å få det beste ut av ERPNext, anbefaler vi at du tar litt tid og se på disse hjelpevideoer."
apps/erpnext/erpnext/accounts/page/pos/pos.js +72, to ,til
DocType: Supplier Quotation Item,Lead Time in days,Lead Tid i dager
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +58,Accounts Payable Summary,Leverandørgjeld Sammendrag
apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +326,Payment of salary from {0} to {1},Utbetaling av lønn fra {0} til {1}
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +213,Not authorized to edit frozen Account {0},Ikke autorisert til å redigere fryst kontoen {0}
DocType: Journal Entry,Get Outstanding Invoices,Få utestående fakturaer
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +70,Sales Order {0} is not valid,Salgsordre {0} er ikke gyldig
apps/erpnext/erpnext/utilities/activation.py +89,Purchase orders help you plan and follow up on your purchases,Innkjøpsordrer hjelpe deg å planlegge og følge opp kjøpene
apps/erpnext/erpnext/setup/doctype/company/company.py +225,"Sorry, companies cannot be merged","Sorry, kan selskapene ikke fusjoneres"
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +167,"The total Issue / Transfer quantity {0} in Material Request {1}  \
							cannot be greater than requested quantity {2} for Item {3}",Den totale Issue / Transfer mengde {0} i Material Request {1} \ kan ikke være større enn ønsket antall {2} for Element {3}
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +166,Small,Liten
DocType: Employee,Employee Number,Ansatt Number
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +65,Case No(s) already in use. Try from Case No {0},Tilfellet Nei (e) allerede er i bruk. Prøv fra sak nr {0}
DocType: Project,% Completed,% Fullført
,Invoiced Amount (Exculsive Tax),Fakturert beløp (exculsive Tax)
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +14,Item 2,Sak 2
DocType: Supplier,SUPP-,leve-
DocType: Training Event,Training Event,trening Hendelses
DocType: Item,Auto re-order,Auto re-order
apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.py +59,Total Achieved,Oppnådd Total
DocType: Employee,Place of Issue,Utstedelsessted
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +70,Contract,Kontrakts
DocType: Email Digest,Add Quote,Legg Sitat
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +868,UOM coversion factor required for UOM: {0} in Item: {1},Målenheter coversion faktor nødvendig for målenheter: {0} i Sak: {1}
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +92,Indirect Expenses,Indirekte kostnader
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +83,Row {0}: Qty is mandatory,Rad {0}: Antall er obligatorisk
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +8,Agriculture,Landbruk
apps/erpnext/erpnext/accounts/page/pos/pos.js +735,Sync Master Data,Sync Master Data
apps/erpnext/erpnext/public/js/setup_wizard.js +294,Your Products or Services,Dine produkter eller tjenester
DocType: Mode of Payment,Mode of Payment,Modus for betaling
apps/erpnext/erpnext/stock/doctype/item/item.py +177,Website Image should be a public file or website URL,Website Bilde bør være en offentlig fil eller nettside URL
DocType: Student Applicant,AP,AP
DocType: Purchase Invoice Item,BOM,BOM
apps/erpnext/erpnext/setup/doctype/item_group/item_group.js +37,This is a root item group and cannot be edited.,Dette er en rot varegruppe og kan ikke redigeres.
DocType: Journal Entry Account,Purchase Order,Bestilling
DocType: Vehicle,Fuel UOM,drivstoff målenheter
DocType: Warehouse,Warehouse Contact Info,Warehouse Kontaktinfo
DocType: Payment Entry,Write Off Difference Amount,Skriv Off differansebeløpet
DocType: Purchase Invoice,Recurring Type,Gjentakende Type
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +401,"{0}: Employee email not found, hence email not sent","{0}: Ansattes e-post ikke funnet, derav e-posten ikke sendt"
DocType: Item,Foreign Trade Details,Foreign Trade Detaljer
DocType: Email Digest,Annual Income,Årsinntekt
DocType: Serial No,Serial No Details,Serie ingen opplysninger
DocType: Purchase Invoice Item,Item Tax Rate,Sak Skattesats
DocType: Student Group Student,Group Roll Number,Gruppe-nummer
DocType: Student Group Student,Group Roll Number,Gruppe-nummer
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +145,"For {0}, only credit accounts can be linked against another debit entry",For {0} kan bare kredittkontoer kobles mot en annen belastning oppføring
apps/erpnext/erpnext/projects/doctype/project/project.py +73,Total of all task weights should be 1. Please adjust weights of all Project tasks accordingly,Summen av alle oppgave vekter bør være 1. Juster vekter av alle prosjektoppgaver tilsvar
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +566,Delivery Note {0} is not submitted,Levering Note {0} er ikke innsendt
apps/erpnext/erpnext/stock/get_item_details.py +151,Item {0} must be a Sub-contracted Item,Elementet {0} må være en underleverandør Element
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +43,Capital Equipments,Capital Equipments
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +33,"Pricing Rule is first selected based on 'Apply On' field, which can be Item, Item Group or Brand.","Prising Rule først valgt basert på &quot;Apply On-feltet, som kan være varen, varegruppe eller Brand."
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +215,Please set the Item Code first,Vennligst sett inn varenummeret først
DocType: Hub Settings,Seller Website,Selger Hjemmeside
DocType: Item,ITEM-,PUNKT-
apps/erpnext/erpnext/controllers/selling_controller.py +148,Total allocated percentage for sales team should be 100,Totalt bevilget prosent for salgsteam skal være 100
DocType: Appraisal Goal,Goal,Mål
DocType: Sales Invoice Item,Edit Description,Rediger Beskrivelse
,Team Updates,laget Oppdateringer
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +783,For Supplier,For Leverandør
DocType: Account,Setting Account Type helps in selecting this Account in transactions.,Stille Kontotype hjelper i å velge denne kontoen i transaksjoner.
DocType: Purchase Invoice,Grand Total (Company Currency),Grand Total (Selskap Valuta)
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +9,Create Print Format,Opprett Print Format
apps/erpnext/erpnext/utilities/bot.py +39,Did not find any item called {0},Fant ikke noe element som heter {0}
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +42,Total Outgoing,Total Utgående
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +47,"There can only be one Shipping Rule Condition with 0 or blank value for ""To Value""",Det kan bare være én Shipping Rule Forhold med 0 eller blank verdi for &quot;å verd&quot;
DocType: Authorization Rule,Transaction,Transaksjons
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +27,Note: This Cost Center is a Group. Cannot make accounting entries against groups.,Merk: Denne Cost Center er en gruppe. Kan ikke gjøre regnskapspostene mot grupper.
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +54,Child warehouse exists for this warehouse. You can not delete this warehouse.,Barn lager finnes for dette lageret. Du kan ikke slette dette lageret.
DocType: Item,Website Item Groups,Website varegrupper
DocType: Purchase Invoice,Total (Company Currency),Total (Company Valuta)
apps/erpnext/erpnext/stock/utils.py +200,Serial number {0} entered more than once,Serienummer {0} angitt mer enn én gang
DocType: Depreciation Schedule,Journal Entry,Journal Entry
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +140,{0} items in progress,{0} elementer i fremgang
DocType: Workstation,Workstation Name,Arbeidsstasjon Name
DocType: Grading Scale Interval,Grade Code,grade Kode
DocType: POS Item Group,POS Item Group,POS Varegruppe
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +17,Email Digest:,E-post Digest:
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +553,BOM {0} does not belong to Item {1},BOM {0} tilhører ikke Element {1}
DocType: Sales Partner,Target Distribution,Target Distribution
DocType: Salary Slip,Bank Account No.,Bank Account No.
DocType: Naming Series,This is the number of the last created transaction with this prefix,Dette er nummeret på den siste laget transaksjonen med dette prefikset
DocType: Quality Inspection Reading,Reading 8,Reading 8
DocType: Sales Partner,Agent,Agent
DocType: Purchase Invoice,Taxes and Charges Calculation,Skatter og avgifter Beregning
DocType: Accounts Settings,Book Asset Depreciation Entry Automatically,Bokføring av aktivavskrivninger automatisk
DocType: Accounts Settings,Book Asset Depreciation Entry Automatically,Bokføring av aktivavskrivninger automatisk
DocType: BOM Operation,Workstation,Arbeidsstasjon
DocType: Request for Quotation Supplier,Request for Quotation Supplier,Forespørsel om prisanslag Leverandør
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +123,Hardware,Hardware
DocType: Sales Order,Recurring Upto,Tilbakevendende Opp
DocType: Attendance,HR Manager,HR Manager
apps/erpnext/erpnext/accounts/party.py +173,Please select a Company,Vennligst velg et selskap
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +61,Privilege Leave,Privilege La
DocType: Purchase Invoice,Supplier Invoice Date,Leverandør Fakturadato
apps/erpnext/erpnext/templates/includes/product_page.js +18,per,per
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +90,You need to enable Shopping Cart,Du må aktivere Handlevogn
DocType: Payment Entry,Writeoff,writeoff
DocType: Appraisal Template Goal,Appraisal Template Goal,Appraisal Mal Goal
DocType: Salary Component,Earning,Tjene
DocType: Purchase Invoice,Party Account Currency,Partiet konto Valuta
,BOM Browser,BOM Nettleser
DocType: Purchase Taxes and Charges,Add or Deduct,Legge til eller trekke fra
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +80,Overlapping conditions found between:,Overlappende vilkår funnet mellom:
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +187,Against Journal Entry {0} is already adjusted against some other voucher,Mot Journal Entry {0} er allerede justert mot en annen kupong
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +68,Total Order Value,Total ordreverdi
apps/erpnext/erpnext/demo/setup/setup_data.py +324,Food,Mat
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +51,Ageing Range 3,Aldring Range 3
DocType: Maintenance Schedule Item,No of Visits,Ingen av besøk
apps/erpnext/erpnext/schools/doctype/student_attendance_tool/student_attendance_tool.js +112,Mark Attendence,Mark frammøte
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +165,Maintenance Schedule {0} exists against {1},Vedlikeholdsplan {0} eksisterer mot {1}
apps/erpnext/erpnext/schools/doctype/student_applicant/student_applicant.js +32,Enrolling student,påmelding student
apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +33,Currency of the Closing Account must be {0},Valuta ifølge kursen konto må være {0}
apps/erpnext/erpnext/hr/doctype/appraisal_template/appraisal_template.py +21,Sum of points for all goals should be 100. It is {0},Summen av poeng for alle mål bør være 100. Det er {0}
DocType: Project,Start and End Dates,Start- og sluttdato
,Delivered Items To Be Billed,Leverte varer til å bli fakturert
apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html +16,Open BOM {0},Åpen BOM {0}
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +60,Warehouse cannot be changed for Serial No.,Warehouse kan ikke endres for Serial No.
DocType: Authorization Rule,Average Discount,Gjennomsnittlig Rabatt
DocType: Purchase Invoice Item,UOM,målenheter
DocType: Rename Tool,Utilities,Verktøy
DocType: Purchase Invoice Item,Accounting,Regnskap
DocType: Employee,EMP/,EMP /
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +107,Please select batches for batched item ,Vennligst velg batch for batched item
DocType: Asset,Depreciation Schedules,avskrivninger tidsplaner
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +89,Application period cannot be outside leave allocation period,Tegningsperioden kan ikke være utenfor permisjon tildeling periode
DocType: Activity Cost,Projects,Prosjekter
DocType: Payment Request,Transaction Currency,transaksjonsvaluta
apps/erpnext/erpnext/controllers/buying_controller.py +25,From {0} | {1} {2},Fra {0} | {1} {2}
DocType: Production Order Operation,Operation Description,Operasjon Beskrivelse
DocType: Item,Will also apply to variants,Vil også gjelde for varianter
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +34,Cannot change Fiscal Year Start Date and Fiscal Year End Date once the Fiscal Year is saved.,Kan ikke endre regnskapsåret Startdato og regnskapsår sluttdato når regnskapsåret er lagret.
DocType: Quotation,Shopping Cart,Handlevogn
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +42,Avg Daily Outgoing,Gjennomsnittlig Daily Utgående
DocType: POS Profile,Campaign,Kampanje
DocType: Supplier,Name and Type,Navn og Type
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +60,Approval Status must be 'Approved' or 'Rejected',Godkjenningsstatus må være &quot;Godkjent&quot; eller &quot;Avvist&quot;
DocType: Purchase Invoice,Contact Person,Kontaktperson
apps/erpnext/erpnext/projects/doctype/task/task.py +37,'Expected Start Date' can not be greater than 'Expected End Date',&#39;Tiltredelse&#39; ikke kan være større enn &quot;Forventet sluttdato
DocType: Course Scheduling Tool,Course End Date,Kurs Sluttdato
DocType: Holiday List,Holidays,Ferier
DocType: Sales Order Item,Planned Quantity,Planlagt Antall
DocType: Purchase Invoice Item,Item Tax Amount,Sak Skattebeløp
DocType: Item,Maintain Stock,Oppretthold Stock
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +212,Stock Entries already created for Production Order ,Arkiv Innlegg allerede opprettet for produksjonsordre
DocType: Employee,Prefered Email,foretrukne e-post
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +33,Net Change in Fixed Asset,Netto endring i Fixed Asset
DocType: Leave Control Panel,Leave blank if considered for all designations,La stå tom hvis vurderes for alle betegnelser
apps/erpnext/erpnext/controllers/accounts_controller.py +676,Charge of type 'Actual' in row {0} cannot be included in Item Rate,Charge of type &#39;Actual&#39; i rad {0} kan ikke inkluderes i Element Ranger
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +350,Max: {0},Max: {0}
apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py +24,From Datetime,Fra Datetime
DocType: Email Digest,For Company,For selskapet
apps/erpnext/erpnext/config/support.py +17,Communication log.,Kommunikasjonsloggen.
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +151,"Request for Quotation is disabled to access from portal, for more check portal settings.",Forespørsel om prisanslag er deaktivert tilgang fra portal for flere sjekkportalinnstillingene.
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +74,Buying Amount,Kjøpe Beløp
DocType: Sales Invoice,Shipping Address Name,Leveringsadresse Navn
apps/erpnext/erpnext/accounts/doctype/account/account.js +58,Chart of Accounts,Konto
DocType: Material Request,Terms and Conditions Content,Betingelser innhold
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +555,cannot be greater than 100,kan ikke være større enn 100
apps/erpnext/erpnext/stock/doctype/item/item.py +683,Item {0} is not a stock Item,Element {0} er ikke en lagervare
DocType: Maintenance Visit,Unscheduled,Ikke planlagt
DocType: Employee,Owned,Eies
DocType: Salary Detail,Depends on Leave Without Pay,Avhenger La Uten Pay
DocType: Pricing Rule,"Higher the number, higher the priority","Høyere tallet er, høyere prioritet"
,Purchase Invoice Trends,Fakturaen Trender
DocType: Employee,Better Prospects,Bedre utsikter
apps/erpnext/erpnext/stock/doctype/batch/batch.py +114,"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} har bare {2} antall. Vennligst velg en annen batch som har {3} antall tilgjengelig eller del opp raden i flere rader for å levere / utføre fra flere batcher
DocType: Vehicle,License Plate,Bilskilt
DocType: Appraisal,Goals,Mål
DocType: Warranty Claim,Warranty / AMC Status,Garanti / AMC Status
,Accounts Browser,Kontoer Browser
DocType: Payment Entry Reference,Payment Entry Reference,Betaling Entry Reference
DocType: GL Entry,GL Entry,GL Entry
DocType: HR Settings,Employee Settings,Medarbeider Innstillinger
,Batch-Wise Balance History,Batch-Wise Balance Historie
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +73,Print settings updated in respective print format,Utskriftsinnstillingene oppdatert i respektive utskriftsformat
DocType: Package Code,Package Code,pakke kode
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +74,Apprentice,Lærling
DocType: Purchase Invoice,Company GSTIN,Firma GSTIN
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +103,Negative Quantity is not allowed,Negative Antall er ikke tillatt
DocType: Purchase Invoice Item,"Tax detail table fetched from item master as a string and stored in this field.
Used for Taxes and Charges","Tax detalj tabell hentet fra elementet Hoved som en streng, og som er lagret på dette feltet. Brukes for skatter og avgifter"
apps/erpnext/erpnext/hr/doctype/employee/employee.py +154,Employee cannot report to himself.,Arbeidstaker kan ikke rapportere til seg selv.
DocType: Account,"If the account is frozen, entries are allowed to restricted users.","Hvis kontoen er fryst, er oppføringer lov til begrensede brukere."
DocType: Email Digest,Bank Balance,Bank Balanse
apps/erpnext/erpnext/accounts/party.py +236,Accounting Entry for {0}: {1} can only be made in currency: {2},Regnskap Entry for {0}: {1} kan bare gjøres i valuta: {2}
DocType: Job Opening,"Job profile, qualifications required etc.","Jobb profil, kvalifikasjoner som kreves etc."
DocType: Journal Entry Account,Account Balance,Saldo
apps/erpnext/erpnext/config/accounts.py +185,Tax Rule for transactions.,Skatteregel for transaksjoner.
DocType: Rename Tool,Type of document to rename.,Type dokument for å endre navn.
apps/erpnext/erpnext/public/js/setup_wizard.js +314,We buy this Item,Vi kjøper denne varen
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +53,{0} {1}: Customer is required against Receivable account {2},{0} {1}: Kunden er nødvendig mot fordringer kontoen {2}
DocType: Purchase Invoice,Total Taxes and Charges (Company Currency),Totale skatter og avgifter (Selskapet valuta)
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +60,Show unclosed fiscal year's P&L balances,Vis unclosed regnskapsårets P &amp; L balanserer
DocType: Shipping Rule,Shipping Account,Shipping konto
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +92,{0} {1}: Account {2} is inactive,{0} {1}: Account {2} er inaktiv
apps/erpnext/erpnext/utilities/activation.py +80,Make Sales Orders to help you plan your work and deliver on-time,Gjør salgsordrer for å hjelpe deg med å planlegge arbeidet ditt og levere i tide
DocType: Quality Inspection,Readings,Readings
DocType: Stock Entry,Total Additional Costs,Samlede merkostnader
DocType: Course Schedule,SH,SH
DocType: BOM,Scrap Material Cost(Company Currency),Skrap Material Cost (Selskap Valuta)
apps/erpnext/erpnext/public/js/setup_wizard.js +305,Sub Assemblies,Sub Assemblies
DocType: Asset,Asset Name,Asset Name
DocType: Project,Task Weight,Task Vekt
DocType: Shipping Rule Condition,To Value,I Value
DocType: Asset Movement,Stock Manager,Stock manager
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +144,Source warehouse is mandatory for row {0},Kilde lageret er obligatorisk for rad {0}
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +792,Packing Slip,Pakkseddel
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +110,Office Rent,Kontor Leie
apps/erpnext/erpnext/config/setup.py +111,Setup SMS gateway settings,Oppsett SMS gateway-innstillinger
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +60,Import Failed!,Import mislyktes!
apps/erpnext/erpnext/public/js/templates/address_list.html +20,No address added yet.,Ingen adresse er lagt til ennå.
DocType: Workstation Working Hour,Workstation Working Hour,Arbeidsstasjon Working Hour
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +94,Analyst,Analytiker
DocType: Item,Inventory,Inventar
DocType: Item,Sales Details,Salgs Detaljer
DocType: Quality Inspection,QI-,QI-
DocType: Opportunity,With Items,Med Items
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37,In Qty,I Antall
DocType: School Settings,Validate Enrolled Course for Students in Student Group,Bekreft innmeldt kurs for studenter i studentgruppen
DocType: Notification Control,Expense Claim Rejected,Expense krav Avvist
DocType: Item,Item Attribute,Sak Egenskap
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +116,Government,Regjeringen
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +40,Expense Claim {0} already exists for the Vehicle Log,Expense krav {0} finnes allerede for Vehicle Log
apps/erpnext/erpnext/public/js/setup_wizard.js +54,Institute Name,Institute Name
apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +117,Please enter repayment Amount,Fyll inn gjenværende beløpet
apps/erpnext/erpnext/config/stock.py +300,Item Variants,Element Varianter
DocType: Company,Services,Tjenester
DocType: HR Settings,Email Salary Slip to Employee,E-post Lønn Slip til Employee
DocType: Cost Center,Parent Cost Center,Parent kostnadssted
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +877,Select Possible Supplier,Velg Mulig Leverandør
DocType: Sales Invoice,Source,Source
apps/erpnext/erpnext/templates/pages/projects.html +31,Show closed,Vis stengt
DocType: Leave Type,Is Leave Without Pay,Er permisjon uten Pay
apps/erpnext/erpnext/stock/doctype/item/item.py +235,Asset Category is mandatory for Fixed Asset item,Asset Kategori er obligatorisk for Fixed Asset element
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +145,No records found in the Payment table,Ingen poster ble funnet i Payment tabellen
apps/erpnext/erpnext/schools/utils.py +19,This {0} conflicts with {1} for {2} {3},Denne {0} konflikter med {1} for {2} {3}
DocType: Student Attendance Tool,Students HTML,studenter HTML
DocType: POS Profile,Apply Discount,Bruk rabatt
DocType: GST HSN Code,GST HSN Code,GST HSN-kode
DocType: Employee External Work History,Total Experience,Total Experience
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +70,Open Projects,åpne Prosjekter
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +286,Packing Slip(s) cancelled,Pakking Slip (s) kansellert
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +31,Cash Flow from Investing,Kontantstrøm fra investerings
DocType: Program Course,Program Course,program Course
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +99,Freight and Forwarding Charges,Spedisjons- og Kostnader
DocType: Homepage,Company Tagline for website homepage,Selskapet Undertittel for nettstedet hjemmeside
DocType: Item Group,Item Group Name,Sak Gruppenavn
apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py +27,Taken,Tatt
DocType: Student,Date of Leaving,Dato Leaving
DocType: Pricing Rule,For Price List,For Prisliste
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +27,Executive Search,Executive Search
apps/erpnext/erpnext/utilities/activation.py +61,Create Leads,Lag Leads
DocType: Maintenance Schedule,Schedules,Rutetider
DocType: Purchase Invoice Item,Net Amount,Nettobeløp
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +143,{0} {1} has not been submitted so the action cannot be completed,"{0} {1} er ikke sendt, så handlingen kan ikke fullføres"
DocType: Purchase Order Item Supplied,BOM Detail No,BOM Detail Nei
DocType: Landed Cost Voucher,Additional Charges,Ekstra kostnader
DocType: Purchase Invoice,Additional Discount Amount (Company Currency),Ekstra rabatt Beløp (Selskap Valuta)
apps/erpnext/erpnext/accounts/doctype/account/account.js +21,Please create new account from Chart of Accounts.,Opprett ny konto fra kontoplanen.
,Support Hour Distribution,Support Time Distribution
DocType: Maintenance Visit,Maintenance Visit,Vedlikehold Visit
DocType: Student,Leaving Certificate Number,Leaving Certificate Number
DocType: Sales Invoice Item,Available Batch Qty at Warehouse,Tilgjengelig Batch Antall på Warehouse
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +9,Update Print Format,Oppdater Print Format
DocType: Landed Cost Voucher,Landed Cost Help,Landed Cost Hjelp
DocType: Purchase Invoice,Select Shipping Address,Velg leveringsadresse
DocType: Leave Block List,Block Holidays on important days.,Block Ferie på viktige dager.
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js +71,Accounts Receivable Summary,Kundefordringer Sammendrag
DocType: Employee Loan,Monthly Repayment Amount,Månedlig nedbetaling beløpet
apps/erpnext/erpnext/hr/doctype/employee/employee.py +191,Please set User ID field in an Employee record to set Employee Role,Vennligst angi bruker-ID-feltet i en Employee rekord å sette Employee Rolle
DocType: UOM,UOM Name,Målenheter Name
DocType: GST HSN Code,HSN Code,HSN kode
apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +43,Contribution Amount,Bidrag Beløp
DocType: Purchase Invoice,Shipping Address,Sendingsadresse
DocType: Stock Reconciliation,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.,Dette verktøyet hjelper deg til å oppdatere eller fikse mengde og verdsetting av aksjer i systemet. Det er vanligvis brukes til å synkronisere systemverdier og hva som faktisk eksisterer i ditt varehus.
DocType: Delivery Note,In Words will be visible once you save the Delivery Note.,I Ord vil være synlig når du lagrer følgeseddel.
DocType: Expense Claim,EXP,EXP
apps/erpnext/erpnext/config/stock.py +200,Brand master.,Brand mester.
apps/erpnext/erpnext/schools/utils.py +50,Student {0} - {1} appears Multiple times in row {2} & {3},Student {0} - {1} vises flere ganger på rad {2} og {3}
DocType: Program Enrollment Tool,Program Enrollments,program~~POS=TRUNC påmeldinger
DocType: Sales Invoice Item,Brand Name,Merkenavn
DocType: Purchase Receipt,Transporter Details,Transporter Detaljer
apps/erpnext/erpnext/accounts/page/pos/pos.js +2568,Default warehouse is required for selected item,Standardlager er nødvendig til den valgte artikkelen
apps/erpnext/erpnext/public/js/setup_wizard.js +308,Box,Eske
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +874,Possible Supplier,mulig Leverandør
DocType: Budget,Monthly Distribution,Månedlig Distribution
apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +68,Receiver List is empty. Please create Receiver List,Mottaker-listen er tom. Opprett Receiver Liste
DocType: Production Plan Sales Order,Production Plan Sales Order,Produksjonsplan Salgsordre
DocType: Sales Partner,Sales Partner Target,Sales Partner Target
DocType: Loan Type,Maximum Loan Amount,Maksimal Lånebeløp
DocType: Pricing Rule,Pricing Rule,Prising Rule
apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +53,Duplicate roll number for student {0},Dupliseringsnummer for student {0}
apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +53,Duplicate roll number for student {0},Dupliseringsnummer for student {0}
DocType: Budget,Action if Annual Budget Exceeded,Tiltak hvis Årlig budsjett Skredet
apps/erpnext/erpnext/config/learn.py +197,Material Request to Purchase Order,Materialet Request til innkjøpsordre
DocType: Shopping Cart Settings,Payment Success URL,Betaling Suksess URL
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +80,Row # {0}: Returned Item {1} does not exists in {2} {3},Row # {0}: Returned Element {1} ikke eksisterer i {2} {3}
DocType: Purchase Receipt,PREC-,PREC-
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +16,Bank Accounts,Bankkontoer
,Bank Reconciliation Statement,Bankavstemming Statement
,Lead Name,Lead Name
,POS,POS
DocType: C-Form,III,III
apps/erpnext/erpnext/config/stock.py +305,Opening Stock Balance,Åpning Stock Balance
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +58,{0} must appear only once,{0} må vises bare en gang
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +368,Not allowed to tranfer more {0} than {1} against Purchase Order {2},Ikke lov til å overfør mer {0} enn {1} mot innkjøpsordre {2}
apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +59,Leaves Allocated Successfully for {0},Etterlater Avsatt Vellykket for {0}
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +40,No Items to pack,Ingenting å pakke
DocType: Shipping Rule Condition,From Value,Fra Verdi
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +555,Manufacturing Quantity is mandatory,Manufacturing Antall er obligatorisk
DocType: Employee Loan,Repayment Method,tilbakebetaling Method
DocType: Products Settings,"If checked, the Home page will be the default Item Group for the website","Hvis det er merket, vil hjemmesiden være standard Varegruppe for nettstedet"
DocType: Quality Inspection Reading,Reading 4,Reading 4
apps/erpnext/erpnext/config/hr.py +127,Claims for company expense.,Krav på bekostning av selskapet.
apps/erpnext/erpnext/utilities/activation.py +116,"Students are at the heart of the system, add all your students","Studentene er i hjertet av systemet, legge til alle elevene"
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +81,Row #{0}: Clearance date {1} cannot be before Cheque Date {2},Row # {0}: Clearance date {1} kan ikke være før Cheque Dato {2}
DocType: Company,Default Holiday List,Standard Holiday List
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +186,Row {0}: From Time and To Time of {1} is overlapping with {2},Rad {0}: Fra tid og klokkeslett {1} er overlappende med {2}
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +145,Stock Liabilities,Aksje Gjeld
DocType: Purchase Invoice,Supplier Warehouse,Leverandør Warehouse
DocType: Opportunity,Contact Mobile No,Kontakt Mobile No
,Material Requests for which Supplier Quotations are not created,Materielle Forespørsler som Leverandør Sitater ikke er opprettet
DocType: Student Group,Set 0 for no limit,Sett 0 for ingen begrensning
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +141,The day(s) on which you are applying for leave are holidays. You need not apply for leave.,Dagen (e) der du søker om permisjon er helligdager. Du trenger ikke søke om permisjon.
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +20,Resend Payment Email,Sende Betaling Email
apps/erpnext/erpnext/templates/pages/projects.html +27,New task,Ny oppgave
apps/erpnext/erpnext/utilities/activation.py +72,Make Quotation,Gjør sitat
apps/erpnext/erpnext/config/selling.py +216,Other Reports,andre rapporter
DocType: Dependent Task,Dependent Task,Avhengig Task
apps/erpnext/erpnext/stock/doctype/item/item.py +401,Conversion factor for default Unit of Measure must be 1 in row {0},Omregningsfaktor for standard Enhet må være en i rad {0}
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +208,Leave of type {0} cannot be longer than {1},Permisjon av typen {0} kan ikke være lengre enn {1}
DocType: Manufacturing Settings,Try planning operations for X days in advance.,Prøv å planlegge operasjoner for X dager i forveien.
DocType: HR Settings,Stop Birthday Reminders,Stop bursdagspåminnelser
apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +250,Please set Default Payroll Payable Account in Company {0},Vennligst sette Standard Lønn betales konto i selskapet {0}
DocType: SMS Center,Receiver List,Mottaker List
apps/erpnext/erpnext/accounts/page/pos/pos.js +1059,Search Item,Søk Element
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +46,Consumed Amount,Forbrukes Beløp
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +98,Net Change in Cash,Netto endring i kontanter
DocType: Assessment Plan,Grading Scale,Grading Scale
apps/erpnext/erpnext/stock/doctype/item/item.py +396,Unit of Measure {0} has been entered more than once in Conversion Factor Table,Enhet {0} har blitt lagt inn mer enn én gang i omregningsfaktor tabell
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +603,Already completed,allerede fullført
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +33,Stock In Hand,Lager i hånd
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +28,Payment Request already exists {0},Betaling Request allerede eksisterer {0}
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +27,Cost of Issued Items,Cost of Utstedte Items
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +353,Quantity must not be more than {0},Antall må ikke være mer enn {0}
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +117,Previous Financial Year is not closed,Foregående regnskapsår er ikke stengt
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +46,Age (Days),Alder (dager)
DocType: Quotation Item,Quotation Item,Sitat Element
DocType: Customer,Customer POS Id,Kundens POS-ID
DocType: Account,Account Name,Brukernavn
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +40,From Date cannot be greater than To Date,Fra dato ikke kan være større enn To Date
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +198,Serial No {0} quantity {1} cannot be a fraction,Serial No {0} mengde {1} kan ikke være en brøkdel
apps/erpnext/erpnext/config/buying.py +43,Supplier Type master.,Leverandør Type mester.
DocType: Purchase Order Item,Supplier Part Number,Leverandør delenummer
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +101,Conversion rate cannot be 0 or 1,Konverteringsfrekvens kan ikke være 0 eller 1
DocType: Sales Invoice,Reference Document,Reference Document
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +213,{0} {1} is cancelled or stopped,{0} {1} avbrytes eller stoppes
DocType: Accounts Settings,Credit Controller,Credit Controller
DocType: Sales Order,Final Delivery Date,Endelig Leveringsdato
DocType: Delivery Note,Vehicle Dispatch Date,Vehicle Publiseringsdato
DocType: Purchase Invoice Item,HSN/SAC,HSN / SAC
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +230,Purchase Receipt {0} is not submitted,Kvitteringen {0} er ikke innsendt
DocType: Company,Default Payable Account,Standard Betales konto
apps/erpnext/erpnext/config/website.py +17,"Settings for online shopping cart such as shipping rules, price list etc.","Innstillinger for online shopping cart som skipsregler, prisliste etc."
apps/erpnext/erpnext/controllers/website_list_for_contact.py +86,{0}% Billed,{0}% Fakturert
apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +18,Reserved Qty,Reservert Antall
DocType: Party Account,Party Account,Partiet konto
apps/erpnext/erpnext/config/setup.py +122,Human Resources,Menneskelige Ressurser
DocType: Lead,Upper Income,Øvre Inntekt
apps/erpnext/erpnext/schools/doctype/student_applicant/student_applicant.js +13,Reject,Avvis
DocType: Journal Entry Account,Debit in Company Currency,Debet i selskapet Valuta
DocType: BOM Item,BOM Item,BOM Element
DocType: Appraisal,For Employee,For Employee
apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.js +41,Make Disbursement Entry,Gjør Utbetaling Entry
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +138,Row {0}: Advance against Supplier must be debit,Rad {0}: Advance mot Leverandøren skal belaste
DocType: Company,Default Values,Standardverdier
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +61,{frequency} Digest,{Frequency} Digest
DocType: Expense Claim,Total Amount Reimbursed,Totalbeløp Refusjon
apps/erpnext/erpnext/hr/doctype/vehicle/vehicle_dashboard.py +5,This is based on logs against this Vehicle. See timeline below for details,Dette er basert på loggene mot denne bilen. Se tidslinjen nedenfor for detaljer
apps/erpnext/erpnext/schools/doctype/fees/fees.js +41,Collect,Samle inn
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +83,Against Supplier Invoice {0} dated {1},Mot Leverandør Faktura {0} datert {1}
DocType: Customer,Default Price List,Standard Prisliste
apps/erpnext/erpnext/accounts/doctype/asset/asset.py +243,Asset Movement record {0} created,Asset Movement rekord {0} er opprettet
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +51,You cannot delete Fiscal Year {0}. Fiscal Year {0} is set as default in Global Settings,Du kan ikke slette regnskapsår {0}. Regnskapsåret {0} er satt som standard i Globale innstillinger
DocType: Journal Entry,Entry Type,Entry Type
apps/erpnext/erpnext/schools/report/course_wise_assessment_report/course_wise_assessment_report.py +44,No assessment plan linked with this assessment group,Ingen vurderingsplan knyttet til denne vurderingsgruppen
,Customer Credit Balance,Customer Credit Balance
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +23,Net Change in Accounts Payable,Netto endring i leverandørgjeld
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +42,Customer required for 'Customerwise Discount',Kunden nødvendig for &#39;Customerwise Discount&#39;
apps/erpnext/erpnext/config/accounts.py +142,Update bank payment dates with journals.,Oppdatere bankbetalings datoer med tidsskrifter.
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +21,Pricing,Priser
DocType: Quotation,Term Details,Term Detaljer
DocType: Project,Total Sales Cost (via Sales Order),Total salgspris (via salgsordre)
apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +29,Cannot enroll more than {0} students for this student group.,Kan ikke registrere mer enn {0} studentene på denne studentgruppen.
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +17,Lead Count,Lead Count
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +17,Lead Count,Lead Count
apps/erpnext/erpnext/accounts/doctype/asset_category/asset_category.py +15,{0} must be greater than 0,{0} må være større enn 0
DocType: Manufacturing Settings,Capacity Planning For (Days),Kapasitetsplanlegging For (dager)
apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py +10,Procurement,innkjøp
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +64,None of the items have any change in quantity or value.,Ingen av elementene har noen endring i mengde eller verdi.
apps/erpnext/erpnext/schools/doctype/program_enrollment_tool/program_enrollment_tool.py +16,Mandatory field - Program,Obligatorisk felt - Program
apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.js +46,Warranty Claim,Garantikrav
,Lead Details,Lead Detaljer
DocType: Salary Slip,Loan repayment,lån tilbakebetaling
DocType: Purchase Invoice,End date of current invoice's period,Sluttdato for gjeldende faktura periode
DocType: Pricing Rule,Applicable For,Aktuelt For
DocType: Accounts Settings,Unlink Payment on Cancellation of Invoice,Oppheve koblingen Betaling ved kansellering av faktura
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +16,Current Odometer reading entered should be greater than initial Vehicle Odometer {0},Nåværende Kilometerstand inngått bør være større enn første Vehicle Teller {0}
DocType: Shipping Rule Country,Shipping Rule Country,Shipping Rule Land
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +10,Leave and Attendance,La og oppmøte
DocType: Maintenance Visit,Partially Completed,Delvis Fullført
DocType: Leave Type,Include holidays within leaves as leaves,Inkluder hellig innen blader som løv
DocType: Sales Invoice,Packed Items,Lunsj Items
apps/erpnext/erpnext/config/support.py +27,Warranty Claim against Serial No.,Garantikrav mot Serial No.
DocType: BOM Replace 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","Erstatte en bestemt BOM i alle andre stykklister der det brukes. Det vil erstatte den gamle BOM link, oppdatere kostnader og regenerere &quot;BOM Explosion Item&quot; bord som per ny BOM"
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +61,'Total',&#39;Total&#39;
DocType: Shopping Cart Settings,Enable Shopping Cart,Aktiver Handlevogn
DocType: Employee,Permanent Address,Permanent Adresse
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +260,"Advance paid against {0} {1} cannot be greater \
						than Grand Total {2}",Advance betalt mot {0} {1} kan ikke være større \ enn Totalsum {2}
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +147,Please select item code,Velg elementet kode
DocType: Student Sibling,Studying in Same Institute,Å studere i samme institutt
DocType: Territory,Territory Manager,Distriktssjef
DocType: Packed Item,To Warehouse (Optional),Til Warehouse (valgfritt)
DocType: Payment Entry,Paid Amount (Company Currency),Innbetalt beløp (Company Valuta)
DocType: Purchase Invoice,Additional Discount,Ekstra rabatt
DocType: Selling Settings,Selling Settings,Selge Innstillinger
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +39,Online Auctions,Online auksjoner
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +98,Please specify either Quantity or Valuation Rate or both,Vennligst oppgi enten Mengde eller Verdivurdering Rate eller begge deler
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order_dashboard.py +17,Fulfillment,Oppfyllelse
apps/erpnext/erpnext/templates/generators/item.html +67,View in Cart,Vis i handlekurven
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +103,Marketing Expenses,Markedsføringskostnader
,Item Shortage Report,Sak Mangel Rapporter
apps/erpnext/erpnext/stock/doctype/item/item.js +265,"Weight is mentioned,\nPlease mention ""Weight UOM"" too","Vekt er nevnt, \ nVennligst nevne &quot;Weight målenheter&quot; også"
DocType: Stock Entry Detail,Material Request used to make this Stock Entry,Materialet Request brukes til å gjøre dette lager Entry
apps/erpnext/erpnext/accounts/doctype/asset/asset.py +68,Next Depreciation Date is mandatory for new asset,Neste Avskrivninger dato er obligatorisk for ny aktiva
DocType: Student Group Creation Tool,Separate course based Group for every Batch,Separat kursbasert gruppe for hver batch
DocType: Student Group Creation Tool,Separate course based Group for every Batch,Separat kursbasert gruppe for hver batch
apps/erpnext/erpnext/config/support.py +32,Single unit of an Item.,Enkelt enhet av et element.
DocType: Fee Category,Fee Category,Fee Kategori
,Student Fee Collection,Student Fee Collection
DocType: Accounts Settings,Make Accounting Entry For Every Stock Movement,Gjør regnskap Entry For Hver Stock Movement
DocType: Leave Allocation,Total Leaves Allocated,Totalt Leaves Avsatt
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +156,Warehouse required at Row No {0},Warehouse kreves ved Row Nei {0}
apps/erpnext/erpnext/public/js/setup_wizard.js +122,Please enter valid Financial Year Start and End Dates,Fyll inn gyldig Regnskapsår start- og sluttdato
DocType: Employee,Date Of Retirement,Pensjoneringstidspunktet
DocType: Upload Attendance,Get Template,Få Mal
DocType: Material Request,Transferred,overført
DocType: Vehicle,Doors,dører
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +206,ERPNext Setup Complete!,ERPNext Setup Complete!
DocType: Course Assessment Criteria,Weightage,Weightage
DocType: Purchase Invoice,Tax Breakup,Skatteavbrudd
DocType: Packing Slip,PS-,PS
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +67,{0} {1}: Cost Center is required for 'Profit and Loss' account {2}. Please set up a default Cost Center for the Company.,{0} {1}: Det kreves kostnadssted for &#39;resultat&#39; konto {2}. Sett opp en standardkostnadssted for selskapet.
apps/erpnext/erpnext/selling/doctype/customer/customer.py +115,A Customer Group exists with same name please change the Customer name or rename the Customer Group,En kundegruppe eksisterer med samme navn kan du endre Kundens navn eller endre navn på Kundegruppe
apps/erpnext/erpnext/public/js/templates/contact_list.html +37,New Contact,Ny kontakt
DocType: Territory,Parent Territory,Parent Territory
DocType: Quality Inspection Reading,Reading 2,Reading 2
DocType: Stock Entry,Material Receipt,Materialet Kvittering
DocType: Homepage,Products,Produkter
DocType: Announcement,Instructor,Instruktør
DocType: Employee,AB+,AB +
DocType: Item,"If this item has variants, then it cannot be selected in sales orders etc.","Hvis dette elementet har varianter, så det kan ikke velges i salgsordrer etc."
DocType: Lead,Next Contact By,Neste Kontakt Av
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +282,Quantity required for Item {0} in row {1},Mengden som kreves for Element {0} i rad {1}
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +46,Warehouse {0} can not be deleted as quantity exists for Item {1},Warehouse {0} kan ikke slettes som kvantitet finnes for Element {1}
DocType: Quotation,Order Type,Ordretype
DocType: Purchase Invoice,Notification Email Address,Varsling e-postadresse
,Item-wise Sales Register,Element-messig Sales Register
DocType: Asset,Gross Purchase Amount,Bruttobeløpet
DocType: Asset,Depreciation Method,avskrivningsmetode
apps/erpnext/erpnext/accounts/page/pos/pos.js +698,Offline,offline
DocType: Purchase Taxes and Charges,Is this Tax included in Basic Rate?,Er dette inklusiv i Basic Rate?
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +56,Total Target,Total Target
DocType: Job Applicant,Applicant for a Job,Kandidat til en jobb
DocType: Production Plan Material Request,Production Plan Material Request,Produksjonsplan Material Request
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +235,No Production Orders created,Ingen produksjonsordrer som er opprettet
DocType: Stock Reconciliation,Reconciliation JSON,Avstemming JSON
apps/erpnext/erpnext/accounts/report/financial_statements.html +3,Too many columns. Export the report and print it using a spreadsheet application.,For mange kolonner. Eksportere rapporten og skrive den ut ved hjelp av et regnearkprogram.
DocType: Purchase Invoice Item,Batch No,Batch No
DocType: Selling Settings,Allow multiple Sales Orders against a Customer's Purchase Order,Tillat flere salgsordrer mot kundens innkjøpsordre
DocType: Student Group Instructor,Student Group Instructor,Studentgruppeinstruktør
apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +61,Guardian2 Mobile No,Guardian2 Mobile No
apps/erpnext/erpnext/setup/doctype/company/company.py +204,Main,Hoved
apps/erpnext/erpnext/stock/doctype/item/item.js +60,Variant,Variant
DocType: Naming Series,Set prefix for numbering series on your transactions,Still prefiks for nummerering serien på dine transaksjoner
DocType: Employee Attendance Tool,Employees HTML,ansatte HTML
apps/erpnext/erpnext/stock/doctype/item/item.py +415,Default BOM ({0}) must be active for this item or its template,Standard BOM ({0}) må være aktiv for denne varen eller dens mal
DocType: Employee,Leave Encashed?,Permisjon encashed?
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +32,Opportunity From field is mandatory,Opportunity Fra-feltet er obligatorisk
DocType: Email Digest,Annual Expenses,årlige utgifter
DocType: Item,Variants,Varianter
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1052,Make Purchase Order,Gjør innkjøpsordre
DocType: SMS Center,Send To,Send Til
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +152,There is not enough leave balance for Leave Type {0},Det er ikke nok permisjon balanse for La Type {0}
DocType: Payment Reconciliation Payment,Allocated amount,Bevilget beløp
DocType: Sales Team,Contribution to Net Total,Bidrag til Net Total
DocType: Sales Invoice Item,Customer's Item Code,Kundens Elementkode
DocType: Stock Reconciliation,Stock Reconciliation,Stock Avstemming
DocType: Territory,Territory Name,Territorium Name
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +177,Work-in-Progress Warehouse is required before Submit,Work-in-progress Warehouse er nødvendig før Send
apps/erpnext/erpnext/config/hr.py +40,Applicant for a Job.,Kandidat til en jobb.
DocType: Purchase Order Item,Warehouse and Reference,Warehouse og Reference
DocType: Supplier,Statutory info and other general information about your Supplier,Lovfestet info og annen generell informasjon om din Leverandør
DocType: Item,Serial Nos and Batches,Serienummer og partier
apps/erpnext/erpnext/schools/report/student_batch_wise_attendance/student_batch_wise_attendance.py +42,Student Group Strength,Studentgruppestyrke
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +237,Against Journal Entry {0} does not have any unmatched {1} entry,Mot Journal Entry {0} har ikke noen enestående {1} oppføring
apps/erpnext/erpnext/config/hr.py +137,Appraisals,medarbeidersamtaler
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +205,Duplicate Serial No entered for Item {0},Duplisere serie Ingen kom inn for Element {0}
DocType: Shipping Rule Condition,A condition for a Shipping Rule,En forutsetning for en Shipping Rule
apps/erpnext/erpnext/hr/doctype/employee/employee.py +161,Please enter ,Vennligst skriv inn
apps/erpnext/erpnext/controllers/accounts_controller.py +436,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Buying Settings","Kan ikke bill for Element {0} i rad {1} mer enn {2}. For å tillate overfakturering, kan du sette i å kjøpe Innstillinger"
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +212,Please set filter based on Item or Warehouse,Vennligst sette filter basert på varen eller Warehouse
DocType: Packing Slip,The net weight of this package. (calculated automatically as sum of net weight of items),Nettovekten av denne pakken. (Automatisk beregnet som summen av nettovekt elementer)
DocType: Sales Order,To Deliver and Bill,Å levere og Bill
DocType: Student Group,Instructors,instruktører
DocType: GL Entry,Credit Amount in Account Currency,Credit beløp på kontoen Valuta
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +550,BOM {0} must be submitted,BOM {0} må sendes
DocType: Authorization Control,Authorization Control,Autorisasjon kontroll
apps/erpnext/erpnext/controllers/buying_controller.py +304,Row #{0}: Rejected Warehouse is mandatory against rejected Item {1},Row # {0}: Avvist Warehouse er obligatorisk mot avvist Element {1}
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +767,Payment,Betaling
apps/erpnext/erpnext/controllers/stock_controller.py +92,"Warehouse {0} is not linked to any account, please mention the account in  the warehouse record or set default inventory account in company {1}.","Lager {0} er ikke knyttet til noen konto, vennligst oppgi kontoen i lagerregisteret eller sett inn standardbeholdningskonto i selskap {1}."
apps/erpnext/erpnext/utilities/activation.py +79,Manage your orders,Administrere dine bestillinger
DocType: Production Order Operation,Actual Time and Cost,Faktisk leveringstid og pris
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +54,Material Request of maximum {0} can be made for Item {1} against Sales Order {2},Materialet Request av maksimal {0} kan gjøres for Element {1} mot Salgsordre {2}
DocType: Course,Course Abbreviation,Kurs forkortelse
DocType: Student Leave Application,Student Leave Application,Student La Application
DocType: Item,Will also apply for variants,Vil også gjelde for varianter
apps/erpnext/erpnext/accounts/doctype/asset/asset.py +159,"Asset cannot be cancelled, as it is already {0}","Asset kan ikke avbestilles, som det allerede er {0}"
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +29,Employee {0} on Half day on {1},Employee {0} på halv dag {1}
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +41,Total working hours should not be greater than max working hours {0},Samlet arbeidstid må ikke være større enn maks arbeidstid {0}
apps/erpnext/erpnext/templates/pages/task_info.html +90,On,På
apps/erpnext/erpnext/config/selling.py +62,Bundle items at time of sale.,Bundle elementer på salgstidspunktet.
DocType: Quotation Item,Actual Qty,Selve Antall
DocType: Sales Invoice Item,References,Referanser
DocType: Quality Inspection Reading,Reading 10,Lese 10
apps/erpnext/erpnext/public/js/setup_wizard.js +295,"List your products or services that you buy or sell. Make sure to check the Item Group, Unit of Measure and other properties when you start.","Vise dine produkter eller tjenester som du kjøper eller selger. Sørg for å sjekke varegruppen, Enhet og andre egenskaper når du starter."
DocType: Hub Settings,Hub Node,Hub Node
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +78,You have entered duplicate items. Please rectify and try again.,Du har skrevet inn like elementer. Vennligst utbedre og prøv igjen.
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +98,Associate,Forbinder
DocType: Company,Sales Target,Salgsmålgruppe
DocType: Asset Movement,Asset Movement,Asset Movement
apps/erpnext/erpnext/accounts/page/pos/pos.js +2102,New Cart,New Handlekurv
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +44,Item {0} is not a serialized Item,Element {0} er ikke en serie Element
DocType: SMS Center,Create Receiver List,Lag Receiver List
DocType: Vehicle,Wheels,hjul
DocType: Packing Slip,To Package No.,Å pakke No.
DocType: Production Planning Tool,Material Requests,material~~POS=TRUNC Forespørsler
DocType: Warranty Claim,Issue Date,Utgivelsesdato
DocType: Activity Cost,Activity Cost,Aktivitet Kostnad
DocType: Sales Invoice Timesheet,Timesheet Detail,Timeregistrering Detalj
DocType: Purchase Receipt Item Supplied,Consumed Qty,Forbrukes Antall
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +52,Telecommunications,Telekommunikasjon
DocType: Packing Slip,Indicates that the package is a part of this delivery (Only Draft),Indikerer at pakken er en del av denne leveransen (Kun Draft)
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +36,Make Payment Entry,Utfør betaling Entry
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +126,Quantity for Item {0} must be less than {1},Kvantum for Element {0} må være mindre enn {1}
,Sales Invoice Trends,Salgsfaktura Trender
DocType: Leave Application,Apply / Approve Leaves,Påfør / Godkjenn Løv
apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +23,For,Til
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +150,Can refer row only if the charge type is 'On Previous Row Amount' or 'Previous Row Total',Kan referere rad bare hvis belastningen typen er &#39;On Forrige Row beløp &quot;eller&quot; Forrige Row Totals
DocType: Sales Order Item,Delivery Warehouse,Levering Warehouse
DocType: SMS Settings,Message Parameter,Melding Parameter
apps/erpnext/erpnext/config/accounts.py +243,Tree of financial Cost Centers.,Tre av finansielle kostnadssteder.
DocType: Serial No,Delivery Document No,Levering Dokument nr
apps/erpnext/erpnext/accounts/doctype/asset/depreciation.py +184,Please set 'Gain/Loss Account on Asset Disposal' in Company {0},Vennligst sett &#39;Gevinst / tap-konto på Asset Deponering &quot;i selskapet {0}
DocType: Landed Cost Voucher,Get Items From Purchase Receipts,Få elementer fra innkjøps Receipts
DocType: Serial No,Creation Date,Dato opprettet
apps/erpnext/erpnext/stock/doctype/item_price/item_price.py +33,Item {0} appears multiple times in Price List {1},Element {0} forekommer flere ganger i Prisliste {1}
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +40,"Selling must be checked, if Applicable For is selected as {0}","Selling må sjekkes, hvis dette gjelder for er valgt som {0}"
DocType: Production Plan Material Request,Material Request Date,Materiale Request Dato
DocType: Purchase Order Item,Supplier Quotation Item,Leverandør sitat Element
DocType: Manufacturing Settings,Disables creation of time logs against Production Orders. Operations shall not be tracked against Production Order,Deaktiverer etableringen av tids logger mot produksjonsordrer. Driften skal ikke spores mot produksjonsordre
DocType: Student,Student Mobile Number,Student Mobilnummer
DocType: Item,Has Variants,Har Varianter
apps/erpnext/erpnext/public/js/utils.js +182,You have already selected items from {0} {1},Du har allerede valgt elementer fra {0} {1}
DocType: Monthly Distribution,Name of the Monthly Distribution,Navn på Monthly Distribution
apps/erpnext/erpnext/stock/doctype/batch/batch.py +25,Batch ID is mandatory,Batch-ID er obligatorisk
apps/erpnext/erpnext/stock/doctype/batch/batch.py +25,Batch ID is mandatory,Batch-ID er obligatorisk
DocType: Sales Person,Parent Sales Person,Parent Sales Person
DocType: Purchase Invoice,Recurring Invoice,Tilbakevendende Faktura
apps/erpnext/erpnext/config/learn.py +263,Managing Projects,Managing Projects
DocType: Supplier,Supplier of Goods or Services.,Leverandør av varer eller tjenester.
DocType: Budget,Fiscal Year,Regnskapsår
DocType: Vehicle Log,Fuel Price,Fuel Pris
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +88,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Vennligst oppsett nummereringsserie for Deltakelse via Oppsett&gt; Nummereringsserie
DocType: Budget,Budget,Budsjett
apps/erpnext/erpnext/stock/doctype/item/item.py +232,Fixed Asset Item must be a non-stock item.,Fast Asset varen må være et ikke-lagervare.
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +50,"Budget cannot be assigned against {0}, as it's not an Income or Expense account","Budsjettet kan ikke overdras mot {0}, som det er ikke en inntekt eller kostnad konto"
apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.py +51,Achieved,Oppnås
DocType: Student Admission,Application Form Route,Søknadsskjema Rute
apps/erpnext/erpnext/selling/page/sales_analytics/sales_analytics.js +66,Territory / Customer,Territorium / Customer
apps/erpnext/erpnext/public/js/setup_wizard.js +245,e.g. 5,f.eks 5
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +44,Leave Type {0} cannot be allocated since it is leave without pay,La Type {0} kan ikke tildeles siden det er permisjon uten lønn
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +166,Row {0}: Allocated amount {1} must be less than or equals to invoice outstanding amount {2},Rad {0}: Nummerert mengden {1} må være mindre enn eller lik fakturere utestående beløp {2}
DocType: Sales Invoice,In Words will be visible once you save the Sales Invoice.,I Ord vil være synlig når du lagrer salgsfaktura.
DocType: Item,Is Sales Item,Er Sales Element
apps/erpnext/erpnext/setup/doctype/item_group/item_group.js +21,Item Group Tree,Varegruppe treet
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +69,Item {0} is not setup for Serial Nos. Check Item master,Element {0} er ikke oppsett for Serial Nos. Sjekk Element mester
DocType: Maintenance Visit,Maintenance Time,Vedlikehold Tid
,Amount to Deliver,Beløp å levere
apps/erpnext/erpnext/public/js/setup_wizard.js +302,A Product or Service,Et produkt eller tjeneste
apps/erpnext/erpnext/schools/doctype/academic_term/academic_term.py +30,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.,"Begrepet Startdato kan ikke være tidligere enn året startdato av studieåret som begrepet er knyttet (studieåret {}). Korriger datoene, og prøv igjen."
DocType: Guardian,Guardian Interests,Guardian Interesser
DocType: Naming Series,Current Value,Nåværende Verdi
apps/erpnext/erpnext/controllers/accounts_controller.py +253,Multiple fiscal years exist for the date {0}. Please set company in Fiscal Year,Flere regnskapsårene finnes for datoen {0}. Vennligst satt selskapet i regnskapsåret
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +233,{0} created,{0} opprettet
DocType: Delivery Note Item,Against Sales Order,Mot Salgsordre
,Serial No Status,Serial No Status
DocType: Payment Entry Reference,Outstanding,Utestående
,Daily Timesheet Summary,Daglig Timeregistrering Oppsummering
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +137,"Row {0}: To set {1} periodicity, difference between from and to date \
						must be greater than or equal to {2}","Rad {0}: Slik stiller {1} periodisitet, forskjellen mellom fra og til dato \ må være større enn eller lik {2}"
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +6,This is based on stock movement. See {0} for details,Dette er basert på lagerbevegelse. Se {0} for detaljer
DocType: Pricing Rule,Selling,Selling
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +366,Amount {0} {1} deducted against {2},Mengden {0} {1} trukket mot {2}
DocType: Employee,Salary Information,Lønn Informasjon
DocType: Sales Person,Name and Employee ID,Navn og Employee ID
apps/erpnext/erpnext/accounts/party.py +300,Due Date cannot be before Posting Date,Due Date kan ikke være før konteringsdato
DocType: Website Item Group,Website Item Group,Website varegruppe
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +150,Duties and Taxes,Skatter og avgifter
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +356,Please enter Reference date,Skriv inn Reference dato
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +44,{0} payment entries can not be filtered by {1},{0} oppføringer betalings kan ikke bli filtrert av {1}
DocType: Item Website Specification,Table for Item that will be shown in Web Site,Tabell for element som vil bli vist på nettsiden
DocType: Purchase Order Item Supplied,Supplied Qty,Medfølgende Antall
DocType: Purchase Order Item,Material Request Item,Materialet Request Element
apps/erpnext/erpnext/config/selling.py +75,Tree of Item Groups.,Tree of varegrupper.
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +160,Cannot refer row number greater than or equal to current row number for this Charge type,Kan ikke se rad tall større enn eller lik gjeldende rad nummer for denne debiteringstype
DocType: Asset,Sold,selges
,Item-wise Purchase History,Element-messig Purchase History
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +230,Please click on 'Generate Schedule' to fetch Serial No added for Item {0},Vennligst klikk på &quot;Generer Schedule &#39;for å hente serienummer lagt for Element {0}
DocType: Account,Frozen,Frozen
,Open Production Orders,Åpne produksjonsordrer
DocType: Sales Invoice Payment,Base Amount (Company Currency),Grunnbeløp (Selskap Valuta)
DocType: Payment Reconciliation Payment,Reference Row,Referanse Row
DocType: Installation Note,Installation Time,Installasjon Tid
DocType: Sales Invoice,Accounting Details,Regnskap Detaljer
apps/erpnext/erpnext/setup/doctype/company/company.js +74,Delete all the Transactions for this Company,Slett alle transaksjoner for dette selskapet
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +190,Row #{0}: Operation {1} is not completed for {2} qty of finished goods in Production Order # {3}. Please update operation status via Time Logs,Row # {0}: Operation {1} er ikke fullført for {2} qty av ferdigvarer i Produksjonsordre # {3}. Vennligst oppdater driftsstatus via Tid Logger
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +68,Investments,Investeringer
DocType: Issue,Resolution Details,Oppløsning Detaljer
apps/erpnext/erpnext/hr/doctype/leave_type/leave_type.js +3,Allocations,Avsetninger
DocType: Item Quality Inspection Parameter,Acceptance Criteria,Akseptkriterier
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +163,Please enter Material Requests in the above table,Fyll inn Material forespørsler i tabellen over
DocType: Item Attribute,Attribute Name,Attributt navn
DocType: BOM,Show In Website,Show I Website
DocType: Shopping Cart Settings,Show Quantity in Website,Vis Antall i Website
DocType: Employee Loan Application,Total Payable Amount,Totalt betales beløpet
DocType: Task,Expected Time (in hours),Forventet tid (i timer)
DocType: Item Reorder,Check in (group),Sjekk inn (gruppe)
,Qty to Order,Antall å bestille
DocType: Period Closing Voucher,"The account head under Liability or Equity, in which Profit/Loss will be booked","Kontoen hodet etter forpliktelse eller et egenkapital, der gevinst / tap vil bli bokført"
apps/erpnext/erpnext/config/projects.py +25,Gantt chart of all tasks.,Gantt diagram av alle oppgaver.
DocType: Opportunity,Mins to First Response,Minutter til First Response
DocType: Pricing Rule,Margin Type,margin Type
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +15,{0} hours,{0} timer
DocType: Course,Default Grading Scale,Standard Grading Scale
DocType: Appraisal,For Employee Name,For Employee Name
DocType: Holiday List,Clear Table,Clear Table
DocType: C-Form Invoice Detail,Invoice No,Faktura Nei
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +342,Make Payment,Utføre betaling
DocType: Room,Room Name,Room Name
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +100,"Leave cannot be applied/cancelled before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}","La ikke kan brukes / kansellert før {0}, som permisjon balanse har allerede vært carry-sendt i fremtiden permisjon tildeling posten {1}"
DocType: Activity Cost,Costing Rate,Costing Rate
apps/erpnext/erpnext/config/selling.py +229,Customer Addresses And Contacts,Kunde Adresser og kontakter
,Campaign Efficiency,Kampanjeeffektivitet
,Campaign Efficiency,Kampanjeeffektivitet
DocType: Discussion,Discussion,Diskusjon
DocType: Payment Entry,Transaction ID,Transaksjons-ID
DocType: Employee,Resignation Letter Date,Resignasjon Letter Dato
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +39,Pricing Rules are further filtered based on quantity.,Prising Reglene er videre filtreres basert på kvantitet.
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +330,Please set the Date Of Joining for employee {0},Vennligst sett datoen for å bli med på ansatt {0}
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +330,Please set the Date Of Joining for employee {0},Vennligst sett datoen for å bli med på ansatt {0}
DocType: Task,Total Billing Amount (via Time Sheet),Total Billing Beløp (via Timeregistrering)
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +61,Repeat Customer Revenue,Gjenta kunden Revenue
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +171,{0} ({1}) must have role 'Expense Approver',{0} ({1}) må ha rollen &#39;Expense Godkjenner&#39;
apps/erpnext/erpnext/public/js/setup_wizard.js +308,Pair,Par
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +876,Select BOM and Qty for Production,Velg BOM og Stk for produksjon
DocType: Asset,Depreciation Schedule,avskrivninger Schedule
apps/erpnext/erpnext/config/selling.py +124,Sales Partner Addresses And Contacts,Salgspartneradresser og kontakter
DocType: Bank Reconciliation Detail,Against Account,Mot konto
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +71,Half Day Date should be between From Date and To Date,Half Day Date bør være mellom Fra dato og Til dato
DocType: Maintenance Schedule Detail,Actual Date,Selve Dato
DocType: Item,Has Batch No,Har Batch No
apps/erpnext/erpnext/public/js/utils.js +96,Annual Billing: {0},Årlig Billing: {0}
apps/erpnext/erpnext/config/accounts.py +202,Goods and Services Tax (GST India),Varer og tjenester skatt (GST India)
DocType: Delivery Note,Excise Page Number,Vesenet Page Number
apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.js +157,"Company, From Date and To Date is mandatory","Company, Fra dato og Til dato er obligatorisk"
DocType: Asset,Purchase Date,Kjøpsdato
DocType: Employee,Personal Details,Personlig Informasjon
apps/erpnext/erpnext/accounts/doctype/asset/depreciation.py +186,Please set 'Asset Depreciation Cost Center' in Company {0},Vennligst sett &#39;Asset Avskrivninger kostnadssted &quot;i selskapet {0}
,Maintenance Schedules,Vedlikeholdsplaner
DocType: Task,Actual End Date (via Time Sheet),Faktisk Sluttdato (via Timeregistrering)
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +361,Amount {0} {1} against {2} {3},Mengden {0} {1} mot {2} {3}
,Quotation Trends,Anførsels Trender
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +159,Item Group not mentioned in item master for item {0},Varegruppe ikke nevnt i punkt master for elementet {0}
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +346,Debit To account must be a Receivable account,Uttak fra kontoen må være en fordring konto
DocType: Shipping Rule Condition,Shipping Amount,Fraktbeløp
apps/erpnext/erpnext/public/js/setup_wizard.js +254,Add Customers,Legg til kunder
apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +20,Pending Amount,Avventer Beløp
DocType: Purchase Invoice Item,Conversion Factor,Omregningsfaktor
DocType: Purchase Order,Delivered,Levert
,Vehicle Expenses,Vehicle Utgifter
DocType: Serial No,Invoice Details,Fakturadetaljer
apps/erpnext/erpnext/accounts/doctype/asset/asset.py +154,Expected value after useful life must be greater than or equal to {0},Forventet verdi etter levetid må være større enn eller lik {0}
DocType: Purchase Receipt,Vehicle Number,Vehicle Number
DocType: Purchase Invoice,The date on which recurring invoice will be stop,Datoen som tilbakevendende faktura vil bli stoppe
DocType: Employee Loan,Loan Amount,Lånebeløp
DocType: Program Enrollment,Self-Driving Vehicle,Selvkjørende kjøretøy
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +424,Row {0}: Bill of Materials not found for the Item {1},P {0}: stykk ikke funnet med Element {1}
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +98,Total allocated leaves {0} cannot be less than already approved leaves {1} for the period,Totalt bevilget blader {0} kan ikke være mindre enn allerede godkjente blader {1} for perioden
DocType: Journal Entry,Accounts Receivable,Kundefordringer
,Supplier-Wise Sales Analytics,Leverandør-Wise Salgs Analytics
apps/erpnext/erpnext/schools/doctype/fees/fees.js +41,Enter Paid Amount,Skriv inn beløpet som betales
DocType: Salary Structure,Select employees for current Salary Structure,Velg ansatte for nåværende lønn struktur
DocType: Sales Invoice,Company Address Name,Bedriftsadresse Navn
DocType: Production Order,Use Multi-Level BOM,Bruk Multi-Level BOM
DocType: Bank Reconciliation,Include Reconciled Entries,Inkluder forsonet Entries
DocType: Course,"Parent Course (Leave blank, if this isn't part of Parent Course)","Foreldrekurs (Foreløpig, hvis dette ikke er en del av foreldrenes kurs)"
DocType: Course,"Parent Course (Leave blank, if this isn't part of Parent Course)","Foreldrekurs (Foreløpig, hvis dette ikke er en del av foreldrenes kurs)"
DocType: Leave Control Panel,Leave blank if considered for all employee types,La stå tom hvis vurderes for alle typer medarbeider
DocType: Landed Cost Voucher,Distribute Charges Based On,Distribuere Kostnader Based On
apps/erpnext/erpnext/templates/pages/projects.html +48,Timesheets,Timelister
DocType: HR Settings,HR Settings,HR-innstillinger
DocType: Salary Slip,net pay info,nettolønn info
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +130,Expense Claim is pending approval. Only the Expense Approver can update status.,Expense krav venter på godkjenning. Bare den Expense Godkjenner kan oppdatere status.
DocType: Email Digest,New Expenses,nye Utgifter
DocType: Purchase Invoice,Additional Discount Amount,Ekstra rabatt Beløp
apps/erpnext/erpnext/controllers/accounts_controller.py +544,"Row #{0}: Qty must be 1, as item is a fixed asset. Please use separate row for multiple qty.",Row # {0}: Antall må være en som elementet er et anleggsmiddel. Bruk egen rad for flere stk.
DocType: Leave Block List Allow,Leave Block List Allow,La Block List Tillat
apps/erpnext/erpnext/setup/doctype/company/company.py +289,Abbr can not be blank or space,Abbr kan ikke være tomt eller plass
apps/erpnext/erpnext/accounts/doctype/account/account.js +62,Group to Non-Group,Gruppe til Non-gruppe
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +50,Sports,Sport
DocType: Loan Type,Loan Name,lån Name
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +56,Total Actual,Total Actual
DocType: Student Siblings,Student Siblings,student Søsken
apps/erpnext/erpnext/public/js/setup_wizard.js +308,Unit,Enhet
apps/erpnext/erpnext/stock/get_item_details.py +141,Please specify Company,Vennligst oppgi selskapet
,Customer Acquisition and Loyalty,Kunden Oppkjøp og Loyalty
DocType: Purchase Invoice,Warehouse where you are maintaining stock of rejected items,Warehouse hvor du opprettholder lager avviste elementer
DocType: Production Order,Skip Material Transfer,Hopp over materialoverføring
DocType: Production Order,Skip Material Transfer,Hopp over materialoverføring
apps/erpnext/erpnext/setup/utils.py +95,Unable to find exchange rate for {0} to {1} for key date {2}. Please create a Currency Exchange record manually,Kan ikke finne valutakurs for {0} til {1} for nøkkeldato {2}. Vennligst opprett en valutautvekslingsrekord manuelt
DocType: POS Profile,Price List,Pris Liste
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +22,{0} is now the default Fiscal Year. Please refresh your browser for the change to take effect.,{0} er nå standard regnskapsåret. Vennligst oppdater nettleser for at endringen skal tre i kraft.
apps/erpnext/erpnext/projects/doctype/task/task.js +37,Expense Claims,Regninger
DocType: Issue,Support,Support
,BOM Search,BOM Søk
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +189,Closing (Opening + Totals),Lukking (Åpning + Totals)
DocType: Vehicle,Fuel Type,drivstoff
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +27,Please specify currency in Company,Vennligst oppgi valuta i selskapet
DocType: Workstation,Wages per hour,Lønn per time
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +47,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},Stock balanse i Batch {0} vil bli negativ {1} for Element {2} på Warehouse {3}
apps/erpnext/erpnext/templates/emails/reorder_item.html +1,Following Material Requests have been raised automatically based on Item's re-order level,Følgende materiale Requests har vært reist automatisk basert på element re-order nivå
DocType: Email Digest,Pending Sales Orders,Avventer salgsordrer
apps/erpnext/erpnext/controllers/accounts_controller.py +292,Account {0} is invalid. Account Currency must be {1},Konto {0} er ugyldig. Account Valuta må være {1}
apps/erpnext/erpnext/buying/utils.py +34,UOM Conversion factor is required in row {0},Målenheter Omregningsfaktor er nødvendig i rad {0}
DocType: Production Plan Item,material_request_item,material_request_item
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1014,"Row #{0}: Reference Document Type must be one of Sales Order, Sales Invoice or Journal Entry","Row # {0}: Reference Document Type må være en av salgsordre, salgsfaktura eller bilagsregistrering"
DocType: Salary Component,Deduction,Fradrag
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +111,Row {0}: From Time and To Time is mandatory.,Rad {0}: Fra tid og Tid er obligatorisk.
DocType: Stock Reconciliation Item,Amount Difference,beløp Difference
apps/erpnext/erpnext/stock/get_item_details.py +296,Item Price added for {0} in Price List {1},Varen Pris lagt for {0} i Prisliste {1}
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js +8,Please enter Employee Id of this sales person,Skriv inn Employee Id av denne salgs person
DocType: Territory,Classification of Customers by region,Klassifisering av kunder etter region
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +57,Difference Amount must be zero,Forskjellen Beløpet må være null
DocType: Project,Gross Margin,Bruttomargin
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +53,Please enter Production Item first,Skriv inn Produksjon varen først
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +45,Calculated Bank Statement balance,Beregnet kontoutskrift balanse
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +64,disabled user,deaktivert bruker
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.js +749,Quotation,Sitat
DocType: Quotation,QTN-,QTN-
DocType: Salary Slip,Total Deduction,Total Fradrag
,Production Analytics,produksjons~~POS=TRUNC Analytics
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +179,Cost Updated,Kostnad Oppdatert
DocType: Employee,Date of Birth,Fødselsdato
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +129,Item {0} has already been returned,Element {0} er allerede returnert
DocType: Fiscal Year,**Fiscal Year** represents a Financial Year. All accounting entries and other major transactions are tracked against **Fiscal Year**.,** Regnskapsår ** representerer et regnskapsår. Alle regnskapspostene og andre store transaksjoner spores mot ** regnskapsår **.
DocType: Opportunity,Customer / Lead Address,Kunde / Lead Adresse
apps/erpnext/erpnext/stock/doctype/item/item.py +207,Warning: Invalid SSL certificate on attachment {0},Advarsel: Ugyldig SSL-sertifikat på vedlegg {0}
DocType: Student Admission,Eligibility,kvalifikasjon
apps/erpnext/erpnext/utilities/activation.py +62,"Leads help you get business, add all your contacts and more as your leads","Leads hjelpe deg å få virksomheten, legge til alle dine kontakter og mer som dine potensielle kunder"
DocType: Production Order Operation,Actual Operation Time,Selve Operasjon Tid
DocType: Authorization Rule,Applicable To (User),Gjelder til (User)
DocType: Purchase Taxes and Charges,Deduct,Trekke
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +195,Job Description,Stillingsbeskrivelse
DocType: Student Applicant,Applied,Tatt i bruk
DocType: Sales Invoice Item,Qty as per Stock UOM,Antall pr Stock målenheter
apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +59,Guardian2 Name,Guardian2 Name
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +131,"Special Characters except ""-"", ""#"", ""."" and ""/"" not allowed in naming series","Spesialtegn unntatt &quot;-&quot; &quot;.&quot;, &quot;#&quot;, og &quot;/&quot; ikke tillatt i navngi serie"
DocType: Campaign,"Keep Track of Sales Campaigns. Keep track of Leads, Quotations, Sales Order etc from Campaigns to gauge Return on Investment.","Hold orden på salgskampanjer. Hold styr på Leads, Sitater, Salgsordre etc fra kampanjer for å måle avkastning på investeringen."
DocType: Expense Claim,Approver,Godkjenner
,SO Qty,SO Antall
DocType: Guardian,Work Address,arbeid Adresse
DocType: Appraisal,Calculate Total Score,Beregn Total Score
DocType: Request for Quotation,Manufacturing Manager,Produksjonssjef
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +191,Serial No {0} is under warranty upto {1},Serial No {0} er under garanti opptil {1}
apps/erpnext/erpnext/config/stock.py +158,Split Delivery Note into packages.,Split følgeseddel i pakker.
apps/erpnext/erpnext/hooks.py +87,Shipments,Forsendelser
DocType: Payment Entry,Total Allocated Amount (Company Currency),Totalt tildelte beløp (Selskap Valuta)
DocType: Purchase Order Item,To be delivered to customer,Som skal leveres til kunde
DocType: BOM,Scrap Material Cost,Skrap Material Cost
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +227,Serial No {0} does not belong to any Warehouse,Serial No {0} tilhører ikke noen Warehouse
DocType: Purchase Invoice,In Words (Company Currency),I Words (Company Valuta)
DocType: Asset,Supplier,Leverandør
DocType: C-Form,Quarter,Quarter
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +106,Miscellaneous Expenses,Diverse utgifter
DocType: Global Defaults,Default Company,Standard selskapet
apps/erpnext/erpnext/controllers/stock_controller.py +227,Expense or Difference account is mandatory for Item {0} as it impacts overall stock value,Kostnad eller Difference konto er obligatorisk for Element {0} som det påvirker samlede børsverdi
DocType: Payment Request,PR,PR
DocType: Cheque Print Template,Bank Name,Bank Name
apps/erpnext/erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.py +29,-Above,-Above
DocType: Employee Loan,Employee Loan Account,Medarbeider Loan konto
DocType: Leave Application,Total Leave Days,Totalt La Days
DocType: Email Digest,Note: Email will not be sent to disabled users,Merk: E-post vil ikke bli sendt til funksjonshemmede brukere
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +14,Number of Interaction,Antall interaksjoner
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +14,Number of Interaction,Antall interaksjoner
apps/erpnext/erpnext/manufacturing/page/production_analytics/production_analytics.js +39,Select Company...,Velg Company ...
DocType: Leave Control Panel,Leave blank if considered for all departments,La stå tom hvis vurderes for alle avdelinger
apps/erpnext/erpnext/config/hr.py +219,"Types of employment (permanent, contract, intern etc.).","Typer arbeid (fast, kontrakt, lærling etc.)."
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +412,{0} is mandatory for Item {1},{0} er obligatorisk for Element {1}
DocType: Process Payroll,Fortnightly,hver fjortende dag
DocType: Currency Exchange,From Currency,Fra Valuta
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +170,"Please select Allocated Amount, Invoice Type and Invoice Number in atleast one row","Vennligst velg avsatt beløp, fakturatype og fakturanummer i minst én rad"
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +125,Cost of New Purchase,Kostnad for nye kjøp
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +97,Sales Order required for Item {0},Salgsordre kreves for Element {0}
DocType: Purchase Invoice Item,Rate (Company Currency),Rate (Selskap Valuta)
DocType: Student Guardian,Others,Annet
DocType: Payment Entry,Unallocated Amount,uallokert Beløp
apps/erpnext/erpnext/templates/includes/product_page.js +71,Cannot find a matching Item. Please select some other value for {0}.,Kan ikke finne en matchende element. Vennligst velg en annen verdi for {0}.
DocType: POS Profile,Taxes and Charges,Skatter og avgifter
DocType: Item,"A Product or a Service that is bought, sold or kept in stock.","Et produkt eller en tjeneste som er kjøpt, solgt eller holdes på lager."
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +48,Item Code &gt; Item Group &gt; Brand,Varenummer&gt; Varegruppe&gt; Varemerke
apps/erpnext/erpnext/hr/page/team_updates/team_updates.js +44,No more updates,Ingen flere oppdateringer
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +154,Cannot select charge type as 'On Previous Row Amount' or 'On Previous Row Total' for first row,Kan ikke velge charge type som &#39;On Forrige Row beløp &quot;eller&quot; On Forrige Row Totals for første rad
apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.py +29,Child Item should not be a Product Bundle. Please remove item `{0}` and save,Barn Varen bør ikke være et produkt Bundle. Vennligst fjern element `{0}` og lagre
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +12,Banking,Banking
apps/erpnext/erpnext/utilities/activation.py +106,Add Timesheets,Legg Timelister
DocType: Vehicle Service,Service Item,tjenesten Element
DocType: Bank Guarantee,Bank Guarantee,Bankgaranti
DocType: Bank Guarantee,Bank Guarantee,Bankgaranti
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +39,Please click on 'Generate Schedule' to get schedule,Vennligst klikk på &quot;Generer Schedule &#39;for å få timeplanen
apps/erpnext/erpnext/schools/doctype/course_scheduling_tool/course_scheduling_tool.py +56,There were errors while deleting following schedules:,Det var feil under sletting av følgende planer:
DocType: Bin,Ordered Quantity,Bestilte Antall
apps/erpnext/erpnext/public/js/setup_wizard.js +98,"e.g. ""Build tools for builders""",f.eks &quot;Bygg verktøy for utbyggere&quot;
DocType: Grading Scale,Grading Scale Intervals,Karakterskalaen Intervaller
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +125,{0} {1}: Accounting Entry for {2} can only be made in currency: {3},{0} {1}: Regnskap Entry for {2} kan bare gjøres i valuta: {3}
DocType: Production Order,In Process,Igang
DocType: Authorization Rule,Itemwise Discount,Itemwise Rabatt
apps/erpnext/erpnext/config/accounts.py +69,Tree of financial accounts.,Tre av finansregnskap.
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +364,{0} against Sales Order {1},{0} mot Salgsordre {1}
DocType: Account,Fixed Asset,Fast Asset
apps/erpnext/erpnext/config/stock.py +315,Serialized Inventory,Serialisert Lager
DocType: Employee Loan,Account Info,Kontoinformasjon
DocType: Activity Type,Default Billing Rate,Standard Billing pris
apps/erpnext/erpnext/schools/doctype/student_group_creation_tool/student_group_creation_tool.py +71,{0} Student Groups created.,{0} Studentgrupper opprettet.
apps/erpnext/erpnext/schools/doctype/student_group_creation_tool/student_group_creation_tool.py +71,{0} Student Groups created.,{0} Studentgrupper opprettet.
DocType: Sales Invoice,Total Billing Amount,Total Billing Beløp
apps/erpnext/erpnext/hr/doctype/daily_work_summary_settings/daily_work_summary_settings.py +17,There must be a default incoming Email Account enabled for this to work. Please setup a default incoming Email Account (POP/IMAP) and try again.,Det må være en standard innkommende e-postkonto aktivert for at dette skal fungere. Vennligst sette opp en standard innkommende e-postkonto (POP / IMAP) og prøv igjen.
apps/erpnext/erpnext/accounts/report/item_wise_sales_register/item_wise_sales_register.py +75,Receivable Account,Fordring konto
apps/erpnext/erpnext/controllers/accounts_controller.py +566,Row #{0}: Asset {1} is already {2},Row # {0}: Asset {1} er allerede {2}
DocType: Quotation Item,Stock Balance,Stock Balance
apps/erpnext/erpnext/config/selling.py +316,Sales Order to Payment,Salgsordre til betaling
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +92,CEO,administrerende direktør
DocType: Expense Claim Detail,Expense Claim Detail,Expense krav Detalj
DocType: Sales Invoice,TRIPLICATE FOR SUPPLIER,TRIPLIKAT FOR LEVERANDØR
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +859,Please select correct account,Velg riktig konto
DocType: Item,Weight UOM,Vekt målenheter
DocType: Salary Structure Employee,Salary Structure Employee,Lønn Struktur Employee
DocType: Employee,Blood Group,Blodgruppe
DocType: Production Order Operation,Pending,Avventer
DocType: Course,Course Name,Course Name
DocType: Employee Leave Approver,Users who can approve a specific employee's leave applications,Brukere som kan godkjenne en bestemt ansattes permisjon applikasjoner
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +52,Office Equipments,Kontor utstyr
DocType: Purchase Invoice Item,Qty,Antall
DocType: Fiscal Year,Companies,Selskaper
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +24,Electronics,Elektronikk
DocType: Stock Settings,Raise Material Request when stock reaches re-order level,Hev Material Request når aksjen når re-order nivå
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +67,Full-time,Fulltid
DocType: Salary Structure,Employees,medarbeidere
DocType: Employee,Contact Details,Kontaktinformasjon
DocType: C-Form,Received Date,Mottatt dato
DocType: Delivery Note,"If you have created a standard template in Sales Taxes and Charges Template, select one and click on the button below.","Hvis du har opprettet en standard mal i salgs skatter og avgifter mal, velger du ett og klikk på knappen under."
DocType: BOM Scrap Item,Basic Amount (Company Currency),Grunnbeløpet (Selskap Valuta)
DocType: Student,Guardians,Voktere
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +54,Supplier &gt; Supplier Type,Leverandør&gt; Leverandør Type
DocType: Shopping Cart Settings,Prices will not be shown if Price List is not set,Prisene vil ikke bli vist hvis prislisten er ikke satt
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +28,Please specify a country for this Shipping Rule or check Worldwide Shipping,Vennligst oppgi et land for denne Shipping Regel eller sjekk Worldwide Shipping
DocType: Stock Entry,Total Incoming Value,Total Innkommende Verdi
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +340,Debit To is required,Debet Å kreves
apps/erpnext/erpnext/utilities/activation.py +107,"Timesheets help keep track of time, cost and billing for activites done by your team","Timelister bidra til å holde styr på tid, kostnader og fakturering for aktiviteter gjort av teamet ditt"
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +39,Purchase Price List,Kjøp Prisliste
DocType: Offer Letter Term,Offer Term,Tilbudet Term
DocType: Quality Inspection,Quality Manager,Quality Manager
DocType: Job Applicant,Job Opening,Job Opening
DocType: Payment Reconciliation,Payment Reconciliation,Betaling Avstemming
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +153,Please select Incharge Person's name,Vennligst velg Incharge persons navn
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +51,Technology,Teknologi
apps/erpnext/erpnext/public/js/utils.js +98,Total Unpaid: {0},Total Ubetalte: {0}
DocType: BOM Website Operation,BOM Website Operation,BOM Nettstedet Operasjon
apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.js +13,Offer Letter,Tilbudsbrev
apps/erpnext/erpnext/config/manufacturing.py +18,Generate Material Requests (MRP) and Production Orders.,Generere Material Requests (MRP) og produksjonsordrer.
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +67,Total Invoiced Amt,Total Fakturert Amt
DocType: BOM,Conversion Rate,konverterings~~POS=TRUNC
apps/erpnext/erpnext/templates/pages/product_search.html +3,Product Search,Produktsøk
DocType: Timesheet Detail,To Time,Til Time
DocType: Authorization Rule,Approving Role (above authorized value),Godkjenne Role (ovenfor autorisert verdi)
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +111,Credit To account must be a Payable account,Kreditt til kontoen må være en Betales konto
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +306,BOM recursion: {0} cannot be parent or child of {2},BOM rekursjon: {0} kan ikke være forelder eller barn av {2}
DocType: Production Order Operation,Completed Qty,Fullført Antall
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +148,"For {0}, only debit accounts can be linked against another credit entry",For {0} kan bare belastning kontoer knyttes opp mot en annen kreditt oppføring
apps/erpnext/erpnext/stock/doctype/item_price/item_price.py +27,Price List {0} is disabled,Prisliste {0} er deaktivert
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +123,Row {0}: Completed Qty cannot be more than {1} for operation {2},Rad {0}: Fullført Antall kan ikke være mer enn {1} for drift {2}
DocType: Manufacturing Settings,Allow Overtime,Tillat Overtid
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +146,"Serialized Item {0} cannot be updated using Stock Reconciliation, please use Stock Entry","Serialisert element {0} kan ikke oppdateres ved hjelp av Stock Forsoning, vennligst bruk Stock Entry"
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +146,"Serialized Item {0} cannot be updated using Stock Reconciliation, please use Stock Entry","Serialisert element {0} kan ikke oppdateres ved hjelp av Stock Forsoning, vennligst bruk Stock Entry"
DocType: Training Event Employee,Training Event Employee,Trening Hendelses Employee
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +201,{0} Serial Numbers required for Item {1}. You have provided {2}.,{0} serienumre som kreves for Element {1}. Du har gitt {2}.
DocType: Stock Reconciliation Item,Current Valuation Rate,Nåværende Verdivurdering Rate
DocType: Item,Customer Item Codes,Kunden element Codes
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +122,Exchange Gain/Loss,Valutagevinst / tap
DocType: Opportunity,Lost Reason,Mistet Reason
apps/erpnext/erpnext/public/js/templates/address_list.html +22,New Address,Ny adresse
DocType: Quality Inspection,Sample Size,Sample Size
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +45,Please enter Receipt Document,Fyll inn Kvittering Document
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +374,All items have already been invoiced,Alle elementene er allerede blitt fakturert
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +47,Please specify a valid 'From Case No.',Vennligst oppgi en gyldig &quot;Fra sak nr &#39;
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +24,Further cost centers can be made under Groups but entries can be made against non-Groups,Ytterligere kostnadsbærere kan gjøres under Grupper men oppføringene kan gjøres mot ikke-grupper
DocType: Project,External,Ekstern
apps/erpnext/erpnext/config/setup.py +66,Users and Permissions,Brukere og tillatelser
DocType: Vehicle Log,VLOG.,Vlog.
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +909,Production Orders Created: {0},Produksjonsordrer Laget: {0}
DocType: Branch,Branch,Branch
DocType: Guardian,Mobile Number,Mobilnummer
apps/erpnext/erpnext/config/setup.py +61,Printing and Branding,Trykking og merkevarebygging
DocType: Company,Total Monthly Sales,Totalt månedlig salg
DocType: Bin,Actual Quantity,Selve Antall
DocType: Shipping Rule,example: Next Day Shipping,Eksempel: Neste Day Shipping
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +187,Serial No {0} not found,Serial No {0} ikke funnet
DocType: Program Enrollment,Student Batch,student Batch
apps/erpnext/erpnext/utilities/activation.py +117,Make Student,Gjør Student
apps/erpnext/erpnext/projects/doctype/project/project.py +198,You have been invited to collaborate on the project: {0},Du har blitt invitert til å samarbeide om prosjektet: {0}
DocType: Leave Block List Date,Block Date,Block Dato
apps/erpnext/erpnext/templates/generators/student_admission.html +23,Apply Now,Søk nå
apps/erpnext/erpnext/stock/dashboard/item_dashboard_list.html +25,Actual Qty {0} / Waiting Qty {1},Faktisk antall {0} / Venter antall {1}
apps/erpnext/erpnext/stock/dashboard/item_dashboard_list.html +25,Actual Qty {0} / Waiting Qty {1},Faktisk antall {0} / Venter antall {1}
DocType: Sales Order,Not Delivered,Ikke levert
,Bank Clearance Summary,Bank Lagersalg Summary
apps/erpnext/erpnext/config/setup.py +106,"Create and manage daily, weekly and monthly email digests.","Opprette og administrere daglige, ukentlige og månedlige e-postfordøyer."
DocType: Appraisal Goal,Appraisal Goal,Appraisal Goal
DocType: Stock Reconciliation Item,Current Amount,Gjeldende Beløp
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +58,Buildings,bygninger
DocType: Fee Structure,Fee Structure,Avgiftsstruktur struktur~~POS=HEADCOMP
DocType: Timesheet Detail,Costing Amount,Costing Beløp
DocType: Student Admission,Application Fee,Påmeldingsavgift
DocType: Process Payroll,Submit Salary Slip,Send Lønn Slip
apps/erpnext/erpnext/controllers/selling_controller.py +162,Maxiumm discount for Item {0} is {1}%,Maxiumm rabatt for Element {0} er {1}%
apps/erpnext/erpnext/stock/doctype/item_price/item_price.js +16,Import in Bulk,Import i Bulk
DocType: Sales Partner,Address & Contacts,Adresse og Kontakt
DocType: SMS Log,Sender Name,Avsender Navn
DocType: POS Profile,[Select],[Velg]
DocType: SMS Log,Sent To,Sendt til
DocType: Payment Request,Make Sales Invoice,Gjør Sales Faktura
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +61,Softwares,programvare
apps/erpnext/erpnext/crm/doctype/lead/lead.py +50,Next Contact Date cannot be in the past,Neste Kontakt Datoen kan ikke være i fortiden
DocType: Company,For Reference Only.,For referanse.
apps/erpnext/erpnext/accounts/page/pos/pos.js +2449,Select Batch No,Velg batchnummer
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +52,Invalid {0}: {1},Ugyldig {0}: {1}
DocType: Purchase Invoice,PINV-RET-,PINV-RET-
DocType: Sales Invoice Advance,Advance Amount,Forskuddsbeløp
DocType: Manufacturing Settings,Capacity Planning,Kapasitetsplanlegging
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +43,'From Date' is required,&quot;Fra dato&quot; er nødvendig
DocType: Journal Entry,Reference Number,Referanse Nummer
DocType: Employee,Employment Details,Sysselsetting Detaljer
DocType: Employee,New Workplace,Nye arbeidsplassen
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +17,Set as Closed,Sett som Stengt
apps/erpnext/erpnext/stock/get_item_details.py +131,No Item with Barcode {0},Ingen Element med Barcode {0}
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +51,Case No. cannot be 0,Sak nr kan ikke være 0
DocType: Item,Show a slideshow at the top of the page,Vis en lysbildeserie på toppen av siden
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +481,Boms,Boms
apps/erpnext/erpnext/stock/doctype/item/item.py +136,Stores,Butikker
DocType: Serial No,Delivery Time,Leveringstid
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +27,Ageing Based On,Aldring Based On
DocType: Item,End of Life,Slutten av livet
apps/erpnext/erpnext/demo/setup/setup_data.py +327,Travel,Reise
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +177,No active or default Salary Structure found for employee {0} for the given dates,Ingen aktive eller standard Lønn Struktur funnet for arbeidstaker {0} for den gitte datoer
DocType: Leave Block List,Allow Users,Gi brukere
DocType: Purchase Order,Customer Mobile No,Kunden Mobile No
DocType: Cost Center,Track separate Income and Expense for product verticals or divisions.,Spor separat inntekter og kostnader for produkt vertikaler eller divisjoner.
DocType: Rename Tool,Rename Tool,Rename Tool
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +37,Update Cost,Oppdater Cost
DocType: Item Reorder,Item Reorder,Sak Omgjøre
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +446,Show Salary Slip,Vis Lønn Slip
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +794,Transfer Material,Transfer Material
DocType: BOM,"Specify the operations, operating cost and give a unique Operation no to your operations.","Spesifiser drift, driftskostnadene og gi en unik Operation nei til driften."
apps/erpnext/erpnext/controllers/status_updater.py +201,This document is over limit by {0} {1} for item {4}. Are you making another {3} against the same {2}?,Dette dokumentet er over grensen av {0} {1} for elementet {4}. Er du gjør en annen {3} mot samme {2}?
apps/erpnext/erpnext/public/js/controllers/transaction.js +982,Please set recurring after saving,Vennligst sett gjentakende etter lagring
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +745,Select change amount account,Velg endring mengde konto
DocType: Purchase Invoice,Price List Currency,Prisliste Valuta
DocType: Naming Series,User must always select,Brukeren må alltid velge
DocType: Stock Settings,Allow Negative Stock,Tillat Negative Stock
DocType: Installation Note,Installation Note,Installasjon Merk
apps/erpnext/erpnext/public/js/setup_wizard.js +235,Add Taxes,Legg Skatter
DocType: Topic,Topic,Emne
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +40,Cash Flow from Financing,Kontantstrøm fra finansierings
DocType: Budget Account,Budget Account,budsjett konto
DocType: Quality Inspection,Verified By,Verified by
apps/erpnext/erpnext/setup/doctype/company/company.py +70,"Cannot change company's default currency, because there are existing transactions. Transactions must be cancelled to change the default currency.","Kan ikke endre selskapets standardvaluta, fordi det er eksisterende transaksjoner. Transaksjoner må avbestilles å endre valgt valuta."
DocType: Grading Scale Interval,Grade Description,grade Beskrivelse
DocType: Stock Entry,Purchase Receipt No,Kvitteringen Nei
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +30,Earnest Money,Earnest Penger
DocType: Process Payroll,Create Salary Slip,Lag Lønn Slip
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +34,Traceability,Sporbarhet
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +137,Source of Funds (Liabilities),Source of Funds (Gjeld)
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +381,Quantity in row {0} ({1}) must be same as manufactured quantity {2},Antall på rad {0} ({1}) må være det samme som produsert mengde {2}
DocType: Appraisal,Employee,Ansatt
DocType: Company,Sales Monthly History,Salg Månedlig historie
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +183,Select Batch,Velg Batch
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +244,{0} {1} is fully billed,{0} {1} er fullt fakturert
DocType: Training Event,End Time,Sluttid
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +62,Active Salary Structure {0} found for employee {1} for the given dates,Aktiv Lønn Struktur {0} funnet for ansatt {1} for de gitte datoer
DocType: Payment Entry,Payment Deductions or Loss,Betalings fradrag eller tap
apps/erpnext/erpnext/config/setup.py +42,Standard contract terms for Sales or Purchase.,Standard kontraktsvilkår for salg eller kjøp.
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +100,Group by Voucher,Grupper etter Voucher
apps/erpnext/erpnext/config/crm.py +6,Sales Pipeline,salgs~~POS=TRUNC
apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +216,Please set default account in Salary Component {0},Vennligst angi standardkonto i Lønn Component {0}
apps/erpnext/erpnext/templates/form_grid/material_request_grid.html +7,Required On,Nødvendig På
DocType: Rename Tool,File to Rename,Filen til Rename
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +204,Please select BOM for Item in Row {0},Vennligst velg BOM for Element i Rad {0}
apps/erpnext/erpnext/accounts/doctype/mode_of_payment/mode_of_payment.py +28,Account {0} does not match with Company {1} in Mode of Account: {2},Konto {0} stemmer ikke overens med Selskapet {1} i Konto modus: {2}
apps/erpnext/erpnext/controllers/buying_controller.py +266,Specified BOM {0} does not exist for Item {1},Spesifisert BOM {0} finnes ikke for Element {1}
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +221,Maintenance Schedule {0} must be cancelled before cancelling this Sales Order,Vedlikeholdsplan {0} må avbestilles før den avbryter denne salgsordre
DocType: Notification Control,Expense Claim Approved,Expense krav Godkjent
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +316,Salary Slip of employee {0} already created for this period,Lønn Slip av ansattes {0} som allerede er opprettet for denne perioden
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +124,Pharmaceutical,Pharmaceutical
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26,Cost of Purchased Items,Kostnad for kjøpte varer
DocType: Selling Settings,Sales Order Required,Salgsordre Påkrevd
DocType: Purchase Invoice,Credit To,Kreditt til
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +31,Active Leads / Customers,Aktive Ledninger / Kunder
DocType: Employee Education,Post Graduate,Post Graduate
DocType: Maintenance Schedule Detail,Maintenance Schedule Detail,Vedlikeholdsplan Detalj
DocType: Quality Inspection Reading,Reading 9,Lese 9
DocType: Supplier,Is Frozen,Er Frozen
apps/erpnext/erpnext/stock/utils.py +217,Group node warehouse is not allowed to select for transactions,Gruppe node lageret er ikke lov til å velge for transaksjoner
DocType: Buying Settings,Buying Settings,Kjøpe Innstillinger
DocType: Stock Entry Detail,BOM No. for a Finished Good Item,BOM No. for et ferdig God Sak
DocType: Upload Attendance,Attendance To Date,Oppmøte To Date
DocType: Warranty Claim,Raised By,Raised By
DocType: Payment Gateway Account,Payment Account,Betaling konto
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +859,Please specify Company to proceed,Vennligst oppgi selskapet å fortsette
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +22,Net Change in Accounts Receivable,Netto endring i kundefordringer
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +57,Compensatory Off,Kompenserende Off
DocType: Offer Letter,Accepted,Akseptert
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +25,Organization,Organisasjon
DocType: SG Creation Tool Course,Student Group Name,Student Gruppenavn
apps/erpnext/erpnext/setup/doctype/company/company.js +52,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.,Sørg for at du virkelig ønsker å slette alle transaksjoner for dette selskapet. Dine stamdata vil forbli som det er. Denne handlingen kan ikke angres.
DocType: Room,Room Number,Romnummer
apps/erpnext/erpnext/utilities/transaction_base.py +96,Invalid reference {0} {1},Ugyldig referanse {0} {1}
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +167,{0} ({1}) cannot be greater than planned quanitity ({2}) in Production Order {3},{0} ({1}) kan ikke være større enn planlagt quanitity ({2}) i produksjonsordre {3}
DocType: Shipping Rule,Shipping Rule Label,Shipping Rule Etikett
apps/erpnext/erpnext/public/js/conf.js +28,User Forum,bruker~~POS=TRUNC
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +276,Raw Materials cannot be blank.,Råvare kan ikke være blank.
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +476,"Could not update stock, invoice contains drop shipping item.","Kunne ikke oppdatere lager, inneholder faktura slippe frakt element."
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +466,Quick Journal Entry,Hurtig Journal Entry
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +165,You can not change rate if BOM mentioned agianst any item,Du kan ikke endre prisen dersom BOM nevnt agianst ethvert element
DocType: Employee,Previous Work Experience,Tidligere arbeidserfaring
DocType: Stock Entry,For Quantity,For Antall
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +209,Please enter Planned Qty for Item {0} at row {1},Skriv inn Planned Antall for Element {0} på rad {1}
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +241,{0} {1} is not submitted,{0} {1} ikke er sendt
apps/erpnext/erpnext/config/stock.py +27,Requests for items.,Forespørsler om elementer.
DocType: Production Planning Tool,Separate production order will be created for each finished good item.,Separat produksjonsordre vil bli opprettet for hvert ferdige godt element.
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +127,{0} must be negative in return document,{0} må være negativ i retur dokument
,Minutes to First Response for Issues,Minutter til First Response for Issues
DocType: Purchase Invoice,Terms and Conditions1,Vilkår og forhold 1
apps/erpnext/erpnext/public/js/setup_wizard.js +89,The name of the institute for which you are setting up this system.,Navnet på institutt for som du setter opp dette systemet.
DocType: Accounts Settings,"Accounting entry frozen up to this date, nobody can do / modify entry except role specified below.","Regnskap oppføring frosset opp til denne datoen, kan ingen gjøre / endre oppføring unntatt rolle angitt nedenfor."
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +116,Please save the document before generating maintenance schedule,Vennligst lagre dokumentet før du genererer vedlikeholdsplan
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +28,Project Status,Prosjekt Status
DocType: UOM,Check this to disallow fractions. (for Nos),Sjekk dette for å forby fraksjoner. (For Nos)
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +428,The following Production Orders were created:,Følgende produksjonsordrer ble opprettet:
DocType: Student Admission,Naming Series (for Student Applicant),Naming Series (Student søkeren)
DocType: Delivery Note,Transporter Name,Transporter Name
DocType: Authorization Rule,Authorized Value,Autorisert Verdi
DocType: BOM,Show Operations,Vis Operations
,Minutes to First Response for Opportunity,Minutter til First Response for Opportunity
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +58,Total Absent,Total Fraværende
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +793,Item or Warehouse for row {0} does not match Material Request,Element eller Warehouse for rad {0} samsvarer ikke Material Request
apps/erpnext/erpnext/config/stock.py +189,Unit of Measure,Måleenhet
DocType: Fiscal Year,Year End Date,År Sluttdato
DocType: Task Depends On,Task Depends On,Task Avhenger
DocType: Supplier Quotation,Opportunity,Opportunity
,Completed Production Orders,Fullførte produksjonsordrer
DocType: Operation,Default Workstation,Standard arbeidsstasjon
DocType: Notification Control,Expense Claim Approved Message,Expense krav Godkjent melding
DocType: Payment Entry,Deductions or Loss,Fradrag eller tap
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +247,{0} {1} is closed,{0} {1} er stengt
DocType: Email Digest,How frequently?,Hvor ofte?
DocType: Purchase Receipt,Get Current Stock,Få Current Stock
apps/erpnext/erpnext/config/manufacturing.py +46,Tree of Bill of Materials,Tree of Bill of Materials
DocType: Student,Joining Date,Bli med dato
,Employees working on a holiday,Arbeidstakere som arbeider på ferie
apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +152,Mark Present,Mark Present
DocType: Project,% Complete Method,% Komplett Method
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +200,Maintenance start date can not be before delivery date for Serial No {0},Vedlikehold startdato kan ikke være før leveringsdato for Serial No {0}
DocType: Production Order,Actual End Date,Selve sluttdato
DocType: BOM,Operating Cost (Company Currency),Driftskostnader (Selskap Valuta)
DocType: Purchase Invoice,PINV-,PINV-
DocType: Authorization Rule,Applicable To (Role),Gjelder til (Role)
DocType: Stock Entry,Purpose,Formålet
DocType: Company,Fixed Asset Depreciation Settings,Fast Asset Avskrivninger Innstillinger
DocType: Item,Will also apply for variants unless overrridden,Vil også gjelde for varianter med mindre overrridden
DocType: Purchase Invoice,Advances,Fremskritt
DocType: Production Order,Manufacture against Material Request,Produksjon mot Material Request
DocType: Item Reorder,Request for,Forespørsel etter
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +32,Approving User cannot be same as user the rule is Applicable To,Godkjenne Brukeren kan ikke være det samme som bruker regelen gjelder for
DocType: Stock Entry Detail,Basic Rate (as per Stock UOM),Basic Rate (som per Stock målenheter)
DocType: SMS Log,No of Requested SMS,Ingen av Spurt SMS
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +240,Leave Without Pay does not match with approved Leave Application records,La Uten Pay ikke samsvarer med godkjente La Søknad poster
DocType: Campaign,Campaign-.####,Kampanje -. ####
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +21,Next Steps,Neste skritt
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +754,Please supply the specified items at the best possible rates,Vennligst oppgi de angitte elementene på de best mulige priser
DocType: Selling Settings,Auto close Opportunity after 15 days,Auto nær mulighet etter 15 dager
apps/erpnext/erpnext/public/js/financial_statements.js +83,End Year,slutt År
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +23,Quot/Lead %,Quot / Lead%
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +23,Quot/Lead %,Quot / Lead%
apps/erpnext/erpnext/hr/doctype/employee/employee.py +119,Contract End Date must be greater than Date of Joining,Kontraktssluttdato må være større enn tidspunktet for inntreden
DocType: Delivery Note,DN-,DN-
DocType: Sales Partner,A third party distributor / dealer / commission agent / affiliate / reseller who sells the companies products for a commission.,En tredjepart distributør / forhandler / kommisjonær / agent / forhandler som selger selskaper produkter for en kommisjon.
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +376,{0} against Purchase Order {1},{0} mot innkjøpsordre {1}
DocType: SMS Settings,"Enter static url parameters here (Eg. sender=ERPNext, username=ERPNext, password=1234 etc.)","Skriv inn statiske webadresseparametere her (F.eks. Avsender = ERPNext, brukernavn = ERPNext, passord = 1234 etc.)"
DocType: Task,Actual Start Date (via Time Sheet),Faktisk startdato (via Timeregistrering)
apps/erpnext/erpnext/portal/doctype/homepage/homepage.py +15,This is an example website auto-generated from ERPNext,Dette er et eksempel nettsiden automatisk generert fra ERPNext
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +37,Ageing Range 1,Aldring Range 1
DocType: Purchase Taxes and Charges Template,"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.

#### Note

The 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.

#### Description of Columns

1. Calculation Type: 
    - This can be on **Net Total** (that is the sum of basic amount).
    - **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.
    - **Actual** (as mentioned).
2. Account Head: The Account ledger under which this tax will be booked
3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.
4. Description: Description of the tax (that will be printed in invoices / quotes).
5. Rate: Tax rate.
6. Amount: Tax amount.
7. Total: Cumulative total to this point.
8. 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).
9. 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.
10. Add or Deduct: Whether you want to add or deduct the tax.","Standard skatt mal som kan brukes på alle kjøpstransaksjoner. Denne malen kan inneholde liste over skatte hoder og også andre utgifter hoder som &quot;Shipping&quot;, &quot;Forsikring&quot;, &quot;Håndtering&quot; osv #### Note Skattesatsen du definerer her vil være standard skattesats for alle ** Items * *. Hvis det er ** Elementer ** som har forskjellige priser, må de legges i ** Sak Skatt ** bord i ** Sak ** mester. #### Beskrivelse av kolonner 1. Beregning Type: - Dette kan være på ** Net Total ** (som er summen av grunnbeløpet). - ** På Forrige Row Total / Beløp ** (for kumulative skatter eller avgifter). Hvis du velger dette alternativet, vil skatten bli brukt som en prosentandel av forrige rad (i skattetabellen) eller en total. - ** Faktisk ** (som nevnt). 2. Account Head: Konto hovedbok der denne skatten vil bli bokført 3. Cost Center: Hvis skatt / avgift er en inntekt (som frakt) eller utgifter det må bestilles mot et kostnadssted. 4. Beskrivelse: Beskrivelse av skatt (som vil bli skrevet ut i fakturaer / sitater). 5. Ranger: skattesats. 6. Beløp: Skatt beløp. 7. Totalt: Akkumulert total til dette punktet. 8. Angi Row: Dersom basert på &quot;Forrige Row Total&quot; du kan velge radnummeret som vil bli tatt som en base for denne beregningen (standard er den forrige rad). 9. Vurdere Skatte eller Charge for: I denne delen kan du angi om skatt / avgift er kun for verdivurdering (ikke en del av total) eller bare for total (ikke tilføre verdi til elementet) eller for begge. 10. legge til eller trekke: Enten du ønsker å legge til eller trekke skatt."
DocType: Homepage,Homepage,hjemmeside
DocType: Purchase Receipt Item,Recd Quantity,Recd Antall
apps/erpnext/erpnext/schools/doctype/program_enrollment/program_enrollment.py +57,Fee Records Created - {0},Fee Records Laget - {0}
DocType: Asset Category Account,Asset Category Account,Asset Kategori konto
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +117,Cannot produce more Item {0} than Sales Order quantity {1},Kan ikke produsere mer Element {0} enn Salgsordre kvantitet {1}
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +539,Stock Entry {0} is not submitted,Stock Entry {0} er ikke innsendt
DocType: Payment Reconciliation,Bank / Cash Account,Bank / minibank konto
apps/erpnext/erpnext/crm/doctype/lead/lead.py +44,Next Contact By cannot be same as the Lead Email Address,Neste Kontakt By kan ikke være samme som Lead e-postadresse
DocType: Tax Rule,Billing City,Fakturering By
DocType: Asset,Manual,Håndbok
DocType: Salary Component Account,Salary Component Account,Lønn Component konto
DocType: Global Defaults,Hide Currency Symbol,Skjule Valutasymbol
apps/erpnext/erpnext/config/accounts.py +327,"e.g. Bank, Cash, Credit Card","f.eks Bank, Cash, Kredittkort"
DocType: Lead Source,Source Name,Source Name
DocType: Journal Entry,Credit Note,Kreditnota
DocType: Warranty Claim,Service Address,Tjenesten Adresse
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +49,Furnitures and Fixtures,Møbler og inventar
DocType: Item,Manufacture,Produksjon
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +13,Please Delivery Note first,Vennligst følgeseddel først
DocType: Student Applicant,Application Date,Søknadsdato
DocType: Salary Detail,Amount based on formula,Beløp basert på formelen
DocType: Purchase Invoice,Currency and Price List,Valuta og prisliste
DocType: Opportunity,Customer / Lead Name,Kunde / Lead navn
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +99,Clearance Date not mentioned,Klaring Dato ikke nevnt
apps/erpnext/erpnext/config/manufacturing.py +7,Production,Produksjon
DocType: Guardian,Occupation,Okkupasjon
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +74,Row {0}:Start Date must be before End Date,Rad {0}: Startdato må være før sluttdato
apps/erpnext/erpnext/controllers/trends.py +19,Total(Qty),Total (Stk)
DocType: Sales Invoice,This Document,dette dokumentet
DocType: Installation Note Item,Installed Qty,Installert antall
DocType: Purchase Taxes and Charges,Parenttype,Parenttype
apps/erpnext/erpnext/hr/doctype/training_event/training_event.js +7,Training Result,trening Resultat
DocType: Purchase Invoice,Is Paid,er betalt
DocType: Salary Structure,Total Earning,Total Tjene
DocType: Purchase Receipt,Time at which materials were received,Tidspunktet for når materialene ble mottatt
DocType: Stock Ledger Entry,Outgoing Rate,Utgående Rate
apps/erpnext/erpnext/config/hr.py +224,Organization branch master.,Organisering gren mester.
apps/erpnext/erpnext/controllers/accounts_controller.py +293, or ,eller
DocType: Sales Order,Billing Status,Billing Status
apps/erpnext/erpnext/public/js/conf.js +32,Report an Issue,Melde om et problem
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +120,Utility Expenses,Utility Utgifter
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +64,90-Above,90-Above
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +228,Row #{0}: Journal Entry {1} does not have account {2} or already matched against another voucher,Row # {0}: Bilagsregistrering {1} har ikke konto {2} eller allerede matchet mot en annen kupong
DocType: Buying Settings,Default Buying Price List,Standard Kjøpe Prisliste
DocType: Process Payroll,Salary Slip Based on Timesheet,Lønn Slip Basert på Timeregistrering
apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +113,No employee for the above selected criteria OR salary slip already created,Ingen ansatte for de oven valgte kriterier ELLER lønn slip allerede opprettet
DocType: Notification Control,Sales Order Message,Salgsordre Message
apps/erpnext/erpnext/config/setup.py +15,"Set Default Values like Company, Currency, Current Fiscal Year, etc.","Sett standardverdier som Company, Valuta, værende regnskapsår, etc."
DocType: Payment Entry,Payment Type,Betalings Type
apps/erpnext/erpnext/stock/doctype/batch/batch.py +130,Please select a Batch for Item {0}. Unable to find a single batch that fulfills this requirement,Vennligst velg en batch for element {0}. Kunne ikke finne en enkelt batch som oppfyller dette kravet
apps/erpnext/erpnext/stock/doctype/batch/batch.py +130,Please select a Batch for Item {0}. Unable to find a single batch that fulfills this requirement,Vennligst velg en batch for element {0}. Kunne ikke finne en enkelt batch som oppfyller dette kravet
DocType: Process Payroll,Select Employees,Velg Medarbeidere
DocType: Opportunity,Potential Sales Deal,Potensielle Sales Deal
DocType: Payment Entry,Cheque/Reference Date,Sjekk / Reference Date
DocType: Purchase Invoice,Total Taxes and Charges,Totale skatter og avgifter
DocType: Employee,Emergency Contact,Nødtelefon
DocType: Bank Reconciliation Detail,Payment Entry,betaling Entry
DocType: Item,Quality Parameters,Kvalitetsparametere
,sales-browser,salg-browser
apps/erpnext/erpnext/accounts/doctype/account/account.js +72,Ledger,Ledger
DocType: Target Detail,Target  Amount,Target Beløp
DocType: Shopping Cart Settings,Shopping Cart Settings,Handlevogn Innstillinger
DocType: Journal Entry,Accounting Entries,Regnskaps Entries
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +24,Duplicate Entry. Please check Authorization Rule {0},Duplisere Entry. Vennligst sjekk Authorization Rule {0}
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +27,Global POS Profile {0} already created for company {1},Globalt POS profil {0} allerede opprettet for selskap {1}
DocType: Purchase Order,Ref SQ,Ref SQ
apps/erpnext/erpnext/config/manufacturing.py +74,Replace Item / BOM in all BOMs,Erstatte varen / BOM i alle stykklister
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +53,Receipt document must be submitted,Kvittering dokumentet må sendes
DocType: Purchase Invoice Item,Received Qty,Mottatt Antall
DocType: Stock Entry Detail,Serial No / Batch,Serial No / Batch
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +320,Not Paid and Not Delivered,Ikke betalt og ikke levert
DocType: Product Bundle,Parent Item,Parent Element
DocType: Account,Account Type,Kontotype
DocType: Delivery Note,DN-RET-,DN-RET-
apps/erpnext/erpnext/templates/pages/projects.html +58,No time sheets,Ingen timelister
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +123,Leave Type {0} cannot be carry-forwarded,La Type {0} kan ikke bære-videre
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +215,Maintenance Schedule is not generated for all the items. Please click on 'Generate Schedule',Vedlikeholdsplan genereres ikke for alle elementene. Vennligst klikk på &quot;Generer Schedule &#39;
,To Produce,Å Produsere
apps/erpnext/erpnext/config/hr.py +93,Payroll,lønn
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +179,"For row {0} in {1}. To include {2} in Item rate, rows {3} must also be included","For rad {0} i {1}. For å inkludere {2} i Element rate, rader {3} må også inkluderes"
apps/erpnext/erpnext/utilities/activation.py +99,Make User,Gjør Bruker
DocType: Packing Slip,Identification of the package for the delivery (for print),Identifikasjon av pakken for levering (for print)
DocType: Bin,Reserved Quantity,Reservert Antall
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +34,Please enter valid email address,Vennligst skriv inn gyldig e-postadresse
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +34,Please enter valid email address,Vennligst skriv inn gyldig e-postadresse
DocType: Landed Cost Voucher,Purchase Receipt Items,Kvitteringen Items
apps/erpnext/erpnext/config/learn.py +21,Customizing Forms,Tilpasse Forms
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +43,Arrear,etterskudd
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +155,Depreciation Amount during the period,Avskrivningsbeløpet i perioden
apps/erpnext/erpnext/accounts/doctype/sales_taxes_and_charges_template/sales_taxes_and_charges_template.py +38,Disabled template must not be default template,Funksjonshemmede malen må ikke være standardmal
DocType: Account,Income Account,Inntekt konto
DocType: Payment Request,Amount in customer's currency,Beløp i kundens valuta
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +759,Delivery,Levering
DocType: Stock Reconciliation Item,Current Qty,Nåværende Antall
DocType: BOM Item,"See ""Rate Of Materials Based On"" in Costing Section",Se &quot;Rate Of materialer basert på&quot; i Costing Seksjon
apps/erpnext/erpnext/templates/generators/item_group.html +36,Prev,prev
DocType: Appraisal Goal,Key Responsibility Area,Key Ansvar Område
apps/erpnext/erpnext/utilities/activation.py +125,"Student Batches help you track attendance, assessments and fees for students","Student batcher hjelpe deg med å spore oppmøte, vurderinger og avgifter for studenter"
DocType: Payment Entry,Total Allocated Amount,Totalt tildelte beløp
apps/erpnext/erpnext/setup/doctype/company/company.py +150,Set default inventory account for perpetual inventory,Angi standard beholdningskonto for evigvarende beholdning
DocType: Item Reorder,Material Request Type,Materialet Request Type
apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +267,Accural Journal Entry for salaries from {0} to {1},Accural dagboken til lønninger fra {0} i {1}
apps/erpnext/erpnext/accounts/page/pos/pos.js +788,"LocalStorage is full, did not save","Localstorage er full, ikke redde"
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +85,Row {0}: UOM Conversion Factor is mandatory,Rad {0}: målenheter omregningsfaktor er obligatorisk
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +14,Ref,Ref
DocType: Budget,Cost Center,Kostnadssted
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +36,Voucher #,Kupong #
DocType: Notification Control,Purchase Order Message,Innkjøpsordre Message
DocType: Tax Rule,Shipping Country,Shipping Land
DocType: Selling Settings,Hide Customer's Tax Id from Sales Transactions,Skjule Kundens Tax ID fra salgstransaksjoner
DocType: Upload Attendance,Upload HTML,Last opp HTML
DocType: Employee,Relieving Date,Lindrende Dato
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +14,"Pricing Rule is made to overwrite Price List / define discount percentage, based on some criteria.","Prising Rule er laget for å overskrive Prisliste / definere rabattprosenten, basert på noen kriterier."
DocType: Serial No,Warehouse can only be changed via Stock Entry / Delivery Note / Purchase Receipt,Lageret kan bare endres via Stock Entry / følgeseddel / Kjøpskvittering
DocType: Employee Education,Class / Percentage,Klasse / Prosent
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +103,Head of Marketing and Sales,Head of Marketing and Sales
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +41,Income Tax,Inntektsskatt
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +17,"If selected Pricing Rule is made for 'Price', it will overwrite Price List. Pricing Rule price is the final price, 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.","Hvis valgt Pricing Rule er laget for &#39;Pris&#39;, det vil overskrive Prisliste. Priser Rule prisen er den endelige prisen, så ingen ytterligere rabatt bør påføres. Derfor, i transaksjoner som Salgsordre, innkjøpsordre osv, det vil bli hentet i &quot;Valuta-feltet, heller enn&quot; Prisliste Valuta-feltet."
apps/erpnext/erpnext/config/selling.py +174,Track Leads by Industry Type.,Spor Leads etter bransje Type.
DocType: Item Supplier,Item Supplier,Sak Leverandør
apps/erpnext/erpnext/public/js/controllers/transaction.js +1083,Please enter Item Code to get batch no,Skriv inn Element kode for å få batch no
apps/erpnext/erpnext/selling/doctype/quotation/quotation.js +782,Please select a value for {0} quotation_to {1},Velg en verdi for {0} quotation_to {1}
apps/erpnext/erpnext/config/selling.py +46,All Addresses.,Alle adresser.
DocType: Company,Stock Settings,Aksje Innstillinger
apps/erpnext/erpnext/accounts/doctype/account/account.py +199,"Merging is only possible if following properties are same in both records. Is Group, Root Type, Company","Sammenslåing er bare mulig hvis følgende egenskaper er samme i begge postene. Er Group, Root Type, Company"
DocType: Vehicle,Electric,Elektrisk
DocType: Task,% Progress,% Progress
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +123,Gain/Loss on Asset Disposal,Gevinst / Tap på Asset Avhending
DocType: Training Event,Will send an email about the event to employees with status 'Open',Vil sende en e-post om hendelsen til ansatte med status &#39;Open&#39;
DocType: Task,Depends on Tasks,Avhenger Oppgaver
apps/erpnext/erpnext/config/selling.py +36,Manage Customer Group Tree.,Administrere kunde Gruppe treet.
DocType: Shopping Cart Settings,Attachments can be shown without enabling the shopping cart,Vedlegg kan vises uten å tillate handlekurven
DocType: Supplier Quotation,SQTN-,SQTN-
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +22,New Cost Center Name,New kostnadssted Navn
DocType: Leave Control Panel,Leave Control Panel,La Kontrollpanel
DocType: Project,Task Completion,Task Fullføring
apps/erpnext/erpnext/templates/includes/product_page.js +21,Not in Stock,Ikke på lager
DocType: Appraisal,HR User,HR User
DocType: Purchase Invoice,Taxes and Charges Deducted,Skatter og avgifter fratrukket
apps/erpnext/erpnext/hooks.py +117,Issues,Problemer
apps/erpnext/erpnext/controllers/status_updater.py +12,Status must be one of {0},Status må være en av {0}
DocType: Sales Invoice,Debit To,Debet Å
DocType: Delivery Note,Required only for sample item.,Kreves bare for prøve element.
DocType: Stock Ledger Entry,Actual Qty After Transaction,Selve Antall Etter Transaksjons
apps/erpnext/erpnext/hr/report/salary_register/salary_register.py +65,No salary slip found between {0} and {1},Ingen lønn slip funnet mellom {0} og {1}
,Pending SO Items For Purchase Request,Avventer SO varer for kjøp Request
apps/erpnext/erpnext/schools/doctype/student_admission/student_admission.py +29,Student Admissions,student Opptak
apps/erpnext/erpnext/accounts/party.py +350,{0} {1} is disabled,{0} {1} er deaktivert
DocType: Supplier,Billing Currency,Faktureringsvaluta
DocType: Sales Invoice,SINV-RET-,SINV-RET-
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +169,Extra Large,Extra large
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +58,Total Leaves,Totalt Leaves
,Profit and Loss Statement,Resultatregnskap
DocType: Bank Reconciliation Detail,Cheque Number,Sjekk Antall
,Sales Browser,Salg Browser
DocType: Journal Entry,Total Credit,Total Credit
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +542,Warning: Another {0} # {1} exists against stock entry {2},Advarsel: Another {0} # {1} finnes mot aksje oppføring {2}
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +120,Local,Lokal
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +26,Loans and Advances (Assets),Utlån (Eiendeler)
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +12,Debtors,Skyldnere
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +168,Large,Stor
DocType: Homepage Featured Product,Homepage Featured Product,Hjemmeside Aktuelle produkter
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +205,All Assessment Groups,Alle Assessment grupper
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js +15,New Warehouse Name,New Warehouse navn
apps/erpnext/erpnext/accounts/report/financial_statements.py +227,Total {0} ({1}),Totalt {0} ({1})
DocType: C-Form Invoice Detail,Territory,Territorium
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +151,Please mention no of visits required,Vennligst oppgi ingen av besøk som kreves
DocType: Stock Settings,Default Valuation Method,Standard verdsettelsesmetode
apps/erpnext/erpnext/schools/doctype/student/student_dashboard.py +26,Fee,Avgift
DocType: Vehicle Log,Fuel Qty,drivstoff Antall
DocType: Production Order Operation,Planned Start Time,Planlagt Starttid
DocType: Course,Assessment,Assessment
DocType: Payment Entry Reference,Allocated,Avsatt
apps/erpnext/erpnext/config/accounts.py +269,Close Balance Sheet and book Profit or Loss.,Lukk Balanse og bok resultatet.
DocType: Student Applicant,Application Status,søknad Status
DocType: Fees,Fees,avgifter
DocType: Currency Exchange,Specify Exchange Rate to convert one currency into another,Spesifiser Exchange Rate å konvertere en valuta til en annen
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +158,Quotation {0} is cancelled,Sitat {0} er kansellert
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +25,Total Outstanding Amount,Totalt utestående beløp
DocType: Sales Partner,Targets,Targets
DocType: Price List,Price List Master,Prisliste Master
DocType: Sales Person,All Sales Transactions can be tagged against multiple **Sales Persons** so that you can set and monitor targets.,Alle salgstransaksjoner kan være merket mot flere ** Salgs Personer ** slik at du kan stille inn og overvåke mål.
,S.O. No.,SO No.
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +176,Please create Customer from Lead {0},Opprett Customer fra Lead {0}
DocType: Price List,Applicable for Countries,Gjelder for Land
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +52,Only Leave Applications with status 'Approved' and 'Rejected' can be submitted,Bare La Applikasjoner med status &#39;Godkjent&#39; og &#39;Avvist&#39; kan sendes inn
apps/erpnext/erpnext/schools/doctype/student_group_creation_tool/student_group_creation_tool.py +51,Student Group Name is mandatory in row {0},Student Gruppenavn er obligatorisk i rad {0}
DocType: Homepage,Products to be shown on website homepage,Produkter som skal vises på nettstedet hjemmeside
apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.js +13,This is a root customer group and cannot be edited.,"Dette er en rot kundegruppe, og kan ikke redigeres."
DocType: Employee,AB-,AB-
DocType: POS Profile,Ignore Pricing Rule,Ignorer Pricing Rule
DocType: Employee Education,Graduate,Utdannet
DocType: Leave Block List,Block Days,Block Days
DocType: Journal Entry,Excise Entry,Vesenet Entry
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +64,Warning: Sales Order {0} already exists against Customer's Purchase Order {1},Advarsel: Salgsordre {0} finnes allerede mot kundens innkjøpsordre {1}
DocType: Terms and Conditions,"Standard Terms and Conditions that can be added to Sales and Purchases.

Examples:

1. Validity of the offer.
1. Payment Terms (In Advance, On Credit, part advance etc).
1. What is extra (or payable by the Customer).
1. Safety / usage warning.
1. Warranty if any.
1. Returns Policy.
1. Terms of shipping, if applicable.
1. Ways of addressing disputes, indemnity, liability, etc.
1. Address and Contact of your Company.","Standardvilkårene som kan legges til salg og kjøp. Eksempler: 1. Gyldighet av tilbudet. 1. Betalingsvilkår (på forhånd, på kreditt, del forhånd etc). 1. Hva er ekstra (eller skal betales av kunden). 1. Sikkerhet / bruk advarsel. 1. Garanti om noen. 1. Returrett. 1. Vilkår for frakt, hvis aktuelt. 1. Måter adressering tvister, erstatning, ansvar, etc. 1. Adresse og kontakt med din bedrift."
DocType: Attendance,Leave Type,La Type
DocType: Purchase Invoice,Supplier Invoice Details,Leverandør Fakturadetaljer
apps/erpnext/erpnext/controllers/stock_controller.py +233,Expense / Difference account ({0}) must be a 'Profit or Loss' account,Expense / Difference konto ({0}) må være en &quot;resultatet&quot; konto
DocType: Project,Copied From,Kopiert fra
DocType: Project,Copied From,Kopiert fra
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +91,Name error: {0},Navn feil: {0}
apps/erpnext/erpnext/stock/doctype/item/item_list.js +8,Shortage,Mangel
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +203,{0} {1} does not associated with {2} {3},{0} {1} ikke er knyttet til {2} {3}
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +18,Attendance for employee {0} is already marked,Oppmøte for arbeidstaker {0} er allerede merket
DocType: Packing Slip,If more than one package of the same type (for print),Hvis mer enn en pakke av samme type (for print)
,Salary Register,lønn Register
DocType: Warehouse,Parent Warehouse,Parent Warehouse
DocType: C-Form Invoice Detail,Net Total,Net Total
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +497,Default BOM not found for Item {0} and Project {1},Standard BOM ikke funnet for element {0} og prosjekt {1}
apps/erpnext/erpnext/config/hr.py +163,Define various loan types,Definere ulike typer lån
DocType: Bin,FCFS Rate,FCFS Rate
DocType: Payment Reconciliation Invoice,Outstanding Amount,Utestående Beløp
apps/erpnext/erpnext/templates/generators/bom.html +71,Time(in mins),Tid (i minutter)
DocType: Project Task,Working,Arbeids
DocType: Stock Ledger Entry,Stock Queue (FIFO),Stock Queue (FIFO)
apps/erpnext/erpnext/public/js/setup_wizard.js +107,Financial Year,Regnskapsår
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +39,{0} does not belong to Company {1},{0} ikke tilhører selskapet {1}
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +119,Cost as on,Koste så på
DocType: Account,Round Off,Avrunde
,Requested Qty,Spurt Antall
DocType: Tax Rule,Use for Shopping Cart,Brukes til handlekurv
apps/erpnext/erpnext/controllers/item_variant.py +96,Value {0} for Attribute {1} does not exist in the list of valid Item Attribute Values for Item {2},Verdi {0} for Egenskap {1} finnes ikke i listen over gyldige elementattributtet Verdier for Element {2}
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +77,Select Serial Numbers,Velg serienummer
DocType: BOM Item,Scrap %,Skrap%
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +46,"Charges will be distributed proportionately based on item qty or amount, as per your selection","Kostnader vil bli fordelt forholdsmessig basert på element stk eller beløp, som per ditt valg"
DocType: Maintenance Visit,Purposes,Formål
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +111,Atleast one item should be entered with negative quantity in return document,Atleast ett element bør legges inn med negativt antall i retur dokument
apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +71,"Operation {0} longer than any available working hours in workstation {1}, break down the operation into multiple operations","Operation {0} lenger enn noen tilgjengelige arbeidstimer i arbeidsstasjonen {1}, bryte ned driften i flere operasjoner"
,Requested,Spurt
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +86,No Remarks,Nei Anmerkninger
DocType: Purchase Invoice,Overdue,Forfalt
DocType: Account,Stock Received But Not Billed,"Stock mottatt, men ikke fakturert"
apps/erpnext/erpnext/accounts/doctype/account/account.py +87,Root Account must be a group,Root-kontoen må være en gruppe
DocType: Fees,FEE.,AVGIFT.
DocType: Employee Loan,Repaid/Closed,Tilbakebetalt / Stengt
DocType: Item,Total Projected Qty,Samlet forventet Antall
DocType: Monthly Distribution,Distribution Name,Distribusjon Name
DocType: Course,Course Code,Kurskode
apps/erpnext/erpnext/controllers/stock_controller.py +331,Quality Inspection required for Item {0},Quality Inspection nødvendig for Element {0}
DocType: Quotation,Rate at which customer's currency is converted to company's base currency,Hastigheten som kundens valuta er konvertert til selskapets hovedvaluta
DocType: Purchase Invoice Item,Net Rate (Company Currency),Netto Rate (Selskap Valuta)
DocType: Salary Detail,Condition and Formula Help,Tilstand og Formula Hjelp
apps/erpnext/erpnext/config/selling.py +105,Manage Territory Tree.,Administrer Territory treet.
DocType: Journal Entry Account,Sales Invoice,Salg Faktura
DocType: Journal Entry Account,Party Balance,Fest Balance
apps/erpnext/erpnext/accounts/page/pos/pos.js +462,Please select Apply Discount On,Vennligst velg Bruk rabatt på
DocType: Company,Default Receivable Account,Standard fordringer konto
DocType: Process Payroll,Create Bank Entry for the total salary paid for the above selected criteria,Lag Bank Entry for den totale lønn for de ovenfor valgte kriterier
DocType: Stock Entry,Material Transfer for Manufacture,Material Transfer for Produksjon
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +20,Discount Percentage can be applied either against a Price List or for all Price List.,Rabattprosenten kan brukes enten mot en prisliste eller for alle Prisliste.
DocType: Purchase Invoice,Half-yearly,Halvårs
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +397,Accounting Entry for Stock,Regnskap Entry for Stock
apps/erpnext/erpnext/schools/doctype/assessment_plan/assessment_plan.py +49,You have already assessed for the assessment criteria {}.,Du har allerede vurdert for vurderingskriteriene {}.
DocType: Vehicle Service,Engine Oil,Motorolje
DocType: Sales Invoice,Sales Team1,Salg TEAM1
apps/erpnext/erpnext/accounts/doctype/asset/asset.py +39,Item {0} does not exist,Element {0} finnes ikke
DocType: Sales Invoice,Customer Address,Kunde Adresse
DocType: Employee Loan,Loan Details,lån Detaljer
DocType: Company,Default Inventory Account,Standard lagerkonto
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +120,Row {0}: Completed Qty must be greater than zero.,Rad {0}: Fullført Antall må være større enn null.
DocType: Purchase Invoice,Apply Additional Discount On,Påfør Ytterligere rabatt på
DocType: Account,Root Type,Root Type
DocType: Item,FIFO,FIFO
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +132,Row # {0}: Cannot return more than {1} for Item {2},Row # {0}: Kan ikke returnere mer enn {1} for Element {2}
apps/erpnext/erpnext/manufacturing/page/production_analytics/production_analytics.js +29,Plot,Plott
DocType: Item Group,Show this slideshow at the top of the page,Vis lysbildefremvisning på toppen av siden
DocType: BOM,Item UOM,Sak målenheter
DocType: Sales Taxes and Charges,Tax Amount After Discount Amount (Company Currency),Skattebeløp Etter Rabattbeløp (Company Valuta)
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +150,Target warehouse is mandatory for row {0},Target lageret er obligatorisk for rad {0}
DocType: Cheque Print Template,Primary Settings,primære Innstillinger
DocType: Purchase Invoice,Select Supplier Address,Velg Leverandør Adresse
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +380,Add Employees,Legg Medarbeidere
DocType: Purchase Invoice Item,Quality Inspection,Quality Inspection
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +165,Extra Small,Extra Small
DocType: Company,Standard Template,standard Template
DocType: Training Event,Theory,Teori
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +762,Warning: Material Requested Qty is less than Minimum Order Qty,Advarsel: Material Requested Antall er mindre enn Minimum Antall
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +211,Account {0} is frozen,Konto {0} er frosset
DocType: Company,Legal Entity / Subsidiary with a separate Chart of Accounts belonging to the Organization.,Legal Entity / Datterselskap med en egen konto tilhørighet til organisasjonen.
DocType: Payment Request,Mute Email,Demp Email
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +29,"Food, Beverage & Tobacco","Mat, drikke og tobakk"
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +642,Can only make payment against unbilled {0},Kan bare gjøre betaling mot fakturert {0}
apps/erpnext/erpnext/controllers/selling_controller.py +127,Commission rate cannot be greater than 100,Kommisjon kan ikke være større enn 100
DocType: Stock Entry,Subcontract,Underentrepriser
apps/erpnext/erpnext/public/js/utils/party.js +165,Please enter {0} first,Fyll inn {0} først
apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py +68,No replies from,Ingen svar fra
DocType: Production Order Operation,Actual End Time,Faktisk Sluttid
DocType: Production Planning Tool,Download Materials Required,Last ned Materialer som er nødvendige
DocType: Item,Manufacturer Part Number,Produsentens varenummer
DocType: Production Order Operation,Estimated Time and Cost,Estimert leveringstid og pris
DocType: Bin,Bin,Bin
DocType: SMS Log,No of Sent SMS,Ingen av Sendte SMS
DocType: Account,Expense Account,Expense konto
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +49,Software,Programvare
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +172,Colour,Farge
DocType: Assessment Plan Criteria,Assessment Plan Criteria,Assessment Plan Kriterier
DocType: Training Event,Scheduled,Planlagt
apps/erpnext/erpnext/config/buying.py +18,Request for quotation.,Forespørsel om kostnadsoverslag.
apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.js +13,"Please select Item where ""Is Stock Item"" is ""No"" and ""Is Sales Item"" is ""Yes"" and there is no other Product Bundle","Vennligst velg Element der &quot;Er Stock Item&quot; er &quot;Nei&quot; og &quot;Er Sales Item&quot; er &quot;Ja&quot;, og det er ingen andre Product Bundle"
DocType: Student Log,Academic,akademisk
apps/erpnext/erpnext/controllers/accounts_controller.py +489,Total advance ({0}) against Order {1} cannot be greater than the Grand Total ({2}),Total forhånd ({0}) mot Bestill {1} kan ikke være større enn totalsummen ({2})
DocType: Sales Partner,Select Monthly Distribution to unevenly distribute targets across months.,Velg Månedlig Distribusjon til ujevnt fordele målene gjennom måneder.
DocType: Purchase Invoice Item,Valuation Rate,Verdivurdering Rate
DocType: Stock Reconciliation,SR/,SR /
DocType: Vehicle,Diesel,diesel
apps/erpnext/erpnext/stock/get_item_details.py +328,Price List Currency not selected,Prisliste Valuta ikke valgt
,Student Monthly Attendance Sheet,Student Månedlig Oppmøte Sheet
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +185,Employee {0} has already applied for {1} between {2} and {3},Ansatt {0} har allerede søkt om {1} mellom {2} og {3}
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +30,Project Start Date,Prosjekt startdato
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +5,Until,Inntil
DocType: Rename Tool,Rename Log,Rename Logg
apps/erpnext/erpnext/schools/doctype/student_attendance/student_attendance.py +27,Student Group or Course Schedule is mandatory,Studentgruppe eller kursplan er obligatorisk
apps/erpnext/erpnext/schools/doctype/student_attendance/student_attendance.py +27,Student Group or Course Schedule is mandatory,Studentgruppe eller kursplan er obligatorisk
DocType: HR Settings,Maintain Billing Hours and Working Hours Same on Timesheet,Opprettholde Fakturerings timer og arbeidstid samme på Timeregistrering
DocType: Maintenance Visit Purpose,Against Document No,Mot Dokument nr
DocType: BOM,Scrap,skrap
apps/erpnext/erpnext/config/selling.py +110,Manage Sales Partners.,Administrer Salgs Partners.
DocType: Quality Inspection,Inspection Type,Inspeksjon Type
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +131,Warehouses with existing transaction can not be converted to group.,Næringslokaler med eksisterende transaksjon kan ikke konverteres til gruppen.
DocType: Assessment Result Tool,Result HTML,resultat HTML
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +35,Expires On,Går ut på dato den
apps/erpnext/erpnext/utilities/activation.py +115,Add Students,Legg Studenter
apps/erpnext/erpnext/controllers/recurring_document.py +169,Please select {0},Vennligst velg {0}
DocType: C-Form,C-Form No,C-Form Nei
DocType: BOM,Exploded_items,Exploded_items
DocType: Employee Attendance Tool,Unmarked Attendance,Umerket Oppmøte
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +106,Researcher,Forsker
DocType: Program Enrollment Tool Student,Program Enrollment Tool Student,Program Påmelding Tool Student
apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py +25,Name or Email is mandatory,Navn eller E-post er obligatorisk
apps/erpnext/erpnext/config/stock.py +163,Incoming quality inspection.,Innkommende kvalitetskontroll.
DocType: Purchase Order Item,Returned Qty,Returnerte Stk
DocType: Employee,Exit,Utgang
apps/erpnext/erpnext/accounts/doctype/account/account.py +159,Root Type is mandatory,Root Type er obligatorisk
DocType: BOM,Total Cost(Company Currency),Totalkostnad (Selskap Valuta)
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +299,Serial No {0} created,Serial No {0} opprettet
DocType: Homepage,Company Description for website homepage,Selskapet beskrivelse for nettstedet hjemmeside
DocType: Item Customer Detail,"For the convenience of customers, these codes can be used in print formats like Invoices and Delivery Notes","For det lettere for kunder, kan disse kodene brukes i trykte formater som regningene og leveringssedlene"
apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py +18,Suplier Name,suplier Name
DocType: Sales Invoice,Time Sheet List,Timeregistrering List
DocType: Employee,You can enter any date manually,Du kan legge inn noen dato manuelt
DocType: Asset Category Account,Depreciation Expense Account,Avskrivninger konto
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +190,Probationary Period,Prøvetid
DocType: Customer Group,Only leaf nodes are allowed in transaction,Bare bladnoder er tillatt i transaksjonen
DocType: Expense Claim,Expense Approver,Expense Godkjenner
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +136,Row {0}: Advance against Customer must be credit,Rad {0}: Advance mot Kunden må være kreditt
apps/erpnext/erpnext/accounts/doctype/account/account.js +82,Non-Group to Group,Non-gruppe til gruppe
apps/erpnext/erpnext/schools/doctype/student_group_creation_tool/student_group_creation_tool.py +57,Batch is mandatory in row {0},Batch er obligatorisk i rad {0}
apps/erpnext/erpnext/schools/doctype/student_group_creation_tool/student_group_creation_tool.py +57,Batch is mandatory in row {0},Batch er obligatorisk i rad {0}
DocType: Purchase Receipt Item Supplied,Purchase Receipt Item Supplied,Kvitteringen Sak Leveres
DocType: Payment Entry,Pay,Betale
apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py +24,To Datetime,Til Datetime
DocType: SMS Settings,SMS Gateway URL,SMS Gateway URL
apps/erpnext/erpnext/schools/doctype/course_scheduling_tool/course_scheduling_tool.py +54,Course Schedules deleted:,Kurstider slettet:
apps/erpnext/erpnext/config/selling.py +297,Logs for maintaining sms delivery status,Logger for å opprettholde sms leveringsstatus
DocType: Accounts Settings,Make Payment via Journal Entry,Utfør betaling via bilagsregistrering
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +77,Printed On,Trykt på
DocType: Item,Inspection Required before Delivery,Inspeksjon Påkrevd før Levering
DocType: Item,Inspection Required before Purchase,Inspeksjon Påkrevd før kjøp
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +93,Pending Activities,Ventende Aktiviteter
apps/erpnext/erpnext/public/js/setup_wizard.js +86,Your Organization,Din organisasjon
DocType: Fee Component,Fees Category,avgifter Kategori
apps/erpnext/erpnext/hr/doctype/employee/employee.py +129,Please enter relieving date.,Skriv inn lindrende dato.
apps/erpnext/erpnext/controllers/trends.py +149,Amt,Amt
DocType: Opportunity,Enter name of campaign if source of enquiry is campaign,Skriv inn navnet på kampanjen hvis kilden til henvendelsen er kampanje
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +38,Newspaper Publishers,Avis Publishers
apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +30,Select Fiscal Year,Velg regnskapsår
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +112,Expected Delivery Date should be after Sales Order Date,Forventet leveringsdato bør være etter salgsordre
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +43,Reorder Level,Omgjøre nivå
DocType: Company,Chart Of Accounts Template,Konto Mal
DocType: Attendance,Attendance Date,Oppmøte Dato
apps/erpnext/erpnext/stock/get_item_details.py +292,Item Price updated for {0} in Price List {1},Sak Pris oppdateres for {0} i prislisten {1}
DocType: Salary Structure,Salary breakup based on Earning and Deduction.,Lønn breakup basert på opptjening og fradrag.
apps/erpnext/erpnext/accounts/doctype/account/account.py +131,Account with child nodes cannot be converted to ledger,Konto med barnet noder kan ikke konverteres til Ledger
DocType: Purchase Invoice Item,Accepted Warehouse,Akseptert Warehouse
DocType: Bank Reconciliation Detail,Posting Date,Publiseringsdato
DocType: Item,Valuation Method,Verdsettelsesmetode
apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +203,Mark Half Day,Mark Half Day
DocType: Sales Invoice,Sales Team,Sales Team
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +85,Duplicate entry,Duplicate entry
DocType: Program Enrollment Tool,Get Students,Få Studenter
DocType: Serial No,Under Warranty,Under Garanti
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +491,[Error],[Error]
DocType: Sales Order,In Words will be visible once you save the Sales Order.,I Ord vil være synlig når du lagrer kundeordre.
,Employee Birthday,Ansatt Bursdag
DocType: Student Batch Attendance Tool,Student Batch Attendance Tool,Student Batch Oppmøte Tool
apps/erpnext/erpnext/controllers/status_updater.py +210,Limit Crossed,Limit Krysset
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +55,Venture Capital,Venture Capital
apps/erpnext/erpnext/schools/doctype/academic_term/academic_term.py +40,An academic term with this 'Academic Year' {0} and 'Term Name' {1} already exists. Please modify these entries and try again.,Et semester med denne &#39;Academic Year&#39; {0} og &quot;Term Name {1} finnes allerede. Vennligst endre disse oppføringene og prøv igjen.
apps/erpnext/erpnext/stock/doctype/item/item.py +461,"As there are existing transactions against item {0}, you can not change the value of {1}","Ettersom det er eksisterende transaksjoner mot item {0}, kan du ikke endre verdien av {1}"
DocType: UOM,Must be Whole Number,Må være hele tall
DocType: Leave Control Panel,New Leaves Allocated (In Days),Nye Løv Tildelte (i dager)
DocType: Sales Invoice,Invoice Copy,Faktura kopi
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +49,Serial No {0} does not exist,Serial No {0} finnes ikke
DocType: Sales Invoice Item,Customer Warehouse (Optional),Customer Warehouse (valgfritt)
DocType: Pricing Rule,Discount Percentage,Rabatt Prosent
DocType: Payment Reconciliation Invoice,Invoice Number,Fakturanummer
DocType: Shopping Cart Settings,Orders,Bestillinger
DocType: Employee Leave Approver,Leave Approver,La Godkjenner
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +251,Please select a batch,Vennligst velg en batch
DocType: Assessment Group,Assessment Group Name,Assessment Gruppenavn
DocType: Manufacturing Settings,Material Transferred for Manufacture,Materialet Overført for Produksjon
DocType: Expense Claim,"A user with ""Expense Approver"" role",En bruker med &quot;Expense Godkjenner&quot; rolle
DocType: Landed Cost Item,Receipt Document Type,Kvittering dokumenttype
DocType: Daily Work Summary Settings,Select Companies,Velg selskaper
,Issued Items Against Production Order,Utstedte gjenstander mot produksjonsordre
DocType: Target Detail,Target Detail,Target Detalj
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +24,All Jobs,alle jobber
DocType: Sales Order,% of materials billed against this Sales Order,% Av materialer fakturert mot denne kundeordre
DocType: Program Enrollment,Mode of Transportation,Transportform
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +49,Period Closing Entry,Periode Closing Entry
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +38,Cost Center with existing transactions can not be converted to group,Kostnadssted med eksisterende transaksjoner kan ikke konverteres til gruppen
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +348,Amount {0} {1} {2} {3},Mengden {0} {1} {2} {3}
DocType: Account,Depreciation,Avskrivninger
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +49,Supplier(s),Leverandør (er)
DocType: Employee Attendance Tool,Employee Attendance Tool,Employee Oppmøte Tool
DocType: Guardian Student,Guardian Student,Guardian Student
DocType: Supplier,Credit Limit,Kredittgrense
DocType: Production Plan Sales Order,Salse Order Date,Salse Ordredato
DocType: Salary Component,Salary Component,lønn Component
apps/erpnext/erpnext/accounts/utils.py +496,Payment Entries {0} are un-linked,Betalings Innlegg {0} er un-linked
DocType: GL Entry,Voucher No,Kupong Ingen
,Lead Owner Efficiency,Leder Eier Effektivitet
,Lead Owner Efficiency,Leder Eier Effektivitet
DocType: Leave Allocation,Leave Allocation,La Allocation
DocType: Payment Request,Recipient Message And Payment Details,Mottakers Message og betalingsinformasjon
DocType: Training Event,Trainer Email,trener E-post
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +546,Material Requests {0} created,Materielle Forespørsler {0} er opprettet
DocType: Production Planning Tool,Include sub-contracted raw materials,Inkluder underleverandør råvarer
apps/erpnext/erpnext/config/selling.py +164,Template of terms or contract.,Mal av begreper eller kontrakt.
DocType: Purchase Invoice,Address and Contact,Adresse og Kontakt
DocType: Cheque Print Template,Is Account Payable,Er konto Betales
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +269,Stock cannot be updated against Purchase Receipt {0},Stock kan ikke oppdateres mot Kjøpskvittering {0}
DocType: Supplier,Last Day of the Next Month,Siste dag av neste måned
DocType: Support Settings,Auto close Issue after 7 days,Auto nær Issue etter 7 dager
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +71,"Leave cannot be allocated before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}","Permisjon kan ikke tildeles før {0}, som permisjon balanse har allerede vært carry-sendt i fremtiden permisjon tildeling posten {1}"
apps/erpnext/erpnext/accounts/party.py +309,Note: Due / Reference Date exceeds allowed customer credit days by {0} day(s),Merk: På grunn / Reference Date stiger tillatt kunde kreditt dager med {0} dag (er)
apps/erpnext/erpnext/schools/doctype/program/program.js +8,Student Applicant,student Søker
DocType: Sales Invoice,ORIGINAL FOR RECIPIENT,ORIGINAL FOR RECIPIENT
DocType: Asset Category Account,Accumulated Depreciation Account,Akkumulerte avskrivninger konto
DocType: Stock Settings,Freeze Stock Entries,Freeze Stock Entries
DocType: Program Enrollment,Boarding Student,Studerende Student
DocType: Asset,Expected Value After Useful Life,Forventet verdi Etter Levetid
DocType: Item,Reorder level based on Warehouse,Omgjøre nivå basert på Warehouse
DocType: Activity Cost,Billing Rate,Billing Rate
,Qty to Deliver,Antall å levere
,Stock Analytics,Aksje Analytics
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +472,Operations cannot be left blank,Operasjoner kan ikke være tomt
DocType: Maintenance Visit Purpose,Against Document Detail No,Mot Document Detail Nei
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +96,Party Type is mandatory,Partiet Type er obligatorisk
DocType: Quality Inspection,Outgoing,Utgående
DocType: Material Request,Requested For,Spurt For
DocType: Quotation Item,Against Doctype,Mot Doctype
apps/erpnext/erpnext/controllers/buying_controller.py +391,{0} {1} is cancelled or closed,{0} {1} er kansellert eller lukket
DocType: Delivery Note,Track this Delivery Note against any Project,Spor dette følgeseddel mot ethvert prosjekt
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +30,Net Cash from Investing,Netto kontantstrøm fra investerings
DocType: Production Order,Work-in-Progress Warehouse,Work-in-progress Warehouse
apps/erpnext/erpnext/accounts/doctype/asset/depreciation.py +108,Asset {0} must be submitted,Asset {0} må fremlegges
apps/erpnext/erpnext/schools/doctype/student_attendance/student_attendance.py +56,Attendance Record {0} exists against Student {1},Oppmøte Record {0} finnes mot Student {1}
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +354,Reference #{0} dated {1},Reference # {0} datert {1}
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +161,Depreciation Eliminated due to disposal of assets,Avskrivninger Slått på grunn av salg av eiendeler
apps/erpnext/erpnext/templates/includes/cart/cart_address.html +15,Manage Addresses,Administrer Adresser
DocType: Asset,Item Code,Sak Kode
DocType: Production Planning Tool,Create Production Orders,Opprett produksjonsordrer
DocType: Serial No,Warranty / AMC Details,Garanti / AMC Detaljer
apps/erpnext/erpnext/schools/doctype/student_group/student_group.js +116,Select students manually for the Activity based Group,Velg studenter manuelt for aktivitetsbasert gruppe
DocType: Journal Entry,User Remark,Bruker Remark
DocType: Lead,Market Segment,Markedssegment
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +900,Paid Amount cannot be greater than total negative outstanding amount {0},Betalt Beløpet kan ikke være større enn total negativ utestående beløp {0}
DocType: Employee Internal Work History,Employee Internal Work History,Ansatt Intern Work History
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +239,Closing (Dr),Lukking (Dr)
DocType: Cheque Print Template,Cheque Size,sjekk Size
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +232,Serial No {0} not in stock,Serial No {0} ikke på lager
apps/erpnext/erpnext/config/selling.py +169,Tax template for selling transactions.,Skatt mal for å selge transaksjoner.
DocType: Sales Invoice,Write Off Outstanding Amount,Skriv Av utestående beløp
apps/erpnext/erpnext/hr/doctype/expense_claim_type/expense_claim_type.py +27,Account {0} does not match with Company {1},Konto {0} stemmer ikke overens med selskapets {1}
DocType: School Settings,Current Academic Year,Nåværende akademisk år
DocType: School Settings,Current Academic Year,Nåværende akademisk år
DocType: Stock Settings,Default Stock UOM,Standard Stock målenheter
DocType: Asset,Number of Depreciations Booked,Antall Avskrivninger bestilt
apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +32,Against Employee Loan: {0},Mot Ansattes lån: {0}
DocType: Landed Cost Item,Receipt Document,kvittering Document
DocType: Production Planning Tool,Create Material Requests,Opprett Material Forespørsler
DocType: Employee Education,School/University,Skole / universitet
DocType: Payment Request,Reference Details,Referanse Detaljer
apps/erpnext/erpnext/accounts/doctype/asset/asset.py +59,Expected Value After Useful Life must be less than Gross Purchase Amount,Forventet verdi Etter Nyttig Livet må være mindre enn Bruttobeløpet
DocType: Sales Invoice Item,Available Qty at Warehouse,Tilgjengelig Antall på Warehouse
apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +20,Billed Amount,Fakturert beløp
DocType: Asset,Double Declining Balance,Dobbel degressiv
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +179,Closed order cannot be cancelled. Unclose to cancel.,Stengt for kan ikke avbestilles. Unclose å avbryte.
DocType: Student Guardian,Father,Far
apps/erpnext/erpnext/controllers/accounts_controller.py +575,'Update Stock' cannot be checked for fixed asset sale,&#39;Oppdater Stock &quot;kan ikke kontrolleres for driftsmiddel salg
DocType: Bank Reconciliation,Bank Reconciliation,Bankavstemming
DocType: Attendance,On Leave,På ferie
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +7,Get Updates,Få oppdateringer
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +96,{0} {1}: Account {2} does not belong to Company {3},{0} {1}: Account {2} ikke tilhører selskapet {3}
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +134,Material Request {0} is cancelled or stopped,Materialet Request {0} blir kansellert eller stoppet
apps/erpnext/erpnext/public/js/setup_wizard.js +393,Add a few sample records,Legg et par eksempler på poster
apps/erpnext/erpnext/config/hr.py +301,Leave Management,La Ledelse
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +106,Group by Account,Grupper etter Account
DocType: Sales Order,Fully Delivered,Fullt Leveres
DocType: Lead,Lower Income,Lavere inntekt
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +169,Source and target warehouse cannot be same for row {0},Kilden og målet lageret kan ikke være det samme for rad {0}
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +241,"Difference Account must be a Asset/Liability type account, since this Stock Reconciliation is an Opening Entry","Forskjellen konto må være en eiendel / forpliktelse type konto, siden dette Stock Forsoning er en åpning Entry"
apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +107,Disbursed Amount cannot be greater than Loan Amount {0},Utbetalt Mengde kan ikke være større enn låne beløpet {0}
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +89,Purchase Order number required for Item {0},Innkjøpsordrenummeret som kreves for Element {0}
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +860,Production Order not created,Produksjonsordre ikke opprettet
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +18,'From Date' must be after 'To Date',&quot;Fra dato&quot; må være etter &#39;To Date&#39;
apps/erpnext/erpnext/schools/doctype/student_applicant/student_applicant.py +29,Cannot change status as student {0} is linked with student application {1},Kan ikke endre status som student {0} er knyttet til studentens søknad {1}
DocType: Asset,Fully Depreciated,fullt avskrevet
,Stock Projected Qty,Lager Antall projiserte
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +422,Customer {0} does not belong to project {1},Kunden {0} ikke hører til prosjektet {1}
DocType: Employee Attendance Tool,Marked Attendance HTML,Merket Oppmøte HTML
apps/erpnext/erpnext/utilities/activation.py +71,"Quotations are proposals, bids you have sent to your customers","Sitater er forslag, bud du har sendt til dine kunder"
DocType: Sales Order,Customer's Purchase Order,Kundens innkjøpsordre
apps/erpnext/erpnext/config/stock.py +112,Serial No and Batch,Serial No og Batch
DocType: Warranty Claim,From Company,Fra Company
apps/erpnext/erpnext/schools/doctype/assessment_plan/assessment_plan.py +40,Sum of Scores of Assessment Criteria needs to be {0}.,Summen av Resultater av vurderingskriterier må være {0}.
apps/erpnext/erpnext/accounts/doctype/asset/asset.py +77,Please set Number of Depreciations Booked,Vennligst sett Antall Avskrivninger bestilt
apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +89,Value or Qty,Verdi eller Stk
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +430,Productions Orders cannot be raised for:,Productions Bestillinger kan ikke heves for:
apps/erpnext/erpnext/public/js/setup_wizard.js +309,Minute,Minutt
DocType: Purchase Invoice,Purchase Taxes and Charges,Kjøpe skatter og avgifter
,Qty to Receive,Antall å motta
DocType: Leave Block List,Leave Block List Allowed,La Block List tillatt
DocType: Grading Scale Interval,Grading Scale Interval,Grading Scale Intervall
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +49,Expense Claim for Vehicle Log {0},Expense krav for Vehicle Logg {0}
DocType: Sales Invoice Item,Discount (%) on Price List Rate with Margin,Rabatt (%) på prisliste med margin
apps/erpnext/erpnext/patches/v7_0/create_warehouse_nestedset.py +59,All Warehouses,alle Næringslokaler
DocType: Sales Partner,Retailer,Forhandler
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +108,Credit To account must be a Balance Sheet account,Kreditt til kontoen må være en balansekonto
apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +122,All Supplier Types,Alle Leverandør Typer
DocType: Global Defaults,Disable In Words,Deaktiver I Ord
apps/erpnext/erpnext/stock/doctype/item/item.py +46,Item Code is mandatory because Item is not automatically numbered,Elementkode er obligatorisk fordi varen ikke blir automatisk nummerert
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +97,Quotation {0} not of type {1},Sitat {0} ikke av typen {1}
DocType: Maintenance Schedule Item,Maintenance Schedule Item,Vedlikeholdsplan Sak
DocType: Sales Order,%  Delivered,% Leveres
DocType: Production Order,PRO-,PRO-
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +157,Bank Overdraft Account,Kassekreditt konto
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js +48,Make Salary Slip,Gjør Lønn Slip
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +79,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Rad # {0}: Tilordnet beløp kan ikke være større enn utestående beløp.
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +40,Browse BOM,Bla BOM
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +155,Secured Loans,Sikret lån
DocType: Purchase Invoice,Edit Posting Date and Time,Rediger konteringsdato og klokkeslett
apps/erpnext/erpnext/accounts/doctype/asset/depreciation.py +98,Please set Depreciation related Accounts in Asset Category {0} or Company {1},Vennligst sett Avskrivninger relatert kontoer i Asset Kategori {0} eller selskapet {1}
DocType: Academic Term,Academic Year,Studieår
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +169,Opening Balance Equity,Åpningsbalanse Equity
DocType: Lead,CRM,CRM
DocType: Appraisal,Appraisal,Appraisal
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +134,Email sent to supplier {0},E-post sendt til leverandøren {0}
DocType: Opportunity,OPTY-,OPTY-
apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py +19,Date is repeated,Dato gjentas
apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +27,Authorized Signatory,Autorisert signatur
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +215,Leave approver must be one of {0},La godkjenner må være en av {0}
DocType: Hub Settings,Seller Email,Selger Email
DocType: Project,Total Purchase Cost (via Purchase Invoice),Total anskaffelseskost (via fakturaen)
DocType: Training Event,Start Time,Starttid
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +368,Select Quantity,Velg Antall
DocType: Customs Tariff Number,Customs Tariff Number,Tolltariffen nummer
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +34,Approving Role cannot be same as role the rule is Applicable To,Godkjenne Role kan ikke være det samme som rollen regelen gjelder for
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +65,Unsubscribe from this Email Digest,Melde deg ut av denne e-post Digest
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +28,Message Sent,Melding Sendt
apps/erpnext/erpnext/accounts/doctype/account/account.py +101,Account with child nodes cannot be set as ledger,Konto med barnet noder kan ikke settes som hovedbok
DocType: C-Form,II,II
DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,Hastigheten som Prisliste valuta er konvertert til kundens basisvaluta
DocType: Purchase Invoice Item,Net Amount (Company Currency),Nettobeløp (Company Valuta)
DocType: Salary Slip,Hour Rate,Time Rate
DocType: Stock Settings,Item Naming By,Sak Naming Av
apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +46,Another Period Closing Entry {0} has been made after {1},En annen periode Closing Entry {0} har blitt gjort etter {1}
DocType: Production Order,Material Transferred for Manufacturing,Materialet Overført for Manufacturing
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +32,Account {0} does not exists,Konto {0} ikke eksisterer
DocType: Project,Project Type,Prosjekttype
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +16,Either target qty or target amount is mandatory.,Enten målet stk eller mål beløpet er obligatorisk.
apps/erpnext/erpnext/config/projects.py +45,Cost of various activities,Kostnad for ulike aktiviteter
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +60,"Setting Events to {0}, since the Employee attached to the below Sales Persons does not have a User ID{1}","Innstilling Hendelser til {0}, siden den ansatte knyttet til under selgerne ikke har en bruker-ID {1}"
DocType: Timesheet,Billing Details,Fakturadetaljer
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +150,Source and target warehouse must be different,Kilde og mål lageret må være annerledes
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +101,Not allowed to update stock transactions older than {0},Ikke lov til å oppdatere lagertransaksjoner eldre enn {0}
DocType: Purchase Invoice Item,PR Detail,PR Detalj
DocType: Sales Order,Fully Billed,Fullt Fakturert
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +20,Cash In Hand,Kontanter
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +136,Delivery warehouse required for stock item {0},Levering lager nødvendig for lagervare {0}
DocType: Packing Slip,The gross weight of the package. Usually net weight + packaging material weight. (for print),Totalvekten av pakken. Vanligvis nettovekt + emballasjematerialet vekt. (For utskrift)
apps/erpnext/erpnext/schools/doctype/course/course.js +3,Program,Program
DocType: Accounts Settings,Users with this role are allowed to set frozen accounts and create / modify accounting entries against frozen accounts,Brukere med denne rollen har lov til å sette frosne kontoer og lage / endre regnskapspostene mot frosne kontoer
DocType: Serial No,Is Cancelled,Er Avlyst
DocType: Student Group,Group Based On,Gruppe basert på
DocType: Student Group,Group Based On,Gruppe basert på
DocType: Journal Entry,Bill Date,Bill Dato
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +20,"Service Item,Type,frequency and expense amount are required","Tjenesten varen, type, frekvens og utgiftene beløp kreves"
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +45,"Even if there are multiple Pricing Rules with highest priority, then following internal priorities are applied:","Selv om det er flere Prising regler med høyest prioritet, deretter følgende interne prioriteringer til grunn:"
apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.js +128,Do you really want to Submit all Salary Slip from {0} to {1},Har du virkelig ønsker å sende alle Lønn Slip fra {0} til {1}
DocType: Cheque Print Template,Cheque Height,sjekk Høyde
DocType: Supplier,Supplier Details,Leverandør Detaljer
DocType: Expense Claim,Approval Status,Godkjenningsstatus
DocType: Hub Settings,Publish Items to Hub,Publiser varer i Hub
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +43,From value must be less than to value in row {0},Fra verdien må være mindre enn til verdien i rad {0}
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +151,Wire Transfer,Wire Transfer
apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +132,Check all,Sjekk alt
DocType: Vehicle Log,Invoice Ref,faktura~~POS=TRUNC Ref
DocType: Purchase Order,Recurring Order,Gjentakende Bestill
DocType: Company,Default Income Account,Standard Inntekt konto
apps/erpnext/erpnext/selling/page/sales_analytics/sales_analytics.js +32,Customer Group / Customer,Kunden Group / Kunde
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +37,Unclosed Fiscal Years Profit / Loss (Credit),Unclosed regnskapsårene Profit / Loss (Credit)
DocType: Sales Invoice,Time Sheets,timelister
DocType: Payment Gateway Account,Default Payment Request Message,Standard betalingsforespørsel Message
DocType: Item Group,Check this if you want to show in website,Sjekk dette hvis du vil vise på nettstedet
apps/erpnext/erpnext/config/accounts.py +136,Banking and Payments,Bank og Betalinger
,Welcome to ERPNext,Velkommen til ERPNext
apps/erpnext/erpnext/config/learn.py +102,Lead to Quotation,Føre til prisanslag
apps/erpnext/erpnext/templates/includes/product_list.js +45,Nothing more to show.,Ingenting mer å vise.
DocType: Lead,From Customer,Fra Customer
apps/erpnext/erpnext/demo/setup/setup_data.py +323,Calls,Samtaler
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +176,Batches,batcher
DocType: Project,Total Costing Amount (via Time Logs),Total koster Beløp (via Time Logger)
DocType: Purchase Order Item Supplied,Stock UOM,Stock målenheter
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +226,Purchase Order {0} is not submitted,Purchase Order {0} ikke er sendt
DocType: Customs Tariff Number,Tariff Number,tariff Antall
DocType: Production Order Item,Available Qty at WIP Warehouse,Tilgjengelig antall på WIP Warehouse
apps/erpnext/erpnext/stock/doctype/item/item.js +39,Projected,Prosjekterte
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +222,Serial No {0} does not belong to Warehouse {1},Serial No {0} tilhører ikke Warehouse {1}
apps/erpnext/erpnext/controllers/status_updater.py +174,Note: System will not check over-delivery and over-booking for Item {0} as quantity or amount is 0,Merk: Systemet vil ikke sjekke over-levering og over-booking for Element {0} som mengde eller beløpet er 0
DocType: Notification Control,Quotation Message,Sitat Message
DocType: Employee Loan,Employee Loan Application,Medarbeider lånesøknad
DocType: Issue,Opening Date,Åpningsdato
apps/erpnext/erpnext/schools/api.py +77,Attendance has been marked successfully.,Oppmøte er merket med hell.
DocType: Program Enrollment,Public Transport,Offentlig transport
DocType: Journal Entry,Remark,Bemerkning
DocType: Purchase Receipt Item,Rate and Amount,Rate og Beløp
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +163,Account Type for {0} must be {1},Kontotype for {0} må være {1}
apps/erpnext/erpnext/config/hr.py +55,Leaves and Holiday,Blader og Holiday
DocType: School Settings,Current Academic Term,Nåværende faglig term
DocType: School Settings,Current Academic Term,Nåværende faglig term
DocType: Sales Order,Not Billed,Ikke Fakturert
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +75,Both Warehouse must belong to same Company,Både Warehouse må tilhøre samme selskapet
apps/erpnext/erpnext/public/js/templates/contact_list.html +34,No contacts added yet.,Ingen kontakter er lagt til ennå.
DocType: Purchase Invoice Item,Landed Cost Voucher Amount,Landed Cost Voucher Beløp
apps/erpnext/erpnext/config/accounts.py +17,Bills raised by Suppliers.,Regninger oppdratt av leverandører.
DocType: POS Profile,Write Off Account,Skriv Off konto
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +69,Debit Note Amt,Debet notat Amt
apps/erpnext/erpnext/templates/print_formats/includes/taxes.html +5,Discount Amount,Rabattbeløp
DocType: Purchase Invoice,Return Against Purchase Invoice,Tilbake mot fakturaen
DocType: Item,Warranty Period (in days),Garantiperioden (i dager)
apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +56,Relation with Guardian1,Relasjon med Guardian1
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +18,Net Cash from Operations,Netto kontantstrøm fra driften
apps/erpnext/erpnext/public/js/setup_wizard.js +243,e.g. VAT,reskontroførsel
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +26,Item 4,Sak 4
DocType: Student Admission,Admission End Date,Opptak Sluttdato
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py +29,Sub-contracting,Underleverandører
DocType: Journal Entry Account,Journal Entry Account,Journal Entry konto
apps/erpnext/erpnext/schools/doctype/academic_year/academic_year.js +3,Student Group,student Gruppe
DocType: Shopping Cart Settings,Quotation Series,Sitat Series
apps/erpnext/erpnext/setup/doctype/item_group/item_group.py +59,"An item exists with same name ({0}), please change the item group name or rename the item","Et element eksisterer med samme navn ({0}), må du endre navn varegruppen eller endre navn på elementet"
apps/erpnext/erpnext/accounts/page/pos/pos.js +1944,Please select customer,Velg kunde
DocType: C-Form,I,Jeg
DocType: Company,Asset Depreciation Cost Center,Asset Avskrivninger kostnadssted
DocType: Sales Order Item,Sales Order Date,Salgsordre Dato
DocType: Sales Invoice Item,Delivered Qty,Leveres Antall
DocType: Production Planning Tool,"If checked, all the children of each production item will be included in the Material Requests.","Hvis det er merket, vil alle barn i hver produksjon element inkluderes i materialet forespørsler."
DocType: Assessment Plan,Assessment Plan,Assessment Plan
DocType: Stock Settings,Limit Percent,grense Prosent
,Payment Period Based On Invoice Date,Betaling perioden basert på Fakturadato
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +58,Missing Currency Exchange Rates for {0},Mangler valutakurser for {0}
DocType: Assessment Plan,Examiner,Examiner
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +205,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Vennligst still inn navngivningsserien for {0} via Setup&gt; Settings&gt; Naming Series
DocType: Student,Siblings,søsken
DocType: Journal Entry,Stock Entry,Stock Entry
DocType: Payment Entry,Payment References,Betalings Referanser
DocType: C-Form,C-FORM-,C-form-
DocType: Vehicle,Insurance Details,forsikring Detaljer
DocType: Account,Payable,Betales
apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +113,Please enter Repayment Periods,Fyll inn nedbetalingstid
apps/erpnext/erpnext/shopping_cart/cart.py +365,Debtors ({0}),Skyldnere ({0})
DocType: Pricing Rule,Margin,Margin
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +57,New Customers,Nye kunder
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +76,Gross Profit %,Bruttofortjeneste%
DocType: Appraisal Goal,Weightage (%),Weightage (%)
DocType: Bank Reconciliation Detail,Clearance Date,Klaring Dato
apps/erpnext/erpnext/accounts/doctype/asset/asset.py +62,Gross Purchase Amount is mandatory,Bruttobeløpet er obligatorisk
DocType: Lead,Address Desc,Adresse Desc
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +99,Party is mandatory,Party er obligatorisk
DocType: Journal Entry,JV-,JV-
DocType: Topic,Topic Name,emne Name
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +36,Atleast one of the Selling or Buying must be selected,Minst én av de selge eller kjøpe må velges
apps/erpnext/erpnext/public/js/setup_wizard.js +28,Select the nature of your business.,Velg formålet med virksomheten.
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +71,Row #{0}: Duplicate entry in References {1} {2},Row # {0}: Dupliseringsoppføring i Referanser {1} {2}
apps/erpnext/erpnext/config/manufacturing.py +57,Where manufacturing operations are carried.,Hvor fabrikasjonsvirksomhet gjennomføres.
DocType: Asset Movement,Source Warehouse,Kilde Warehouse
DocType: Installation Note,Installation Date,Installasjonsdato
apps/erpnext/erpnext/controllers/accounts_controller.py +554,Row #{0}: Asset {1} does not belong to company {2},Row # {0}: Asset {1} ikke tilhører selskapet {2}
DocType: Employee,Confirmation Date,Bekreftelse Dato
DocType: C-Form,Total Invoiced Amount,Total Fakturert beløp
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +49,Min Qty can not be greater than Max Qty,Min Antall kan ikke være større enn Max Antall
DocType: Account,Accumulated Depreciation,akkumulerte avskrivninger
DocType: Stock Entry,Customer or Supplier Details,Kunde eller leverandør Detaljer
DocType: Employee Loan Application,Required by Date,Kreves av Dato
DocType: Lead,Lead Owner,Lead Eier
DocType: Bin,Requested Quantity,Requested Antall
DocType: Employee,Marital Status,Sivilstatus
DocType: Stock Settings,Auto Material Request,Auto Materiell Request
DocType: Delivery Note Item,Available Batch Qty at From Warehouse,Tilgjengelig Batch Antall på From Warehouse
DocType: Customer,CUST-,CUST-
DocType: Salary Slip,Gross Pay - Total Deduction - Loan Repayment,Brutto lønn - Totalt Fradrag - Loan Nedbetaling
apps/erpnext/erpnext/manufacturing/doctype/bom_replace_tool/bom_replace_tool.py +25,Current BOM and New BOM can not be same,Nåværende BOM og New BOM kan ikke være det samme
apps/erpnext/erpnext/hr/report/salary_register/salary_register.py +38,Salary Slip ID,Lønn Slip ID
apps/erpnext/erpnext/hr/doctype/employee/employee.py +113,Date Of Retirement must be greater than Date of Joining,Pensjoneringstidspunktet må være større enn tidspunktet for inntreden
apps/erpnext/erpnext/schools/doctype/course_scheduling_tool/course_scheduling_tool.py +52,There were errors while scheduling course on :,Det var feil mens scheduling kurs på:
DocType: Sales Invoice,Against Income Account,Mot Inntekt konto
apps/erpnext/erpnext/controllers/website_list_for_contact.py +90,{0}% Delivered,{0}% Leveres
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +81,Item {0}: Ordered qty {1} cannot be less than minimum order qty {2} (defined in Item).,Element {0}: Bestilte qty {1} kan ikke være mindre enn minimum ordreantall {2} (definert i punkt).
DocType: Monthly Distribution Percentage,Monthly Distribution Percentage,Månedlig Distribution Prosent
DocType: Territory,Territory Targets,Terri Targets
DocType: Delivery Note,Transporter Info,Transporter Info
apps/erpnext/erpnext/accounts/utils.py +503,Please set default {0} in Company {1},Vennligst sett standard {0} i selskapet {1}
DocType: Cheque Print Template,Starting position from top edge,Startposisjon fra øverste kant
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +30,Same supplier has been entered multiple times,Samme leverandør er angitt flere ganger
apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.py +152,Gross Profit / Loss,Brutto gevinst / tap
DocType: Purchase Order Item Supplied,Purchase Order Item Supplied,Innkjøpsordre Sak Leveres
apps/erpnext/erpnext/public/js/setup_wizard.js +127,Company Name cannot be Company,Firmanavn kan ikke være selskap
apps/erpnext/erpnext/config/setup.py +27,Letter Heads for print templates.,Brevark for utskriftsmaler.
apps/erpnext/erpnext/config/setup.py +32,Titles for print templates e.g. Proforma Invoice.,Titler for utskriftsmaler f.eks Proforma Faktura.
DocType: Program Enrollment,Walking,walking
DocType: Student Guardian,Student Guardian,student Guardian
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +201,Valuation type charges can not marked as Inclusive,Verdsettelse typen kostnader kan ikke merket som Inclusive
DocType: POS Profile,Update Stock,Oppdater Stock
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +100,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.,Ulik målenheter for elementer vil føre til feil (Total) Netto vekt verdi. Sørg for at nettovekt av hvert element er i samme målenheter.
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +39,BOM Rate,BOM Rate
DocType: Asset,Journal Entry for Scrap,Bilagsregistrering for Scrap
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +83,Please pull items from Delivery Note,Kan trekke elementer fra følgeseddel
apps/erpnext/erpnext/accounts/utils.py +473,Journal Entries {0} are un-linked,Journal Entries {0} er un-linked
apps/erpnext/erpnext/config/crm.py +92,"Record of all communications of type email, phone, chat, visit, etc.","Registrering av all kommunikasjon av typen e-post, telefon, chat, besøk, etc."
DocType: Manufacturer,Manufacturers used in Items,Produsenter som brukes i Items
apps/erpnext/erpnext/accounts/general_ledger.py +145,Please mention Round Off Cost Center in Company,Vennligst oppgi Round Off Cost Center i selskapet
DocType: Purchase Invoice,Terms,Vilkår
DocType: Academic Term,Term Name,Term Navn
DocType: Buying Settings,Purchase Order Required,Innkjøpsordre Påkrevd
,Item-wise Sales History,Element-messig Sales History
DocType: Expense Claim,Total Sanctioned Amount,Total vedtatte beløp
,Purchase Analytics,Kjøps Analytics
DocType: Sales Invoice Item,Delivery Note Item,Levering Note Element
DocType: Expense Claim,Task,Task
DocType: Purchase Taxes and Charges,Reference Row #,Referanse Row #
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +76,Batch number is mandatory for Item {0},Batchnummer er obligatorisk for Element {0}
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.js +13,This is a root sales person and cannot be edited.,Dette er en grunnlegg salg person og kan ikke redigeres.
DocType: Salary Detail,"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. ","Hvis valgt, vil verdien som er spesifisert eller beregnet i denne komponenten, ikke bidra til inntektene eller fradragene. Men det er verdien som kan refereres av andre komponenter som kan legges til eller trekkes fra."
DocType: Salary Detail,"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. ","Hvis valgt, vil verdien som er spesifisert eller beregnet i denne komponenten, ikke bidra til inntektene eller fradragene. Men det er verdien som kan refereres av andre komponenter som kan legges til eller trekkes fra."
,Stock Ledger,Stock Ledger
apps/erpnext/erpnext/templates/includes/cart/cart_items.html +29,Rate: {0},Valuta: {0}
DocType: Company,Exchange Gain / Loss Account,Valutagevinst / tap-konto
apps/erpnext/erpnext/config/hr.py +7,Employee and Attendance,Medarbeider og oppmøte
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +78,Purpose must be one of {0},Hensikten må være en av {0}
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +124,Fill the form and save it,Fyll ut skjemaet og lagre det
DocType: Production Planning Tool,Download a report containing all raw materials with their latest inventory status,Last ned en rapport som inneholder alle råvarer med deres nyeste inventar status
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +26,Community Forum,Community Forum
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +51,Actual qty in stock,Faktisk antall på lager
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +51,Actual qty in stock,Faktisk antall på lager
DocType: Homepage,"URL for ""All Products""",URL for &quot;Alle produkter&quot;
DocType: Leave Application,Leave Balance Before Application,La Balance Før Application
DocType: SMS Center,Send SMS,Send SMS
DocType: Cheque Print Template,Width of amount in word,Bredde på beløpet i ord
DocType: Company,Default Letter Head,Standard Brevhode
DocType: Purchase Order,Get Items from Open Material Requests,Få Elementer fra Åpen Material Forespørsler
DocType: Item,Standard Selling Rate,Standard salgskurs
DocType: Account,Rate at which this tax is applied,Hastigheten som denne skatten er brukt
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +65,Reorder Qty,Omgjøre Antall
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +28,Current Job Openings,Nåværende jobb Åpninger
DocType: Company,Stock Adjustment Account,Stock Adjustment konto
apps/erpnext/erpnext/public/js/payment/pos_payment.html +17,Write Off,Skriv Off
DocType: Timesheet Detail,Operation ID,Operation ID
DocType: Employee,"System User (login) ID. If set, it will become default for all HR forms.","Systemet bruker (innlogging) ID. Hvis satt, vil det bli standard for alle HR-skjemaer."
apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +16,{0}: From {1},{0}: Fra {1}
DocType: Task,depends_on,kommer an på
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +26,Name of new Account. Note: Please don't create accounts for Customers and Suppliers,Navn på ny konto. Merk: Vennligst ikke opprette kontoer for kunder og leverandører
DocType: BOM Replace Tool,BOM Replace Tool,BOM Erstatt Tool
apps/erpnext/erpnext/config/setup.py +37,Country wise default Address Templates,Country klok standardadresse Maler
DocType: Sales Order Item,Supplier delivers to Customer,Leverandør leverer til kunden
apps/erpnext/erpnext/utilities/bot.py +34,[{0}](#Form/Item/{0}) is out of stock,[{0}] (# Form / post / {0}) er utsolgt
apps/erpnext/erpnext/controllers/recurring_document.py +177,Next Date must be greater than Posting Date,Neste dato må være større enn konteringsdato
apps/erpnext/erpnext/accounts/party.py +312,Due / Reference Date cannot be after {0},Due / Reference Datoen kan ikke være etter {0}
apps/erpnext/erpnext/config/setup.py +51,Data Import and Export,Data import og eksport
apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +71,No students Found,Ingen studenter Funnet
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +55,Invoice Posting Date,Faktura Publiseringsdato
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +25,Sell,Selge
DocType: Sales Invoice,Rounded Total,Avrundet Total
DocType: Product Bundle,List items that form the package.,Listeelementer som danner pakken.
apps/erpnext/erpnext/accounts/doctype/monthly_distribution/monthly_distribution.py +26,Percentage Allocation should be equal to 100%,Prosentvis Tildeling skal være lik 100%
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +555,Please select Posting Date before selecting Party,Vennligst velg Publiseringsdato før du velger Partiet
DocType: Program Enrollment,School House,school House
DocType: Serial No,Out of AMC,Ut av AMC
apps/erpnext/erpnext/public/js/utils.js +219,Please select Quotations,Vennligst velg tilbud
apps/erpnext/erpnext/accounts/doctype/asset/asset.py +82,Number of Depreciations Booked cannot be greater than Total Number of Depreciations,Antall Avskrivninger reservert kan ikke være større enn Totalt antall Avskrivninger
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +47,Make Maintenance Visit,Gjør Vedlikehold Visit
apps/erpnext/erpnext/selling/doctype/customer/customer.py +167,Please contact to the user who have Sales Master Manager {0} role,Ta kontakt for brukeren som har salgs Master manager {0} rolle
DocType: Company,Default Cash Account,Standard Cash konto
apps/erpnext/erpnext/config/accounts.py +56,Company (not Customer or Supplier) master.,Company (ikke kunde eller leverandør) mester.
apps/erpnext/erpnext/schools/doctype/student/student_dashboard.py +6,This is based on the attendance of this Student,Dette er basert på tilstedeværelse av denne Student
apps/erpnext/erpnext/schools/doctype/student_attendance_tool/student_attendance_tool.js +178,No Students in,Ingen studenter i
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +166,Add more items or open full form,Legg til flere elementer eller åpne full form
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +206,Delivery Notes {0} must be cancelled before cancelling this Sales Order,Levering Merknader {0} må avbestilles før den avbryter denne salgsordre
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +78,Paid amount + Write Off Amount can not be greater than Grand Total,Innbetalt beløp + avskrive Beløpet kan ikke være større enn Totalsum
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +78,{0} is not a valid Batch Number for Item {1},{0} er ikke en gyldig batchnummer for varen {1}
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +149,Note: There is not enough leave balance for Leave Type {0},Merk: Det er ikke nok permisjon balanse for La Type {0}
apps/erpnext/erpnext/regional/india/utils.py +15,Invalid GSTIN or Enter NA for Unregistered,Ugyldig GSTIN eller Skriv inn NA for Uregistrert
DocType: Training Event,Seminar,Seminar
DocType: Program Enrollment Fee,Program Enrollment Fee,Program innmeldingsavgift
DocType: Item,Supplier Items,Leverandør Items
DocType: Opportunity,Opportunity Type,Opportunity Type
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +16,New Company,Nytt firma
apps/erpnext/erpnext/setup/doctype/company/delete_company_transactions.py +17,Transactions can only be deleted by the creator of the Company,Transaksjoner kan bare slettes av skaperen av selskapet
apps/erpnext/erpnext/accounts/general_ledger.py +21,Incorrect number of General Ledger Entries found. You might have selected a wrong Account in the transaction.,Feil antall hovedbok Entries funnet. Du kan ha valgt feil konto i transaksjonen.
DocType: Employee,Prefered Contact Email,Foretrukket Kontakt E-post
DocType: Cheque Print Template,Cheque Width,sjekk Bredde
DocType: Selling Settings,Validate Selling Price for Item against Purchase Rate or Valuation Rate,Validere salgspris for varen mot Purchase Rate Verdivurdering Ranger
DocType: Program,Fee Schedule,Prisliste
DocType: Hub Settings,Publish Availability,Publiser Tilgjengelighet
DocType: Company,Create Chart Of Accounts Based On,Opprett kontoplan basert på
apps/erpnext/erpnext/hr/doctype/employee/employee.py +107,Date of Birth cannot be greater than today.,Fødselsdato kan ikke være større enn i dag.
,Stock Ageing,Stock Ageing
apps/erpnext/erpnext/schools/doctype/student/student.py +38,Student {0} exist against student applicant {1},Student {0} eksistere mot student Søkeren {1}
apps/erpnext/erpnext/projects/doctype/task/task.js +31,Timesheet,Tids skjema
apps/erpnext/erpnext/controllers/accounts_controller.py +246,{0} '{1}' is disabled,{0} {1} er deaktivert
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +13,Set as Open,Sett som Åpen
DocType: Cheque Print Template,Scanned Cheque,skannede Cheque
DocType: Notification Control,Send automatic emails to Contacts on Submitting transactions.,Send automatisk e-poster til Kontakter på Sende transaksjoner.
DocType: Timesheet,Total Billable Amount,Total Fakturerbart Beløp
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +20,Item 3,Sak 3
DocType: Purchase Order,Customer Contact Email,Kundekontakt E-post
DocType: Warranty Claim,Item and Warranty Details,Element og Garanti Detaljer
DocType: Sales Team,Contribution (%),Bidrag (%)
apps/erpnext/erpnext/controllers/accounts_controller.py +83,Note: Payment Entry will not be created since 'Cash or Bank Account' was not specified,Merk: Betaling Entry vil ikke bli laget siden &quot;Cash eller bankkontoen ble ikke spesifisert
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +196,Responsibilities,Ansvarsområder
DocType: Expense Claim Account,Expense Claim Account,Expense krav konto
DocType: Sales Person,Sales Person Name,Sales Person Name
apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +54,Please enter atleast 1 invoice in the table,Skriv inn atleast en faktura i tabellen
apps/erpnext/erpnext/public/js/setup_wizard.js +196,Add Users,Legg til brukere
DocType: POS Item Group,Item Group,Varegruppe
DocType: Item,Safety Stock,Safety Stock
apps/erpnext/erpnext/projects/doctype/task/task.py +53,Progress % for a task cannot be more than 100.,Progress% for en oppgave kan ikke være mer enn 100.
DocType: Stock Reconciliation Item,Before reconciliation,Før avstemming
apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py +12,To {0},Til {0}
DocType: Purchase Invoice,Taxes and Charges Added (Company Currency),Skatter og avgifter legges (Company Valuta)
apps/erpnext/erpnext/stock/doctype/item/item.py +432,Item Tax Row {0} must have account of type Tax or Income or Expense or Chargeable,Sak Skatte Rad {0} må ha konto for type skatt eller inntekt eller kostnad eller Charge
DocType: Sales Order,Partly Billed,Delvis Fakturert
apps/erpnext/erpnext/accounts/doctype/asset/asset.py +43,Item {0} must be a Fixed Asset Item,Element {0} må være et driftsmiddel element
DocType: Item,Default BOM,Standard BOM
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +24,Debit Note Amount,Debet Note Beløp
apps/erpnext/erpnext/setup/doctype/company/company.js +50,Please re-type company name to confirm,Vennligst re-type firmanavn for å bekrefte
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +70,Total Outstanding Amt,Total Outstanding Amt
DocType: Journal Entry,Printing Settings,Utskriftsinnstillinger
DocType: Sales Invoice,Include Payment (POS),Inkluder Payment (POS)
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +292,Total Debit must be equal to Total Credit. The difference is {0},Total debet må være lik samlet kreditt. Forskjellen er {0}
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +11,Automotive,Automotive
DocType: Vehicle,Insurance Company,Forsikringsselskap
DocType: Asset Category Account,Fixed Asset Account,Fast Asset konto
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +397,Variable,variabel
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.js +47,From Delivery Note,Fra følgeseddel
DocType: Student,Student Email Address,Student e-postadresse
DocType: Timesheet Detail,From Time,Fra Time
apps/erpnext/erpnext/public/js/pos/pos_bill_item.html +12,In Stock: ,På lager:
DocType: Notification Control,Custom Message,Standard melding
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +33,Investment Banking,Investment Banking
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +74,Cash or Bank Account is mandatory for making payment entry,Kontanter eller bankkontoen er obligatorisk for å gjøre betaling oppføring
apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +54,Student Address,Studentadresse
apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +54,Student Address,Studentadresse
DocType: Purchase Invoice,Price List Exchange Rate,Prisliste Exchange Rate
DocType: Purchase Invoice Item,Rate,Rate
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +73,Intern,Intern
apps/erpnext/erpnext/accounts/page/pos/pos.js +1516,Address Name,Adressenavn
DocType: Stock Entry,From BOM,Fra BOM
DocType: Assessment Code,Assessment Code,Assessment Kode
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +42,Basic,Grunnleggende
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +94,Stock transactions before {0} are frozen,Lagertransaksjoner før {0} er frosset
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +219,Please click on 'Generate Schedule',Vennligst klikk på &quot;Generer Schedule &#39;
apps/erpnext/erpnext/config/stock.py +190,"e.g. Kg, Unit, Nos, m","f.eks Kg, Unit, Nos, m"
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +122,Reference No is mandatory if you entered Reference Date,Referansenummer er obligatorisk hvis du skrev Reference Date
DocType: Bank Reconciliation Detail,Payment Document,betaling Document
apps/erpnext/erpnext/hr/doctype/employee/employee.py +110,Date of Joining must be greater than Date of Birth,Dato Bli må være større enn fødselsdato
DocType: Salary Slip,Salary Structure,Lønn Struktur
DocType: Account,Bank,Bank
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +9,Airline,Flyselskap
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +798,Issue Material,Issue Material
DocType: Material Request Item,For Warehouse,For Warehouse
DocType: Employee,Offer Date,Tilbudet Dato
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +33,Quotations,Sitater
apps/erpnext/erpnext/accounts/page/pos/pos.js +677,You are in offline mode. You will not be able to reload until you have network.,Du er i frakoblet modus. Du vil ikke være i stand til å laste før du har nettverk.
apps/erpnext/erpnext/schools/doctype/student_group_creation_tool/student_group_creation_tool.py +46,No Student Groups created.,Ingen studentgrupper opprettet.
DocType: Purchase Invoice Item,Serial No,Serial No
apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +119,Monthly Repayment Amount cannot be greater than Loan Amount,Månedlig nedbetaling beløpet kan ikke være større enn Lånebeløp
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +143,Please enter Maintaince Details first,Skriv inn maintaince detaljer Første
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +55,Row #{0}: Expected Delivery Date cannot be before Purchase Order Date,Rute # {0}: Forventet leveringsdato kan ikke være før innkjøpsordrenes dato
DocType: Purchase Invoice,Print Language,Print Språk
DocType: Salary Slip,Total Working Hours,Samlet arbeidstid
DocType: Stock Entry,Including items for sub assemblies,Inkludert elementer for sub samlinger
apps/erpnext/erpnext/accounts/page/pos/pos.js +1873,Enter value must be positive,Oppgi verdien skal være positiv
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +109,All Territories,Alle Territories
DocType: Purchase Invoice,Items,Elementer
apps/erpnext/erpnext/schools/doctype/program_enrollment/program_enrollment.py +26,Student is already enrolled.,Student er allerede registrert.
DocType: Fiscal Year,Year Name,År Navn
DocType: Process Payroll,Process Payroll,Process Lønn
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +234,There are more holidays than working days this month.,Det er mer ferie enn virkedager denne måneden.
DocType: Product Bundle Item,Product Bundle Item,Produktet Bundle Element
DocType: Sales Partner,Sales Partner Name,Sales Partner Name
apps/erpnext/erpnext/hooks.py +111,Request for Quotations,Forespørsel om Sitater
DocType: Payment Reconciliation,Maximum Invoice Amount,Maksimal Fakturert beløp
DocType: Student Language,Student Language,student Språk
apps/erpnext/erpnext/config/selling.py +23,Customers,kunder
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +24,Order/Quot %,Ordre / Quot%
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +24,Order/Quot %,Ordre / Quot%
DocType: Student Sibling,Institution,institusjon
DocType: Asset,Partially Depreciated,delvis Avskrives
DocType: Issue,Opening Time,Åpning Tid
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +92,From and To dates required,Fra og Til dato kreves
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +46,Securities & Commodity Exchanges,Verdipapirer og råvarebørser
apps/erpnext/erpnext/stock/doctype/item/item.py +624,Default Unit of Measure for Variant '{0}' must be same as in Template '{1}',Standard Enhet for Variant {0} må være samme som i malen {1}
DocType: Shipping Rule,Calculate Based On,Beregn basert på
DocType: Delivery Note Item,From Warehouse,Fra Warehouse
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +861,No Items with Bill of Materials to Manufacture,Ingen elementer med Bill of Materials til Manufacture
DocType: Assessment Plan,Supervisor Name,Supervisor Name
DocType: Program Enrollment Course,Program Enrollment Course,Programopptakskurs
DocType: Program Enrollment Course,Program Enrollment Course,Programopptakskurs
DocType: Purchase Taxes and Charges,Valuation and Total,Verdivurdering og Total
DocType: Tax Rule,Shipping City,Shipping by
DocType: Notification Control,Customize the Notification,Tilpass varslings
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +19,Cash Flow from Operations,Kontantstrøm fra driften
DocType: Sales Invoice,Shipping Rule,Shipping Rule
DocType: Manufacturer,Limited to 12 characters,Begrenset til 12 tegn
DocType: Journal Entry,Print Heading,Print Overskrift
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +57,Total cannot be zero,Totalt kan ikke være null
DocType: Training Event Employee,Attended,Deltok
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +16,'Days Since Last Order' must be greater than or equal to zero,&#39;Dager siden siste Bestill &quot;må være større enn eller lik null
DocType: Process Payroll,Payroll Frequency,lønn Frequency
DocType: Asset,Amended From,Endret Fra
apps/erpnext/erpnext/public/js/setup_wizard.js +305,Raw Material,Råmateriale
DocType: Leave Application,Follow via Email,Følg via e-post
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +55,Plants and Machineries,Planter og Machineries
DocType: Purchase Taxes and Charges,Tax Amount After Discount Amount,Skattebeløp Etter Rabattbeløp
DocType: Daily Work Summary Settings,Daily Work Summary Settings,Daglige arbeid Oppsummering Innstillinger
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +247,Currency of the price list {0} is not similar with the selected currency {1},Valuta av prislisten {0} er ikke lik med den valgte valutaen {1}
DocType: Payment Entry,Internal Transfer,Internal Transfer
apps/erpnext/erpnext/accounts/doctype/account/account.py +179,Child account exists for this account. You can not delete this account.,Barnekonto som finnes for denne kontoen. Du kan ikke slette denne kontoen.
apps/erpnext/erpnext/setup/doctype/territory/territory.py +19,Either target qty or target amount is mandatory,Enten målet stk eller mål beløpet er obligatorisk
apps/erpnext/erpnext/stock/get_item_details.py +526,No default BOM exists for Item {0},Ingen standard BOM finnes for Element {0}
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +341,Please select Posting Date first,Vennligst velg Publiseringsdato først
apps/erpnext/erpnext/public/js/account_tree_grid.js +210,Opening Date should be before Closing Date,Åpningsdato bør være før påmeldingsfristens utløp
DocType: Leave Control Panel,Carry Forward,Fremføring
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +30,Cost Center with existing transactions can not be converted to ledger,Kostnadssted med eksisterende transaksjoner kan ikke konverteres til Ledger
DocType: Department,Days for which Holidays are blocked for this department.,Dager som Holidays er blokkert for denne avdelingen.
,Produced,Produsert
apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +118,Created Salary Slips,Opprettet lønnsslipper
DocType: Item,Item Code for Suppliers,Sak Kode for leverandører
DocType: Issue,Raised By (Email),Raised By (e-post)
DocType: Training Event,Trainer Name,trener Name
DocType: Mode of Payment,General,Generelt
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +28,Last Communication,Siste kommunikasjon
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +28,Last Communication,Siste kommunikasjon
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +355,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',Kan ikke trekke når kategorien er for verdsetting &quot;eller&quot; Verdsettelse og Totals
apps/erpnext/erpnext/public/js/setup_wizard.js +236,"List your tax heads (e.g. VAT, Customs etc; they should have unique names) and their standard rates. This will create a standard template, which you can edit and add more later.","List dine skatte hoder (f.eks merverdiavgift, toll etc, de bør ha unike navn) og deres standardsatser. Dette vil skape en standard mal, som du kan redigere og legge til mer senere."
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +234,Serial Nos Required for Serialized Item {0},Serial Nos Nødvendig for Serialisert Element {0}
apps/erpnext/erpnext/config/accounts.py +146,Match Payments with Invoices,Match Betalinger med Fakturaer
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +108,Row #{0}: Please enter Delivery Date against item {1},Rad # {0}: Vennligst skriv leveringsdato mot element {1}
DocType: Journal Entry,Bank Entry,Bank Entry
DocType: Authorization Rule,Applicable To (Designation),Gjelder til (Betegnelse)
,Profitability Analysis,lønnsomhets~~POS=TRUNC
apps/erpnext/erpnext/templates/generators/item.html +62,Add to Cart,Legg til i handlevogn
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.js +28,Group By,Grupper etter
DocType: Guardian,Interests,Interesser
apps/erpnext/erpnext/config/accounts.py +300,Enable / disable currencies.,Aktivere / deaktivere valutaer.
DocType: Production Planning Tool,Get Material Request,Få Material Request
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +111,Postal Expenses,Post Utgifter
apps/erpnext/erpnext/controllers/trends.py +19,Total(Amt),Total (Amt)
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +26,Entertainment & Leisure,Entertainment &amp; Leisure
DocType: Quality Inspection,Item Serial No,Sak Serial No
apps/erpnext/erpnext/utilities/activation.py +133,Create Employee Records,Lag Medarbeider Records
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +58,Total Present,Total Present
apps/erpnext/erpnext/config/accounts.py +107,Accounting Statements,regnskaps~~POS=TRUNC Uttalelser
apps/erpnext/erpnext/public/js/setup_wizard.js +309,Hour,Time
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +29,New Serial No cannot have Warehouse. Warehouse must be set by Stock Entry or Purchase Receipt,New Serial No kan ikke ha Warehouse. Warehouse må settes av Stock Entry eller Kjøpskvittering
DocType: Lead,Lead Type,Lead Type
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +133,You are not authorized to approve leaves on Block Dates,Du er ikke autorisert til å godkjenne blader på Block Datoer
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +383,All these items have already been invoiced,Alle disse elementene er allerede blitt fakturert
apps/erpnext/erpnext/public/js/setup_wizard.js +226,Monthly Sales Target,Månedlig salgsmål
apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py +37,Can be approved by {0},Kan godkjennes av {0}
DocType: Item,Default Material Request Type,Standard Material Request Type
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +7,Unknown,Ukjent
DocType: Shipping Rule,Shipping Rule Conditions,Frakt Regel betingelser
DocType: BOM Replace Tool,The new BOM after replacement,Den nye BOM etter utskiftning
apps/erpnext/erpnext/accounts/page/pos/pos.js +644,Point of Sale,Utsalgssted
DocType: Payment Entry,Received Amount,mottatt beløp
DocType: GST Settings,GSTIN Email Sent On,GSTIN Email Sent On
DocType: Program Enrollment,Pick/Drop by Guardian,Pick / Drop av Guardian
DocType: Production Planning Tool,"Create for full quantity, ignoring quantity already on order","Lag full mengde, ignorerer mengde allerede er i ordre"
DocType: Account,Tax,Skatte
apps/erpnext/erpnext/schools/report/student_batch_wise_attendance/student_batch_wise_attendance.py +45,Not Marked,ikke Merket
DocType: Production Planning Tool,Production Planning Tool,Produksjonsplanlegging Tool
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +150,"Batched Item {0} cannot be updated using Stock Reconciliation, instead use Stock Entry","Batched Item {0} kan ikke oppdateres ved hjelp av Stock Forsoning, bruk i stedet Lagerinngang"
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +150,"Batched Item {0} cannot be updated using Stock Reconciliation, instead use Stock Entry","Batched Item {0} kan ikke oppdateres ved hjelp av Stock Forsoning, bruk i stedet Lagerinngang"
DocType: Quality Inspection,Report Date,Rapporter Date
DocType: Student,Middle Name,Mellomnavn
DocType: C-Form,Invoices,Fakturaer
DocType: Batch,Source Document Name,Kilde dokumentnavn
DocType: Batch,Source Document Name,Kilde dokumentnavn
DocType: Job Opening,Job Title,Jobbtittel
apps/erpnext/erpnext/utilities/activation.py +97,Create Users,Lag brukere
apps/erpnext/erpnext/public/js/setup_wizard.js +309,Gram,Gram
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +393,Quantity to Manufacture must be greater than 0.,Antall å Manufacture må være større enn 0.
apps/erpnext/erpnext/config/maintenance.py +17,Visit report for maintenance call.,Besøk rapport for vedlikehold samtale.
DocType: Stock Entry,Update Rate and Availability,Oppdateringsfrekvens og tilgjengelighet
DocType: Stock Settings,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.,Prosentvis du har lov til å motta eller levere mer mot antall bestilte produkter. For eksempel: Hvis du har bestilt 100 enheter. og din Fradrag er 10% så du har lov til å motta 110 enheter.
DocType: POS Customer Group,Customer Group,Kundegruppe
apps/erpnext/erpnext/stock/doctype/batch/batch.js +108,New Batch ID (Optional),Ny batch-ID (valgfritt)
apps/erpnext/erpnext/stock/doctype/batch/batch.js +108,New Batch ID (Optional),Ny batch-ID (valgfritt)
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +194,Expense account is mandatory for item {0},Utgiftskonto er obligatorisk for elementet {0}
DocType: BOM,Website Description,Website Beskrivelse
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +42,Net Change in Equity,Netto endring i egenkapital
apps/erpnext/erpnext/accounts/doctype/asset/asset.py +162,Please cancel Purchase Invoice {0} first,Vennligst avbryte fakturaen {0} først
apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py +43,"Email Address must be unique, already exists for {0}","E-post adresse må være unikt, allerede eksisterer for {0}"
DocType: Serial No,AMC Expiry Date,AMC Utløpsdato
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +800,Receipt,Kvittering
,Sales Register,Salg Register
DocType: Daily Work Summary Settings Company,Send Emails At,Send e-post til
DocType: Quotation,Quotation Lost Reason,Sitat av Lost Reason
apps/erpnext/erpnext/public/js/setup_wizard.js +15,Select your Domain,Velg Domene
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +355,Transaction reference no {0} dated {1},Transaksjonsreferanse ikke {0} datert {1}
apps/erpnext/erpnext/setup/doctype/supplier_type/supplier_type.js +5,There is nothing to edit.,Det er ingenting å redigere.
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +117,Summary for this month and pending activities,Oppsummering for denne måneden og ventende aktiviteter
DocType: Customer Group,Customer Group Name,Kundegruppenavn
apps/erpnext/erpnext/public/js/pos/pos.html +100,No Customers yet!,Ingen kunder ennå!
apps/erpnext/erpnext/public/js/financial_statements.js +56,Cash Flow Statement,Kontantstrømoppstilling
apps/erpnext/erpnext/hr/doctype/employee_loan_application/employee_loan_application.py +23,Loan Amount cannot exceed Maximum Loan Amount of {0},Lånebeløp kan ikke overstige maksimalt lånebeløp på {0}
apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py +22,License,Tillatelse
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +469,Please remove this Invoice {0} from C-Form {1},Vennligst fjern denne Faktura {0} fra C-Form {1}
DocType: Leave Control Panel,Please select Carry Forward if you also want to include previous fiscal year's balance leaves to this fiscal year,Vennligst velg bære frem hvis du også vil ha med forrige regnskapsår balanse later til dette regnskapsåret
DocType: GL Entry,Against Voucher Type,Mot Voucher Type
DocType: Item,Attributes,Egenskaper
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +219,Please enter Write Off Account,Skriv inn avskrive konto
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +71,Last Order Date,Siste Order Date
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +47,Account {0} does not belongs to company {1},Konto {0} ikke tilhører selskapet {1}
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +845,Serial Numbers in row {0} does not match with Delivery Note,Serienumre i rad {0} stemmer ikke overens med leveringsnotat
DocType: Student,Guardian Details,Guardian Detaljer
DocType: C-Form,C-Form,C-Form
apps/erpnext/erpnext/config/hr.py +18,Mark Attendance for multiple employees,Mark Oppmøte for flere ansatte
DocType: Vehicle,Chassis No,chassis Nei
DocType: Payment Request,Initiated,Initiert
DocType: Production Order,Planned Start Date,Planlagt startdato
DocType: Serial No,Creation Document Type,Creation dokumenttype
DocType: Leave Type,Is Encash,Er encash
DocType: Leave Allocation,New Leaves Allocated,Nye Leaves Avsatt
apps/erpnext/erpnext/controllers/trends.py +269,Project-wise data is not available for Quotation,Prosjekt-messig data er ikke tilgjengelig for prisanslag
DocType: Project,Expected End Date,Forventet sluttdato
DocType: Budget Account,Budget Amount,budsjett~~POS=TRUNC
DocType: Appraisal Template,Appraisal Template Title,Appraisal Mal Tittel
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +38,From Date {0} for Employee {1} cannot be before employee's joining Date {2},Fra Dato {0} for Employee {1} kan ikke være før arbeidstakers begynte Dato {2}
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +114,Commercial,Commercial
DocType: Payment Entry,Account Paid To,Konto Betalt for å
apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.py +24,Parent Item {0} must not be a Stock Item,Parent Element {0} må ikke være en lagervare
apps/erpnext/erpnext/config/selling.py +57,All Products or Services.,Alle produkter eller tjenester.
DocType: Expense Claim,More Details,Mer informasjon
DocType: Supplier Quotation,Supplier Address,Leverandør Adresse
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +128,{0} Budget for Account {1} against {2} {3} is {4}. It will exceed by {5},{0} budsjettet for kontoen {1} mot {2} {3} er {4}. Det vil overstige ved {5}
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +665,Row {0}# Account must be of type 'Fixed Asset',Rad {0} # konto må være av typen &quot;Fixed Asset &#39;
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37,Out Qty,Ut Antall
apps/erpnext/erpnext/config/accounts.py +316,Rules to calculate shipping amount for a sale,Regler for å beregne frakt beløp for et salg
apps/erpnext/erpnext/selling/doctype/customer/customer.py +34,Series is mandatory,Serien er obligatorisk
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +28,Financial Services,Finansielle Tjenester
DocType: Student Sibling,Student ID,Student ID
apps/erpnext/erpnext/config/projects.py +40,Types of activities for Time Logs,Typer aktiviteter for Tid Logger
DocType: Tax Rule,Sales,Salgs
DocType: Stock Entry Detail,Basic Amount,Grunnbeløp
DocType: Training Event,Exam,Eksamen
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +440,Warehouse required for stock Item {0},Warehouse nødvendig for lager Element {0}
DocType: Leave Allocation,Unused leaves,Ubrukte blader
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +161,Cr,Cr
DocType: Tax Rule,Billing State,Billing State
apps/erpnext/erpnext/accounts/doctype/asset/asset.js +287,Transfer,Transfer
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +212,{0} {1} does not associated with Party Account {2},{0} {1} ikke forbundet med Party-konto {2}
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +862,Fetch exploded BOM (including sub-assemblies),Hente eksploderte BOM (inkludert underenheter)
DocType: Authorization Rule,Applicable To (Employee),Gjelder til (Employee)
apps/erpnext/erpnext/controllers/accounts_controller.py +123,Due Date is mandatory,Due Date er obligatorisk
apps/erpnext/erpnext/controllers/item_variant.py +80,Increment for Attribute {0} cannot be 0,Økning for Egenskap {0} kan ikke være 0
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +51,Customer &gt; Customer Group &gt; Territory,Kunde&gt; Kundegruppe&gt; Territorium
DocType: Journal Entry,Pay To / Recd From,Betal Til / recd From
DocType: Naming Series,Setup Series,Oppsett Series
DocType: Payment Reconciliation,To Invoice Date,Å Fakturadato
DocType: Supplier,Contact HTML,Kontakt HTML
,Inactive Customers,inaktive kunder
DocType: Landed Cost Voucher,LCV,LCV
DocType: Landed Cost Voucher,Purchase Receipts,Kjøps Kvitteringer
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +29,How Pricing Rule is applied?,Hvordan Pricing Rule er brukt?
DocType: Stock Entry,Delivery Note No,Levering Note Nei
DocType: Production Planning Tool,"If checked, only Purchase material requests for final raw materials will be included in the Material Requests. Otherwise, Material Requests for parent items will be created","Hvis det er merket, bare kjøpe materielle forespørsler for endelig råvarer vil bli inkludert i materialet forespørsler. Ellers vil material Forespørsler om ordnede elementer opprettes"
DocType: Cheque Print Template,Message to show,Melding for visning
DocType: Company,Retail,Retail
DocType: Attendance,Absent,Fraværende
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +566,Product Bundle,Produktet Bundle
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +212,Row {0}: Invalid reference {1},Rad {0}: Ugyldig referanse {1}
DocType: Purchase Taxes and Charges Template,Purchase Taxes and Charges Template,Kjøpe skatter og avgifter Mal
DocType: Upload Attendance,Download Template,Last ned Mal
DocType: Timesheet,TS-,TS-
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +61,{0} {1}: Either debit or credit amount is required for {2},{0} {1}: Enten debet- eller kredittbeløpet er nødvendig for {2}
DocType: GL Entry,Remarks,Bemerkninger
DocType: Payment Entry,Account Paid From,Konto betalt fra
DocType: Purchase Order Item Supplied,Raw Material Item Code,Raw Material Elementkode
DocType: Journal Entry,Write Off Based On,Skriv Off basert på
apps/erpnext/erpnext/utilities/activation.py +63,Make Lead,Gjør Lead
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +112,Print and Stationery,Skriv ut og Saker
DocType: Stock Settings,Show Barcode Field,Vis strekkodefelt
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +767,Send Supplier Emails,Send Leverandør e-post
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +115,"Salary already processed for period between {0} and {1}, Leave application period cannot be between this date range.","Lønn allerede behandlet for perioden mellom {0} og {1}, La søknadsperioden kan ikke være mellom denne datoperioden."
apps/erpnext/erpnext/config/stock.py +127,Installation record for a Serial No.,Installasjon rekord for en Serial No.
DocType: Guardian Interest,Guardian Interest,Guardian Rente
apps/erpnext/erpnext/config/hr.py +177,Training,Opplæring
DocType: Timesheet,Employee Detail,Medarbeider Detalj
apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +58,Guardian1 Email ID,Guardian1 Email ID
apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +58,Guardian1 Email ID,Guardian1 Email ID
apps/erpnext/erpnext/controllers/recurring_document.py +190,Next Date's day and Repeat on Day of Month must be equal,Neste Date dag og gjenta på dag i måneden må være lik
apps/erpnext/erpnext/config/website.py +11,Settings for website homepage,Innstillinger for nettstedet hjemmeside
DocType: Offer Letter,Awaiting Response,Venter på svar
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +60,Above,Fremfor
apps/erpnext/erpnext/controllers/item_variant.py +216,Invalid attribute {0} {1},Ugyldig egenskap {0} {1}
DocType: Supplier,Mention if non-standard payable account,Nevn hvis ikke-standard betalingskonto
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +292,Same item has been entered multiple times. {list},Samme gjenstand er oppgitt flere ganger. {liste}
apps/erpnext/erpnext/schools/report/course_wise_assessment_report/course_wise_assessment_report.py +18,Please select the assessment group other than 'All Assessment Groups',Vennligst velg vurderingsgruppen annet enn &#39;Alle vurderingsgrupper&#39;
DocType: Salary Slip,Earning & Deduction,Tjene &amp; Fradrag
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +36,Optional. This setting will be used to filter in various transactions.,Valgfritt. Denne innstillingen vil bli brukt for å filtrere i forskjellige transaksjoner.
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +108,Negative Valuation Rate is not allowed,Negative Verdivurdering Rate er ikke tillatt
DocType: Holiday List,Weekly Off,Ukentlig Off
DocType: Fiscal Year,"For e.g. 2012, 2012-13","For eksempel 2012, 2012-13"
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +96,Provisional Profit / Loss (Credit),Foreløpig Profit / Loss (Credit)
DocType: Sales Invoice,Return Against Sales Invoice,Tilbake Mot Salg Faktura
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +32,Item 5,Sak 5
DocType: Serial No,Creation Time,Creation Tid
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +62,Total Revenue,Totale Inntekter
DocType: Sales Invoice,Product Bundle Help,Produktet Bundle Hjelp
,Monthly Attendance Sheet,Månedlig Oppmøte Sheet
DocType: Production Order Item,Production Order Item,Produksjonsordre Element
apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +19,No record found,Ingen rekord funnet
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +137,Cost of Scrapped Asset,Kostnad for kasserte Asset
apps/erpnext/erpnext/controllers/stock_controller.py +236,{0} {1}: Cost Center is mandatory for Item {2},{0} {1}: Kostnadssted er obligatorisk for Element {2}
DocType: Vehicle,Policy No,Regler Nei
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +659,Get Items from Product Bundle,Få Elementer fra Produkt Bundle
DocType: Asset,Straight Line,Rett linje
DocType: Project User,Project User,prosjekt Bruker
apps/erpnext/erpnext/stock/doctype/batch/batch.js +59,Split,Dele
apps/erpnext/erpnext/stock/doctype/batch/batch.js +59,Split,Dele
DocType: GL Entry,Is Advance,Er Advance
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +21,Attendance From Date and Attendance To Date is mandatory,Oppmøte Fra Dato og oppmøte To Date er obligatorisk
apps/erpnext/erpnext/controllers/buying_controller.py +149,Please enter 'Is Subcontracted' as Yes or No,Skriv inn &#39;Er underleverandør&#39; som Ja eller Nei
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +29,Last Communication Date,Siste kommunikasjonsdato
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +29,Last Communication Date,Siste kommunikasjonsdato
DocType: Sales Team,Contact No.,Kontaktnummer.
DocType: Bank Reconciliation,Payment Entries,Betalings Entries
DocType: Production Order,Scrap Warehouse,skrap Warehouse
DocType: Production Order,Check if material transfer entry is not required,Sjekk om materialoverføring ikke er nødvendig
DocType: Production Order,Check if material transfer entry is not required,Sjekk om materialoverføring ikke er nødvendig
apps/erpnext/erpnext/hr/doctype/employee/employee.py +23,Please setup Employee Naming System in Human Resource &gt; HR Settings,Vennligst oppsett Ansattes navngivningssystem i menneskelig ressurs&gt; HR-innstillinger
DocType: Program Enrollment Tool,Get Students From,Få studenter fra
DocType: Hub Settings,Seller Country,Selger Land
apps/erpnext/erpnext/config/learn.py +273,Publish Items on Website,Publiser Elementer på nettstedet
apps/erpnext/erpnext/utilities/activation.py +124,Group your students in batches,Gruppe elevene i grupper
DocType: Authorization Rule,Authorization Rule,Autorisasjon Rule
DocType: Sales Invoice,Terms and Conditions Details,Vilkår og betingelser Detaljer
apps/erpnext/erpnext/templates/generators/item.html +85,Specifications,Spesifikasjoner
DocType: Sales Taxes and Charges Template,Sales Taxes and Charges Template,Salgs skatter og avgifter Mal
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +68,Total (Credit),Total (Credit)
DocType: Repayment Schedule,Payment Date,Betalingsdato
apps/erpnext/erpnext/stock/doctype/batch/batch.js +102,New Batch Qty,Ny batch Antall
apps/erpnext/erpnext/stock/doctype/batch/batch.js +102,New Batch Qty,Ny batch Antall
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +10,Apparel & Accessories,Klær og tilbehør
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +67,Number of Order,Antall Bestill
DocType: Item Group,HTML / Banner that will show on the top of product list.,HTML / Banner som vil vises på toppen av listen over produkter.
DocType: Shipping Rule,Specify conditions to calculate shipping amount,Spesifiser forhold til å beregne frakt beløp
DocType: Accounts Settings,Role Allowed to Set Frozen Accounts & Edit Frozen Entries,Rolle lov til å sette Frosne Kontoer og Rediger Frosne Entries
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +28,Cannot convert Cost Center to ledger as it has child nodes,Kan ikke konvertere kostnadssted til hovedbok som den har barnet noder
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +56,Opening Value,åpning Verdi
DocType: Salary Detail,Formula,Formel
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +37,Serial #,Serial #
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +94,Commission on Sales,Provisjon på salg
DocType: Offer Letter Term,Value / Description,Verdi / beskrivelse
apps/erpnext/erpnext/controllers/accounts_controller.py +578,"Row #{0}: Asset {1} cannot be submitted, it is already {2}","Row # {0}: Asset {1} kan ikke sendes inn, er det allerede {2}"
DocType: Tax Rule,Billing Country,Fakturering Land
DocType: Purchase Order Item,Expected Delivery Date,Forventet Leveringsdato
apps/erpnext/erpnext/accounts/general_ledger.py +132,Debit and Credit not equal for {0} #{1}. Difference is {2}.,Debet- og kredittkort ikke lik for {0} # {1}. Forskjellen er {2}.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +98,Entertainment Expenses,Underholdning Utgifter
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +48,Make Material Request,Gjør Material Request
apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html +20,Open Item {0},Åpen Element {0}
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +214,Sales Invoice {0} must be cancelled before cancelling this Sales Order,Salg Faktura {0} må slettes før den sletter denne salgsordre
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +60,Age,Alder
DocType: Sales Invoice Timesheet,Billing Amount,Faktureringsbeløp
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +84,Invalid quantity specified for item {0}. Quantity should be greater than 0.,Ugyldig kvantum spesifisert for elementet {0}. Antall må være større enn 0.
apps/erpnext/erpnext/config/hr.py +60,Applications for leave.,Søknader om permisjon.
apps/erpnext/erpnext/accounts/doctype/account/account.py +177,Account with existing transaction can not be deleted,Konto med eksisterende transaksjon kan ikke slettes
DocType: Vehicle,Last Carbon Check,Siste Carbon Sjekk
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +102,Legal Expenses,Rettshjelp
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +113,Please select quantity on row ,Vennligst velg antall på rad
DocType: Purchase Invoice,Posting Time,Postering Tid
DocType: Timesheet,% Amount Billed,% Mengde Fakturert
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +118,Telephone Expenses,Telefon Utgifter
DocType: Sales Partner,Logo,Logo
DocType: Naming Series,Check this if you want to force the user to select a series before saving. There will be no default if you check this.,Sjekk dette hvis du vil tvinge brukeren til å velge en serie før du lagrer. Det blir ingen standard hvis du sjekke dette.
apps/erpnext/erpnext/stock/get_item_details.py +135,No Item with Serial No {0},Ingen Element med Serial No {0}
DocType: Email Digest,Open Notifications,Åpne Påminnelser
DocType: Payment Entry,Difference Amount (Company Currency),Forskjell Beløp (Selskap Valuta)
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +79,Direct Expenses,Direkte kostnader
apps/erpnext/erpnext/controllers/recurring_document.py +213,"{0} is an invalid email address in 'Notification \
						Email Address'",{0} er en ugyldig e-postadresse i &quot;Melding om \ e-postadresse &#39;
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +60,New Customer Revenue,Ny kunde Revenue
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +119,Travel Expenses,Reiseutgifter
DocType: Maintenance Visit,Breakdown,Sammenbrudd
apps/erpnext/erpnext/controllers/accounts_controller.py +690,Account: {0} with currency: {1} can not be selected,Konto: {0} med valuta: {1} kan ikke velges
DocType: Bank Reconciliation Detail,Cheque Date,Sjekk Dato
apps/erpnext/erpnext/accounts/doctype/account/account.py +54,Account {0}: Parent account {1} does not belong to company: {2},Konto {0}: Parent konto {1} ikke tilhører selskapet: {2}
DocType: Program Enrollment Tool,Student Applicants,student Søkere
apps/erpnext/erpnext/setup/doctype/company/company.js +67,Successfully deleted all transactions related to this company!,Slettet alle transaksjoner knyttet til dette selskapet!
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +21,As on Date,Som på dato
DocType: Appraisal,HR,HR
DocType: Program Enrollment,Enrollment Date,påmelding Dato
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +69,Probation,Prøvetid
apps/erpnext/erpnext/config/hr.py +115,Salary Components,lønn Components
DocType: Program Enrollment Tool,New Academic Year,Nytt studieår
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +745,Return / Credit Note,Retur / kreditnota
DocType: Stock Settings,Auto insert Price List rate if missing,Auto innsats Prisliste rente hvis mangler
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +23,Total Paid Amount,Totalt innbetalt beløp
DocType: Production Order Item,Transferred Qty,Overført Antall
apps/erpnext/erpnext/config/learn.py +11,Navigating,Navigere
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +157,Planning,Planlegging
DocType: Material Request,Issued,Utstedt
apps/erpnext/erpnext/schools/doctype/student/student_dashboard.py +14,Student Activity,Studentaktivitet
DocType: Project,Total Billing Amount (via Time Logs),Total Billing Beløp (via Time Logger)
apps/erpnext/erpnext/public/js/setup_wizard.js +312,We sell this Item,Vi selger denne vare
apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +80,Supplier Id,Leverandør Id
DocType: Payment Request,Payment Gateway Details,Betaling Gateway Detaljer
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +242,Quantity should be greater than 0,Mengden skal være større enn 0
apps/erpnext/erpnext/public/js/setup_wizard.js +390,Sample Data,Eksempeldata
DocType: Journal Entry,Cash Entry,Cash Entry
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js +17,Child nodes can be only created under 'Group' type nodes,Ordnede noder kan bare opprettes under &#39;Gruppe&#39; type noder
DocType: Leave Application,Half Day Date,Half Day Date
DocType: Academic Year,Academic Year Name,Akademisk År Navn
DocType: Sales Partner,Contact Desc,Kontakt Desc
apps/erpnext/erpnext/config/hr.py +65,"Type of leaves like casual, sick etc.","Type blader som casual, syke etc."
DocType: Email Digest,Send regular summary reports via Email.,Send vanlige oppsummeringsrapporter via e-post.
DocType: Payment Entry,PE-,PE
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +250,Please set default account in Expense Claim Type {0},Vennligst angi standardkonto i Expense krav Type {0}
DocType: Assessment Result,Student Name,Student navn
DocType: Brand,Item Manager,Sak manager
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +143,Payroll Payable,lønn Betales
DocType: Buying Settings,Default Supplier Type,Standard Leverandør Type
DocType: Production Order,Total Operating Cost,Total driftskostnader
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +171,Note: Item {0} entered multiple times,Merk: Element {0} inngått flere ganger
apps/erpnext/erpnext/config/selling.py +41,All Contacts.,Alle kontakter.
apps/erpnext/erpnext/public/js/setup_wizard.js +223,Set your Target,Angi målet ditt
apps/erpnext/erpnext/public/js/setup_wizard.js +60,Company Abbreviation,Firma Forkortelse
apps/erpnext/erpnext/hr/doctype/employee/employee.py +136,User {0} does not exist,Bruker {0} finnes ikke
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +95,Raw material cannot be same as main Item,Råstoff kan ikke være det samme som hoved Element
DocType: Item Attribute Value,Abbreviation,Forkortelse
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +171,Payment Entry already exists,Betaling Entry finnes allerede
apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py +36,Not authroized since {0} exceeds limits,Ikke authroized siden {0} overskrider grensene
apps/erpnext/erpnext/config/hr.py +110,Salary template master.,Lønn mal mester.
DocType: Leave Type,Max Days Leave Allowed,Max Dager La tillatt
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +63,Set Tax Rule for shopping cart,Still skatteregel for shopping cart
DocType: Purchase Invoice,Taxes and Charges Added,Skatter og avgifter legges
,Sales Funnel,Sales trakt
apps/erpnext/erpnext/setup/doctype/company/company.py +48,Abbreviation is mandatory,Forkortelsen er obligatorisk
DocType: Project,Task Progress,Task Progress
apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html +7,Cart,Kurven
,Qty to Transfer,Antall overføre
apps/erpnext/erpnext/config/selling.py +13,Quotes to Leads or Customers.,Sitater for å Leads eller kunder.
DocType: Stock Settings,Role Allowed to edit frozen stock,Rolle tillatt å redigere frossen lager
,Territory Target Variance Item Group-Wise,Territorium Target Avviks varegruppe-Wise
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +112,All Customer Groups,Alle kundegrupper
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +114,Accumulated Monthly,akkumulert pr måned
apps/erpnext/erpnext/controllers/accounts_controller.py +651,{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2}.,{0} er obligatorisk. Kanskje Valutaveksling posten ikke er skapt for {1} til {2}.
apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +39,Tax Template is mandatory.,Skatt Mal er obligatorisk.
apps/erpnext/erpnext/accounts/doctype/account/account.py +48,Account {0}: Parent account {1} does not exist,Konto {0}: Parent konto {1} finnes ikke
DocType: Purchase Invoice Item,Price List Rate (Company Currency),Prisliste Rate (Selskap Valuta)
DocType: Products Settings,Products Settings,Produkter Innstillinger
DocType: Account,Temporary,Midlertidig
DocType: Program,Courses,kurs
DocType: Monthly Distribution Percentage,Percentage Allocation,Prosentvis Allocation
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +97,Secretary,Sekretær
DocType: Global Defaults,"If disable, 'In Words' field will not be visible in any transaction","Hvis deaktivere, &#39;I Ord-feltet ikke vil være synlig i enhver transaksjon"
DocType: Serial No,Distinct unit of an Item,Distinkt enhet av et element
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1209,Please set Company,Vennligst sett selskap
DocType: Pricing Rule,Buying,Kjøpe
DocType: HR Settings,Employee Records to be created by,Medarbeider Records å være skapt av
DocType: POS Profile,Apply Discount On,Påfør rabatt på
,Reqd By Date,Reqd etter dato
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +140,Creditors,Kreditorer
DocType: Assessment Plan,Assessment Name,Assessment Name
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +96,Row # {0}: Serial No is mandatory,Row # {0}: Serial No er obligatorisk
DocType: Purchase Taxes and Charges,Item Wise Tax Detail,Sak Wise Skatt Detalj
apps/erpnext/erpnext/public/js/setup_wizard.js +60,Institute Abbreviation,Institute forkortelse
,Item-wise Price List Rate,Element-messig Prisliste Ranger
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +901,Supplier Quotation,Leverandør sitat
DocType: Quotation,In Words will be visible once you save the Quotation.,I Ord vil være synlig når du lagrer Tilbud.
apps/erpnext/erpnext/utilities/transaction_base.py +153,Quantity ({0}) cannot be a fraction in row {1},Antall ({0}) kan ikke være en brøkdel i rad {1}
apps/erpnext/erpnext/utilities/transaction_base.py +153,Quantity ({0}) cannot be a fraction in row {1},Antall ({0}) kan ikke være en brøkdel i rad {1}
apps/erpnext/erpnext/schools/doctype/fees/fees.js +26,Collect Fees,samle gebyrer
DocType: Attendance,ATT-,ATT-
apps/erpnext/erpnext/stock/doctype/item/item.py +444,Barcode {0} already used in Item {1},Barcode {0} allerede brukt i Element {1}
DocType: Lead,Add to calendar on this date,Legg til i kalender på denne datoen
apps/erpnext/erpnext/config/selling.py +86,Rules for adding shipping costs.,Regler for å legge til fraktkostnader.
DocType: Item,Opening Stock,åpning Stock
apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +20,Customer is required,Kunden må
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +20,{0} is mandatory for Return,{0} er obligatorisk for Return
DocType: Purchase Order,To Receive,Å Motta
apps/erpnext/erpnext/public/js/setup_wizard.js +205,user@example.com,user@example.com
DocType: Employee,Personal Email,Personlig e-post
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +57,Total Variance,Total Variance
DocType: Accounts Settings,"If enabled, the system will post accounting entries for inventory automatically.","Hvis aktivert, vil systemet starte regnskapspostene for inventar automatisk."
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +15,Brokerage,Brokerage
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +232,Attendance for employee {0} is already marked for this day,Oppmøte for arbeidstaker {0} er allerede markert for denne dagen
DocType: Production Order Operation,"in Minutes
Updated via 'Time Log'",Minutter Oppdatert via &#39;Time Logg&#39;
DocType: Customer,From Lead,Fra Lead
apps/erpnext/erpnext/config/manufacturing.py +13,Orders released for production.,Bestillinger frigitt for produksjon.
apps/erpnext/erpnext/public/js/account_tree_grid.js +66,Select Fiscal Year...,Velg regnskapsår ...
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +545,POS Profile required to make POS Entry,POS Profile nødvendig å foreta POS Entry
DocType: Program Enrollment Tool,Enroll Students,Meld Studenter
DocType: Hub Settings,Name Token,Navn Token
apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py +21,Standard Selling,Standard Selling
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +138,Atleast one warehouse is mandatory,Minst én lageret er obligatorisk
DocType: Serial No,Out of Warranty,Ut av Garanti
DocType: BOM Replace Tool,Replace,Erstatt
apps/erpnext/erpnext/templates/includes/product_list.js +42,No products found.,Ingen produkter funnet.
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +360,{0} against Sales Invoice {1},{0} mot Sales Faktura {1}
DocType: Sales Invoice,SINV-,SINV-
DocType: Request for Quotation Item,Project Name,Prosjektnavn
DocType: Customer,Mention if non-standard receivable account,Nevn hvis ikke-standard fordring konto
DocType: Journal Entry Account,If Income or Expense,Dersom inntekt eller kostnad
DocType: Production Order,Required Items,nødvendige elementer
DocType: Stock Ledger Entry,Stock Value Difference,Stock Verdi Difference
apps/erpnext/erpnext/config/learn.py +234,Human Resource,Menneskelig Resurs
DocType: Payment Reconciliation Payment,Payment Reconciliation Payment,Betaling Avstemming Betaling
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +38,Tax Assets,Skattefordel
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +617,Production Order has been {0},Produksjonsordre har vært {0}
DocType: BOM Item,BOM No,BOM Nei
DocType: Instructor,INS/,INS /
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +160,Journal Entry {0} does not have account {1} or already matched against other voucher,Journal Entry {0} ikke har konto {1} eller allerede matchet mot andre verdikupong
DocType: Item,Moving Average,Glidende gjennomsnitt
DocType: BOM Replace Tool,The BOM which will be replaced,BOM som vil bli erstattet
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +46,Electronic Equipments,elektronisk utstyr
DocType: Account,Debit,Debet
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +49,Leaves must be allocated in multiples of 0.5,"Bladene skal avsettes i multipler av 0,5"
DocType: Production Order,Operation Cost,Operation Cost
apps/erpnext/erpnext/config/hr.py +29,Upload attendance from a .csv file,Last opp oppmøte fra en CSV-fil
apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +39,Outstanding Amt,Enestående Amt
DocType: Sales Person,Set targets Item Group-wise for this Sales Person.,Sette mål varegruppe-messig for Sales Person.
DocType: Stock Settings,Freeze Stocks Older Than [Days],Freeze Aksjer Eldre enn [dager]
apps/erpnext/erpnext/controllers/accounts_controller.py +548,Row #{0}: Asset is mandatory for fixed asset purchase/sale,Row # {0}: Asset er obligatorisk for anleggsmiddel kjøp / salg
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +42,"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.","Hvis to eller flere Prising Reglene er funnet basert på de ovennevnte forhold, er Priority brukt. Prioritet er et tall mellom 0 og 20, mens standardverdi er null (blank). Høyere tall betyr at det vil ha forrang dersom det er flere Prising regler med samme betingelser."
apps/erpnext/erpnext/controllers/trends.py +36,Fiscal Year: {0} does not exists,Fiscal Year: {0} ikke eksisterer
DocType: Currency Exchange,To Currency,Å Valuta
DocType: Leave Block List,Allow the following users to approve Leave Applications for block days.,Tillat følgende brukere å godkjenne La Applications for blokk dager.
apps/erpnext/erpnext/config/hr.py +132,Types of Expense Claim.,Typer av Expense krav.
apps/erpnext/erpnext/controllers/selling_controller.py +173,Selling rate for item {0} is lower than its {1}. Selling rate should be atleast {2},Selgingsfrekvensen for elementet {0} er lavere enn dens {1}. Salgsprisen bør være minst {2}
DocType: Item,Taxes,Skatter
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +324,Paid and Not Delivered,Betalt og ikke levert
DocType: Project,Default Cost Center,Standard kostnadssted
DocType: Bank Guarantee,End Date,Sluttdato
apps/erpnext/erpnext/config/stock.py +7,Stock Transactions,aksje~~POS=TRUNC
DocType: Budget,Budget Accounts,Budsjett Regnskap
DocType: Employee,Internal Work History,Intern Work History
DocType: Depreciation Schedule,Accumulated Depreciation Amount,Akkumulerte avskrivninger beløp
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +42,Private Equity,Private Equity
DocType: Employee Loan,Fully Disbursed,fullt utbetalt
DocType: Maintenance Visit,Customer Feedback,Customer Feedback
DocType: Account,Expense,Expense
apps/erpnext/erpnext/schools/doctype/assessment_result/assessment_result.js +34,Score cannot be greater than Maximum Score,Score kan ikke være større enn Maksimal poengsum
DocType: Item Attribute,From Range,Fra Range
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +93,Syntax error in formula or condition: {0},Syntaksfeil i formelen eller tilstand: {0}
DocType: Daily Work Summary Settings Company,Daily Work Summary Settings Company,Daglig arbeid Oppsummering Innstillinger selskapet
apps/erpnext/erpnext/stock/utils.py +123,Item {0} ignored since it is not a stock item,Element {0} ignorert siden det ikke er en lagervare
DocType: Appraisal,APRSL,APRSL
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +101,Submit this Production Order for further processing.,Send dette produksjonsordre for videre behandling.
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +23,"To not apply Pricing Rule in a particular transaction, all applicable Pricing Rules should be disabled.","Hvis du ikke vil bruke Prissetting regel i en bestemt transaksjon, bør alle gjeldende reglene for prissetting deaktiveres."
DocType: Assessment Group,Parent Assessment Group,Parent Assessment Group
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +27,Jobs,Jobs
,Sales Order Trends,Salgsordre Trender
DocType: Employee,Held On,Avholdt
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order_calendar.js +36,Production Item,Produksjon Element
,Employee Information,Informasjon ansatt
apps/erpnext/erpnext/public/js/setup_wizard.js +245,Rate (%),Rate (%)
DocType: Stock Entry Detail,Additional Cost,Tilleggs Cost
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +39,"Can not filter based on Voucher No, if grouped by Voucher","Kan ikke filtrere basert på Voucher Nei, hvis gruppert etter Voucher"
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +789,Make Supplier Quotation,Gjør Leverandør sitat
DocType: Quality Inspection,Incoming,Innkommende
DocType: BOM,Materials Required (Exploded),Materialer som er nødvendige (Exploded)
apps/erpnext/erpnext/public/js/setup_wizard.js +197,"Add users to your organization, other than yourself","Legge til brukere i organisasjonen, annet enn deg selv"
apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py +60,Please set Company filter blank if Group By is 'Company',Vennligst sett Company filter blank hvis Group By er &#39;Company&#39;
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +66,Posting Date cannot be future date,Publiseringsdato kan ikke være fremtidig dato
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +101,Row # {0}: Serial No {1} does not match with {2} {3},Row # {0}: Serial No {1} samsvarer ikke med {2} {3}
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +55,Casual Leave,Casual La
DocType: Batch,Batch ID,Batch ID
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +380,Note: {0},Merk: {0}
,Delivery Note Trends,Levering Note Trender
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +113,This Week's Summary,Denne ukens oppsummering
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py +20,In Stock Qty,På lager Antall
apps/erpnext/erpnext/accounts/general_ledger.py +111,Account: {0} can only be updated via Stock Transactions,Konto: {0} kan bare oppdateres via lagertransaksjoner
DocType: Student Group Creation Tool,Get Courses,Få Kurs
DocType: GL Entry,Party,Selskap
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +964,Delivery Date,Leveringsdato
DocType: Opportunity,Opportunity Date,Opportunity Dato
DocType: Purchase Receipt,Return Against Purchase Receipt,Tilbake Against Kjøpskvittering
DocType: Request for Quotation Item,Request for Quotation Item,Forespørsel om prisanslag Element
DocType: Purchase Order,To Bill,Til Bill
DocType: Material Request,% Ordered,% Bestilt
DocType: School Settings,"For Course based Student Group, the Course will be validated for every Student from the enrolled Courses in Program Enrollment.",For kursbasert studentgruppe vil kurset bli validert for hver student fra de innmeldte kursene i programopptaket.
DocType: Purchase Invoice,"Enter Email Address separated by commas, invoice will be mailed automatically on particular date","Skriv inn e-postadresse atskilt med komma, vil fakturaen bli sendt automatisk på bestemt dato"
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +72,Piecework,Akkord
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +72,Avg. Buying Rate,Avg. Kjøpe Rate
DocType: Task,Actual Time (in Hours),Virkelig tid (i timer)
DocType: Employee,History In Company,Historie I selskapet
apps/erpnext/erpnext/config/learn.py +107,Newsletters,Nyhetsbrev
DocType: Stock Ledger Entry,Stock Ledger Entry,Stock Ledger Entry
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +82,Same item has been entered multiple times,Samme element er angitt flere ganger
DocType: Department,Leave Block List,La Block List
DocType: Sales Invoice,Tax ID,Skatt ID
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +192,Item {0} is not setup for Serial Nos. Column must be blank,Element {0} er ikke oppsett for Serial Nos. Kolonne må være tomt
DocType: Accounts Settings,Accounts Settings,Regnskap Innstillinger
apps/erpnext/erpnext/schools/doctype/student_applicant/student_applicant.js +7,Approve,Vedta
DocType: Customer,Sales Partner and Commission,Sales Partner og Kommisjonen
DocType: Employee Loan,Rate of Interest (%) / Year,Rente (%) / År
,Project Quantity,prosjekt Antall
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +73,"Total {0} for all items is zero, may be you should change 'Distribute Charges Based On'","Totalt {0} for alle elementer er null, kan være du bør endre &#39;Fordel Avgifter basert på&#39;"
DocType: Opportunity,To Discuss,Å Diskutere
apps/erpnext/erpnext/stock/stock_ledger.py +368,{0} units of {1} needed in {2} to complete this transaction.,{0} enheter av {1} trengs i {2} for å fullføre denne transaksjonen.
DocType: Loan Type,Rate of Interest (%) Yearly,Rente (%) Årlig
DocType: SMS Settings,SMS Settings,SMS-innstillinger
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +71,Temporary Accounts,Midlertidige kontoer
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +176,Black,Svart
DocType: BOM Explosion Item,BOM Explosion Item,BOM Explosion Element
DocType: Account,Auditor,Revisor
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +124,{0} items produced,{0} elementer produsert
DocType: Cheque Print Template,Distance from top edge,Avstand fra øvre kant
apps/erpnext/erpnext/stock/get_item_details.py +307,Price List {0} is disabled or does not exist,Prisliste {0} er deaktivert eller eksisterer ikke
DocType: Purchase Invoice,Return,Return
DocType: Production Order Operation,Production Order Operation,Produksjon Bestill Operation
DocType: Pricing Rule,Disable,Deaktiver
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +157,Mode of payment is required to make a payment,Modus for betaling er nødvendig å foreta en betaling
DocType: Project Task,Pending Review,Avventer omtale
apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +38,{0} - {1} is not enrolled in the Batch {2},{0} - {1} er ikke påmeldt i batch {2}
apps/erpnext/erpnext/accounts/doctype/asset/depreciation.py +110,"Asset {0} cannot be scrapped, as it is already {1}","Asset {0} kan ikke bli vraket, som det er allerede {1}"
DocType: Task,Total Expense Claim (via Expense Claim),Total Expense krav (via Expense krav)
apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +177,Mark Absent,Mark Fraværende
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +139,Row {0}: Currency of the BOM #{1} should be equal to the selected currency {2},Rad {0}: valuta BOM # {1} bør være lik den valgte valutaen {2}
DocType: Journal Entry Account,Exchange Rate,Vekslingskurs
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +563,Sales Order {0} is not submitted,Salgsordre {0} er ikke innsendt
DocType: Homepage,Tag Line,tag Linje
DocType: Fee Component,Fee Component,Fee Component
apps/erpnext/erpnext/config/hr.py +195,Fleet Management,Flåtestyring
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +899,Add items from,Legg elementer fra
DocType: Cheque Print Template,Regular,Regelmessig
apps/erpnext/erpnext/schools/doctype/course/course.py +20,Total Weightage of all Assessment Criteria must be 100%,Totalt weightage av alle vurderingskriteriene må være 100%
DocType: BOM,Last Purchase Rate,Siste Purchase Rate
DocType: Account,Asset,Asset
DocType: Project Task,Task ID,Task ID
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +84,Stock cannot exist for Item {0} since has variants,Stock kan ikke eksistere for Element {0} siden har varianter
,Sales Person-wise Transaction Summary,Transaksjons Oppsummering Sales Person-messig
DocType: Training Event,Contact Number,Kontakt nummer
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +72,Warehouse {0} does not exist,Warehouse {0} finnes ikke
apps/erpnext/erpnext/hub_node/page/hub/register_in_hub.html +2,Register For ERPNext Hub,Registrer For ERPNext Hub
DocType: Monthly Distribution,Monthly Distribution Percentages,Månedlig Distribusjonsprosent
apps/erpnext/erpnext/stock/doctype/batch/batch.py +37,The selected item cannot have Batch,Den valgte elementet kan ikke ha Batch
apps/erpnext/erpnext/stock/stock_ledger.py +464,"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 sample 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","Verdsettelse hastighet ikke funnet med Element {0}, som er nødvendig for å gjøre regnskap oppføringer for {1} {2}. Hvis elementet er transacting som en prøve element i {1}, kan nevnes at i {1} Element tabell. Ellers må du opprette en innkommende lager transaksjon for varen eller omtale verdivurdering hastighet i element posten, og deretter prøve submiting / avbryter denne oppføringen"
DocType: Delivery Note,% of materials delivered against this Delivery Note,% Av materialer leveres mot denne følgeseddel
DocType: Project,Customer Details,Kunde Detaljer
DocType: Employee,Reports to,Rapporter til
,Unpaid Expense Claim,Ubetalte Expense krav
DocType: SMS Settings,Enter url parameter for receiver nos,Skriv inn url parameter for mottaker nos
DocType: Payment Entry,Paid Amount,Innbetalt beløp
DocType: Assessment Plan,Supervisor,Supervisor
apps/erpnext/erpnext/accounts/page/pos/pos.js +704,Online,på nett
,Available Stock for Packing Items,Tilgjengelig på lager for pakk gjenstander
DocType: Item Variant,Item Variant,Sak Variant
DocType: Assessment Result Tool,Assessment Result Tool,Assessment Resultat Tool
DocType: BOM Scrap Item,BOM Scrap Item,BOM Scrap Element
apps/erpnext/erpnext/accounts/page/pos/pos.js +865,Submitted orders can not be deleted,Innsendte bestillinger kan ikke slettes
apps/erpnext/erpnext/accounts/doctype/account/account.py +117,"Account balance already in Debit, you are not allowed to set 'Balance Must Be' as 'Credit'","Saldo allerede i debet, har du ikke lov til å sette &quot;Balance må være &#39;som&#39; Credit &#39;"
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +87,Quality Management,Kvalitetsstyring
apps/erpnext/erpnext/accounts/doctype/asset/asset.py +41,Item {0} has been disabled,Element {0} har blitt deaktivert
DocType: Employee Loan,Repay Fixed Amount per Period,Smelle fast beløp per periode
apps/erpnext/erpnext/buying/utils.py +47,Please enter quantity for Item {0},Skriv inn antall for Element {0}
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +69,Credit Note Amt,Kreditt notat Amt
DocType: Employee External Work History,Employee External Work History,Ansatt Ekstern Work History
DocType: Tax Rule,Purchase,Kjøp
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37,Balance Qty,Balanse Antall
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +20,Goals cannot be empty,Mål kan ikke være tomt
DocType: Item Group,Parent Item Group,Parent varegruppe
apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +21,{0} for {1},{0} for {1}
apps/erpnext/erpnext/setup/doctype/company/company.js +25,Cost Centers,Kostnadssteder
DocType: Purchase Receipt,Rate at which supplier's currency is converted to company's base currency,Hastigheten som leverandørens valuta er konvertert til selskapets hovedvaluta
apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +36,Row #{0}: Timings conflicts with row {1},Row # {0}: timings konflikter med rad {1}
DocType: Purchase Invoice Item,Allow Zero Valuation Rate,Tillat null verdivurdering
DocType: Training Event Employee,Invited,invitert
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +172,Multiple active Salary Structures found for employee {0} for the given dates,Flere aktive Lønn Structures funnet for arbeidstaker {0} for den gitte datoer
DocType: Opportunity,Next Contact,Neste Kontakt
apps/erpnext/erpnext/config/accounts.py +310,Setup Gateway accounts.,Oppsett Gateway kontoer.
DocType: Employee,Employment Type,Type stilling
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +42,Fixed Assets,Anleggsmidler
DocType: Payment Entry,Set Exchange Gain / Loss,Sett valutagevinst / tap
,GST Purchase Register,GST Innkjøpsregister
,Cash Flow,Cash Flow
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +92,Application period cannot be across two alocation records,Tegningsperioden kan ikke være over to alocation poster
DocType: Item Group,Default Expense Account,Standard kostnadskonto
apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +53,Student Email ID,Student Email ID
DocType: Employee,Notice (days),Varsel (dager)
DocType: Tax Rule,Sales Tax Template,Merverdiavgift Mal
apps/erpnext/erpnext/accounts/page/pos/pos.js +2378,Select items to save the invoice,Velg elementer for å lagre fakturaen
DocType: Employee,Encashment Date,Encashment Dato
DocType: Training Event,Internet,Internett
DocType: Account,Stock Adjustment,Stock Adjustment
apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +34,Default Activity Cost exists for Activity Type - {0},Standard Aktivitet Kostnad finnes for Aktivitetstype - {0}
DocType: Production Order,Planned Operating Cost,Planlagt driftskostnader
DocType: Academic Term,Term Start Date,Term Startdato
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +18,Opp Count,Opptelling
apps/erpnext/erpnext/controllers/recurring_document.py +136,Please find attached {0} #{1},Vedlagt {0} # {1}
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +34,Bank Statement balance as per General Ledger,Kontoutskrift balanse pr hovedbok
DocType: Job Applicant,Applicant Name,Søkerens navn
DocType: Authorization Rule,Customer / Item Name,Kunde / Navn
DocType: Product Bundle,"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**. 

The package **Item** will have ""Is Stock Item"" as ""No"" and ""Is Sales Item"" as ""Yes"".

For 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.

Note: BOM = Bill of Materials","Samlet gruppe ** Elementer ** i en annen ** Sak **. Dette er nyttig hvis du er bunting en viss ** Elementer ** inn i en pakke, og du opprettholde bestanden av de pakkede ** Elementer ** og ikke samlet ** Sak **. Pakken ** Sak ** vil ha &quot;Er Stock Item&quot; som &quot;Nei&quot; og &quot;Er Sales Item&quot; som &quot;Ja&quot;. For eksempel: Hvis du selger bærbare datamaskiner og ryggsekker separat og har en spesiell pris hvis kunden kjøper begge, så Laptop + Backpack vil være et nytt produkt Bundle varen. Merk: BOM = Bill of Materials"
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +42,Serial No is mandatory for Item {0},Serial No er obligatorisk for Element {0}
DocType: Item Variant Attribute,Attribute,Attributt
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +43,Please specify from/to range,Vennligst oppgi fra / til spenner
DocType: Serial No,Under AMC,Under AMC
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +55,Item valuation rate is recalculated considering landed cost voucher amount,Sak verdivurdering rente beregnes på nytt vurderer inntakskost kupong beløp
apps/erpnext/erpnext/config/selling.py +153,Default settings for selling transactions.,Standardinnstillingene for salg transaksjoner.
DocType: Guardian,Guardian Of ,Guardian Av
DocType: Grading Scale Interval,Threshold,Terskel
DocType: BOM Replace Tool,Current BOM,Nåværende BOM
apps/erpnext/erpnext/public/js/utils.js +45,Add Serial No,Legg Serial No
DocType: Production Order Item,Available Qty at Source Warehouse,Tilgjengelig antall på Source Warehouse
apps/erpnext/erpnext/config/support.py +22,Warranty,Garanti
DocType: Purchase Invoice,Debit Note Issued,Debitnota Utstedt
DocType: Production Order,Warehouses,Næringslokaler
apps/erpnext/erpnext/accounts/doctype/asset_movement/asset_movement.py +18,{0} asset cannot be transferred,{0} eiendelen kan ikke overføres
apps/erpnext/erpnext/stock/doctype/item/item.js +66,This Item is a Variant of {0} (Template).,Denne varen er en variant av {0} (mal).
DocType: Workstation,per hour,per time
apps/erpnext/erpnext/config/buying.py +7,Purchasing,innkjøp
DocType: Announcement,Announcement,Kunngjøring
DocType: School Settings,"For Batch based Student Group, the Student Batch will be validated for every Student from the Program Enrollment.","For Batch-baserte Studentgruppen, vil studentenes batch bli validert for hver student fra programopptaket."
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +51,Warehouse can not be deleted as stock ledger entry exists for this warehouse.,Warehouse kan ikke slettes som finnes lager hovedbok oppføring for dette lageret.
DocType: Company,Distribution,Distribusjon
apps/erpnext/erpnext/schools/doctype/fees/fees.js +27,Amount Paid,Beløpet Betalt
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +102,Project Manager,Prosjektleder
,Quoted Item Comparison,Sitert Element Sammenligning
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +83,Dispatch,Dispatch
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +73,Max discount allowed for item: {0} is {1}%,Maks rabatt tillatt for element: {0} er {1}%
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +173,Net Asset value as on,Net Asset verdi som på
DocType: Account,Receivable,Fordring
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +288,Row #{0}: Not allowed to change Supplier as Purchase Order already exists,Row # {0}: Ikke lov til å endre Leverandør som innkjøpsordre allerede eksisterer
DocType: Accounts Settings,Role that is allowed to submit transactions that exceed credit limits set.,Rollen som får lov til å sende transaksjoner som overstiger kredittgrenser fastsatt.
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +893,Select Items to Manufacture,Velg delbetaling Produksjon
apps/erpnext/erpnext/accounts/page/pos/pos.js +929,"Master data syncing, it might take some time","Master data synkronisering, kan det ta litt tid"
DocType: Item,Material Issue,Material Issue
DocType: Hub Settings,Seller Description,Selger Beskrivelse
DocType: Employee Education,Qualification,Kvalifisering
DocType: Item Price,Item Price,Sak Pris
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +48,Soap & Detergent,Såpe og vaskemiddel
DocType: BOM,Show Items,Vis Items
apps/erpnext/erpnext/schools/doctype/course_schedule/course_schedule.py +30,From Time cannot be greater than To Time.,Fra tid kan ikke være større enn til annen.
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +36,Motion Picture & Video,Motion Picture &amp; Video
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js +5,Ordered,Bestilt
DocType: Salary Detail,Component,Komponent
DocType: Assessment Criteria,Assessment Criteria Group,Vurderingskriterier Gruppe
apps/erpnext/erpnext/accounts/doctype/asset/asset.py +72,Opening Accumulated Depreciation must be less than equal to {0},Åpning akkumulerte avskrivninger må være mindre enn eller lik {0}
DocType: Warehouse,Warehouse Name,Warehouse Name
DocType: Naming Series,Select Transaction,Velg Transaksjons
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +30,Please enter Approving Role or Approving User,Skriv inn Godkjenne Rolle eller Godkjenne User
DocType: Journal Entry,Write Off Entry,Skriv Off Entry
DocType: BOM,Rate Of Materials Based On,Valuta materialer basert på
apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +21,Support Analtyics,Støtte Analtyics
apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +142,Uncheck all,Fjern haken ved alle
DocType: POS Profile,Terms and Conditions,Vilkår og betingelser
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +49,To Date should be within the Fiscal Year. Assuming To Date = {0},To Date bør være innenfor regnskapsåret. Antar To Date = {0}
DocType: Employee,"Here you can maintain height, weight, allergies, medical concerns etc","Her kan du opprettholde høyde, vekt, allergier, medisinske bekymringer etc"
DocType: Leave Block List,Applies to Company,Gjelder Selskapet
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +202,Cannot cancel because submitted Stock Entry {0} exists,Kan ikke avbryte fordi innsendt Stock Entry {0} finnes
DocType: Employee Loan,Disbursement Date,Innbetalingsdato
DocType: Vehicle,Vehicle,Kjøretøy
DocType: Purchase Invoice,In Words,I Words
DocType: POS Profile,Item Groups,varegruppene
apps/erpnext/erpnext/hr/doctype/employee/employee.py +217,Today is {0}'s birthday!,I dag er {0} s bursdag!
DocType: Production Planning Tool,Material Request For Warehouse,Materialet Request For Warehouse
DocType: Sales Order Item,For Production,For Production
DocType: Payment Request,payment_url,payment_url
DocType: Project Task,View Task,Vis Task
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +22,Opp/Lead %,Opp / Lead%
DocType: Material Request,MREQ-,MREQ-
,Asset Depreciations and Balances,Asset Avskrivninger og Balanserer
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +344,Amount {0} {1} transferred from {2} to {3},Mengden {0} {1} overført fra {2} til {3}
DocType: Sales Invoice,Get Advances Received,Få Fremskritt mottatt
DocType: Email Digest,Add/Remove Recipients,Legg til / fjern Mottakere
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +461,Transaction not allowed against stopped Production Order {0},Transaksjonen ikke lov mot stoppet Produksjonsordre {0}
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.js +19,"To set this Fiscal Year as Default, click on 'Set as Default'","For å sette dette regnskapsåret som standard, klikk på &quot;Angi som standard &#39;"
apps/erpnext/erpnext/projects/doctype/project/project.py +200,Join,Bli med
apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +20,Shortage Qty,Mangel Antall
apps/erpnext/erpnext/stock/doctype/item/item.py +648,Item variant {0} exists with same attributes,Sak variant {0} finnes med samme attributtene
DocType: Employee Loan,Repay from Salary,Smelle fra Lønn
DocType: Leave Application,LAP/,RUNDE/
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +339,Requesting payment against {0} {1} for amount {2},Ber om betaling mot {0} {1} for mengden {2}
DocType: Salary Slip,Salary Slip,Lønn Slip
DocType: Lead,Lost Quotation,mistet sitat
DocType: Pricing Rule,Margin Rate or Amount,Margin Rate Beløp
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +48,'To Date' is required,&#39;To Date&#39; er påkrevd
DocType: Packing Slip,"Generate packing slips for packages to be delivered. Used to notify package number, package contents and its weight.","Generere pakksedler for pakker som skal leveres. Brukes til å varsle pakke nummer, innholdet i pakken og vekten."
DocType: Sales Invoice Item,Sales Order Item,Salgsordre Element
DocType: Salary Slip,Payment Days,Betalings Days
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +121,Warehouses with child nodes cannot be converted to ledger,Næringslokaler med barn noder kan ikke konverteres til Ledger
DocType: BOM,Manage cost of operations,Administrer driftskostnader
DocType: Notification Control,"When any of the checked transactions are ""Submitted"", an email pop-up automatically opened to send an email to the associated ""Contact"" in that transaction, with the transaction as an attachment. The user may or may not send the email.","Når noen av de merkede transaksjonene &quot;Skrevet&quot;, en e-pop-up automatisk åpnet for å sende en e-post til den tilhørende &quot;Kontakt&quot; i at transaksjonen med transaksjonen som et vedlegg. Brukeren kan eller ikke kan sende e-posten."
apps/erpnext/erpnext/config/setup.py +14,Global Settings,Globale innstillinger
DocType: Assessment Result Detail,Assessment Result Detail,Assessment Resultat Detalj
DocType: Employee Education,Employee Education,Ansatt Utdanning
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +46,Duplicate item group found in the item group table,Duplicate varegruppe funnet i varegruppen bordet
apps/erpnext/erpnext/public/js/controllers/transaction.js +941,It is needed to fetch Item Details.,Det er nødvendig å hente Element detaljer.
DocType: Salary Slip,Net Pay,Netto Lønn
DocType: Account,Account,Konto
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +217,Serial No {0} has already been received,Serial No {0} er allerede mottatt
,Requested Items To Be Transferred,Etterspør elementene som skal overføres
DocType: Expense Claim,Vehicle Log,Vehicle Log
DocType: Purchase Invoice,Recurring Id,Gjentakende Id
DocType: Customer,Sales Team Details,Salgsteam Detaljer
apps/erpnext/erpnext/accounts/page/pos/pos.js +1311,Delete permanently?,Slett permanent?
DocType: Expense Claim,Total Claimed Amount,Total Hevdet Beløp
apps/erpnext/erpnext/config/crm.py +17,Potential opportunities for selling.,Potensielle muligheter for å selge.
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +228,Invalid {0},Ugyldig {0}
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +59,Sick Leave,Sykefravær
DocType: Email Digest,Email Digest,E-post Digest
DocType: Delivery Note,Billing Address Name,Billing Address Navn
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +22,Department Stores,Varehus
DocType: Warehouse,PIN,PIN
apps/erpnext/erpnext/setup/setup_wizard/sample_data.py +108,Setup your School in ERPNext,Oppsettet ditt School i ERPNext
DocType: Sales Invoice,Base Change Amount (Company Currency),Base Endre Beløp (Selskap Valuta)
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +309,No accounting entries for the following warehouses,Ingen regnskapspostene for følgende varehus
apps/erpnext/erpnext/projects/doctype/project/project.js +109,Save the document first.,Lagre dokumentet først.
DocType: Account,Chargeable,Avgift
DocType: Company,Change Abbreviation,Endre Forkortelse
DocType: Expense Claim Detail,Expense Date,Expense Dato
DocType: Item,Max Discount (%),Max Rabatt (%)
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +70,Last Order Amount,Siste ordrebeløp
DocType: Task,Is Milestone,Er Milestone
DocType: Daily Work Summary,Email Sent To,E-post sendt Å
DocType: Budget,Warn,Advare
DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","Eventuelle andre bemerkninger, bemerkelsesverdig innsats som bør gå i postene."
DocType: BOM,Manufacturing User,Manufacturing User
DocType: Purchase Invoice,Raw Materials Supplied,Råvare Leveres
DocType: Purchase Invoice,Recurring Print Format,Gjentakende Print Format
DocType: C-Form,Series,Series
DocType: Appraisal,Appraisal Template,Appraisal Mal
DocType: Item Group,Item Classification,Sak Klassifisering
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +100,Business Development Manager,Business Development Manager
DocType: Maintenance Visit Purpose,Maintenance Visit Purpose,Vedlikehold Besøk Formål
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js +16,Period,Periode
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.js +18,General Ledger,General Ledger
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +33,Employee {0} on Leave on {1},Employee {0} på La den {1}
apps/erpnext/erpnext/selling/doctype/campaign/campaign.js +10,View Leads,Vis Leads
DocType: Program Enrollment Tool,New Program,nytt program
DocType: Item Attribute Value,Attribute Value,Attributtverdi
,Itemwise Recommended Reorder Level,Itemwise Anbefalt Omgjøre nivå
DocType: Salary Detail,Salary Detail,lønn Detalj
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +997,Please select {0} first,Vennligst velg {0} først
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +803,Batch {0} of Item {1} has expired.,Batch {0} av Element {1} er utløpt.
DocType: Sales Invoice,Commission,Kommisjon
apps/erpnext/erpnext/config/manufacturing.py +27,Time Sheet for manufacturing.,Timeregistrering for produksjon.
apps/erpnext/erpnext/templates/pages/cart.html +37,Subtotal,delsum
DocType: Salary Detail,Default Amount,Standard Beløp
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +93,Warehouse not found in the system,Warehouse ikke funnet i systemet
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +116,This Month's Summary,Denne måneden Oppsummering
DocType: Quality Inspection Reading,Quality Inspection Reading,Quality Inspection Reading
apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +24,`Freeze Stocks Older Than` should be smaller than %d days.,`Freeze Aksjer Eldre Than` bør være mindre enn% d dager.
DocType: Tax Rule,Purchase Tax Template,Kjøpe Tax Mal
,Project wise Stock Tracking,Prosjektet klok Stock Tracking
DocType: GST HSN Code,Regional,Regional
DocType: Stock Entry Detail,Actual Qty (at source/target),Faktiske antall (ved kilden / target)
DocType: Item Customer Detail,Ref Code,Ref Kode
apps/erpnext/erpnext/config/hr.py +12,Employee records.,Medarbeider poster.
apps/erpnext/erpnext/accounts/doctype/asset/asset.py +92,Please set Next Depreciation Date,Vennligst sett Neste Avskrivninger Dato
DocType: HR Settings,Payroll Settings,Lønn Innstillinger
apps/erpnext/erpnext/config/accounts.py +148,Match non-linked Invoices and Payments.,Matche ikke bundet fakturaer og betalinger.
apps/erpnext/erpnext/templates/pages/cart.html +16,Place Order,Legg inn bestilling
DocType: Email Digest,New Purchase Orders,Nye innkjøpsordrer
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +24,Root cannot have a parent cost center,Root kan ikke ha en forelder kostnadssted
apps/erpnext/erpnext/public/js/stock_analytics.js +57,Select Brand...,Velg merke ...
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +18,Training Events/Results,Treningsarrangementer / resultater
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +149,Accumulated Depreciation as on,Akkumulerte avskrivninger som på
DocType: Sales Invoice,C-Form Applicable,C-Form Gjelder
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +398,Operation Time must be greater than 0 for Operation {0},Operation Tid må være større enn 0 for operasjon {0}
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +106,Warehouse is mandatory,Warehouse er obligatorisk
DocType: Supplier,Address and Contacts,Adresse og Kontakt
DocType: UOM Conversion Detail,UOM Conversion Detail,Målenheter Conversion Detalj
DocType: Program,Program Abbreviation,program forkortelse
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +386,Production Order cannot be raised against a Item Template,Produksjonsordre kan ikke heves mot et elementmal
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +52,Charges are updated in Purchase Receipt against each item,Kostnader er oppdatert i Purchase Mottak mot hvert element
DocType: Warranty Claim,Resolved By,Løst Av
DocType: Bank Guarantee,Start Date,Startdato
apps/erpnext/erpnext/config/hr.py +75,Allocate leaves for a period.,Bevilge blader for en periode.
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +42,Cheques and Deposits incorrectly cleared,Sjekker og Innskudd feil ryddet
apps/erpnext/erpnext/accounts/doctype/account/account.py +50,Account {0}: You can not assign itself as parent account,Konto {0}: Du kan ikke tildele seg selv som forelder konto
DocType: Purchase Invoice Item,Price List Rate,Prisliste Rate
apps/erpnext/erpnext/utilities/activation.py +70,Create customer quotes,Opprett kunde sitater
DocType: Item,"Show ""In Stock"" or ""Not in Stock"" based on stock available in this warehouse.",Vis &quot;på lager&quot; eller &quot;Not in Stock&quot; basert på lager tilgjengelig i dette lageret.
apps/erpnext/erpnext/config/manufacturing.py +38,Bill of Materials (BOM),Bill of Materials (BOM)
DocType: Item,Average time taken by the supplier to deliver,Gjennomsnittlig tid tatt av leverandøren til å levere
apps/erpnext/erpnext/schools/doctype/assessment_plan/assessment_plan.js +22,Assessment Result,Assessment Resultat
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +13,Hours,Timer
DocType: Project,Expected Start Date,Tiltredelse
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +49,Remove item if charges is not applicable to that item,Fjern artikkel om avgifter er ikke aktuelt til dette elementet
DocType: SMS Settings,Eg. smsgateway.com/api/send_sms.cgi,Eg. smsgateway.com/api/send_sms.cgi
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +33,Transaction currency must be same as Payment Gateway currency,Transaksjons valuta må være samme som Payment Gateway valuta
DocType: Payment Entry,Receive,Motta
apps/erpnext/erpnext/templates/pages/rfq.html +75,Quotations: ,sitater:
DocType: Maintenance Visit,Fully Completed,Fullt Fullført
apps/erpnext/erpnext/projects/doctype/project/project_list.js +6,{0}% Complete,{0}% Komplett
DocType: Employee,Educational Qualification,Pedagogiske Kvalifikasjoner
DocType: Workstation,Operating Costs,Driftskostnader
DocType: Budget,Action if Accumulated Monthly Budget Exceeded,Tiltak hvis Snø Månedlig budsjett Skredet
DocType: Purchase Invoice,Submit on creation,Send inn på skapelse
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +457,Currency for {0} must be {1},Valuta for {0} må være {1}
DocType: Asset,Disposal Date,Deponering Dato
DocType: Daily Work Summary Settings,"Emails will be sent to all Active Employees of the company at the given hour, if they do not have holiday. Summary of responses will be sent at midnight.","E-post vil bli sendt til alle aktive ansatte i selskapet ved den gitte timen, hvis de ikke har ferie. Oppsummering av svarene vil bli sendt ved midnatt."
DocType: Employee Leave Approver,Employee Leave Approver,Ansatt La Godkjenner
apps/erpnext/erpnext/stock/doctype/item/item.py +493,Row {0}: An Reorder entry already exists for this warehouse {1},Rad {0}: En Omgjøre oppføring finnes allerede for dette lageret {1}
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +81,"Cannot declare as lost, because Quotation has been made.","Kan ikke erklære som tapt, fordi tilbudet er gjort."
apps/erpnext/erpnext/hr/doctype/training_event/training_event.js +13,Training Feedback,trening Tilbakemelding
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +458,Production Order {0} must be submitted,Produksjonsordre {0} må sendes
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +149,Please select Start Date and End Date for Item {0},Vennligst velg startdato og sluttdato for Element {0}
apps/erpnext/erpnext/public/js/setup_wizard.js +224,Set a sales target you'd like to achieve.,Sett et salgsmål du vil oppnå.
apps/erpnext/erpnext/schools/doctype/student_group_creation_tool/student_group_creation_tool.py +54,Course is mandatory in row {0},Kurset er obligatorisk i rad {0}
apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.js +16,To date cannot be before from date,Til dags dato kan ikke være før fra dato
DocType: Supplier Quotation Item,Prevdoc DocType,Prevdoc DOCTYPE
apps/erpnext/erpnext/stock/doctype/item/item.js +258,Add / Edit Prices,Legg til / Rediger priser
DocType: Batch,Parent Batch,Parent Batch
DocType: Cheque Print Template,Cheque Print Template,Sjekk ut Mal
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +36,Chart of Cost Centers,Plan Kostnadssteder
,Requested Items To Be Ordered,Etterspør Elementer bestilles
DocType: Price List,Price List Name,Prisliste Name
apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py +32,Daily Work Summary for {0},Daglig arbeid Summary for {0}
DocType: Employee Loan,Totals,Totals
DocType: BOM,Manufacturing,Manufacturing
,Ordered Items To Be Delivered,Bestilte varer som skal leveres
DocType: Account,Income,Inntekt
DocType: Industry Type,Industry Type,Industry Type
apps/erpnext/erpnext/templates/includes/cart.js +150,Something went wrong!,Noe gikk galt!
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +124,Warning: Leave application contains following block dates,Advarsel: La programmet inneholder følgende blokk datoer
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +266,Sales Invoice {0} has already been submitted,Salg Faktura {0} er allerede innsendt
DocType: Assessment Result Detail,Score,Score
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +25,Fiscal Year {0} does not exist,Regnskapsåret {0} finnes ikke
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +30,Completion Date,Ferdigstillelse Dato
DocType: Purchase Invoice Item,Amount (Company Currency),Beløp (Selskap Valuta)
apps/erpnext/erpnext/stock/stock_ledger.py +372,{0} units of {1} needed in {2} on {3} {4} for {5} to complete this transaction.,{0} enheter av {1} trengs i {2} på {3} {4} for {5} for å fullføre denne transaksjonen.
DocType: Fee Structure,Student Category,student Kategori
DocType: Announcement,Student,Student
apps/erpnext/erpnext/config/hr.py +229,Organization unit (department) master.,Organisasjonsenhet (departement) mester.
apps/erpnext/erpnext/setup/doctype/sms_settings/sms_settings.py +26,Please enter valid mobile nos,Skriv inn et gyldig mobil nos
apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +75,Please enter message before sending,Skriv inn meldingen før du sender
DocType: Sales Invoice,DUPLICATE FOR SUPPLIER,DUPLIKATE FOR LEVERANDØR
DocType: Email Digest,Pending Quotations,Avventer Sitater
apps/erpnext/erpnext/config/accounts.py +315,Point-of-Sale Profile,Point-of-Sale Profile
apps/erpnext/erpnext/setup/doctype/sms_settings/sms_settings.py +75,Please Update SMS Settings,Oppdater SMS-innstillinger
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +156,Unsecured Loans,Usikret lån
DocType: Cost Center,Cost Center Name,Kostnadssteds Name
DocType: Employee,B+,B +
DocType: HR Settings,Max working hours against Timesheet,Max arbeidstid mot Timeregistrering
DocType: Maintenance Schedule Detail,Scheduled Date,Planlagt dato
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +68,Total Paid Amt,Sum innskutt Amt
DocType: SMS Center,Messages greater than 160 characters will be split into multiple messages,Meldinger som er større enn 160 tegn vil bli delt inn i flere meldinger
DocType: Purchase Receipt Item,Received and Accepted,Mottatt og akseptert
,GST Itemised Sales Register,GST Artized Sales Register
,Serial No Service Contract Expiry,Serial No Service kontraktsutløp
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +299,You cannot credit and debit same account at the same time,Du kan ikke kreditt- og debet samme konto samtidig
DocType: Naming Series,Help HTML,Hjelp HTML
DocType: Student Group Creation Tool,Student Group Creation Tool,Student Gruppe Creation Tool
DocType: Item,Variant Based On,Variant basert på
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +53,Total weightage assigned should be 100%. It is {0},Total weightage tilordnet skal være 100%. Det er {0}
apps/erpnext/erpnext/public/js/setup_wizard.js +274,Your Suppliers,Dine Leverandører
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +58,Cannot set as Lost as Sales Order is made.,Kan ikke settes som tapt som Salgsordre er gjort.
DocType: Request for Quotation Item,Supplier Part No,Leverandør varenummer
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +365,Cannot deduct when category is for 'Valuation' or 'Vaulation and Total',Kan ikke trekke når kategorien er for verdsetting &#39;eller&#39; Vaulation og Total &#39;
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +351,Received From,Mottatt fra
DocType: Lead,Converted,Omregnet
DocType: Item,Has Serial No,Har Serial No
DocType: Employee,Date of Issue,Utstedelsesdato
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +20,{0}: From {0} for {1},{0}: Fra {0} for {1}
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +215,"As per the Buying Settings if Purchase Reciept Required == 'YES', then for creating Purchase Invoice, user need to create Purchase Receipt first for item {0}","I henhold til kjøpsinnstillingene hvis kjøp tilbakekjøpt er nødvendig == &#39;JA&#39; og deretter for å opprette kjøpfaktura, må brukeren opprette kjøpsmottak først for element {0}"
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +166,Row #{0}: Set Supplier for item {1},Row # {0}: Sett Leverandør for elementet {1}
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +117,Row {0}: Hours value must be greater than zero.,Rad {0}: Timer verdien må være større enn null.
apps/erpnext/erpnext/stock/doctype/item/item.py +170,Website Image {0} attached to Item {1} cannot be found,Website Bilde {0} festet til Element {1} kan ikke finnes
DocType: Issue,Content Type,Innholdstype
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +17,Computer,Datamaskin
DocType: Item,List this Item in multiple groups on the website.,Liste denne vare i flere grupper på nettstedet.
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +323,Please check Multi Currency option to allow accounts with other currency,Vennligst sjekk Multi Valuta alternativet for å tillate kontoer med andre valuta
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +89,Item: {0} does not exist in the system,Sak: {0} finnes ikke i systemet
apps/erpnext/erpnext/accounts/doctype/account/account.py +109,You are not authorized to set Frozen value,Du er ikke autorisert til å sette Frozen verdi
DocType: Payment Reconciliation,Get Unreconciled Entries,Få avstemte Entries
DocType: Payment Reconciliation,From Invoice Date,Fra Fakturadato
apps/erpnext/erpnext/accounts/party.py +259,Billing currency must be equal to either default comapany's currency or party account currency,Fakturering valuta må være lik enten standard comapany valuta eller fremmed regning av valuta
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +44,Leave Encashment,La Encashment
apps/erpnext/erpnext/public/js/setup_wizard.js +94,What does it do?,Hva gjør det?
apps/erpnext/erpnext/stock/doctype/batch/batch.js +70,To Warehouse,Til Warehouse
apps/erpnext/erpnext/schools/doctype/student_admission/student_admission.py +23,All Student Admissions,Alle Student Opptak
,Average Commission Rate,Gjennomsnittlig kommisjon
apps/erpnext/erpnext/stock/doctype/item/item.py +405,'Has Serial No' can not be 'Yes' for non-stock item,«Har Serial No &#39;kan ikke være&#39; Ja &#39;for ikke-lagervare
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +41,Attendance can not be marked for future dates,Oppmøte kan ikke merkes for fremtidige datoer
DocType: Pricing Rule,Pricing Rule Help,Prising Rule Hjelp
DocType: School House,House Name,Husnavn
DocType: Purchase Taxes and Charges,Account Head,Account Leder
apps/erpnext/erpnext/config/stock.py +168,Update additional costs to calculate landed cost of items,Oppdater ekstra kostnader for å beregne inntakskost annonser
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +122,Electrical,Elektrisk
apps/erpnext/erpnext/utilities/activation.py +98,Add the rest of your organization as your users. You can also add invite Customers to your portal by adding them from Contacts,Tilsett resten av organisasjonen som brukerne. Du kan også legge invitere kunder til portalen ved å legge dem fra Kontakter
DocType: Stock Entry,Total Value Difference (Out - In),Total verdi Difference (ut -)
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +348,Row {0}: Exchange Rate is mandatory,Rad {0}: Exchange Rate er obligatorisk
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +27,User ID not set for Employee {0},Bruker-ID ikke satt for Employee {0}
DocType: Vehicle,Vehicle Value,Vehicle Verdi
DocType: Stock Entry,Default Source Warehouse,Standardkilde Warehouse
DocType: Item,Customer Code,Kunden Kode
apps/erpnext/erpnext/hr/doctype/employee/employee.py +216,Birthday Reminder for {0},Bursdag Påminnelse for {0}
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +72,Days Since Last Order,Dager siden siste Bestill
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +343,Debit To account must be a Balance Sheet account,Uttak fra kontoen må være en balansekonto
DocType: Buying Settings,Naming Series,Navngi Series
DocType: Leave Block List,Leave Block List Name,La Block List Name
apps/erpnext/erpnext/hr/doctype/vehicle/vehicle.py +14,Insurance Start date should be less than Insurance End date,Forsikring Startdatoen må være mindre enn Forsikring Sluttdato
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +32,Stock Assets,Aksje Eiendeler
DocType: Timesheet,Production Detail,produksjon Detail
DocType: Target Detail,Target Qty,Target Antall
DocType: Shopping Cart Settings,Checkout Settings,Kasse Innstillinger
DocType: Attendance,Present,Present
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +35,Delivery Note {0} must not be submitted,Levering Note {0} må ikke sendes inn
DocType: Notification Control,Sales Invoice Message,Salgsfaktura Message
apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +27,Closing Account {0} must be of type Liability / Equity,Lukke konto {0} må være av typen Ansvar / Egenkapital
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +320,Salary Slip of employee {0} already created for time sheet {1},Lønn Slip av ansattes {0} allerede opprettet for timeregistrering {1}
DocType: Vehicle Log,Odometer,Kilometerteller
DocType: Sales Order Item,Ordered Qty,Bestilte Antall
apps/erpnext/erpnext/stock/doctype/item/item.py +676,Item {0} is disabled,Element {0} er deaktivert
DocType: Stock Settings,Stock Frozen Upto,Stock Frozen Opp
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +875,BOM does not contain any stock item,BOM inneholder ikke lagervare
apps/erpnext/erpnext/controllers/recurring_document.py +172,Period From and Period To dates mandatory for recurring {0},Periode Fra og perioden Til dato obligatoriske for gjentakende {0}
apps/erpnext/erpnext/config/projects.py +18,Project activity / task.,Prosjektet aktivitet / oppgave.
DocType: Vehicle Log,Refuelling Details,Fylle drivstoff Detaljer
apps/erpnext/erpnext/config/hr.py +104,Generate Salary Slips,Generere lønnsslipper
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +44,"Buying must be checked, if Applicable For is selected as {0}","Kjøper må sjekkes, hvis dette gjelder for er valgt som {0}"
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +40,Discount must be less than 100,Rabatt må være mindre enn 100
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +108,Last purchase rate not found,Siste kjøp sats ikke funnet
DocType: Purchase Invoice,Write Off Amount (Company Currency),Skriv Off Beløp (Selskap Valuta)
DocType: Sales Invoice Timesheet,Billing Hours,fakturerings~~POS=TRUNC Timer
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +499,Default BOM for {0} not found,Standard BOM for {0} ikke funnet
apps/erpnext/erpnext/stock/doctype/item/item.py +485,Row #{0}: Please set reorder quantity,Row # {0}: Vennligst sett omgjøring kvantitet
apps/erpnext/erpnext/public/js/pos/pos.html +20,Tap items to add them here,Trykk på elementer for å legge dem til her
DocType: Fees,Program Enrollment,program Påmelding
DocType: Landed Cost Voucher,Landed Cost Voucher,Landed Cost Voucher
apps/erpnext/erpnext/public/js/queries.js +39,Please set {0},Vennligst sett {0}
DocType: Purchase Invoice,Repeat on Day of Month,Gjenta på dag i måneden
apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +36,{0} - {1} is inactive student,{0} - {1} er inaktiv student
apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +36,{0} - {1} is inactive student,{0} - {1} er inaktiv student
DocType: Employee,Health Details,Helse Detaljer
DocType: Offer Letter,Offer Letter Terms,Tilby Letter Vilkår
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +23,To create a Payment Request reference document is required,For å opprette en betalingsforespørsel kreves referansedokument
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +23,To create a Payment Request reference document is required,For å opprette en betalingsforespørsel kreves referansedokument
DocType: Payment Entry,Allocate Payment Amount,Fordele Betalingsbeløp
DocType: Employee External Work History,Salary,Lønn
DocType: Serial No,Delivery Document Type,Levering dokumenttype
DocType: Process Payroll,Submit all salary slips for the above selected criteria,Send inn alle lønnsslipper for de ovenfor valgte kriterier
apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +93,{0} Items synced,{0} elementer synkronisert
DocType: Sales Order,Partly Delivered,Delvis Leveres
DocType: Email Digest,Receivables,Fordringer
DocType: Lead Source,Lead Source,Lead Source
DocType: Customer,Additional information regarding the customer.,Ytterligere informasjon om kunden.
DocType: Quality Inspection Reading,Reading 5,Reading 5
DocType: Maintenance Visit,Maintenance Date,Vedlikehold Dato
DocType: Purchase Invoice Item,Rejected Serial No,Avvist Serial No
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +82,Year start date or end date is overlapping with {0}. To avoid please set company,År startdato eller sluttdato er overlappende med {0}. For å unngå vennligst sett selskap
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +156,Start date should be less than end date for Item {0},Startdato skal være mindre enn sluttdato for Element {0}
DocType: Item,"Example: ABCD.#####
If 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.","Eksempel:. ABCD ##### Hvis serien er satt og serienummer er ikke nevnt i transaksjoner, og deretter automatisk serienummer vil bli opprettet basert på denne serien. Hvis du alltid vil eksplisitt nevne Serial Nos for dette elementet. la dette stå tomt."
DocType: Upload Attendance,Upload Attendance,Last opp Oppmøte
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +319,BOM and Manufacturing Quantity are required,BOM og Industri Antall kreves
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +44,Ageing Range 2,Aldring Range 2
DocType: SG Creation Tool Course,Max Strength,Max Strength
apps/erpnext/erpnext/manufacturing/doctype/bom_replace_tool/bom_replace_tool.py +21,BOM replaced,BOM erstattet
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +956,Select Items based on Delivery Date,Velg elementer basert på leveringsdato
,Sales Analytics,Salgs Analytics
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +114,Available {0},Tilgjengelig {0}
,Prospects Engaged But Not Converted,"Utsikter engasjert, men ikke konvertert"
,Prospects Engaged But Not Converted,"Utsikter engasjert, men ikke konvertert"
DocType: Manufacturing Settings,Manufacturing Settings,Produksjons Innstillinger
apps/erpnext/erpnext/config/setup.py +56,Setting up Email,Sette opp e-post
apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +57,Guardian1 Mobile No,Guardian1 Mobile No
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +99,Please enter default currency in Company Master,Skriv inn standardvaluta i selskapet Master
DocType: Stock Entry Detail,Stock Entry Detail,Stock Entry Detail
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +110,Daily Reminders,Daglige påminnelser
DocType: Products Settings,Home Page is Products,Hjemme side er produkter
,Asset Depreciation Ledger,Asset Avskrivninger Ledger
apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +86,Tax Rule Conflicts with {0},Skatteregel Konflikter med {0}
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +25,New Account Name,New Account Name
DocType: Purchase Invoice Item,Raw Materials Supplied Cost,Råvare Leveres Cost
DocType: Selling Settings,Settings for Selling Module,Innstillinger for å selge Module
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +84,Customer Service,Kundeservice
DocType: BOM,Thumbnail,Thumbnail
DocType: Item Customer Detail,Item Customer Detail,Sak Customer Detalj
apps/erpnext/erpnext/config/hr.py +50,Offer candidate a Job.,Tilbudet kandidat en jobb.
DocType: Notification Control,Prompt for Email on Submission of,Spør for E-post om innsending av
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +88,Total allocated leaves are more than days in the period,Totalt tildelte bladene er mer enn dager i perioden
DocType: Pricing Rule,Percentage,Prosentdel
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +70,Item {0} must be a stock Item,Elementet {0} må være en lagervare
DocType: Manufacturing Settings,Default Work In Progress Warehouse,Standard Work In Progress Warehouse
apps/erpnext/erpnext/config/accounts.py +290,Default settings for accounting transactions.,Standardinnstillingene for regnskapsmessige transaksjoner.
DocType: Maintenance Visit,MV,MV
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +59,Expected Date cannot be before Material Request Date,Forventet Datoen kan ikke være før Material Request Dato
DocType: Purchase Invoice Item,Stock Qty,Varenummer
DocType: Employee Loan,Repayment Period in Months,Nedbetalingstid i måneder
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +26,Error: Not a valid id?,Feil: Ikke en gyldig id?
DocType: Naming Series,Update Series Number,Update-serien Nummer
DocType: Account,Equity,Egenkapital
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +78,{0} {1}: 'Profit and Loss' type account {2} not allowed in Opening Entry,{0} {1}: &#39;Resultat&#39; type konto {2} ikke tillatt i Åpning Entry
DocType: Sales Order,Printing Details,Utskrift Detaljer
DocType: Task,Closing Date,Avslutningsdato
DocType: Sales Order Item,Produced Quantity,Produsert Antall
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +95,Engineer,Ingeniør
DocType: Journal Entry,Total Amount Currency,Totalbeløp Valuta
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +38,Search Sub Assemblies,Søk Sub Assemblies
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +164,Item Code required at Row No {0},Elementkode kreves ved Row Nei {0}
DocType: Sales Partner,Partner Type,Partner Type
DocType: Purchase Taxes and Charges,Actual,Faktiske
DocType: Authorization Rule,Customerwise Discount,Customerwise Rabatt
apps/erpnext/erpnext/config/projects.py +35,Timesheet for tasks.,Timeregistrering for oppgaver.
DocType: Purchase Invoice,Against Expense Account,Mot regning
DocType: Production Order,Production Order,Produksjon Bestill
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +273,Installation Note {0} has already been submitted,Installasjon Merk {0} har allerede blitt sendt
DocType: Bank Reconciliation,Get Payment Entries,Få Betalings Entries
DocType: Quotation Item,Against Docname,Mot Docname
DocType: SMS Center,All Employee (Active),All Employee (Active)
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +9,View Now,Vis nå
DocType: Purchase Invoice,Select the period when the invoice will be generated automatically,Velg perioden når fakturaen blir generert automatisk
DocType: BOM,Raw Material Cost,Raw Material Cost
DocType: Item Reorder,Re-Order Level,Re-Order nivå
DocType: Production Planning Tool,Enter items and planned qty for which you want to raise production orders or download raw materials for analysis.,Skriv inn elementer og planlagt stk som du ønsker å heve produksjonsordrer eller laste råvarer for analyse.
apps/erpnext/erpnext/projects/doctype/project/project.js +62,Gantt Chart,Gantt
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +68,Part-time,Deltid
DocType: Employee,Applicable Holiday List,Gjelder Holiday List
DocType: Employee,Cheque,Cheque
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +61,Series Updated,Serien Oppdatert
apps/erpnext/erpnext/accounts/doctype/account/account.py +162,Report Type is mandatory,Rapporter Type er obligatorisk
DocType: Item,Serial Number Series,Serienummer Series
apps/erpnext/erpnext/buying/utils.py +68,Warehouse is mandatory for stock Item {0} in row {1},Warehouse er obligatorisk for lager Element {0} i rad {1}
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +45,Retail & Wholesale,Retail &amp; Wholesale
DocType: Issue,First Responded On,Først Svarte På
DocType: Website Item Group,Cross Listing of Item in multiple groups,Cross Notering av varen i flere grupper
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +90,Fiscal Year Start Date and Fiscal Year End Date are already set in Fiscal Year {0},Regnskapsår Startdato og regnskapsår sluttdato er allerede satt i regnskapsåret {0}
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +97,Clearance Date updated,Lagersalg oppdatert
apps/erpnext/erpnext/stock/doctype/batch/batch.js +126,Split Batch,Split Batch
apps/erpnext/erpnext/stock/doctype/batch/batch.js +126,Split Batch,Split Batch
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +131,Successfully Reconciled,Vellykket Forsonet
DocType: Request for Quotation Supplier,Download PDF,Last ned PDF
DocType: Production Order,Planned End Date,Planlagt sluttdato
apps/erpnext/erpnext/config/stock.py +184,Where items are stored.,Hvor varene er lagret.
DocType: Request for Quotation,Supplier Detail,Leverandør Detalj
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +95,Error in formula or condition: {0},Feil i formel eller betingelse: {0}
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +16,Invoiced Amount,Fakturert beløp
DocType: Attendance,Attendance,Oppmøte
apps/erpnext/erpnext/public/js/pos/pos.html +106,Stock Items,lager~~POS=TRUNC
DocType: BOM,Materials,Materialer
DocType: Leave Block List,"If not checked, the list will have to be added to each Department where it has to be applied.","Hvis ikke sjekket, vil listen må legges til hver avdeling hvor det må brukes."
apps/erpnext/erpnext/accounts/doctype/asset_movement/asset_movement.py +28,Source and Target Warehouse cannot be same,Kilde og Target Warehouse kan ikke være det samme
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +535,Posting date and posting time is mandatory,Konteringsdato og legger tid er obligatorisk
apps/erpnext/erpnext/config/buying.py +76,Tax template for buying transactions.,Skatt mal for å kjøpe transaksjoner.
,Item Prices,Varepriser
DocType: Purchase Order,In Words will be visible once you save the Purchase Order.,I Ord vil være synlig når du lagrer innkjøpsordre.
DocType: Period Closing Voucher,Period Closing Voucher,Periode Closing Voucher
apps/erpnext/erpnext/config/selling.py +67,Price List master.,Prisliste mester.
DocType: Task,Review Date,Omtale Dato
DocType: Purchase Invoice,Advance Payments,Forskudd
DocType: Purchase Taxes and Charges,On Net Total,On Net Total
apps/erpnext/erpnext/controllers/item_variant.py +90,Value for Attribute {0} must be within the range of {1} to {2} in the increments of {3} for Item {4},Verdi for Egenskap {0} må være innenfor området {1} til {2} i trinn på {3} for Element {4}
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +161,Target warehouse in row {0} must be same as Production Order,Target lager i rad {0} må være samme som produksjonsordre
apps/erpnext/erpnext/controllers/recurring_document.py +217,'Notification Email Addresses' not specified for recurring %s,Varslings E-postadresser som ikke er spesifisert for gjentakende% s
apps/erpnext/erpnext/accounts/doctype/account/account.py +127,Currency can not be changed after making entries using some other currency,Valuta kan ikke endres etter at oppføringer ved hjelp av en annen valuta
DocType: Vehicle Service,Clutch Plate,clutch Plate
DocType: Company,Round Off Account,Rund av konto
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +93,Administrative Expenses,Administrative utgifter
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +18,Consulting,Consulting
DocType: Customer Group,Parent Customer Group,Parent Kundegruppe
DocType: Purchase Invoice,Contact Email,Kontakt Epost
DocType: Appraisal Goal,Score Earned,Resultat tjent
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +198,Notice Period,Oppsigelsestid
DocType: Asset Category,Asset Category Name,Asset Category Name
apps/erpnext/erpnext/setup/doctype/territory/territory.js +13,This is a root territory and cannot be edited.,Dette er en rot territorium og kan ikke redigeres.
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js +5,New Sales Person Name,New Sales Person navn
DocType: Packing Slip,Gross Weight UOM,Bruttovekt målenheter
DocType: Delivery Note Item,Against Sales Invoice,Mot Salg Faktura
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +122,Please enter serial numbers for serialized item ,Vennligst skriv inn serienumre for serialisert element
DocType: Bin,Reserved Qty for Production,Reservert Antall for produksjon
DocType: Student Group Creation Tool,Leave unchecked if you don't want to consider batch while making course based groups. ,La være ukontrollert hvis du ikke vil vurdere batch mens du lager kursbaserte grupper.
DocType: Student Group Creation Tool,Leave unchecked if you don't want to consider batch while making course based groups. ,La være ukontrollert hvis du ikke vil vurdere batch mens du lager kursbaserte grupper.
DocType: Asset,Frequency of Depreciation (Months),Frekvens av Avskrivninger (måneder)
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +475,Credit Account,Credit konto
DocType: Landed Cost Item,Landed Cost Item,Landed Cost Element
apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.js +57,Show zero values,Vis nullverdier
DocType: BOM,Quantity of item obtained after manufacturing / repacking from given quantities of raw materials,Antall element oppnådd etter produksjon / nedpakking fra gitte mengder råvarer
apps/erpnext/erpnext/public/js/setup_wizard.js +395,Setup a simple website for my organization,Oppsett en enkel nettside for min organisasjon
DocType: Payment Reconciliation,Receivable / Payable Account,Fordringer / gjeld konto
DocType: Delivery Note Item,Against Sales Order Item,Mot kundeordreposisjon
apps/erpnext/erpnext/stock/doctype/item/item.py +643,Please specify Attribute Value for attribute {0},Vennligst oppgi data Verdi for attributtet {0}
DocType: Item,Default Warehouse,Standard Warehouse
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +45,Budget cannot be assigned against Group Account {0},Budsjettet kan ikke overdras mot gruppekonto {0}
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +22,Please enter parent cost center,Skriv inn forelder kostnadssted
DocType: Delivery Note,Print Without Amount,Skriv ut Uten Beløp
apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +57,Depreciation Date,avskrivninger Dato
DocType: Issue,Support Team,Support Team
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +36,Expiry (In Days),Utløps (i dager)
DocType: Appraisal,Total Score (Out of 5),Total poengsum (av 5)
DocType: Fee Structure,FS.,FS.
DocType: Student Attendance Tool,Batch,Parti
apps/erpnext/erpnext/stock/doctype/item/item.js +27,Balance,Balanse
DocType: Room,Seating Capacity,Antall seter
DocType: Issue,ISS-,ISS-
DocType: Project,Total Expense Claim (via Expense Claims),Total Expense krav (via Utgifts Krav)
DocType: GST Settings,GST Summary,GST Sammendrag
DocType: Assessment Result,Total Score,Total poengsum
DocType: Journal Entry,Debit Note,Debitnota
DocType: Stock Entry,As per Stock UOM,Pr Stock målenheter
apps/erpnext/erpnext/stock/doctype/batch/batch_list.js +7,Not Expired,Ikke utløpt
DocType: Student Log,Achievement,Oppnåelse
DocType: Batch,Source Document Type,Kilde dokumenttype
DocType: Batch,Source Document Type,Kilde dokumenttype
DocType: Journal Entry,Total Debit,Total debet
DocType: Manufacturing Settings,Default Finished Goods Warehouse,Standardferdigvarelageret
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +78,Sales Person,Sales Person
DocType: SMS Parameter,SMS Parameter,SMS Parameter
apps/erpnext/erpnext/config/accounts.py +235,Budget and Cost Center,Budsjett og kostnadssted
DocType: Vehicle Service,Half Yearly,Halvårlig
DocType: Lead,Blog Subscriber,Blogg Subscriber
DocType: Guardian,Alternate Number,Alternativ nummer
DocType: Assessment Plan Criteria,Maximum Score,maksimal score
apps/erpnext/erpnext/config/setup.py +83,Create rules to restrict transactions based on values.,Lage regler for å begrense transaksjoner basert på verdier.
apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +49, Group Roll No,Grupperulle nr
DocType: Student Group Creation Tool,Leave blank if you make students groups per year,La være tom hvis du lager studentgrupper hvert år
DocType: Student Group Creation Tool,Leave blank if you make students groups per year,La være tom hvis du lager studentgrupper hvert år
DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Hvis det er merket, Total nei. arbeidsdager vil omfatte helligdager, og dette vil redusere verdien av Lønn per dag"
DocType: Purchase Invoice,Total Advance,Total Advance
apps/erpnext/erpnext/schools/doctype/academic_term/academic_term.py +23,The Term End Date cannot be earlier than the Term Start Date. Please correct the dates and try again.,"Begrepet Sluttdatoen kan ikke være tidligere enn Term startdato. Korriger datoene, og prøv igjen."
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +19,Quot Count,Sitatall
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +19,Quot Count,Sitatall
,BOM Stock Report,BOM aksjerapport
DocType: Stock Reconciliation Item,Quantity Difference,Antall Difference
apps/erpnext/erpnext/config/hr.py +311,Processing Payroll,Processing Lønn
DocType: Opportunity Item,Basic Rate,Basic Rate
DocType: GL Entry,Credit Amount,Credit Beløp
DocType: Cheque Print Template,Signatory Position,Signataren plassering
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +175,Set as Lost,Sett som tapte
DocType: Timesheet,Total Billable Hours,Totalt fakturerbare timer
apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +4,Payment Receipt Note,Betaling Kvittering Note
apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +6,This is based on transactions against this Customer. See timeline below for details,Dette er basert på transaksjoner mot denne kunden. Se tidslinjen nedenfor for detaljer
DocType: Supplier,Credit Days Based On,Kreditt Days Based On
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +161,Row {0}: Allocated amount {1} must be less than or equals to Payment Entry amount {2},Rad {0}: Avsatt beløp {1} må være mindre enn eller lik Betaling Entry mengden {2}
,Course wise Assessment Report,Kursbasert vurderingsrapport
DocType: Tax Rule,Tax Rule,Skatt Rule
DocType: Selling Settings,Maintain Same Rate Throughout Sales Cycle,Opprettholde samme hastighet Gjennom Salgssyklus
DocType: Manufacturing Settings,Plan time logs outside Workstation Working Hours.,Planlegg tids logger utenfor arbeidsstasjon arbeidstid.
apps/erpnext/erpnext/public/js/pos/pos.html +89,Customers in Queue,Kunder i kø
DocType: Student,Nationality,Nasjonalitet
,Items To Be Requested,Elementer å bli forespurt
DocType: Purchase Order,Get Last Purchase Rate,Få siste kjøp Ranger
DocType: Company,Company Info,Selskap Info
apps/erpnext/erpnext/accounts/page/pos/pos.js +1343,Select or add new customer,Velg eller legg til ny kunde
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +150,Cost center is required to book an expense claim,Kostnadssted er nødvendig å bestille en utgift krav
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +9,Application of Funds (Assets),Anvendelse av midler (aktiva)
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +6,This is based on the attendance of this Employee,Dette er basert på tilstedeværelse av denne Employee
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +469,Debit Account,Debet konto
DocType: Fiscal Year,Year Start Date,År Startdato
DocType: Attendance,Employee Name,Ansattes Navn
DocType: Sales Invoice,Rounded Total (Company Currency),Avrundet Total (Selskap Valuta)
apps/erpnext/erpnext/accounts/doctype/account/account.py +99,Cannot covert to Group because Account Type is selected.,Kan ikke covert til konsernet fordi Kontotype er valgt.
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +240,{0} {1} has been modified. Please refresh.,{0} {1} har blitt endret. Vennligst oppdater.
DocType: Leave Block List,Stop users from making Leave Applications on following days.,Stoppe brukere fra å gjøre La Applications på følgende dager.
apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +63,Purchase Amount,kjøpesummen
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +212,Supplier Quotation {0} created,Leverandør sitat {0} er opprettet
apps/erpnext/erpnext/accounts/report/financial_statements.py +97,End Year cannot be before Start Year,Slutt År kan ikke være før start År
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +191,Employee Benefits,Ytelser til ansatte
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +255,Packed quantity must equal quantity for Item {0} in row {1},Pakket mengde må være lik mengde for Element {0} i rad {1}
DocType: Production Order,Manufactured Qty,Produsert Antall
DocType: Purchase Receipt Item,Accepted Quantity,Akseptert Antall
apps/erpnext/erpnext/hr/doctype/employee/employee.py +238,Please set a default Holiday List for Employee {0} or Company {1},Vennligst angi en standard Holiday Liste for Employee {0} eller selskapet {1}
apps/erpnext/erpnext/accounts/party.py +30,{0}: {1} does not exists,{0}: {1} ikke eksisterer
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +74,Select Batch Numbers,Velg batchnumre
apps/erpnext/erpnext/config/accounts.py +12,Bills raised to Customers.,Regninger hevet til kundene.
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26,Project Id,Prosjekt Id
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +534,Row No {0}: Amount cannot be greater than Pending Amount against Expense Claim {1}. Pending Amount is {2},Row Nei {0}: Beløpet kan ikke være større enn utestående beløpet mot Expense krav {1}. Avventer Beløp er {2}
DocType: Maintenance Schedule,Schedule,Tidsplan
DocType: Account,Parent Account,Parent konto
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +232,Available,Tilgjengelig
DocType: Quality Inspection Reading,Reading 3,Reading 3
,Hub,Hub
DocType: GL Entry,Voucher Type,Kupong Type
apps/erpnext/erpnext/accounts/page/pos/pos.js +1636,Price List not found or disabled,Prisliste ikke funnet eller deaktivert
DocType: Employee Loan Application,Approved,Godkjent
DocType: Pricing Rule,Price,Pris
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +261,Employee relieved on {0} must be set as 'Left',Ansatt lettet på {0} må være angitt som &quot;venstre&quot;
DocType: Guardian,Guardian,Guardian
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +42,Appraisal {0} created for Employee {1} in the given date range,Appraisal {0} skapt for Employee {1} i den gitte datointervall
DocType: Employee,Education,Utdanning
apps/erpnext/erpnext/public/js/pos/pos.html +80,Del,del
DocType: Selling Settings,Campaign Naming By,Kampanje Naming Av
DocType: Employee,Current Address Is,Gjeldende adresse Er
apps/erpnext/erpnext/templates/includes/projects/project_tasks.html +9,modified,modifisert
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +41,"Optional. Sets company's default currency, if not specified.","Valgfritt. Setter selskapets standardvaluta, hvis ikke spesifisert."
DocType: Sales Invoice,Customer GSTIN,Kunde GSTIN
apps/erpnext/erpnext/config/accounts.py +61,Accounting journal entries.,Regnskap posteringer.
DocType: Delivery Note Item,Available Qty at From Warehouse,Tilgjengelig Antall på From Warehouse
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +295,Please select Employee Record first.,Vennligst velg Employee Record først.
DocType: POS Profile,Account for Change Amount,Konto for Change Beløp
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +217,Row {0}: Party / Account does not match with {1} / {2} in {3} {4},Rad {0}: Party / Account samsvarer ikke med {1} / {2} i {3} {4}
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +238,Please enter Expense Account,Skriv inn Expense konto
DocType: Account,Stock,Lager
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1022,"Row #{0}: Reference Document Type must be one of Purchase Order, Purchase Invoice or Journal Entry","Row # {0}: Reference Document Type må være en av innkjøpsordre, faktura eller bilagsregistrering"
DocType: Employee,Current Address,Nåværende Adresse
DocType: Item,"If item is a variant of another item then description, image, pricing, taxes etc will be set from the template unless explicitly specified","Hvis elementet er en variant av et annet element da beskrivelse, image, priser, avgifter osv vil bli satt fra malen uten eksplisitt spesifisert"
DocType: Serial No,Purchase / Manufacture Details,Kjøp / Produksjon Detaljer
DocType: Assessment Group,Assessment Group,Assessment Group
apps/erpnext/erpnext/config/stock.py +320,Batch Inventory,Batch Lager
DocType: Employee,Contract End Date,Kontraktssluttdato
DocType: Sales Order,Track this Sales Order against any Project,Spor dette Salgsordre mot ethvert prosjekt
DocType: Sales Invoice Item,Discount and Margin,Rabatt og Margin
DocType: Production Planning Tool,Pull sales orders (pending to deliver) based on the above criteria,Pull salgsordrer (pending å levere) basert på kriteriene ovenfor
DocType: Pricing Rule,Min Qty,Min Antall
DocType: Asset Movement,Transaction Date,Transaksjonsdato
DocType: Production Plan Item,Planned Qty,Planlagt Antall
apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +121,Total Tax,Total Skatte
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +177,For Quantity (Manufactured Qty) is mandatory,For Mengde (Produsert Stk) er obligatorisk
DocType: Stock Entry,Default Target Warehouse,Standard Target Warehouse
DocType: Purchase Invoice,Net Total (Company Currency),Net Total (Selskap Valuta)
apps/erpnext/erpnext/schools/doctype/academic_year/academic_year.py +14,The Year End Date cannot be earlier than the Year Start Date. Please correct the dates and try again.,"Året Sluttdatoen kan ikke være tidligere enn året startdato. Korriger datoene, og prøv igjen."
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +105,Row {0}: Party Type and Party is only applicable against Receivable / Payable account,Rad {0}: Party Type og Party gjelder bare mot fordringer / gjeld konto
DocType: Notification Control,Purchase Receipt Message,Kvitteringen Message
DocType: BOM,Scrap Items,skrap Items
DocType: Production Order,Actual Start Date,Faktisk startdato
DocType: Sales Order,% of materials delivered against this Sales Order,% Av materialer leveres mot denne kundeordre
apps/erpnext/erpnext/config/stock.py +12,Record item movement.,Record element bevegelse.
DocType: Training Event Employee,Withdrawn,Tilbaketrukket
DocType: Hub Settings,Hub Settings,Hub-innstillinger
DocType: Project,Gross Margin %,Bruttomargin%
DocType: BOM,With Operations,Med Operations
apps/erpnext/erpnext/accounts/party.py +255,Accounting entries have already been made in currency {0} for company {1}. Please select a receivable or payable account with currency {0}.,Regnskapspostene har allerede blitt gjort i valuta {0} for selskap {1}. Vennligst velg en fordring eller betales konto med valuta {0}.
DocType: Asset,Is Existing Asset,Er Eksisterende Asset
DocType: Salary Detail,Statistical Component,Statistisk komponent
DocType: Salary Detail,Statistical Component,Statistisk komponent
DocType: Warranty Claim,If different than customer address,Hvis annerledes enn kunden adresse
DocType: BOM Operation,BOM Operation,BOM Operation
DocType: Purchase Taxes and Charges,On Previous Row Amount,På Forrige Row Beløp
DocType: Student,Home Address,Hjemmeadresse
apps/erpnext/erpnext/accounts/doctype/asset/asset.js +260,Transfer Asset,Transfer Asset
DocType: POS Profile,POS Profile,POS Profile
DocType: Training Event,Event Name,Aktivitetsnavn
apps/erpnext/erpnext/schools/doctype/student/student_dashboard.py +10,Admission,Adgang
apps/erpnext/erpnext/schools/doctype/student_admission/student_admission.py +26,Admissions for {0},Innleggelser for {0}
apps/erpnext/erpnext/config/accounts.py +259,"Seasonality for setting budgets, targets etc.","Sesong for å sette budsjetter, mål etc."
apps/erpnext/erpnext/stock/get_item_details.py +147,"Item {0} is a template, please select one of its variants","Element {0} er en mal, kan du velge en av variantene"
DocType: Asset,Asset Category,Asset Kategori
apps/erpnext/erpnext/public/js/setup_wizard.js +211,Purchaser,Kjøper
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +30,Net pay cannot be negative,Nettolønn kan ikke være negativ
DocType: SMS Settings,Static Parameters,Statiske Parametere
DocType: Assessment Plan,Room,Rom
DocType: Purchase Order,Advance Paid,Advance Betalt
DocType: Item,Item Tax,Sak Skatte
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +803,Material to Supplier,Materiale til Leverandør
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +384,Excise Invoice,Vesenet Faktura
apps/erpnext/erpnext/schools/doctype/grading_scale/grading_scale.py +16,Treshold {0}% appears more than once,Treshold {0}% kommer mer enn én gang
DocType: Expense Claim,Employees Email Id,Ansatte Email Id
DocType: Employee Attendance Tool,Marked Attendance,merket Oppmøte
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +138,Current Liabilities,Kortsiktig gjeld
apps/erpnext/erpnext/config/selling.py +292,Send mass SMS to your contacts,Sende masse SMS til kontaktene dine
DocType: Program,Program Name,Programnavn
DocType: Purchase Taxes and Charges,Consider Tax or Charge for,Tenk Skatte eller Charge for
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +57,Actual Qty is mandatory,Selve Antall er obligatorisk
DocType: Employee Loan,Loan Type,låne~~POS=TRUNC
DocType: Scheduling Tool,Scheduling Tool,planlegging Tool
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +149,Credit Card,Kredittkort
DocType: BOM,Item to be manufactured or repacked,Elementet som skal produseres eller pakkes
apps/erpnext/erpnext/config/stock.py +179,Default settings for stock transactions.,Standardinnstillingene for aksjetransaksjoner.
DocType: Purchase Invoice,Next Date,Neste dato
DocType: Employee Education,Major/Optional Subjects,Store / valgfrie emner
DocType: Sales Invoice Item,Drop Ship,Drop Ship
DocType: Training Event,Attendees,Deltakere
DocType: Employee,"Here you can maintain family details like name and occupation of parent, spouse and children","Her kan du opprettholde familie informasjon som navn og okkupasjon av foreldre, ektefelle og barn"
DocType: Academic Term,Term End Date,Term Sluttdato
DocType: Hub Settings,Seller Name,Selger Navn
DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),Skatter og avgifter fratrukket (Company Valuta)
DocType: Item Group,General Settings,Generelle Innstillinger
apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py +23,From Currency and To Currency cannot be same,Fra Valuta og til valuta kan ikke være det samme
DocType: Stock Entry,Repack,Pakk
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +6,You must Save the form before proceeding,Du må Lagre skjemaet før du fortsetter
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +96,Please select the Company first,Vennligst velg selskapet først
DocType: Item Attribute,Numeric Values,Numeriske verdier
apps/erpnext/erpnext/public/js/setup_wizard.js +47,Attach Logo,Fest Logo
apps/erpnext/erpnext/stock/doctype/batch/batch.js +38,Stock Levels,lagernivåer
DocType: Customer,Commission Rate,Kommisjon
apps/erpnext/erpnext/stock/doctype/item/item.js +332,Make Variant,Gjør Variant
apps/erpnext/erpnext/config/hr.py +87,Block leave applications by department.,Block permisjon applikasjoner ved avdelingen.
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +142,"Payment Type must be one of Receive, Pay and Internal Transfer","Betalingstype må være en av Motta, Lønn og Internal Transfer"
apps/erpnext/erpnext/config/selling.py +179,Analytics,Analytics
apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html +21,Cart is Empty,Handlevognen er tom
DocType: Vehicle,Model,Modell
DocType: Production Order,Actual Operating Cost,Faktiske driftskostnader
DocType: Payment Entry,Cheque/Reference No,Sjekk / referansenummer
apps/erpnext/erpnext/accounts/doctype/account/account.py +84,Root cannot be edited.,Root kan ikke redigeres.
DocType: Item,Units of Measure,Måleenheter
DocType: Manufacturing Settings,Allow Production on Holidays,Tillat Produksjonen på helligdager
DocType: Sales Order,Customer's Purchase Order Date,Kundens Purchase Order Date
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +163,Capital Stock,Kapitalbeholdningen
DocType: Shopping Cart Settings,Show Public Attachments,Vis offentlige vedlegg
DocType: Packing Slip,Package Weight Details,Pakken vektdetaljer
DocType: Payment Gateway Account,Payment Gateway Account,Betaling Gateway konto
DocType: Shopping Cart Settings,After payment completion redirect user to selected page.,Etter betaling ferdigstillelse omdirigere brukeren til valgt side.
DocType: Company,Existing Company,eksisterende selskapet
apps/erpnext/erpnext/controllers/buying_controller.py +82,"Tax Category has been changed to ""Total"" because all the Items are non-stock items",Skattekategori har blitt endret til &quot;Totalt&quot; fordi alle elementene er ikke-varelager
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +103,Please select a csv file,Vennligst velg en csv-fil
DocType: Student Leave Application,Mark as Present,Merk som Present
DocType: Purchase Order,To Receive and Bill,Å motta og Bill
apps/erpnext/erpnext/templates/pages/home.html +14,Featured Products,Utvalgte produkter
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +105,Designer,Designer
apps/erpnext/erpnext/config/selling.py +163,Terms and Conditions Template,Betingelser Mal
DocType: Serial No,Delivery Details,Levering Detaljer
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +482,Cost Center is required in row {0} in Taxes table for type {1},Kostnadssted er nødvendig i rad {0} i skatter tabell for typen {1}
DocType: Program,Program Code,programkode
DocType: Terms and Conditions,Terms and Conditions Help,Betingelser Hjelp
,Item-wise Purchase Register,Element-messig Purchase Register
DocType: Batch,Expiry Date,Utløpsdato
,accounts-browser,kontoer-browser
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +351,Please select Category first,Vennligst første velg kategori
apps/erpnext/erpnext/config/projects.py +13,Project master.,Prosjektet mester.
apps/erpnext/erpnext/controllers/status_updater.py +209,"To allow over-billing or over-ordering, update ""Allowance"" in Stock Settings or the Item.","Å tillate overfakturering eller over-bestilling, oppdatere &quot;Fradrag&quot; på lager Innstillinger eller elementet."
DocType: Global Defaults,Do not show any symbol like $ etc next to currencies.,Ikke viser noen symbol som $ etc ved siden av valutaer.
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +459, (Half Day),(Halv Dag)
DocType: Supplier,Credit Days,Kreditt Days
apps/erpnext/erpnext/utilities/activation.py +126,Make Student Batch,Gjør Student Batch
DocType: Leave Type,Is Carry Forward,Er fremføring
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +786,Get Items from BOM,Få Elementer fra BOM
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41,Lead Time Days,Ledetid Days
apps/erpnext/erpnext/controllers/accounts_controller.py +569,Row #{0}: Posting Date must be same as purchase date {1} of asset {2},Row # {0}: konteringsdato må være det samme som kjøpsdato {1} av eiendelen {2}
DocType: Program Enrollment,Check this if the Student is residing at the Institute's Hostel.,Sjekk dette hvis studenten er bosatt ved instituttets Hostel.
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +129,Please enter Sales Orders in the above table,Fyll inn salgsordrer i tabellen ovenfor
apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +182,Not Submitted Salary Slips,Ikke Sendt inn lønnsslipper
,Stock Summary,Stock oppsummering
apps/erpnext/erpnext/config/accounts.py +274,Transfer an asset from one warehouse to another,Overfør en eiendel fra en lagerbygning til en annen
DocType: Vehicle,Petrol,Bensin
apps/erpnext/erpnext/config/learn.py +217,Bill of Materials,Bill of Materials
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +103,Row {0}: Party Type and Party is required for Receivable / Payable account {1},Rad {0}: Party Type og Party er nødvendig for fordringer / gjeld kontoen {1}
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +94,Ref Date,Ref Dato
DocType: Employee,Reason for Leaving,Grunn til å forlate
DocType: BOM Operation,Operating Cost(Company Currency),Driftskostnader (Selskap Valuta)
DocType: Employee Loan Application,Rate of Interest,Rente
DocType: Expense Claim Detail,Sanctioned Amount,Sanksjonert Beløp
DocType: GL Entry,Is Opening,Er Åpnings
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +196,Row {0}: Debit entry can not be linked with a {1},Rad {0}: Debet oppføring kan ikke være knyttet til en {1}
apps/erpnext/erpnext/accounts/doctype/account/account.py +193,Account {0} does not exist,Konto {0} finnes ikke
DocType: Account,Cash,Kontanter
DocType: Employee,Short biography for website and other publications.,Kort biografi for hjemmeside og andre publikasjoner.
