diff --git a/erpnext/translations/no.csv b/erpnext/translations/no.csv
index a608a9a..33d2b6f 100644
--- a/erpnext/translations/no.csv
+++ b/erpnext/translations/no.csv
@@ -1,5855 +1,5842 @@
-DocType: Employee,Salary Mode,Lønn Mode
-DocType: Patient,Divorced,Skilt
-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/config/education.py +118,Assessment Reports,Evalueringsrapporter
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +19,Consumer Products,Forbrukerprodukter
-DocType: Purchase Receipt,Subscription Detail,Abonnementsdetaljer
-DocType: Supplier Scorecard,Notify Supplier,Informer Leverandør
-DocType: Item,Customer Items,Kunde Items
-DocType: Project,Costing and Billing,Kalkulasjon og fakturering
-apps/erpnext/erpnext/accounts/doctype/account/account.py +48,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: Consultation,Investigations,undersøkelser
-DocType: Restaurant Order Entry,Click Enter To Add,Klikk på Enter for å legge til
-DocType: Employee,Rented,Leide
-DocType: Purchase Order,PO-,PO-
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +225,"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/assets/doctype/asset/asset.js +253,Do you really want to scrap this asset?,Har du virkelig ønsker å hugge denne eiendelen?
-DocType: Drug Prescription,Update Schedule,Oppdater plan
-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: Patient Appointment,Check availability,Sjekk tilgjengelighet
-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/setup/setup_wizard/operations/install_fixtures.py +120,Legal,Juridisk
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +191,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/operations/company_setup.py +64,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})
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +343,There are no submitted Salary Slips to process.,Det er ingen innsendte lønnslister å behandle.
-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/templates/emails/recurring_document_failed.html +8,It is necessary to take this action today itself for the above mentioned recurring,Det er nødvendig å ta denne handlingen i dag selv for ovennevnte tilbakevendende
-apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.py +24,Diagnosis and Complaints cannot be left blank,Diagnose og klager kan ikke stå tomt
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +151,Series Updated Successfully,Serien er oppdatert
-apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html +6,Checkout,Sjekk ut
-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
-apps/erpnext/erpnext/projects/doctype/project/project.py +74,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 +117,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 +241,New Leave Application,New La Application
-,Batch Item Expiry Status,Batch Element Utløps Status
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +184,Bank Draft,Bank Draft
-DocType: Membership,membership validaty section,medlemskapsvaliditetsseksjon
-DocType: Mode of Payment Account,Mode of Payment Account,Modus for betaling konto
-DocType: Consultation,Consultation,Konsultasjon
-DocType: Accounts Settings,Show Payment Schedule in Print,Vis betalingsplan i utskrift
-apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py +19,Sales and Returns,Salg og retur
-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/setup/setup_wizard/setup_wizard.py +66,Making website,Å lage nettside
-DocType: Opening Invoice Creation Tool Item,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
-DocType: Soil Texture,Soil Texture Criteria,Kriterier for jordstruktur
-apps/erpnext/erpnext/templates/includes/product_page.js +24,In Stock,På Lager
-apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js +16,Primary Contact Details,Primær kontaktdetaljer
-apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +46,Open Issues,åpne spørsmål
-DocType: Production Order,Production Plan Item,Produksjonsplan Sak
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +149,User {0} is already assigned to Employee {1},Bruker {0} er allerede tildelt Employee {1}
-DocType: Lab Test Groups,Add new line,Legg til ny linje
-apps/erpnext/erpnext/setup/setup_wizard/data/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)
-DocType: Payment Terms Template Detail,Payment Terms Template Detail,Betalingsvilkår Maledetaljer
-DocType: Hotel Room Reservation,Guest Name,Gjestenavn
-DocType: Lab Prescription,Lab Prescription,Lab Prescription
-,Delay Days,Forsinkelsesdager
-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 +899,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 +880,Invoice,Faktura
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +145,Make Retention Stock Entry,Lag Retention Stock Entry
-DocType: Purchase Invoice Item,Item Weight Details,Vektdetaljer
-DocType: Asset Maintenance Log,Periodicity,Periodisitet
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +21,Fiscal Year {0} is required,Regnskapsår {0} er nødvendig
-DocType: Crop Cycle,The minimum distance between rows of plants for optimum growth,Minimumsavstanden mellom rader av planter for optimal vekst
-apps/erpnext/erpnext/setup/setup_wizard/data/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 +77,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 +162,Please select Price List,Vennligst velg Prisliste
-DocType: Accounts Settings,Currency Exchange Settings,Valutavekslingsinnstillinger
-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/education/report/absent_student_report/absent_student_report.py +13,Please select date,Vennligst velg dato
-DocType: Daily Work Summary Group,Holiday List,Holiday List
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +127,Accountant,Accountant
-DocType: Hub Settings,Selling Price List,Selge prisliste
-DocType: Patient,Tobacco Current Use,Nåværende bruk av tobakk
-apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +56,Selling Rate,Selgingsfrekvens
-DocType: Cost Center,Stock User,Stock User
-DocType: Soil Analysis,(Ca+Mg)/K,(Ca + Mg) / K
-DocType: Company,Phone No,Telefonnr
-apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +239,New {0}: #{1},New {0} # {1}
-DocType: Delivery Trip,Initial Email Notification Sent,Innledende e-postvarsling sendt
-,Sales Partners Commission,Sales Partners Commission
-DocType: Soil Texture,Sandy Clay Loam,Sandy Clay Loam
-DocType: Purchase Invoice,Rounding Adjustment,Avrundingsjustering
-apps/erpnext/erpnext/setup/doctype/company/company.py +46,Abbreviation cannot have more than 5 characters,Forkortelse kan ikke ha mer enn fem tegn
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +51,Customer &gt; Customer Group &gt; Territory,Kunde&gt; Kundegruppe&gt; Territorium
-DocType: Physician Schedule Time Slot,Physician Schedule Time Slot,Leger Schedule Time Slot
-DocType: Payment Request,Payment Request,Betaling Request
-DocType: Asset,Value After Depreciation,Verdi etter avskrivninger
-DocType: Student,O+,O +
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan_dashboard.py +8,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
-DocType: Subscription,Repeat on Day,Gjenta på dagen
-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/utilities/user_progress.py +143,Kg,Kg
-apps/erpnext/erpnext/config/hr.py +45,Opening for a Job.,Åpning for en jobb.
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +114,BOM is not specified for subcontracting item {0} at row {1},BOM er ikke spesifisert for underleverandørelementet {0} på rad {1}
-apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js +149,{0} Result submittted,{0} Resultat sendt
-DocType: Item Attribute,Increment,Tilvekst
-apps/erpnext/erpnext/utilities/page/leaderboard/leaderboard.js +74,Timespan,Tidsrom
-apps/erpnext/erpnext/public/js/stock_analytics.js +61,Select Warehouse...,Velg Warehouse ...
-apps/erpnext/erpnext/setup/setup_wizard/data/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: Patient,Married,Gift
-apps/erpnext/erpnext/accounts/party.py +42,Not permitted for {0},Ikke tillatt for {0}
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +593,Get items from,Få elementer fra
-DocType: Price List,Price Not UOM Dependant,Pris Ikke UOM Avhengig
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +467,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: Asset Repair,Error Description,Feilbeskrivelse
-DocType: Payment Reconciliation,Reconcile,Forsone
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +30,Grocery,Dagligvare
-DocType: Quality Inspection Reading,Reading 1,Lesing 1
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +40,Pension Funds,Pensjonsfondene
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +91,Next Depreciation Date cannot be before Purchase Date,Neste Avskrivninger Datoen kan ikke være før Kjøpsdato
-DocType: Crop,Perennial,Flerårig
-DocType: Consultation,Consultation Date,Høringsdato
-DocType: Accounts Settings,Use Custom Cash Flow Format,Bruk tilpasset kontantstrømformat
-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 +1752,Not items found,Ikke elementer funnet
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +183,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 +117,"e.g. ""Primary School"" or ""University""",for eksempel &quot;Primary School&quot; eller &quot;University&quot;
-apps/erpnext/erpnext/config/stock.py +28,Stock Reports,lager rapporter
-DocType: Warehouse,Warehouse Detail,Warehouse Detalj
-apps/erpnext/erpnext/education/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 +268,"""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: Delivery Trip,Departure Time,Avgangstid
-DocType: Vehicle Service,Brake Oil,bremse~~POS=TRUNC Oil
-DocType: Tax Rule,Tax Type,Skatt Type
-apps/erpnext/erpnext/controllers/taxes_and_totals.py +581,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)
-DocType: Production Order Operation,(Hour Rate / 60) * Actual Operation Time,(Timepris / 60) * Faktisk Operation Tid
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1076,Row #{0}: Reference Document Type must be one of Expense Claim or Journal Entry,Row # {0}: Referansedokumenttype må være en av kostnadskrav eller journaloppføring
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +966,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/config/hr.py +127,Manage advance amount given to the Employee,Administrer forhåndsbeløp gitt til Medarbeider
-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
-apps/erpnext/erpnext/config/buying.py +165,Templates of supplier standings.,Maler av leverandørstillinger.
-DocType: Lead,Interested,Interessert
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +216,Opening,Åpning
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +32,From {0} to {1},Fra {0} til {1}
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +50,Failed to setup taxes,Kunne ikke sette opp skatt
-DocType: Item,Copy From Item Group,Kopier fra varegruppe
-DocType: Delivery Trip,Delivery Notification,Leveringsvarsling
-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 +138,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: Education 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 +365,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: Soil Analysis,Ca/K,Ca / K
-DocType: Journal Entry Account,Employee Loan,Medarbeider Loan
-DocType: Fee Schedule,Send Payment Request Email,Send betalingsanmodning e-post
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +269,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/data/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/data/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 +260,"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 +56,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/hr/email_alert/training_scheduled/training_scheduled.html +7,Event Location,Hendelsessted
-DocType: Asset Settings,Asset Settings,Asset Settings
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +68,Consumable,Konsum
-DocType: Student,B-,B-
-apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +98,Successfully unregistered.,Helt uregistrert.
-DocType: Assessment Result,Grade,grade
-DocType: Restaurant Table,No of Seats,Antall plasser
-DocType: Subscription,"To add dynamic subject, use jinja tags like
-
-<div><pre><code>New {{ doc.doctype }} #{{ doc.name }}</code></pre></div>","For å legge til dynamisk emne, bruk jinja-koder som <div><pre> <code>New {{ doc.doctype }} #{{ doc.name }}</code> </pre> </div>"
-DocType: Sales Invoice Item,Delivered By Supplier,Levert av Leverandør
-DocType: Asset Maintenance Task,Asset Maintenance Task,Asset Maintenance Task
-DocType: SMS Center,All Contact,All kontakt
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +954,Production Order already created for all items with BOM,Produksjonsordre allerede opprettet for alle varer med BOM
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +231,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 +393,{0} {1} is frozen,{0} {1} er frosset
-apps/erpnext/erpnext/setup/doctype/company/company.py +140,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 +111,Select Target Warehouse,Velg Target Warehouse
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +111,Select Target Warehouse,Velg Target Warehouse
-apps/erpnext/erpnext/hr/doctype/employee/employee.js +80,Please enter Preferred Contact Email,Fyll inn foretrukne e-
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +45,CompAuxNum,CompAuxNum
-DocType: Journal Entry,Contra Entry,Contra Entry
-DocType: Journal Entry Account,Credit in Company Currency,Kreditt i selskapet Valuta
-DocType: Lab Test UOM,Lab Test UOM,Lab Test UOM
-DocType: Delivery Note,Installation Status,Installasjon Status
-DocType: BOM,Quality Inspection Template,Kvalitetskontrollmaler
-apps/erpnext/erpnext/education/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 +344,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
-DocType: Agriculture Analysis Criteria,Fertilizer,Gjødsel
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +152,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
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +519,Item {0} is not active or end of life has been reached,Element {0} er ikke aktiv eller slutten av livet er nådd
-DocType: Student Admission Program,Minimum Age,Minimumsalder
-apps/erpnext/erpnext/utilities/user_progress.py +187,Example: Basic Mathematics,Eksempel: Grunnleggende matematikk
-DocType: Customer,Primary Address,hoved adresse
-DocType: Production Plan,Material Request Detail,Material Request Detail
-DocType: Selling Settings,Default Quotation Validity Days,Standard Quotation Gyldighetsdager
-apps/erpnext/erpnext/controllers/accounts_controller.py +793,"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 +223,Settings for HR Module,Innstillinger for HR Module
-DocType: SMS Center,SMS Center,SMS-senter
-DocType: Sales Invoice,Change Amount,endring Beløp
-DocType: GST Settings,Set Invoice Value for B2C. B2CL and B2CS calculated based on this invoice value.,Angi fakturaverdi for B2C. B2CL og B2CS beregnet ut fra denne fakturaverdien.
-DocType: BOM Update Tool,New BOM,New BOM
-apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js +36,Show only POS,Vis bare POS
-DocType: Driver,Driving License Categories,Kjørelisenskategorier
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +118,Please enter Delivery Date,Vennligst oppgi Leveringsdato
-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/job_offer/job_offer.js +17,Make Employee,Gjør Employee
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +14,Broadcasting,Kringkasting
-apps/erpnext/erpnext/config/accounts.py +313,Setup mode of POS (Online / Offline),Oppsettmodus for POS (Online / Offline)
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +191,Execution,Execution
-apps/erpnext/erpnext/config/manufacturing.py +62,Details of the operations carried out.,Detaljene for operasjonen utføres.
-DocType: Asset Maintenance Log,Maintenance Status,Vedlikehold Status
-apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py +10,Membership Details,Medlemskapsdetaljer
-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: Drug Prescription,Interval,intervall
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +252,Preference,Preference
-DocType: Grant Application,Individual,Individuell
-DocType: Academic Term,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: Supplier Scorecard Period,Supplier Scorecard Period,Leverandør Scorecard Periode
-DocType: Share Transfer,Share Transfer,Del overføring
-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.
-DocType: Daily Work Summary,Daily Work Summary Group,Daglig arbeidsoppsummeringsgruppe
-DocType: Physician Schedule,Time Slots,Tidsluker
-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 (%)
-apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +112,Item Template,Artikkelmal
-apps/erpnext/erpnext/healthcare/setup.py +215,Biochemistry,biokjemi
-DocType: Job Offer,Select Terms and Conditions,Velg Vilkår
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +72,Out Value,ut Verdi
-DocType: Production Plan,Sales Orders,Salgsordrer
-DocType: Purchase Taxes and Charges,Valuation,Verdivurdering
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +386,Set as Default,Satt som standard
-DocType: Production Plan,PLN-,PLN-
-,Purchase Order Trends,Innkjøpsordre Trender
-apps/erpnext/erpnext/utilities/user_progress.py +75,Go to Customers,Gå til Kunder
-DocType: Hotel Room Reservation,Late Checkin,Sen innsjekk
-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 +262,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
-apps/erpnext/erpnext/projects/doctype/project_type/project_type.py +13,You cannot delete Project Type 'External',Du kan ikke slette Project Type &#39;External&#39;
-DocType: Employee,Create User,Opprett bruker
-DocType: Selling Settings,Default Territory,Standard Territory
-apps/erpnext/erpnext/setup/setup_wizard/data/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 +430,Advance amount cannot be greater than {0} {1},Advance beløpet kan ikke være større enn {0} {1}
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +42,JournalCode,JournalCode
-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/education/doctype/student_group/student_group.js +51,Update Email Group,Oppdater E-postgruppe
-DocType: Sales Invoice,Is Opening Entry,Åpner Entry
-DocType: Lab Test Template,"If unchecked, the item wont be appear in Sales Invoice, but can be used in group test creation. ","Hvis ikke merket, vil varen ikke vises i salgsfaktura, men kan brukes i gruppetestopprettelse."
-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
-DocType: Supplier Scorecard,Criteria Setup,Kriterieoppsett
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +206,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: Codification Table,Medical Code,Medisinsk kode
-apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +20,Please enter Company,Skriv inn Firma
-DocType: Delivery Note Item,Against Sales Invoice Item,Mot Salg Faktura Element
-DocType: Agriculture Analysis Criteria,Linked Doctype,Tilknyttet doktype
-,Production Orders in Progress,Produksjonsordrer i Progress
-apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +44,Net Cash from Financing,Netto kontantstrøm fra finansierings
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2359,"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
-DocType: Sales Partner,Partner website,partner nettstedet
-DocType: Restaurant Order Entry,Add Item,Legg til element
-DocType: Lab Test,Custom Result,Tilpasset resultat
-DocType: Delivery Stop,Contact Name,Kontakt Navn
-DocType: Course Assessment Criteria,Course Assessment Criteria,Kursvurderingskriteriene
-DocType: POS Customer Group,POS Customer Group,POS Kundegruppe
-DocType: Land Unit,Land Unit describing various land assets,Land Enhet som beskriver ulike eiendeler
-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.
-DocType: Lab Test,Submitted Date,Innleveringsdato
-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
-DocType: Payment Term,Credit Months,Kredittmåneder
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +408,Net Pay cannot be less than 0,Nettolønn kan ikke være mindre enn 0
-apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +5,"To stop sending repetitive error notifications from the system, we have checked Disabled field in the subscription","For å slutte å sende gjentatte feilmeldinger fra systemet, har vi sjekket deaktivert felt i abonnementet"
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +121,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/operations/install_fixtures.py +239,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 +219,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/utilities/user_progress.py +144,Litre,liter
-DocType: Task,Total Costing Amount (via Time Sheet),Total Costing Beløp (via Timeregistrering)
-apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.py +69,Please setup Students under Student Groups,Vennligst oppsett Studentene under Student Grupper
-DocType: Item Website Specification,Item Website Specification,Sak Nettsted Spesifikasjon
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +449,Leave Blocked,La Blokkert
-apps/erpnext/erpnext/stock/doctype/item/item.py +739,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 +83,Bank Entries,Bank Entries
-DocType: Crop,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/utilities/user_progress.py +207,People who teach at your organisation,Folk som underviser i organisasjonen
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +135,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 +761,Item {0} is cancelled,Element {0} er kansellert
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1055,Material Request,Materialet Request
-DocType: Bank Reconciliation,Update Clearance Date,Oppdater Lagersalg Dato
-,GSTR-2,GSTR-2
-DocType: Item,Purchase Details,Kjøps Detaljer
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +394,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: Salary Slip,Total Principal Amount,Sum hovedbeløp
-DocType: Student Guardian,Relation,Relasjon
-DocType: Student Guardian,Mother,Mor
-DocType: Restaurant Reservation,Reservation End Time,Reservasjons sluttid
-DocType: Crop,Biennial,Biennial
-apps/erpnext/erpnext/config/selling.py +18,Confirmed orders from Customers.,Bekreftede bestillinger fra kunder.
-DocType: Purchase Receipt Item,Rejected Quantity,Avvist Antall
-apps/erpnext/erpnext/education/doctype/fees/fees.py +80,Payment request {0} created,Betalingsforespørsel {0} opprettet
-apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +72,Open Orders,Åpne bestillinger
-apps/erpnext/erpnext/healthcare/setup.py +255,Low Sensitivity,Lav følsomhet
-DocType: Notification Control,Notification Control,Varsling kontroll
-apps/erpnext/erpnext/templates/emails/training_event.html +17,Please confirm once you have completed your training,Vennligst bekreft når du har fullført treningen
-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.
-DocType: Payment Term,Payment Term Name,Betalingsnavn
-DocType: Healthcare Settings,Create documents for sample collection,Lag dokumenter for prøveinnsamling
-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: Shareholder,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 +138,Please select Charge Type first,Vennligst velg Charge Type først
-DocType: Crop,"You can define all the tasks which need to carried out for this crop here. The day field is used to mention the day on which the task needs to be carried out, 1 being the 1st day, etc.. ","Du kan definere alle oppgavene som må utføres for denne avlingen her. Dagfeltet brukes til å nevne hvilken dag oppgaven må utføres, 1 er 1. dag, osv."
-DocType: Student Group Student,Student Group Student,Student Gruppe Student
-apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41,Latest,Siste
-DocType: Asset Maintenance Task,2 Yearly,2 årlig
-DocType: Education Settings,Education Settings,Utdanning Innstillinger
-DocType: Vehicle Service,Inspection,Undersøkelse
-DocType: Supplier Scorecard Scoring Standing,Max Grade,Maksimal karakter
-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 +167,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 +673,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: Driver,Fleet Manager,Flåtesjef
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +542,Row #{0}: {1} can not be negative for item {2},Rad # {0}: {1} ikke kan være negativ for elementet {2}
-apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +59,Wrong Password,Feil Passord
-DocType: Item,Variant Of,Variant av
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +406,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
-DocType: Physician,Time per Appointment,Tid per avtale
-apps/erpnext/erpnext/projects/doctype/task/task.py +110,Circular Reference Error,Rundskriv Reference Error
-DocType: Appointment Type,Is Inpatient,Er pasient
-apps/erpnext/erpnext/education/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
-DocType: BOM Item,Rate & Amount,Pris og beløp
-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
-apps/erpnext/erpnext/healthcare/setup.py +259,Resistant,Resistant
-apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.py +77,Please set Hotel Room Rate on {},Vennligst sett inn hotellrenten på {}
-DocType: Journal Entry,Multi Currency,Multi Valuta
-DocType: Opening Invoice Creation Tool,Invoice Type,Faktura Type
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +939,Delivery Note,Levering Note
-DocType: Consultation,Encounter Impression,Encounter Impression
-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 +134,Cost of Sold Asset,Cost of Selges Asset
-DocType: Volunteer,Morning,Morgen
-apps/erpnext/erpnext/accounts/utils.py +350,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.
-DocType: Program Enrollment Tool,New Student Batch,Ny studentbatch
-apps/erpnext/erpnext/stock/doctype/item/item.py +478,{0} entered twice in Item Tax,{0} registrert to ganger i pkt Skatte
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +113,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/public/js/templates/item_quick_entry.html +1,Variant Attributes,Variant attributter
-apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +85,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
-DocType: Supplier Scorecard,Scoring Standings,Scoring Steder
-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"
-DocType: Grant Application,Grant Application,Grant søknad
-apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +69,Total Order Considered,Total Bestill Regnes
-apps/erpnext/erpnext/config/hr.py +243,"Employee designation (e.g. CEO, Director etc.).","Ansatt betegnelse (f.eks CEO, direktør etc.)."
-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 +622,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}
-apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +257,[Urgent] Error while creating recurring %s for %s,[Urgent] Feil mens du oppretter tilbakevendende% s for% s
-DocType: Land Unit,LInked Analysis,Analyse
-DocType: Item Tax,Tax Rate,Skattesats
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +74,Application period cannot be across two allocation records,Søknadsperioden kan ikke være over to allokeringsregister
-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/stock/doctype/purchase_receipt/purchase_receipt.py +141,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}
-DocType: Material Request Plan Item,Material Request Plan Item,Materialforespørselsplan
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +52,Convert to non-Group,Konverter til ikke-konsernet
-DocType: C-Form Invoice Detail,Invoice Date,Fakturadato
-DocType: GL Entry,Debit Amount,Debet Beløp
-apps/erpnext/erpnext/accounts/party.py +249,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 +425,Please see attachment,Vennligst se vedlegg
-DocType: Purchase Order,% Received,% Mottatt
-apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js +3,Create Student Groups,Opprett studentgrupper
-DocType: Volunteer,Weekends,helger
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +113,Credit Note Amount,Kreditt Note Beløp
-DocType: Setup Progress Action,Action Document,Handlingsdokument
-DocType: Chapter Member,Website URL,Website URL
-,Finished Goods,Ferdigvarer
-DocType: Delivery Note,Instructions,Bruksanvisning
-DocType: Quality Inspection,Inspected By,Inspisert av
-DocType: Asset Maintenance Log,Maintenance Type,Vedlikehold Type
-apps/erpnext/erpnext/education/doctype/student_group/student_group.py +45,{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 +20,Add Items,Legg varer
-DocType: Item Quality Inspection Parameter,Item Quality Inspection Parameter,Sak Quality Inspection Parameter
-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
-DocType: Job Offer Term,Job Offer Term,Jobbtilbudsperiode
-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/education/doctype/program_enrollment_tool/program_enrollment_tool.py +15,Mandatory field - Get Students From,Obligatorisk felt - Få studenter fra
-apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +15,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: Opening Invoice Creation Tool Item,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: Healthcare Settings,Require Lab Test Approval,Krever godkjenning av laboratorietest
-DocType: Salary Slip Timesheet,Working Hours,Arbeidstid
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +54,Total Outstanding,Totalt Utestående
-DocType: Naming Series,Change the starting / current sequence number of an existing series.,Endre start / strøm sekvensnummer av en eksisterende serie.
-DocType: Dosage Strength,Strength,Styrke
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1533,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 +90,Create Purchase Orders,Opprette innkjøpsordrer
-,Purchase Register,Kjøp Register
-apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +119,Patient not found,Pasient ikke funnet
-DocType: Scheduling Tool,Rechedule,Rechedule
-DocType: Landed Cost Item,Applicable Charges,Gjeldende avgifter
-DocType: Workstation,Consumable Cost,Forbrukskostnads
-DocType: Purchase Receipt,Vehicle Date,Vehicle Dato
-DocType: Student Log,Medical,Medisinsk
-apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +175,Reason for losing,Grunnen for å tape
-apps/erpnext/erpnext/accounts/doctype/account/account.js +52,Update Account Number,Oppdater kontonummer
-apps/erpnext/erpnext/crm/doctype/lead/lead.py +42,Lead Owner cannot be same as the Lead,Bly Eier kan ikke være det samme som Lead
-apps/erpnext/erpnext/accounts/utils.py +356,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: Lab Test Template,Single,Enslig
-DocType: Salary Slip,Total Loan Repayment,Total Loan Nedbetaling
-DocType: Account,Cost of Goods Sold,Varekostnad
-DocType: Subscription,Yearly,Årlig
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +230,Please enter Cost Center,Skriv inn kostnadssted
-DocType: Drug Prescription,Dosage,Dosering
-DocType: Journal Entry Account,Sales Order,Salgsordre
-apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +69,Avg. Selling Rate,Avg. Salgskurs
-DocType: Assessment Plan,Examiner Name,Examiner Name
-DocType: Lab Test Template,No Result,Ingen resultater
-DocType: Purchase Invoice Item,Quantity and Rate,Kvantitet og Rate
-DocType: Delivery Note,% Installed,% Installert
-apps/erpnext/erpnext/utilities/user_progress.py +227,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: Purchase Invoice,01-Sales Return,01-salgs retur
-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
-apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js +34,Primary Address Details,Primæradresse detaljer
-DocType: Vehicle Service,Oil Change,Oljeskift
-DocType: Asset Maintenance Log,Asset Maintenance Log,Asset Maintenance Log
-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;
-DocType: Chapter,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/education/doctype/program_enrollment_tool/program_enrollment_tool.py +19,Mandatory field - Academic Year,Obligatorisk felt - akademisk år
-apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +19,Mandatory field - Academic Year,Obligatorisk felt - akademisk år
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +215,{0} {1} is not associated with {2} {3},{0} {1} er ikke knyttet til {2} {3}
-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 +174,Please set default payable account for the company {0},Vennligst angi standard betalbar konto for selskapet {0}
-DocType: Setup Progress Action,Min Doc Count,Min Doc-tall
-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 +699,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.
-apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +85,Opening Invoice Item,Åpning av fakturaelement
-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"
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +46,PieceRef,PieceRef
-DocType: Request for Quotation,Message for Supplier,Beskjed til Leverandør
-DocType: Driver,DRIVER-.#####,SJÅFØR-.#####
-DocType: Sales Invoice,Total Qty,Total Antall
-apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +62,Guardian2 Email ID,Guardian2 Email ID
-apps/erpnext/erpnext/education/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: Payroll Entry,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 +46,"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: Patient,AB Positive,AB Positiv
-DocType: Job Opening,Description of a Job Opening,Beskrivelse av en ledig jobb
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +110,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 +132,{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
-DocType: Patient,Allergies,allergi
-apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +33,The selected BOMs are not for the same item,De valgte stykklister er ikke for den samme varen
-DocType: Supplier Scorecard Standing,Notify Other,Varsle Andre
-DocType: Vital Signs,Blood Pressure (systolic),Blodtrykk (systolisk)
-DocType: Pricing Rule,Valid Upto,Gyldig Opp
-DocType: Training Event,Workshop,Verksted
-DocType: Supplier Scorecard Scoring Standing,Warn Purchase Orders,Varsle innkjøpsordrer
-apps/erpnext/erpnext/utilities/user_progress.py +64,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 +23,Enough Parts to Build,Nok Deler bygge
-DocType: POS Profile User,POS Profile User,POS Profil Bruker
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +128,Direct Income,Direkte Inntekt
-DocType: Patient Appointment,Date TIme,Dato tid
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +45,"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/operations/install_fixtures.py +130,Administrative Officer,Administrative Officer
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +39,Setting up company and taxes,Sette opp selskap og skatter
-apps/erpnext/erpnext/education/doctype/student_group/student_group.py +22,Please select Course,Vennligst velg Kurs
-apps/erpnext/erpnext/education/doctype/student_group/student_group.py +22,Please select Course,Vennligst velg Kurs
-DocType: Codification Table,Codification Table,Kodifiseringstabell
-DocType: Timesheet Detail,Hrs,timer
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +349,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 +47,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 +435,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
-DocType: Lab Test Template,Lab Routine,Lab Rutine
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +20,Cosmetics,Kosmetikk
-apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +18,Please select Completion Date for Completed Asset Maintenance Log,Vennligst velg sluttdato for fullført aktivitetsvedlikeholdslogg
-apps/erpnext/erpnext/stock/doctype/item/item.py +551,"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/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +82,{0} {1} does not exist.,{0} {1} eksisterer ikke.
-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/utilities/user_progress.py +177,Student Application,Student søknad
-apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py +20,Please define grade for Threshold 0%,Vennligst definer karakter for Terskel 0%
-apps/erpnext/erpnext/education/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/healthcare/setup.py +256,High Sensitivity,Høy følsomhet
-apps/erpnext/erpnext/config/non_profit.py +48,Volunteer Type information.,Frivillig Type informasjon.
-DocType: Cash Flow Mapping Template,Cash Flow Mapping Template,Cash Flow Mapping Template
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2539,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/healthcare/doctype/lab_test/lab_test.js +104,"Not permitted, configure Lab Test Template as required","Ikke tillatt, konfigurer Lab Test Template etter behov"
-DocType: Patient,Risk Factors,Risikofaktorer
-DocType: Patient,Occupational Hazards and Environmental Factors,Arbeidsfare og miljøfaktorer
-DocType: Vital Signs,Respiratory rate,Respirasjonsfrekvens
-apps/erpnext/erpnext/config/stock.py +334,Managing Subcontracting,Administrerende Underleverandører
-DocType: Vital Signs,Body Temperature,Kroppstemperatur
-DocType: Project,Project will be accessible on the website to these users,Prosjektet vil være tilgjengelig på nettstedet til disse brukerne
-DocType: Detected Disease,Disease,Sykdom
-apps/erpnext/erpnext/config/projects.py +24,Define Project type.,Definer Prosjekttype.
-DocType: Supplier Scorecard,Weighting Function,Vekting Funksjon
-DocType: Physician,OP Consulting Charge,OP-konsulentkostnad
-apps/erpnext/erpnext/utilities/user_progress.py +25,Setup your ,Oppsett din
-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 +70,Account {0} does not belong to company: {1},Konto {0} tilhører ikke selskapet: {1}
-apps/erpnext/erpnext/setup/doctype/company/company.py +52,Abbreviation already used for another company,Forkortelse allerede brukt for et annet selskap
-DocType: Selling Settings,Default Customer Group,Standard Kundegruppe
-DocType: Asset Repair,ARLOG-,ARLOG-
-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: Crop,Produced Items,Produserte varer
-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: Company,Delete Company Transactions,Slett transaksjoner
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +357,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: Payment Entry Reference,Supplier Invoice No,Leverandør Faktura Nei
-DocType: Territory,For reference,For referanse
-DocType: Healthcare Settings,Appointment Confirmation,Avtalebekreftelse
-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 +256,Closing (Cr),Lukking (Cr)
-apps/erpnext/erpnext/hr/email_alert/training_feedback/training_feedback.html +1,Hello,Hallo
-apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +118,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 +397,{0} {1} is not active,{0} {1} er ikke aktiv
-apps/erpnext/erpnext/config/accounts.py +272,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 +160,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
-apps/erpnext/erpnext/config/buying.py +150,All Supplier scorecards.,Alle leverandørens scorecards.
-DocType: Buying Settings,Purchase Receipt Required,Kvitteringen Påkrevd
-apps/erpnext/erpnext/stock/doctype/item/item.py +154,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 +143,No records found in the Invoice table,Ingen poster ble funnet i Faktura tabellen
-apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js +34,Please select Company and Party Type first,Vennligst velg først selskapet og Party Type
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +31,"Already set default in pos profile {0} for user {1}, kindly disabled default","Sett allerede standard i pos profil {0} for bruker {1}, vennligst deaktivert standard"
-apps/erpnext/erpnext/config/accounts.py +293,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/accounts/doctype/pos_profile/pos_profile.py +72,Territory is Required in POS Profile,Område er påkrevd i POS-profil
-DocType: Supplier,Prevent RFQs,Forhindre RFQs
-apps/erpnext/erpnext/utilities/activation.py +83,Make Sales Order,Gjør Salgsordre
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +168,Salary Slip submitted for period from {0} to {1},Lønnsslipp legges inn for perioden fra {0} til {1}
-DocType: Project Task,Project Task,Prosjektet Task
-,Lead Id,Lead Id
-DocType: C-Form Invoice Detail,Grand Total,Grand Total
-DocType: Assessment Plan,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 +76,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/public/js/utils/item_quick_entry.js +108,Create Variant,Opprett variant
-DocType: Sales Invoice,Shipping Bill Date,Fraktregningsdato
-DocType: Production Order,Production Plan,Produksjonsplan
-DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,Åpning av fakturaopprettingsverktøy
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +853,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)
-DocType: Healthcare Settings,Confirmation Message,Bekreftelsesmelding
-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 +228,Opening (Cr),Åpning (Cr)
-apps/erpnext/erpnext/stock/doctype/item/item.py +871,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 +354,Allocated amount can not be negative,Bevilget beløpet kan ikke være negativ
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +11,Please set the Company,Vennligst sett selskapet
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +11,Please set the Company,Vennligst sett selskapet
-DocType: Share Balance,Share Balance,Andelsbalanse
-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
-apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +60,Total Outstanding: {0},Totalt utestående: {0}
-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: Payroll Entry,Select Payment Account to make Bank Entry,Velg betalingskonto å lage Bank Entry
-DocType: Hotel Settings,Default Invoice Naming Series,Standard Faktura Naming Series
-apps/erpnext/erpnext/utilities/activation.py +136,"Create Employee records to manage leaves, expense claims and payroll","Lag personalregistre for å håndtere blader, refusjonskrav og lønn"
-DocType: Restaurant Reservation,Restaurant Reservation,Restaurantreservasjon
-DocType: Land Unit,Land Unit Name,Land Enhetsnavn
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +190,Proposal Writing,Forslaget Writing
-DocType: Payment Entry Deduction,Payment Entry Deduction,Betaling Entry Fradrag
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +14,Wrapping up,Innpakning
-apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +35,Notify Customers via Email,Meld kundene via e-post
-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: Employee Advance,Claimed Amount,Påkrevd beløp
-apps/erpnext/erpnext/config/education.py +176,Masters,Masters
-DocType: Assessment Plan,Maximum Assessment Score,Maksimal Assessment Score
-apps/erpnext/erpnext/config/accounts.py +138,Update Bank Transaction Dates,Oppdater Banktransaksjons Datoer
-apps/erpnext/erpnext/config/projects.py +36,Time Tracking,Time Tracking
-DocType: Purchase Invoice,DUPLICATE FOR TRANSPORTER,DUPLIKERER FOR TRANSPORTER
-apps/erpnext/erpnext/hr/doctype/employee_advance/employee_advance.py +49,Row {0}# Paid Amount cannot be greater than requested advance amount,Rå {0} # Betalt beløp kan ikke være større enn ønsket beløp
-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/education/doctype/student_group_creation_tool/student_group_creation_tool.js +12,Creating student groups,Opprette studentgrupper
-apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js +12,Creating student groups,Opprette studentgrupper
-apps/erpnext/erpnext/accounts/utils.py +727,"Payment Gateway Account not created, please create one manually.","Betaling Gateway konto ikke opprettet, kan du opprette en manuelt."
-DocType: Supplier Scorecard,Per Year,Per år
-apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +51,Not eligible for the admission in this program as per DOB,Ikke kvalifisert for opptak i dette programmet i henhold til DOB
-DocType: Sales Invoice,Sales Taxes and Charges,Salgs Skatter og avgifter
-DocType: Employee,Organization Profile,Organisasjonsprofil
-DocType: Vital Signs,Height (In Meter),Høyde (i meter)
-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 +152,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/assets/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 +29,Net Change in Inventory,Netto endring i varelager
-apps/erpnext/erpnext/config/hr.py +162,Employee Loan Management,Ansattes lån Ledelse
-DocType: Employee,Passport Number,Passnummer
-apps/erpnext/erpnext/education/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/operations/install_fixtures.py +124,Manager,Manager
-DocType: Payment Entry,Payment From / To,Betaling fra / til
-apps/erpnext/erpnext/selling/doctype/customer/customer.py +177,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}
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +428,Please set account in Warehouse {0},Vennligst sett inn konto i Lager {0}
-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: Lab Test Template,Compound,forbindelse
-DocType: Student Batch Name,Batch Name,batch Name
-DocType: Fee Validity,Max number of visit,Maks antall besøk
-,Hotel Room Occupancy,Hotellrom Occupancy
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +358,Timesheet created:,Timeregistrering opprettet:
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +931,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/education/doctype/student_applicant/student_applicant.js +24,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: Delivery Trip,TOUR-.#####,TOUR -. #####
-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: 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/data/industry_type.py +43,Publishing,Publisering
-DocType: Accounts Settings,Report Settings,Rapporter innstillinger
-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 +158,{0}: {1} not found in Invoice Details table,{0}: {1} ble ikke funnet i Fakturadetaljer tabellen
-DocType: Asset,Asset Owner Company,Asset Owner Company
-DocType: Company,Round Off Cost Center,Rund av kostnadssted
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +242,Maintenance Visit {0} must be cancelled before cancelling this Sales Order,Vedlikehold Besøk {0} må avbestilles før den avbryter denne salgsordre
-DocType: Asset Maintenance Log,AML-,AML-
-DocType: Item,Material Transfer,Material Transfer
-apps/erpnext/erpnext/buying/doctype/supplier_scorecard_variable/supplier_scorecard_variable.py +24,Could not find path for ,Kunne ikke finne banen for
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +221,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}
-apps/erpnext/erpnext/config/accounts.py +39,To make recurring documents,Å gjøre gjentatte dokumenter
-,GST Itemised Purchase Register,GST Artized Purchase Register
-DocType: Course Scheduling Tool,Reschedule,Planlegge på nytt
-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 +316,Finish,Bli ferdig
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +412,Base,Utgangspunkt
-DocType: Timesheet,Total Billed Hours,Totalt fakturert timer
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1526,Write Off Amount,Skriv Off Beløp
-DocType: Leave Block List Allow,Allow User,Tillat User
-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: Subscription,Quarterly,Quarterly
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +47,EcritureLib,EcritureLib
-DocType: Lab Test Template,Grouped,gruppert
-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å
-DocType: Sales Invoice,Port Code,Portkode
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +948,Reserve Warehouse,Reserve Warehouse
-DocType: Lead,Lead is an Organization,Bly er en organisasjon
-DocType: Guardian Interest,Interest,Renter
-apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +10,Pre Sales,Før salg
-DocType: Instructor Log,Other Details,Andre detaljer
-apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +18,Suplier,suplier
-DocType: Lab Test,Test Template,Testmal
-DocType: Restaurant Order Entry Item,Served,serveres
-apps/erpnext/erpnext/config/non_profit.py +13,Chapter information.,Kapittelinformasjon.
-DocType: Account,Accounts,Kontoer
-DocType: Vehicle,Odometer Value (Last),Kilometerstand (Siste)
-apps/erpnext/erpnext/config/buying.py +160,Templates of supplier scorecard criteria.,Maler med leverandørpoengkriterier.
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +109,Marketing,Markedsføring
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +290,Payment Entry is already created,Betaling Entry er allerede opprettet
-DocType: Request for Quotation,Get Suppliers,Få leverandører
-DocType: Purchase Receipt Item Supplied,Current Stock,Nåværende Stock
-apps/erpnext/erpnext/controllers/accounts_controller.py +609,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 +394,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
-apps/erpnext/erpnext/non_profit/doctype/membership/membership.py +37,You can only renew if your membership expires within 30 days,Du kan bare fornye hvis medlemskapet ditt utløper innen 30 dager
-DocType: Land Unit,Longitude,lengde~~POS=TRUNC
-,Absent Student Report,Fraværende Student Rapporter
-DocType: Crop,Crop Spacing UOM,Beskjære plassering UOM
-DocType: Accounts Settings,Only select if you have setup Cash Flow Mapper documents,Bare velg hvis du har installert Cash Flow Mapper-dokumenter
-DocType: Email Digest,Next email will be sent on:,Neste post vil bli sendt på:
-DocType: Supplier Scorecard,Per Week,Per uke
-apps/erpnext/erpnext/stock/doctype/item/item.py +665,Item has variants.,Elementet har varianter.
-apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +154,Total Student,Totalt Student
-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/education/doctype/fee_schedule/fee_schedule.js +42,Fee records will be created in the background. In case of any error the error message will be updated in the Schedule.,Avgiftsposter vil bli opprettet i bakgrunnen. Ved feil vil feilmeldingen bli oppdatert i Schedule.
-apps/erpnext/erpnext/accounts/doctype/account/account.py +239,Company {0} does not exist,Selskapet {0} finnes ikke
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +40,{0} has fee validity till {1},{0} har gebyrgyldighet til {1}
-apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +57,Tree Type,Tre Type
-DocType: BOM Explosion Item,Qty Consumed Per Unit,Antall som forbrukes per enhet
-DocType: GST Account,IGST Account,IGST-konto
-DocType: Serial No,Warranty Expiry Date,Garantiutløpsdato
-DocType: Material Request Item,Quantity and Warehouse,Kvantitet og Warehouse
-DocType: Hub Settings,Unregister,Avregistrer
-DocType: Sales Invoice,Commission Rate (%),Kommisjonen Rate (%)
-apps/erpnext/erpnext/education/doctype/student_group/student_group.py +24,Please select Program,Vennligst velg Program
-apps/erpnext/erpnext/education/doctype/student_group/student_group.py +24,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
-DocType: Hub Settings,Publish,publisere
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +7,Aerospace,Aerospace
-,Fichier des Ecritures Comptables [FEC],Fichier des Ecritures Comptables [FEC]
-DocType: Journal Entry,Credit Card Entry,Kredittkort Entry
-apps/erpnext/erpnext/config/accounts.py +57,Company and Accounts,Selskapet og regnskap
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +70,In Value,i Verdi
-DocType: Asset Settings,Depreciation Options,Avskrivningsalternativer
-apps/erpnext/erpnext/utilities/transaction_base.py +35,Invalid Posting Time,Ugyldig innleggstid
-DocType: Lead,Campaign Name,Kampanjenavn
-DocType: Hotel Room,Capacity,Kapasitet
-DocType: Selling Settings,Close Opportunity After Days,Lukk mulighet da Days
-,Reserved,Reservert
-DocType: Driver,License Details,Lisensdetaljer
-apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +85,The field From Shareholder cannot be blank,Feltet fra Aksjonær kan ikke være tomt
-DocType: Purchase Order,Supply Raw Materials,Leverer råvare
-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 +108,{0} is not a stock Item,{0} er ikke en lagervare
-apps/erpnext/erpnext/hr/email_alert/training_feedback/training_feedback.html +6,Please share your feedback to the training by clicking on 'Training Feedback' and then 'New',Vennligst del din tilbakemelding til treningen ved å klikke på &#39;Trenings tilbakemelding&#39; og deretter &#39;Ny&#39;
-DocType: Mode of Payment Account,Default Account,Standard konto
-apps/erpnext/erpnext/stock/doctype/item/item.py +272,Please select Sample Retention Warehouse in Stock Settings first,Vennligst velg Sample Retention Warehouse i lagerinnstillinger først
-DocType: Payment Entry,Received Amount (Company Currency),Mottatt beløp (Selskap Valuta)
-apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +192,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: Patient,O Negative,O Negativ
-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 +93,Account with existing transaction cannot be converted to ledger,Konto med eksisterende transaksjon kan ikke konverteres til Ledger
-apps/erpnext/erpnext/config/non_profit.py +33,Memebership Type Details,Memebership Type Detaljer
-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/hr/doctype/payroll_entry/payroll_entry.py +445,There's no employee for the given criteria. Check that Salary Slips have not already been created.,Det er ingen ansatt for de oppgitte kriteriene. Sjekk at Lønnslister ikke allerede er opprettet.
-apps/erpnext/erpnext/stock/reorder_item.py +194,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
-DocType: Soil Texture,Sand,Sand
-apps/erpnext/erpnext/setup/setup_wizard/data/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 +887,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}.
-apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +79,Please select a table,Vennligst velg en tabell
-DocType: BOM,Website Specifications,Nettstedet Spesifikasjoner
-apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +78,{0} is an invalid email address in 'Recipients',{0} er en ugyldig e-postadresse i &quot;Mottakere&quot;
-DocType: Special Test Items,Particulars,opplysninger
-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 +310,Row {0}: Conversion Factor is mandatory,Rad {0}: Omregningsfaktor er obligatorisk
-DocType: Student,A+,A +
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +344,"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 +514,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: Asset,Maintenance,Vedlikehold
-DocType: Item Attribute Value,Item Attribute Value,Sak data Verdi
-DocType: Item,Maximum sample quantity that can be retained,Maksimal prøvemengde som kan beholdes
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +405,Row {0}# Item {1} cannot be transferred more than {2} against Purchase Order {3},Row {0} # Item {1} kan ikke overføres mer enn {2} mot innkjøpsordre {3}
-apps/erpnext/erpnext/config/selling.py +158,Sales campaigns.,Salgskampanjer.
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +117,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: Lab Test,Lab Test,Lab Test
-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/healthcare/doctype/physician_schedule/physician_schedule.js +26,Add Timeslots,Legg til Timeslots
-apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +138,Asset scrapped via Journal Entry {0},Asset kasserte via bilagsregistrering {0}
-DocType: Employee Loan,Interest Income Account,Renteinntekter konto
-apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.py +58,Review Invitation Sent,Gjennomgå invitasjon sendt
-apps/erpnext/erpnext/setup/setup_wizard/data/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/utilities/user_progress.py +51,Go to ,Gå til
-apps/erpnext/erpnext/config/learn.py +47,Setting up Email Account,Sette opp e-postkonto
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js +21,Please enter Item first,Skriv inn Sak først
-DocType: Asset Repair,Downtime,nedetid
-DocType: Account,Liability,Ansvar
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +218,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}.
-apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +11,Academic Term: ,Faglig semester:
-DocType: Salary Detail,Do not include in total,Ikke inkluder i alt
-DocType: Company,Default Cost of Goods Sold Account,Standard varekostnader konto
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1005,Sample quantity {0} cannot be more than received quantity {1},Prøvekvantitet {0} kan ikke være mer enn mottatt mengde {1}
-apps/erpnext/erpnext/stock/get_item_details.py +369,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 +227,Warning: Invalid Attachment {0},Advarsel: Ugyldig Vedlegg {0}
-DocType: Item,Max Sample Quantity,Maks antall prøver
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +766,No Permission,Ingen tillatelse
-DocType: Vital Signs,Heart Rate / Pulse,Hjertefrekvens / puls
-DocType: Company,Default Bank Account,Standard Bank Account
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +59,"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/utilities/user_progress.py +143,Nos,Nos
-DocType: Item,Items with higher weightage will be shown higher,Elementer med høyere weightage vil bli vist høyere
-apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +14,Lab Tests and Vital Signs,Lab Tests og Vital Signs
-DocType: Bank Reconciliation Detail,Bank Reconciliation Detail,Bankavstemming Detalj
-apps/erpnext/erpnext/controllers/accounts_controller.py +613,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: Subscription,Stopped,Stoppet
-DocType: Item,If subcontracted to a vendor,Dersom underleverandør til en leverandør
-apps/erpnext/erpnext/education/doctype/student_group/student_group.js +111,Student Group is already updated.,Studentgruppen er allerede oppdatert.
-apps/erpnext/erpnext/education/doctype/student_group/student_group.js +111,Student Group is already updated.,Studentgruppen er allerede oppdatert.
-DocType: SMS Center,All Customer Contact,All Kundekontakt
-DocType: Land Unit,Tree Details,Tree Informasjon
-DocType: Training Event,Event Status,Hendelses Status
-DocType: Volunteer,Availability Timeslot,Tilgjengelighet Timeslot
-,Support Analytics,Støtte Analytics
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +352,"If you have any questions, please get back to us.","Hvis du har spørsmål, kan du komme tilbake til oss."
-DocType: Cash Flow Mapper,Cash Flow Mapper,Cash Flow Mapper
-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/utilities/user_progress.py +89,Upload your letter head (Keep it web friendly as 900px by 100px),Last opp brevhodet ditt (Hold det nettvennlig som 900px ved 100px)
-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 +63,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 +295,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: Item Variant Settings,Copy Fields to Variant,Kopier felt til variant
-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 +335,C-Form records,C-Form poster
-apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +73,The shares already exist,Aksjene eksisterer allerede
-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 +354,Thank you for your business!,Takk for handelen!
-apps/erpnext/erpnext/config/support.py +12,Support queries from customers.,Støtte henvendelser fra kunder.
-DocType: Setup Progress Action,Action Doctype,Handling Doctype
-,Production Order Stock Report,Produksjonsordre aksjerapport
-DocType: HR Settings,Retirement Age,Pensjonsalder
-DocType: Bin,Moving Average Rate,Moving Gjennomsnittlig pris
-DocType: Production Plan,Select Items,Velg Items
-DocType: Share Transfer,To Shareholder,Til Aksjonær
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +372,{0} against Bill {1} dated {2},{0} mot Bill {1} datert {2}
-apps/erpnext/erpnext/utilities/user_progress.py +24,Setup Institution,Oppsettinstitusjon
-DocType: Program Enrollment,Vehicle/Bus Number,Kjøretøy / bussnummer
-apps/erpnext/erpnext/education/doctype/course/course.js +17,Course Schedule,Kursplan
-DocType: Request for Quotation Supplier,Quote Status,Sitatstatus
-DocType: Maintenance Visit,Completion Status,Completion Status
-DocType: Daily Work Summary Group,Select Users,Velg Brukere
-DocType: Hotel Room Pricing Item,Hotel Room Pricing Item,Hotellromprisepris
-DocType: HR Settings,Enter retirement age in years,Skriv inn pensjonsalder i år
-DocType: Crop,Target Warehouse,Target Warehouse
-DocType: Payroll Employee Detail,Payroll Employee Detail,Lønnspersonelldetaljer
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +128,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 +113,All Item Groups,Alle varegrupper
-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/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +44,CompteLib,CompteLib
-apps/erpnext/erpnext/buying/utils.py +80,{0} {1} status is {2},{0} {1} status er {2}
-DocType: Water Analysis,Collection Temperature ,Samlingstemperatur
-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
-DocType: Drug Prescription,Interval UOM,Intervall UOM
-DocType: Customer,"Reselect, if the chosen address is edited after save",Velg hvis den valgte adressen redigeres etter lagre
-apps/erpnext/erpnext/stock/doctype/item/item.js +492,Item Variant {0} already exists with same attributes,Sak Variant {0} finnes allerede med samme attributtene
-DocType: Item,Hub Publishing Details,Hub Publishing Detaljer
-apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +114,'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: Lab Test Template,Result Format,Resultatformat
-DocType: Expense Claim,Expenses,Utgifter
-DocType: Item Variant Attribute,Item Variant Attribute,Sak Variant Egenskap
-,Purchase Receipt Trends,Kvitteringen Trender
-DocType: Payroll Entry,Bimonthly,annenhver måned
-DocType: Vehicle Service,Brake Pad,Bremsekloss
-DocType: Fertilizer,Fertilizer Contents,Innhold av gjødsel
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +119,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
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +93,BOM #{0}: Raw material cannot be same as main Item,BOM # {0}: Råmateriale kan ikke være det samme som hovedelementet
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +92,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: Volunteer,Evening,Kveld
-DocType: Customer,Bypass credit limit check at Sales Order,Bypass kredittgrense sjekke på salgsordre
-apps/erpnext/erpnext/config/hr.py +147,Performance appraisal.,Medarbeidersamtaler.
-apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +99,"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 +411,"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: Fee Schedule,Fee Creation Status,Fee Creation Status
-DocType: Vehicle Log,Odometer Reading,Kilometerteller Reading
-apps/erpnext/erpnext/accounts/doctype/account/account.py +116,"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: Setup Progress Action,Action Field,Handlingsfelt
-DocType: Healthcare Settings,Manage Customer,Administrer kunde
-DocType: Delivery Trip,Delivery Stops,Levering stopper
-DocType: Salary Slip,Working Days,Arbeidsdager
-DocType: Serial No,Incoming Rate,Innkommende Rate
-DocType: Packing Slip,Gross Weight,Bruttovekt
-,Final Assessment Grades,Final Assessment Grades
-apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +47,Enable Hub,Aktiver nav
-apps/erpnext/erpnext/public/js/setup_wizard.js +110,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
-apps/erpnext/erpnext/setup/setup_wizard/operations/sample_data.py +108,Setup your Institute in ERPNext,Oppsett ditt institutt i ERPNext
-DocType: Agriculture Analysis Criteria,Plant Analysis,Plantanalyse
-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: Restaurant Table,Minimum Seating,Minimum sitteplasser
-DocType: Item Attribute,Item Attribute Values,Sak attributtverdier
-DocType: Examination Result,Examination Result,Sensur
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +845,Purchase Receipt,Kvitteringen
-,Received Items To Be Billed,Mottatte elementer å bli fakturert
-apps/erpnext/erpnext/config/accounts.py +303,Currency exchange rate master.,Valutakursen mester.
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +204,Reference Doctype must be one of {0},Referanse DOCTYPE må være en av {0}
-apps/erpnext/erpnext/stock/report/warehouse_wise_item_balance_age_and_value/warehouse_wise_item_balance_age_and_value.js +46,Filter Total Zero Qty,Filter totalt null antall
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +341,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 +595,BOM {0} must be active,BOM {0} må være aktiv
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +409,No Items available for transfer,Ingen elementer tilgjengelig for overføring
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +218,Closing (Opening + Total),Avslutning (Åpning + Totalt)
-DocType: Journal Entry,Depreciation Entry,avskrivninger Entry
-apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +32,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
-DocType: Crop Cycle,ISO 8016 standard,ISO 8016 standard
-DocType: Pricing Rule,Rate or Discount,Pris eller rabatt
-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 +127,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/data/industry_type.py +32,Internet Publishing,Internett Publisering
-DocType: Prescription Duration,Number,Antall
-apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +25,Creating {0} Invoice,Opprette {0} faktura
-DocType: Medical Code,Medical Code Standard,Medisinskode Standard
-DocType: Soil Texture,Clay Composition (%),Leirekomposisjon (%)
-apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js +81,Please save before assigning task.,Vennligst lagre før du tilordner oppgaven.
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +74,Balance Value,Balanse Verdi
-DocType: Lab Test,Lab Technician,Lab tekniker
-apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +38,Sales Price List,Salg Prisliste
-DocType: Healthcare Settings,"If checked, a customer will be created, mapped to Patient.
-Patient Invoices will be created against this Customer. You can also select existing Customer while creating Patient.","Hvis det er merket, vil en kunde bli opprettet, kartlagt til Pasient. Pasientfakturaer vil bli opprettet mot denne kunden. Du kan også velge eksisterende kunde mens du oppretter pasient."
-DocType: Bank Reconciliation,Account Currency,Account Valuta
-DocType: Lab Test,Sample ID,Eksempel ID
-apps/erpnext/erpnext/accounts/general_ledger.py +165,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
-DocType: Item Barcode,Item Barcode,Sak Barcode
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +329,Please enter Asset Category in Item {0},Fyll inn Asset kategori i Element {0}
-apps/erpnext/erpnext/stock/doctype/item/item.py +660,Item Variants {0} updated,Sak Varianter {0} oppdatert
-DocType: Quality Inspection Reading,Reading 6,Reading 6
-apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +9,"to be generated. If delayed, you will have to manually change the ""Repeat on Day of Month"" field
-of this","å bli generert. Hvis forsinket, må du manuelt endre feltet Repeter på dag i måneden av dette"
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +945,Cannot {0} {1} {2} without any negative outstanding invoice,Kan ikke {0} {1} {2} uten noen negativ utestående faktura
-DocType: Share Transfer,From Folio No,Fra Folio nr
-DocType: Purchase Invoice Advance,Purchase Invoice Advance,Fakturaen Advance
-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 +246,Define budget for a financial year.,Definer budsjett for et regnskapsår.
-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?
-DocType: Payment Terms Template,Payment Terms Template,Betalingsbetingelser mal
-apps/erpnext/erpnext/public/js/setup_wizard.js +51,The Brand,The Brand
-DocType: Employee,Exit Interview Details,Exit Intervju Detaljer
-DocType: Item,Is Purchase Item,Er Purchase Element
-DocType: Journal Entry Account,Purchase Invoice,Fakturaen
-DocType: Stock Ledger Entry,Voucher Detail No,Kupong Detail Ingen
-apps/erpnext/erpnext/accounts/page/pos/pos.js +789,New Sales Invoice,Ny salgsfaktura
-DocType: Stock Entry,Total Outgoing Value,Total Utgående verdi
-DocType: Physician,Appointments,avtaler
-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
-DocType: Sales Invoice Item,Rate With Margin (Company Currency),Vurder med margin (Bedriftsvaluta)
-apps/erpnext/erpnext/accounts/page/pos/pos.js +802,Sync Offline Invoices,Synkroniser Offline Fakturaer
-DocType: Payment Request,Paid,Betalt
-DocType: Program Fee,Program Fee,program Fee
-DocType: BOM Update Tool,"Replace a particular BOM in all other BOMs where it is used. It will replace the old BOM link, update cost and regenerate ""BOM Explosion Item"" table as per new BOM.
-It also updates latest price in all the BOMs.","Bytt ut en bestemt BOM i alle andre BOM-er der den brukes. Det vil erstatte den gamle BOM-lenken, oppdatere kostnadene og regenerere &quot;BOM Explosion Item&quot; -tabellen som per ny BOM. Det oppdaterer også siste pris i alle BOMene."
-DocType: Salary Slip,Total in words,Totalt i ord
-DocType: Material Request Item,Lead Time Date,Lead Tid Dato
-DocType: Asset,Available-for-use Date,Tilgjengelig dato for bruk
-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 +75, 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 +126,Row #{0}: Please specify Serial No for Item {1},Row # {0}: Vennligst oppgi serienummer for varen {1}
-DocType: Crop Cycle,Crop Cycle,Beskjæringssyklus
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +633,"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: Student Admission,Publish on website,Publiser på nettstedet
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +651,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
-DocType: Agriculture Task,Agriculture Task,Landbruk Oppgave
-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: Restaurant Menu,Price List (Auto created),Prisliste (automatisk opprettet)
-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)
-DocType: Share Balance,Purchased,kjøpt
-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: Agriculture Analysis Criteria,Soil Texture,Jordstruktur
-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/data/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 +783,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/utilities/user_progress.py +144,Meter,Måler
-DocType: Workstation,Electricity Cost,Elektrisitet Cost
-apps/erpnext/erpnext/agriculture/doctype/water_analysis/water_analysis.py +22,Lab testing datetime cannot be before collection datetime,Labtesting datetime kan ikke være før datetime samling
-DocType: HR Settings,Don't send Employee Birthday Reminders,Ikke send Employee bursdagspåminnelser
-DocType: Expense Claim,Total Advance Amount,Total forhåndsbeløp
-DocType: Delivery Stop,Estimated Arrival,forventet ankomst
-apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +34,Save Settings,Lagre innstillinger
-DocType: Delivery Stop,Notified by Email,Meldes via e-post
-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 +52,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/assets/doctype/asset/asset.py +88,Next Depreciation Date is entered as past date,Neste avskrivningsdato legges inn som siste dato
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +208,White,Hvit
-DocType: SMS Center,All Lead (Open),All Lead (Open)
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +257,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})
-apps/erpnext/erpnext/accounts/doctype/cash_flow_mapping/cash_flow_mapping.py +18,You can only select a maximum of one option from the list of check boxes.,Du kan bare velge maksimalt ett alternativ fra listen med avmerkingsbokser.
-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 +635,Assigning {0} to {1} (row {2}),Tilordne {0} til {1} (rad {2})
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +810,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/hr/doctype/employee/employee_tree.js +29,New Employee,Ny ansatt
-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 +129,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
-DocType: Healthcare Settings,Appointment Reminder,Avtale påminnelse
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +478,Please enter Account for Change Amount,Vennligst oppgi konto for Change Beløp
-DocType: Program Enrollment Tool Student,Student Batch Name,Student Batch Name
-DocType: Consultation,Doctor,Doktor
-DocType: Holiday List,Holiday List Name,Holiday Listenavn
-DocType: Repayment Schedule,Balance Loan Amount,Balanse Lånebeløp
-apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +14,Schedule Course,Schedule Course
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +235,Stock Options,Aksjeopsjoner
-DocType: Buying Settings,Disable Fetching Last Purchase Details in Purchase Order,Deaktiver Henting av siste innkjøpsdetaljer i innkjøpsordre
-DocType: Journal Entry Account,Expense Claim,Expense krav
-apps/erpnext/erpnext/assets/doctype/asset/asset.js +267,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 +381,Qty for {0},Antall for {0}
-DocType: Leave Application,Leave Application,La Application
-DocType: Patient,Patient Relation,Pasientrelasjon
-apps/erpnext/erpnext/config/hr.py +80,Leave Allocation Tool,La Allocation Tool
-DocType: Item,Hub Category to Publish,Hub kategori for publisering
-DocType: Leave Block List,Leave Block List Dates,La Block List Datoer
-DocType: Sales Invoice,Billing Address GSTIN,Faktureringsadresse GSTIN
-DocType: Assessment Plan,Evaluate,Evaluere
-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: Supplier Scorecard Period,Criteria,kriterier
-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 +73,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.js +386,Variant creation has been queued.,Variantskaping har vært i kø.
-apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py +100,Work Summary for {0},Arbeidssammendrag for {0}
-apps/erpnext/erpnext/stock/doctype/item/item.py +695,Attribute table is mandatory,Attributt tabellen er obligatorisk
-DocType: Production Plan,Get Sales Orders,Få salgsordrer
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +68,{0} can not be negative,{0} kan ikke være negativ
-DocType: Training Event,Self-Study,Selvstudium
-apps/erpnext/erpnext/agriculture/doctype/soil_texture/soil_texture.py +26,Soil compositions do not add up to 100,Jordblandinger legger ikke opp til 100
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +554,Discount,Rabatt
-DocType: Membership,Membership,Medlemskap
-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: Asset Maintenance,Maintenance Manager Name,Vedlikeholdsansvarlig navn
-DocType: Agriculture Task,Urgent,Haster
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +174,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/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py +84,Unable to find variable: ,Kan ikke finne variabel:
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +790,Please select a field to edit from numpad,Vennligst velg et felt for å redigere fra numpad
-apps/erpnext/erpnext/stock/doctype/item/item.py +263,Cannot be a fixed asset item as Stock Ledger is created.,Kan ikke være en fast eiendelsobjekt når lagerboksen er opprettet.
-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: Quality Inspection Template,Quality Inspection Template Name,Kvalitetsinspeksjonsmalnavn
-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 +71,Selling Amount,Selge Beløp
-DocType: Repayment Schedule,Interest Amount,rente~~POS=TRUNC
-DocType: Serial No,Creation Document No,Creation Dokument nr
-DocType: Share Transfer,Issue,Problem
-apps/erpnext/erpnext/healthcare/doctype/consultation/consultation_dashboard.py +11,Records,Records
-DocType: Asset,Scrapped,skrotet
-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 +61,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
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +858,Delivery Trip,Leveringsreise
-DocType: Student,A-,EN-
-DocType: Share Transfer,Transfer Type,Overføringstype
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +117,Sales Expenses,Salgs Utgifter
-DocType: Consultation,Diagnosis,Diagnose
-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 +1623,ZIP Code,Post kode
-apps/erpnext/erpnext/controllers/selling_controller.py +251,Sales Order {0} is {1},Salgsordre {0} er {1}
-DocType: Opportunity,Contact Info,Kontaktinfo
-apps/erpnext/erpnext/config/stock.py +319,Making Stock Entries,Making Stock Entries
-DocType: Packing Slip,Net Weight UOM,Vekt målenheter
-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
-apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +337,Invoice can't be made for zero billing hour,Fakturaen kan ikke gjøres for null faktureringstid
-DocType: Sales Person,Select company name first.,Velg firmanavn først.
-apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +189,Email sent to {0},E-post sendt til {0}
-apps/erpnext/erpnext/config/buying.py +23,Quotations received from Suppliers.,Sitater mottatt fra leverandører.
-apps/erpnext/erpnext/config/manufacturing.py +74,Replace BOM and update latest price in all BOMs,Erstatt BOM og oppdater siste pris i alle BOMs
-apps/erpnext/erpnext/controllers/selling_controller.py +27,To {0} | {1} {2},Til {0} | {1} {2}
-DocType: Delivery Trip,Driver Name,Drivernavn
-apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +40,Average Age,Gjennomsnittsalder
-DocType: Education Settings,Attendance Freeze Date,Deltagelsesfrysedato
-DocType: Education Settings,Attendance Freeze Date,Deltagelsesfrysedato
-apps/erpnext/erpnext/utilities/user_progress.py +107,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 +59,All BOMs,alle stykklister
-apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.py +35,Hotel Rooms of type {0} are unavailable on {1},Hotellrom av typen {0} er utilgjengelig på {1}
-DocType: Patient,Default Currency,Standard Valuta
-DocType: Expense Claim,From Employee,Fra Employee
-DocType: Driver,Cellphone Number,Mobiltelefonnummer
-apps/erpnext/erpnext/controllers/accounts_controller.py +471,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 +94,Invalid Attribute,Ugyldig Egenskap
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +235,{0} {1} must be submitted,{0} {1} må sendes
-apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +159,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
-DocType: Employee Advance,Claimed,hevdet
-DocType: Crop,Row Spacing,Row Spacing
-apps/erpnext/erpnext/controllers/buying_controller.py +164,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 +38,Contribution %,Bidrag%
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +215,"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 +252,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 +71,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 +228,Project Collaboration Invitation,Prosjekt Samarbeid Invitasjon
-DocType: Salary Slip,Deductions,Fradrag
-DocType: Leave Allocation,LAL/,LAL /
-DocType: Setup Progress Action,Action Name,Handlingsnavn
-apps/erpnext/erpnext/public/js/financial_statements.js +75,Start Year,start-år
-apps/erpnext/erpnext/regional/india/utils.py +25,First 2 digits of GSTIN should match with State number {0},De to første sifrene i GSTIN skal samsvare med statens nummer {0}
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +63,PDC/LC,PDC / LC
-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 +385,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 +428,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 +552,Nothing to request,Ingenting å be om
-apps/erpnext/erpnext/public/js/setup_wizard.js +18,Select your Domains,Velg domenene dine
-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}
-DocType: Item Variant Settings,Fields will be copied over only at time of creation.,Feltene vil bli kopiert bare på tidspunktet for opprettelsen.
-DocType: Setup Progress Action,Domains,Domener
-apps/erpnext/erpnext/projects/doctype/task/task.py +41,'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/operations/install_fixtures.py +117,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/buying/doctype/purchase_order/purchase_order.py +92,Caution,Forsiktighet
-apps/erpnext/erpnext/agriculture/doctype/disease/disease.py +16,Start day is greater than end day in task '{0}',Startdagen er større enn sluttdagen i oppgaven &#39;{0}&#39;
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +815,Return / Debit Note,Retur / debitnota
-DocType: Price List Country,Price List Country,Prisliste Land
-DocType: Item,UOMs,UOMs
-apps/erpnext/erpnext/stock/utils.py +212,{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.
-DocType: Purchase Invoice Item,UOM Conversion Factor,Målenheter Omregningsfaktor
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +40,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/non_profit.py +73,Grant information.,Gi informasjon.
-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 +750,Cost Center For Item with Item Code ',Koste Center For Element med Element kode &#39;
-DocType: Fee Validity,Valid Till,Gyldig til
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2500,"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."
-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 +30,"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 +105,Stock Entry {0} created,Stock Entry {0} er opprettet
-apps/erpnext/erpnext/controllers/buying_controller.py +316,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
-apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +63,Updating estimated arrival times.,Oppdaterer estimerte ankomsttider.
-DocType: Program Enrollment Tool,Enrollment Details,Registreringsdetaljer
-DocType: Purchase Invoice Item,Net Rate,Net Rate
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +152,Please select a customer,Vennligst velg en kunde
-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/non_profit/doctype/member/member_dashboard.py +6,Member Activity,Medlemsaktivitet
-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: Purchase Invoice,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
-DocType: Maintenance Team Member,Maintenance Role,Vedlikeholdsrolle
-apps/erpnext/erpnext/utilities/transaction_base.py +88,Duplicate row {0} with same {1},Duplicate rad {0} med samme {1}
-,Trial Balance,Balanse Trial
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +438,Fiscal Year {0} not found,Regnskapsåret {0} ikke funnet
-apps/erpnext/erpnext/config/hr.py +305,Setting up Employees,Sette opp ansatte
-DocType: Sales Order,SO-,SÅ-
-DocType: Hotel Room Reservation,Hotel Reservation User,Hotel Reservation Bruker
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +153,Please select prefix first,Vennligst velg først prefiks
-DocType: Student,O-,O-
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +189,Research,Forskning
-DocType: Maintenance Visit Purpose,Work Done,Arbeidet Som Er Gjort
-apps/erpnext/erpnext/controllers/item_variant.py +35,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/assets/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 +525,"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"
-DocType: Crop Cycle,Less than a year,Mindre enn et år
-apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py +52,Student Mobile No.,Student Mobile No.
-apps/erpnext/erpnext/setup/setup_wizard/operations/defaults_setup.py +105,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
-DocType: Crop,Yield UOM,Utbytte UOM
-,Budget Variance Report,Budsjett Avvik Rapporter
-DocType: Salary Slip,Gross Pay,Brutto Lønn
-DocType: Item,Is Item from Hub,Er element fra nav
-apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +118,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/healthcare/doctype/patient_appointment/patient_appointment.py +112,Dr {0} on Leave on {1},Dr {0} på permisjon på {1}
-DocType: Purchase Invoice,Reverse Charge,Omvendt ladning
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +172,Retained Earnings,Opptjent egenkapital
-DocType: Purchase Invoice,05-Change in POS,05-Endring i POS
-DocType: Vehicle Log,Service Detail,tjenesten Detalj
-DocType: BOM,Item Description,Element Beskrivelse
-DocType: Student Sibling,Student Sibling,student Søsken
-apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py +18,Payment Mode,Betaling Mode
-DocType: Purchase Invoice,Supplied Items,Leveringen
-apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +85,Please set an active menu for Restaurant {0},Vennligst sett inn en aktiv meny for Restaurant {0}
-DocType: Student,STUD.,STUD.
-DocType: Production Order,Qty To Manufacture,Antall å produsere
-DocType: Email Digest,New Income,New Inntekt
-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 +53,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
-apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +10,View Hub,Se Hub
-,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}
-DocType: Patient Appointment,More Info,Mer Info
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +180,Valuation Rate required for Item in row {0},Verdsettelse Rate kreves for varen i rad {0}
-DocType: Supplier Scorecard,Scorecard Actions,Scorecard Actions
-apps/erpnext/erpnext/utilities/user_progress.py +166,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 +76, 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/payroll_entry/payroll_entry.py +321,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 +84,Sales Order {0} is not valid,Salgsordre {0} er ikke gyldig
-DocType: Supplier Scorecard,Warn for new Request for Quotations,Varsle om ny forespørsel om tilbud
-apps/erpnext/erpnext/utilities/activation.py +91,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/healthcare/doctype/lab_test/lab_test.js +151,Lab Test Prescriptions,Lab Test Prescriptions
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +166,"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/operations/install_fixtures.py +197,Small,Liten
-DocType: Opening Invoice Creation Tool Item,Opening Invoice Creation Tool Item,Åpning av fakturaopprettingsverktøyet
-DocType: Education Settings,Employee Number,Ansatt Number
-apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +67,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/operations/install_fixtures.py +101,Contract,Kontrakts
-DocType: Plant Analysis,Laboratory Testing Datetime,Laboratorietesting Datetime
-DocType: Email Digest,Add Quote,Legg Sitat
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +973,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 +97,Row {0}: Qty is mandatory,Rad {0}: Antall er obligatorisk
-DocType: Agriculture Analysis Criteria,Agriculture,Landbruk
-apps/erpnext/erpnext/accounts/page/pos/pos.js +794,Sync Master Data,Sync Master Data
-DocType: Asset Repair,Repair Cost,Reparasjonskostnad
-apps/erpnext/erpnext/utilities/user_progress.py +135,Your Products or Services,Dine produkter eller tjenester
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +15,Failed to login,Kunne ikke logge inn
-DocType: Special Test Items,Special Test Items,Spesielle testelementer
-DocType: Mode of Payment,Mode of Payment,Modus for betaling
-apps/erpnext/erpnext/stock/doctype/item/item.py +201,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: Volunteer,Volunteer Name,Frivillig navn
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +433,"{0}: Employee email not found, hence email not sent","{0}: Ansattes e-post ikke funnet, derav e-posten ikke sendt"
-apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +85,Shipping rule not applicable for country {0},Fraktregel gjelder ikke for land {0}
-DocType: Item,Foreign Trade Details,Foreign Trade Detaljer
-,Assessment Plan Status,Evalueringsplan Status
-DocType: Email Digest,Annual Income,Årsinntekt
-DocType: Serial No,Serial No Details,Serie ingen opplysninger
-DocType: Purchase Invoice Item,Item Tax Rate,Sak Skattesats
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +75,Please select Physician and Date,Vennligst velg Leger og dato
-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 +82,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 +588,Delivery Note {0} is not submitted,Levering Note {0} er ikke innsendt
-apps/erpnext/erpnext/stock/get_item_details.py +148,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 +246,Please set the Item Code first,Vennligst sett inn varenummeret først
-DocType: Item,ITEM-,PUNKT-
-apps/erpnext/erpnext/controllers/selling_controller.py +122,Total allocated percentage for sales team should be 100,Totalt bevilget prosent for salgsteam skal være 100
-DocType: Sales Invoice Item,Edit Description,Rediger Beskrivelse
-DocType: Antibiotic,Antibiotic,Antibiotika
-,Team Updates,laget Oppdateringer
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +912,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/education/doctype/fee_schedule/fee_schedule_list.js +5,Fee Created,Avgift er opprettet
-apps/erpnext/erpnext/utilities/bot.py +39,Did not find any item called {0},Fant ikke noe element som heter {0}
-DocType: Supplier Scorecard Criteria,Criteria Formula,Kriterier Formel
-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 +39,"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
-DocType: Patient Appointment,Duration,Varighet
-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)
-DocType: Daily Work Summary Group,Reminder,påminnelse
-apps/erpnext/erpnext/stock/utils.py +207,Serial number {0} entered more than once,Serienummer {0} angitt mer enn én gang
-DocType: Journal Entry,Journal Entry,Journal Entry
-DocType: Expense Claim Advance,Unclaimed amount,Uoppfordret beløp
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +148,{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 +608,BOM {0} does not belong to Item {1},BOM {0} tilhører ikke Element {1}
-DocType: Sales Partner,Target Distribution,Target Distribution
-DocType: Purchase Invoice,06-Finalization of Provisional assessment,06-Finalisering av foreløpig vurdering
-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: Supplier Scorecard,"Scorecard variables can be used, as well as:
-{total_score} (the total score from that period),
-{period_number} (the number of periods to present day)
-","Scorecard-variabler kan brukes, så vel som: {total_score} (totalpoengsummen fra den perioden), {period_number} (antall perioder i dag)"
-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
-DocType: Healthcare Settings,Registration Message,Registreringsmelding
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +154,Hardware,Hardware
-DocType: Prescription Dosage,Prescription Dosage,Reseptdosering
-DocType: Attendance,HR Manager,HR Manager
-apps/erpnext/erpnext/accounts/party.py +176,Please select a Company,Vennligst velg et selskap
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +92,Privilege Leave,Privilege La
-DocType: Purchase Invoice,Supplier Invoice Date,Leverandør Fakturadato
-DocType: Asset Settings,This value is used for pro-rata temporis calculation,Denne verdien brukes til pro rata temporis beregning
-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: Stock Settings,Naming Series Prefix,Naming Series Prefix
-DocType: Appraisal Template Goal,Appraisal Template Goal,Appraisal Mal Goal
-DocType: Salary Component,Earning,Tjene
-DocType: Supplier Scorecard,Scoring Criteria,Scoringskriterier
-DocType: Purchase Invoice,Party Account Currency,Partiet konto Valuta
-,BOM Browser,BOM Nettleser
-apps/erpnext/erpnext/templates/emails/training_event.html +13,Please update your status for this training event,Vennligst oppdatere statusen din for denne treningshendelsen
-DocType: Item Barcode,EAN,EAN
-DocType: Purchase Taxes and Charges,Add or Deduct,Legge til eller trekke fra
-apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +148,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 +328,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/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +165,Maintenance Schedule {0} exists against {1},Vedlikeholdsplan {0} eksisterer mot {1}
-apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +36,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: POS Profile,Accounting,Regnskap
-DocType: Employee,EMP/,EMP /
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +133,Please select batches for batched item ,Vennligst velg batch for batched item
-DocType: Asset,Depreciation Schedules,avskrivninger tidsplaner
-apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py +192,Following accounts might be selected in GST Settings:,Følgende kontoer kan velges i GST-innstillinger:
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +71,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 +30,From {0} | {1} {2},Fra {0} | {1} {2}
-DocType: Production Order Operation,Operation Description,Operasjon Beskrivelse
-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
-DocType: Physician,Contacts and Address,Kontakter og adresse
-DocType: Purchase Invoice,Contact Person,Kontaktperson
-apps/erpnext/erpnext/projects/doctype/task/task.py +38,'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: Water Analysis,Water Analysis Criteria,Vannanalysekriterier
-DocType: Item,Maintain Stock,Oppretthold Stock
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +226,Stock Entries already created for Production Order ,Arkiv Innlegg allerede opprettet for produksjonsordre
-DocType: Employee,Prefered Email,foretrukne e-post
-DocType: Student Admission,Eligibility and Details,Kvalifisering og detaljer
-apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +38,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 +799,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 +382,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 +195,"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/hr/doctype/employee/employee.py +24,Please setup Employee Naming System in Human Resource &gt; HR Settings,Vennligst oppsett Medarbeiders navngivningssystem i menneskelig ressurs&gt; HR-innstillinger
-DocType: Supplier Scorecard Scoring Variable,Supplier Scorecard Scoring Variable,Leverandør Scorecard Scoring Variable
-apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +72,Buying Amount,Kjøpe Beløp
-DocType: Sales Invoice,Shipping Address Name,Leveringsadresse Navn
-DocType: Material Request,Terms and Conditions Content,Betingelser innhold
-apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +18,There were errors creating Course Schedule,Det var feil å opprette kursplan
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +581,cannot be greater than 100,kan ikke være større enn 100
-apps/erpnext/erpnext/stock/doctype/item/item.py +751,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 +217,"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
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +349,Select POS Profile,Velg POS-profil
-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/operations/install_fixtures.py +105,Apprentice,Lærling
-DocType: Purchase Invoice,Company GSTIN,Firma GSTIN
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +105,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"
-DocType: Supplier Scorecard Period,SSC-,SSC-
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +159,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 +241,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 +183,Tax Rule for transactions.,Skatteregel for transaksjoner.
-DocType: Rename Tool,Type of document to rename.,Type dokument for å endre navn.
-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)
-DocType: Weather,Weather Parameter,Værparameter
-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: Lab Test Template,Collection Details,Samlingsdetaljer
-DocType: POS Profile,Allow Print Before Pay,Tillat utskrift før betaling
-DocType: Land Unit,Linked Soil Texture,Koblet jordstruktur
-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 +82,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/setup/setup_wizard/operations/install_fixtures.py +66,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 +158,Source warehouse is mandatory for row {0},Kilde lageret er obligatorisk for rad {0}
-apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +38,The Payment Term at row {0} is possibly a duplicate.,Betalingsperioden i rad {0} er muligens en duplikat.
-apps/erpnext/erpnext/public/js/setup_wizard.js +30,Agriculture (beta),Jordbruk (beta)
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +863,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
-DocType: Disease,Common Name,Vanlig navn
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +61,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
-DocType: Vital Signs,Blood Pressure,Blodtrykk
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +125,Analyst,Analytiker
-DocType: Item,Inventory,Inventar
-DocType: Item,Sales Details,Salgs Detaljer
-DocType: Quality Inspection,QI-,QI-
-DocType: Opportunity,With Items,Med Items
-DocType: Asset Maintenance,Maintenance Team,Vedlikeholdsteam
-apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37,In Qty,I Antall
-DocType: Education 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/operations/install_fixtures.py +147,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 +64,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 +309,Item Variants,Element Varianter
-apps/erpnext/erpnext/public/js/setup_wizard.js +29,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 +1041,Select Possible Supplier,Velg Mulig Leverandør
-DocType: Sales Invoice,Source,Source
-DocType: Customer,"Select, to make the customer searchable with these fields","Velg, for å gjøre kunden søkbar med disse feltene"
-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 +260,Asset Category is mandatory for Fixed Asset item,Asset Kategori er obligatorisk for Fixed Asset element
-DocType: Fee Validity,Fee Validity,Avgift Gyldighet
-apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +146,No records found in the Payment table,Ingen poster ble funnet i Payment tabellen
-apps/erpnext/erpnext/education/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/hr/doctype/upload_attendance/upload_attendance.py +88,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Vennligst oppsett nummereringsserie for Tilstedeværelse via Oppsett&gt; Nummereringsserie
-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 +295,Packing Slip(s) cancelled,Pakking Slip (s) kansellert
-apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +36,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/data/industry_type.py +27,Executive Search,Executive Search
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +55,Setting defaults,Angir standardinnstillinger
-apps/erpnext/erpnext/utilities/activation.py +63,Create Leads,Lag Leads
-DocType: Maintenance Schedule,Schedules,Rutetider
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +464,POS Profile is required to use Point-of-Sale,POS-profilen kreves for å bruke Point-of-Sale
-DocType: Purchase Invoice Item,Net Amount,Nettobeløp
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +141,{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)
-DocType: Supplier Scorecard,Supplier Scorecard,Leverandør Scorecard
-DocType: Plant Analysis,Result Datetime,Resultat Datetime
-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
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +63,"Appointment cancelled, Please review and cancel the invoice {0}","Avtale avbrutt, vennligst kontroller og avbryt fakturaen {0}"
-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
-apps/erpnext/erpnext/config/non_profit.py +28,Memebership Details,Memebership Detaljer
-DocType: Leave Block List,Block Holidays on important days.,Block Ferie på viktige dager.
-apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +220,Please input all required Result Value(s),Vennligst skriv inn alle nødvendige Resultat Verdi (r)
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js +94,Accounts Receivable Summary,Kundefordringer Sammendrag
-DocType: Employee Loan,Monthly Repayment Amount,Månedlig nedbetaling beløpet
-apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html +9,Opening Invoices,Åpning av fakturaer
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +195,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 +39,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
-DocType: Water Analysis,Container,Container
-apps/erpnext/erpnext/education/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: Healthcare Settings,Manage Sample Collection,Administrer prøveinnsamling
-DocType: Production Plan,Ignore Existing Ordered Quantity,Ignorer eksisterende bestilt antall
-DocType: Patient,Tobacco Past Use,Tidligere bruk av tobakk
-DocType: Sales Invoice Item,Brand Name,Merkenavn
-DocType: Purchase Receipt,Transporter Details,Transporter Detaljer
-apps/erpnext/erpnext/healthcare/doctype/physician/physician.py +65,User {0} is already assigned to Physician {1},Bruker {0} er allerede tilordnet Legen {1}
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2684,Default warehouse is required for selected item,Standardlager er nødvendig til den valgte artikkelen
-apps/erpnext/erpnext/utilities/user_progress.py +143,Box,Eske
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1038,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
-apps/erpnext/erpnext/public/js/setup_wizard.js +31,Healthcare (beta),Helsevesenet (beta)
-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/education/doctype/student_group/student_group.py +58,Duplicate roll number for student {0},Dupliseringsnummer for student {0}
-apps/erpnext/erpnext/education/doctype/student_group/student_group.py +58,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
-DocType: Consultation,Medical Coding,Medisinsk koding
-DocType: Healthcare Settings,Reminder Message,Påminnelsesmelding
-,Lead Name,Lead Name
-,POS,POS
-DocType: C-Form,III,III
-apps/erpnext/erpnext/config/stock.py +314,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/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 +42,No Items to pack,Ingenting å pakke
-apps/erpnext/erpnext/education/doctype/instructor/instructor.py +15,Please setup Instructor Naming System in Education &gt; Education Settings,Vennligst oppsett Instruktør Navngivningssystem under utdanning&gt; Utdanningsinnstillinger
-DocType: Shipping Rule Condition,From Value,Fra Verdi
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +593,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 +132,Claims for company expense.,Krav på bekostning av selskapet.
-apps/erpnext/erpnext/utilities/activation.py +118,"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: Asset Maintenance Task,Certificate Required,Sertifikat kreves
-DocType: Company,Default Holiday List,Standard Holiday List
-apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +196,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
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +395,Select Company,Velg firma
-,Material Requests for which Supplier Quotations are not created,Materielle Forespørsler som Leverandør Sitater ikke er opprettet
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +34,User {0} doesn't have any default POS Profile. Check Default at Row {1} for this User.,Bruker {0} har ingen standard POS-profil. Kontroller standard i rad {1} for denne brukeren.
-DocType: Student Group,Set 0 for no limit,Sett 0 for ingen begrensning
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +123,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/opening_invoice_creation_tool/opening_invoice_creation_tool.py +64,Row {idx}: {field} is required to create the Opening {invoice_type} Invoices,Row {idx}: {field} er påkrevd for å opprette Fakturaer for åpning {faktura_type}
-DocType: Customer,Primary Address and Contact Detail,Primæradresse og kontaktdetaljer
-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
-DocType: Consultation,Appointment,Avtale
-apps/erpnext/erpnext/utilities/activation.py +74,Make Quotation,Gjør sitat
-apps/erpnext/erpnext/config/education.py +226,Other Reports,andre rapporter
-apps/erpnext/erpnext/public/js/setup_wizard.js +39,Please select at least one domain.,Vennligst velg minst ett domene.
-DocType: Dependent Task,Dependent Task,Avhengig Task
-apps/erpnext/erpnext/stock/doctype/item/item.py +443,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 +189,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/payroll_entry/payroll_entry.py +235,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 +1093,Search Item,Søk Element
-DocType: Payment Schedule,Payment Amount,Betalings Beløp
-DocType: Patient Appointment,Referring Physician,Refererende lege
-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 +100,Net Change in Cash,Netto endring i kontanter
-DocType: Assessment Plan,Grading Scale,Grading Scale
-apps/erpnext/erpnext/stock/doctype/item/item.py +437,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 +639,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/hr/doctype/upload_attendance/upload_attendance.js +64,Import Successful!,Import Vellykket!
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +29,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
-DocType: Physician,Hospital,Sykehus
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +385,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 +108,Conversion rate cannot be 0 or 1,Konverteringsfrekvens kan ikke være 0 eller 1
-DocType: Share Balance,To No,Til nr
-DocType: Subscription,Reference Document,Reference Document
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +229,{0} {1} is cancelled or stopped,{0} {1} avbrytes eller stoppes
-DocType: Accounts Settings,Credit Controller,Credit Controller
-DocType: Grant Application,Applicant Type,Søker Type
-DocType: Purchase Invoice,03-Deficiency in services,03-mangel på tjenester
-DocType: Delivery Note,Vehicle Dispatch Date,Vehicle Publiseringsdato
-DocType: Healthcare Settings,Default Medical Code Standard,Standard medisinsk kode Standard
-DocType: Purchase Invoice Item,HSN/SAC,HSN / SAC
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +237,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 +113,{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/education/doctype/student_applicant/student_applicant.js +17,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 +49,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
-DocType: Membership,INR,INR
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +60,{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/accounts/doctype/purchase_invoice/purchase_invoice.py +90,Against Supplier Invoice {0} dated {1},Mot Leverandør Faktura {0} datert {1}
-DocType: Customer,Default Price List,Standard Prisliste
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +322,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
-apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.py +20,A customer with the same name already exists,En kunde med samme navn eksisterer allerede
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +185,This will submit Salary Slips and create accrual Journal Entry. Do you want to proceed?,Dette vil sende Lønnsslipp og opprette periodiseringstabell. Vil du fortsette?
-DocType: Purchase Invoice,Total Net Weight,Total nettovikt
-DocType: Purchase Invoice,Eligibility For ITC,Kvalifisering for ITC
-DocType: Journal Entry,Entry Type,Entry Type
-,Customer Credit Balance,Customer Credit Balance
-apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +28,Net Change in Accounts Payable,Netto endring i leverandørgjeld
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +48,EcritureLet,EcritureLet
-apps/erpnext/erpnext/selling/doctype/customer/customer.py +216,Credit limit has been crossed for customer {0} ({1}/{2}),Kredittgrensen er krysset for kunden {0} ({1} / {2})
-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 +140,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
-apps/erpnext/erpnext/education/doctype/student_group/student_group.py +30,Cannot enroll more than {0} students for this student group.,Kan ikke registrere mer enn {0} studentene på denne studentgruppen.
-apps/erpnext/erpnext/templates/print_formats/includes/total.html +4,Total (Without Tax),Totalt (uten skatt)
-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/assets/doctype/asset_category/asset_category.py +15,{0} must be greater than 0,{0} må være større enn 0
-apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +30,Stock Available,På lager
-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 +66,None of the items have any change in quantity or value.,Ingen av elementene har noen endring i mengde eller verdi.
-apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +17,Mandatory field - Program,Obligatorisk felt - Program
-DocType: Special Test Template,Result Component,Resultat Komponent
-apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.js +46,Warranty Claim,Garantikrav
-,Lead Details,Lead Detaljer
-DocType: Volunteer,Availability and Skills,Tilgjengelighet og ferdigheter
-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: Lab Test,Technician Name,Tekniker Navn
-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: Restaurant Reservation,No Show,Uteblivelse
-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
-apps/erpnext/erpnext/healthcare/setup.py +257,Moderate Sensitivity,Moderat følsomhet
-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.
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +192,'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}
-DocType: Patient,Medication,medisinering
-DocType: Production Plan,Include Non Stock Items,Inkluder ikke-varelager
-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: GST Settings,GST Accounts,GST-kontoer
-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/hub_node/doctype/hub_settings/hub_settings.js +83,Confirm Action,Bekreft handling
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +39,Online Auctions,Online auksjoner
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +100,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 +18,Fulfillment,Oppfyllelse
-apps/erpnext/erpnext/templates/generators/item.html +82,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/education/doctype/assessment_criteria/assessment_criteria.py +15,Can't create standard criteria. Please rename the criteria,Kan ikke opprette standard kriterier. Vennligst gi nytt navn til kriteriene
-apps/erpnext/erpnext/stock/doctype/item/item.js +282,"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/assets/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
-DocType: Agriculture Task,Next Business Day,Neste arbeidsdag
-DocType: Drug Prescription,Dosage by time interval,Dosering etter tidsintervall
-DocType: Cash Flow Mapper,Section Header,Seksjonsoverskrift
-,Student Fee Collection,Student Fee Collection
-apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +23,Appointment Duration (mins),Avtale Varighet (min)
-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 +163,Warehouse required at Row No {0},Warehouse kreves ved Row Nei {0}
-apps/erpnext/erpnext/public/js/setup_wizard.js +145,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/operations/defaults_setup.py +117,ERPNext Setup Complete!,ERPNext Setup Complete!
-DocType: Healthcare Settings,Collect Fee for Patient Registration,Samle avgift for pasientregistrering
-apps/erpnext/erpnext/stock/doctype/item/item.py +677,Cannot change Attributes after stock transaction. Make a new Item and transfer stock to the new Item,Kan ikke endre attributter etter aksje transaksjon. Lag en ny vare og overfør lager til den nye varen
-DocType: Course Assessment Criteria,Weightage,Weightage
-DocType: Purchase Invoice,Tax Breakup,Skatteavbrudd
-DocType: Packing Slip,PS-,PS
-DocType: Member,Non Profit Member,Ikke-profittmedlem
-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.
-DocType: Payment Schedule,Payment Term,Betalingsperiode
-apps/erpnext/erpnext/selling/doctype/customer/customer.py +167,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
-DocType: Land Unit,Area,Område
-apps/erpnext/erpnext/public/js/templates/contact_list.html +37,New Contact,Ny kontakt
-DocType: Territory,Parent Territory,Parent Territory
-DocType: Purchase Invoice,Place of Supply,Leveringssted
-DocType: Quality Inspection Reading,Reading 2,Reading 2
-DocType: Stock Entry,Material Receipt,Materialet Kvittering
-DocType: Homepage,Products,Produkter
-DocType: Announcement,Instructor,Instruktør
-apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js +61,Select Item (optional),Velg element (valgfritt)
-DocType: Fee Schedule Student Group,Fee Schedule Student Group,Avgift Schedule Student Group
-DocType: Student,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 +324,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
-,Item-wise Sales Register,Element-messig Sales Register
-DocType: Asset,Gross Purchase Amount,Bruttobeløpet
-apps/erpnext/erpnext/utilities/user_progress.py +36,Opening Balances,Åpningsbalanser
-DocType: Asset,Depreciation Method,avskrivningsmetode
-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: Soil Texture,Sand Composition (%),Sandkomposisjon (%)
-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 +231,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
-DocType: Grant Application,Assessment  Mark (Out of 10),Vurderingsmerke (ut av 10)
-apps/erpnext/erpnext/education/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 +218,Main,Hoved
-apps/erpnext/erpnext/stock/doctype/item/item.js +72,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 +457,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 +1139,Make Purchase Order,Gjør innkjøpsordre
-DocType: SMS Center,Send To,Send Til
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +134,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 +204,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/education/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 +256,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 +142,Appraisals,medarbeidersamtaler
-apps/erpnext/erpnext/hr/doctype/training_program/training_program_dashboard.py +8,Training Events,Treningsarrangementer
-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 +167,Please enter ,Vennligst skriv inn
-apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js +43,Maintenance Log,Vedlikeholdslogg
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +236,Please set filter based on Item or Warehouse,Vennligst sette filter basert på varen eller Warehouse
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +48,Item Code &gt; Item Group &gt; Brand,Varenummer&gt; Varegruppe&gt; Varemerke
-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)
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +798,Discount amount cannot be greater than 100%,Rabattbeløp kan ikke være større enn 100%
-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 +598,BOM {0} must be submitted,BOM {0} må sendes
-apps/erpnext/erpnext/config/accounts.py +460,Share Management,Aksjeforvaltning
-DocType: Authorization Control,Authorization Control,Autorisasjon kontroll
-apps/erpnext/erpnext/controllers/buying_controller.py +327,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 +810,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 +81,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 +56,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: Crop,Crop Spacing,Beskjæringsavstand
-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/assets/doctype/asset/asset.py +217,"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 +42,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: Material Request Plan Item,Actual Qty,Selve Antall
-DocType: Sales Invoice Item,References,Referanser
-DocType: Quality Inspection Reading,Reading 10,Lese 10
-DocType: Item,Barcodes,strek~~POS=TRUNC
-DocType: Hub Category,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/operations/install_fixtures.py +129,Associate,Forbinder
-DocType: Asset Movement,Asset Movement,Asset Movement
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2199,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: Patient Relation,Family,Familie
-DocType: Production Plan,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/data/industry_type.py +52,Telecommunications,Telekommunikasjon
-apps/erpnext/erpnext/accounts/party.py +264,Billing currency must be equal to either default company's currency or party account currency,Faktureringsvaluta må være lik enten selskapets valuta- eller partikonto-valuta
-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)
-DocType: Soil Texture,Loam,leirjord
-apps/erpnext/erpnext/controllers/accounts_controller.py +700,Row {0}: Due Date cannot be before posting date,Row {0}: Forfallsdato kan ikke være før innleggsdato
-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 +129,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/templates/emails/recurring_document_failed.html +3,For,Til
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +167,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
-apps/erpnext/erpnext/config/accounts.py +241,Tree of financial Cost Centers.,Tre av finansielle kostnadssteder.
-DocType: Serial No,Delivery Document No,Levering Dokument nr
-apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +191,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 +41,"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/controllers/accounts_controller.py +487,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings","Kan ikke overbillett for element {0} i rad {1} mer enn {2}. For å tillate overfakturering, vennligst sett inn Lagerinnstillinger"
-apps/erpnext/erpnext/templates/emails/training_event.html +11,Update Response,Oppdater svar
-apps/erpnext/erpnext/public/js/utils.js +232,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 +95,Batch ID is mandatory,Batch-ID er obligatorisk
-apps/erpnext/erpnext/stock/doctype/batch/batch.py +95,Batch ID is mandatory,Batch-ID er obligatorisk
-DocType: Sales Person,Parent Sales Person,Parent Sales Person
-apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +100,The seller and the buyer cannot be the same,Selgeren og kjøperen kan ikke være det samme
-apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +24,Select the program first,Velg programmet først
-DocType: Patient Appointment,Patient Age,Pasientalder
-apps/erpnext/erpnext/config/learn.py +253,Managing Projects,Managing Projects
-DocType: Supplier,Supplier of Goods or Services.,Leverandør av varer eller tjenester.
-DocType: Budget,Fiscal Year,Regnskapsår
-DocType: Asset Maintenance Log,Planned,planlagt
-DocType: Healthcare Settings,Default receivable accounts to be used if not set in Patient to book Consultation charges.,Standardfordelbare kontoer som skal brukes hvis ikke satt inn i pasienten for å bestille konsultasjonsgebyrer.
-DocType: Vehicle Log,Fuel Price,Fuel Pris
-DocType: Budget,Budget,Budsjett
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +51,Set Open,Sett inn
-apps/erpnext/erpnext/stock/doctype/item/item.py +257,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/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 +167,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: Lead,Follow Up,Følge opp
-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/manufacturing/doctype/bom/bom.py +334,Same item has been entered multiple times. {0},Samme gjenstand er oppgitt flere ganger. {0}
-apps/erpnext/erpnext/education/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."
-apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +190,There were errors.,Det var feil.
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +167,Employee {0} has already applied for {1} between {2} and {3} : ,Ansatt {0} har allerede søkt om {1} mellom {2} og {3}:
-DocType: Guardian,Guardian Interests,Guardian Interesser
-DocType: Naming Series,Current Value,Nåværende Verdi
-apps/erpnext/erpnext/controllers/accounts_controller.py +272,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
-DocType: Education Settings,Instructor Records to be created by,Instruktørposter som skal opprettes av
-apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +229,{0} created,{0} opprettet
-DocType: GST Account,GST Account,GST-konto
-DocType: Delivery Note Item,Against Sales Order,Mot Salgsordre
-,Serial No Status,Serial No Status
-DocType: Payment Entry Reference,Outstanding,Utestående
-DocType: Supplier,Warn POs,Advarsel POs
-,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 +385,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 +309,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/hr/doctype/payroll_entry/payroll_entry.py +458,No salary slip found to submit for the above selected criteria OR salary slip already submitted,Ingen lønnsslipp funnet å sende inn for ovennevnte utvalgte kriterier ELLER lønnsslipp allerede sendt
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +150,Duties and Taxes,Skatter og avgifter
-DocType: Projects Settings,Projects Settings,Prosjekter Innstillinger
-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.
-DocType: Production Plan,Total Produced Qty,Totalt produsert antall
-DocType: Payroll Entry,Get Employee Details,Få medarbeiderdetaljer
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +177,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)
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +919,Raw Materials,Råstoffer
-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 +113,Delete all the Transactions for this Company,Slett alle transaksjoner for dette selskapet
-DocType: Patient,O Positive,O Positiv
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +204,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 +159,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)
-DocType: Soil Texture,Silt,silt
-,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 +31,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
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +106,Available slots,Tilgjengelige spor
-DocType: C-Form Invoice Detail,Invoice No,Faktura Nei
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +350,Make Payment,Utføre betaling
-DocType: Room,Room Name,Room Name
-DocType: Prescription Duration,Prescription Duration,Reseptbeløp
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +82,"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: Volunteer,Anytime,Når som helst
-DocType: Patient,Surgical History,Kirurgisk historie
-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/buying/page/purchase_analytics/purchase_analytics.js +131,Not Set,Ikke sett
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +334,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 +334,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
-DocType: Soil Texture,Silty Clay Loam,Silty Clay Loam
-DocType: Chapter,Chapter,Kapittel
-apps/erpnext/erpnext/utilities/user_progress.py +143,Pair,Par
-DocType: Mode of Payment Account,Default account will be automatically updated in POS Invoice when this mode is selected.,Standardkontoen oppdateres automatisk i POS-faktura når denne modusen er valgt.
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +961,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/accounts/doctype/pricing_rule/pricing_rule.js +54,Supplier &gt; Supplier Type,Leverandør&gt; Leverandør Type
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +53,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
-apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +139,Please set the Default Cost Center in {0} company.,Angi standardkostnadssenteret i {0} selskapet.
-DocType: Item,Has Batch No,Har Batch No
-apps/erpnext/erpnext/public/js/utils.js +106,Annual Billing: {0},Årlig Billing: {0}
-apps/erpnext/erpnext/config/accounts.py +200,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/payroll_entry/payroll_entry.js +227,"Company, From Date and To Date is mandatory","Company, Fra dato og Til dato er obligatorisk"
-apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +33,Get from Consultation,Få fra konsultasjon
-DocType: Asset,Purchase Date,Kjøpsdato
-DocType: Volunteer,Volunteer Type,Frivillig Type
-DocType: Student,Personal Details,Personlig Informasjon
-apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +193,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)
-DocType: Soil Texture,Soil Type,Jordtype
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +380,Amount {0} {1} against {2} {3},Mengden {0} {1} mot {2} {3}
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +277,New Message,Ny melding
-,Quotation Trends,Anførsels Trender
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +160,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 +368,Debit To account must be a Receivable account,Uttak fra kontoen må være en fordring konto
-DocType: Shipping Rule,Shipping Amount,Fraktbeløp
-DocType: Supplier Scorecard Period,Period Score,Periodepoeng
-apps/erpnext/erpnext/utilities/user_progress.py +63,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: Lab Test Template,Special,Spesiell
-DocType: Purchase Order Item Supplied,Conversion Factor,Omregningsfaktor
-DocType: Purchase Order,Delivered,Levert
-,Vehicle Expenses,Vehicle Utgifter
-DocType: Serial No,Invoice Details,Fakturadetaljer
-DocType: Grant Application,Show on Website,Vis på nettstedet
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +212,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}
-apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +29,Start on,Start på
-DocType: Hub Category,Hub Category,Hub kategori
-DocType: Purchase Invoice,SEZ,SEZ
-DocType: Purchase Receipt,Vehicle Number,Vehicle Number
-DocType: Employee Loan,Loan Amount,Lånebeløp
-apps/erpnext/erpnext/utilities/user_progress.py +88,Add Letterhead,Legg til brevpapir
-DocType: Program Enrollment,Self-Driving Vehicle,Selvkjørende kjøretøy
-DocType: Supplier Scorecard Standing,Supplier Scorecard Standing,Leverandør Scorecard Standing
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +442,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
-DocType: Purchase Invoice,Availed ITC Central Tax,Availed ITC Central Tax
-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
-DocType: Projects Settings,Timesheets,Timelister
-DocType: HR Settings,HR Settings,HR-innstillinger
-DocType: Salary Slip,net pay info,nettolønn info
-DocType: Lab Test Template,This value is updated in the Default Sales Price List.,Denne verdien er oppdatert i standard salgsprislisten.
-DocType: Email Digest,New Expenses,nye Utgifter
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +79,PDC/LC Amount,PDC / LC Beløp
-DocType: Shareholder,Shareholder,Aksjonær
-DocType: Purchase Invoice,Additional Discount Amount,Ekstra rabatt Beløp
-DocType: Cash Flow Mapper,Position,Posisjon
-DocType: Patient,Patient Details,Pasientdetaljer
-DocType: Patient,B Positive,B Positiv
-apps/erpnext/erpnext/controllers/accounts_controller.py +595,"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 +317,Abbr can not be blank or space,Abbr kan ikke være tomt eller plass
-DocType: Patient Medical Record,Patient Medical Record,Patient Medical Record
-apps/erpnext/erpnext/accounts/doctype/account/account.js +68,Group to Non-Group,Gruppe til Non-gruppe
-apps/erpnext/erpnext/setup/setup_wizard/data/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: Lab Test UOM,Test UOM,Test UOM
-DocType: Student Siblings,Student Siblings,student Søsken
-apps/erpnext/erpnext/utilities/user_progress.py +143,Unit,Enhet
-apps/erpnext/erpnext/stock/get_item_details.py +138,Please specify Company,Vennligst oppgi selskapet
-,Customer Acquisition and Loyalty,Kunden Oppkjøp og Loyalty
-DocType: Asset Maintenance Task,Maintenance Task,Vedlikeholdsoppgave
-apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py +118,Please set B2C Limit in GST Settings.,Vennligst sett inn B2C Limit i GST-innstillinger.
-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 +109,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 +45,Expense Claims,Regninger
-DocType: Issue,Support,Support
-,BOM Search,BOM Søk
-DocType: Item,"Publish ""In Stock"" or ""Not in Stock"" on Hub based on stock available in this warehouse.",Publiser &quot;På lager&quot; eller &quot;Ikke på lager&quot; på Hub basert på lager tilgjengelig i dette varehuset.
-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 +311,Account {0} is invalid. Account Currency must be {1},Konto {0} er ugyldig. Account Valuta må være {1}
-DocType: Healthcare Settings,Remind Before,Påminn før
-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 +1060,"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
-DocType: Item,Retain Sample,Behold prøve
-apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +115,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 +356,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/stock/report/item_variant_details/item_variant_details.py +71,In Production,I produksjon
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +60,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 +61,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
-DocType: Normal Test Template,Normal Test Template,Normal testmal
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +64,disabled user,deaktivert bruker
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +919,Quotation,Sitat
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +984,Cannot set a received RFQ to No Quote,Kan ikke angi en mottatt RFQ til No Quote
-DocType: Quotation,QTN-,QTN-
-DocType: Salary Slip,Total Deduction,Total Fradrag
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +18,Select an account to print in account currency,Velg en konto for å skrive ut i kontovaluta
-,Production Analytics,produksjons~~POS=TRUNC Analytics
-apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +6,This is based on transactions against this Patient. See timeline below for details,Dette er basert på transaksjoner mot denne pasienten. Se tidslinjen nedenfor for detaljer
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +203,Cost Updated,Kostnad Oppdatert
-DocType: Patient,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
-DocType: Supplier Scorecard Period,Supplier Scorecard Setup,Leverandør Scorecard Setup
-apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +133,Assessment Plan Name,Evalueringsplan Navn
-apps/erpnext/erpnext/stock/doctype/item/item.py +232,Warning: Invalid SSL certificate on attachment {0},Advarsel: Ugyldig SSL-sertifikat på vedlegg {0}
-apps/erpnext/erpnext/utilities/activation.py +64,"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/operations/install_fixtures.py +237,Job Description,Stillingsbeskrivelse
-DocType: Student Applicant,Applied,Tatt i bruk
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +865,Re-open,Re-open
-DocType: Sales Invoice Item,Qty as per Stock UOM,Antall pr Stock målenheter
-apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +59,Guardian2 Name,Guardian2 Name
-DocType: Purchase Invoice,02-Post Sale Discount,02-post salg rabatt
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +127,"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."
-,SO Qty,SO Antall
-apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +91,The field To Shareholder cannot be blank,Feltet Til Aksjonær kan ikke være tomt
-DocType: Guardian,Work Address,arbeid Adresse
-DocType: Appraisal,Calculate Total Score,Beregn Total Score
-DocType: Asset Repair,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}
-DocType: Plant Analysis Criteria,Minimum Permissible Value,Minste tillatte verdi
-apps/erpnext/erpnext/education/doctype/guardian/guardian.py +41,User {0} already exists,Bruker {0} eksisterer allerede
-apps/erpnext/erpnext/hooks.py +109,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: Grant Application,Email Notification Sent,E-postvarsling sendt
-DocType: Purchase Invoice,In Words (Company Currency),I Words (Company Valuta)
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1009,"Item Code, warehouse, quantity are required on row","Varenummer, lager, antall er påkrevd på rad"
-DocType: Pricing Rule,Supplier,Leverandør
-apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js +41,Show Payment Details,Vis betalingsdetaljer
-DocType: Consultation,Consultation Time,Konsultasjonstid
-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/stock/doctype/item/item.js +105,Item Variant Settings,Variantinnstillinger
-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 +228,"Types of employment (permanent, contract, intern etc.).","Typer arbeid (fast, kontrakt, lærling etc.)."
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +434,{0} is mandatory for Item {1},{0} er obligatorisk for Element {1}
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js +136,"Item {0}: {1} qty produced, ","Vare {0}: {1} Antall produsert,"
-DocType: Payroll Entry,Fortnightly,hver fjortende dag
-DocType: Currency Exchange,From Currency,Fra Valuta
-DocType: Vital Signs,Weight (In Kilogram),Vekt (i kilogram)
-DocType: Chapter,"chapters/chapter_name
-leave blank automatically set after saving chapter.",kapitler / kapittelnavn la blankt sett automatisk etter lagring av kapittel.
-apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py +202,Please set GST Accounts in GST Settings,Vennligst sett GST-kontoer i GST-innstillinger
-apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js +31,Type of Business,Type virksomhet
-apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +171,"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 +128,Cost of New Purchase,Kostnad for nye kjøp
-apps/erpnext/erpnext/agriculture/doctype/crop_cycle/crop_cycle.py +35,All tasks for the detected diseases were imported,Alle oppgaver for de oppdagede sykdommene ble importert
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +97,Sales Order required for Item {0},Salgsordre kreves for Element {0}
-DocType: Grant Application,Grant Description,Grant Beskrivelse
-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 +90,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/hr/page/team_updates/team_updates.js +44,No more updates,Ingen flere oppdateringer
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +171,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/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py +6,This covers all scorecards tied to this Setup,Dette dekker alle scorecards knyttet til denne oppsettet
-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/data/industry_type.py +12,Banking,Banking
-apps/erpnext/erpnext/utilities/activation.py +108,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
-DocType: Bin,Ordered Quantity,Bestilte Antall
-apps/erpnext/erpnext/public/js/setup_wizard.js +118,"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/report/profit_and_loss_statement/profit_and_loss_statement.py +39,Profit for the year,Årets resultat
-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: Fee Schedule,In Process,Igang
-DocType: Authorization Rule,Itemwise Discount,Itemwise Rabatt
-apps/erpnext/erpnext/config/accounts.py +75,Tree of financial accounts.,Tre av finansregnskap.
-DocType: Cash Flow Mapping,Cash Flow Mapping,Cash Flow Mapping
-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 +324,Serialized Inventory,Serialisert Lager
-apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +74,Email not found in default contact,E-post ikke funnet i standardkontakt
-DocType: Employee Loan,Account Info,Kontoinformasjon
-DocType: Activity Type,Default Billing Rate,Standard Billing pris
-DocType: Fees,Include Payment,Inkluder betaling
-apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +77,{0} Student Groups created.,{0} Studentgrupper opprettet.
-apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +77,{0} Student Groups created.,{0} Studentgrupper opprettet.
-DocType: Sales Invoice,Total Billing Amount,Total Billing Beløp
-apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.py +50,Program in the Fee Structure and Student Group {0} are different.,Programmet i avgiftsstrukturen og studentgruppen {0} er forskjellig.
-DocType: Fee Schedule,Receivable Account,Fordring konto
-apps/erpnext/erpnext/controllers/accounts_controller.py +617,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/operations/install_fixtures.py +123,CEO,administrerende direktør
-DocType: Purchase Invoice,With Payment of Tax,Med betaling av skatt
-DocType: Expense Claim Detail,Expense Claim Detail,Expense krav Detalj
-DocType: Purchase Invoice,TRIPLICATE FOR SUPPLIER,TRIPLIKAT FOR LEVERANDØR
-DocType: Land Unit,Is Container,Er Container
-DocType: Crop Cycle,This will be day 1 of the crop cycle,Dette blir dag 1 i avlingen syklus
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +871,Please select correct account,Velg riktig konto
-DocType: Purchase Invoice Item,Weight UOM,Vekt målenheter
-apps/erpnext/erpnext/config/accounts.py +466,List of available Shareholders with folio numbers,Liste over tilgjengelige Aksjonærer med folio nummer
-DocType: Salary Structure Employee,Salary Structure Employee,Lønn Struktur Employee
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.js +45,Show Variant Attributes,Vis variantattributter
-DocType: Student,Blood Group,Blodgruppe
-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
-DocType: Supplier Scorecard,Scoring Setup,Scoring Setup
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +24,Electronics,Elektronikk
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +326,Debit ({0}),Debet ({0})
-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/operations/install_fixtures.py +98,Full-time,Fulltid
-DocType: Payroll Entry,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
-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
-DocType: Stock Entry,Total Incoming Value,Total Innkommende Verdi
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +362,Debit To is required,Debet Å kreves
-apps/erpnext/erpnext/utilities/activation.py +109,"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
-apps/erpnext/erpnext/config/buying.py +155,Templates of supplier scorecard variables.,Maler av leverandørens scorecard-variabler.
-DocType: Job Offer Term,Offer Term,Tilbudet Term
-DocType: Asset,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/data/industry_type.py +51,Technology,Teknologi
-DocType: Hub Settings,Unregister from Hub,Avregistrer fra Hub
-apps/erpnext/erpnext/public/js/utils.js +108,Total Unpaid: {0},Total Ubetalte: {0}
-DocType: BOM Website Operation,BOM Website Operation,BOM Nettstedet Operasjon
-apps/erpnext/erpnext/config/manufacturing.py +18,Generate Material Requests (MRP) and Production Orders.,Generere Material Requests (MRP) og produksjonsordrer.
-DocType: Supplier Scorecard,Supplier Score,Leverandørpoeng
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +208,Total Invoiced Amt,Total Fakturert Amt
-DocType: Supplier,Warn RFQs,Advarsel RFQs
-DocType: BOM,Conversion Rate,konverterings~~POS=TRUNC
-apps/erpnext/erpnext/templates/pages/product_search.html +3,Product Search,Produktsøk
-DocType: Assessment Plan,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 +118,Credit To account must be a Payable account,Kreditt til kontoen må være en Betales konto
-apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +43,Please select Student Admission which is mandatory for the paid student applicant,"Vennligst velg Student Admission, som er obligatorisk for den betalte student søkeren"
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +348,BOM recursion: {0} cannot be parent or child of {2},BOM rekursjon: {0} kan ikke være forelder eller barn av {2}
-apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +21,Please select a Price List to publish pricing,Vennligst velg en prisliste for å publisere priser
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +38,Budget List,Budsjettliste
-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 +127,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 +148,"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 +148,"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/stock_entry/stock_entry.py +1017,Maximum Samples - {0} can be retained for Batch {1} and Item {2}.,Maksimale prøver - {0} kan beholdes for Batch {1} og Item {2}.
-apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +6,Add Time Slots,Legg til tidsluker
-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
-DocType: Training Event,Advance,Avansere
-apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +6,for making recurring again.,for å gjenta igjen.
-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/controllers/accounts_controller.py +264,Row #{0}: Account {1} does not belong to company {2},Rute # {0}: Konto {1} tilhører ikke firma {2}
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +30,Unable to find DocType {0},Kan ikke finne DocType {0}
-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 +47,Please enter Receipt Document,Fyll inn Kvittering Document
-apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +369,All items have already been invoiced,Alle elementene er allerede blitt fakturert
-apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +49,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
-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 +996,Production Orders Created: {0},Produksjonsordrer Laget: {0}
-DocType: Branch,Branch,Branch
-DocType: Soil Analysis,Ca/(K+Ca+Mg),Ca / (K + Ca + Mg)
-DocType: Delivery Trip,Fulfillment User,Fulfillment User
-apps/erpnext/erpnext/config/setup.py +61,Printing and Branding,Trykking og merkevarebygging
-DocType: Company,Total Monthly Sales,Totalt månedlig salg
-DocType: Agriculture Analysis Criteria,Weather,Vær
-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
-apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +291,Subscription has been {0},Abonnementet har vært {0}
-DocType: Fee Schedule Program,Fee Schedule Program,Avgift Schedule Program
-DocType: Fee Schedule Program,Student Batch,student Batch
-apps/erpnext/erpnext/utilities/activation.py +119,Make Student,Gjør Student
-DocType: Supplier Scorecard Scoring Standing,Min Grade,Min karakter
-apps/erpnext/erpnext/projects/doctype/project/project.py +216,You have been invited to collaborate on the project: {0},Du har blitt invitert til å samarbeide om prosjektet: {0}
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +135,Physician not available on {0},Legen ikke tilgjengelig på {0}
-DocType: Leave Block List Date,Block Date,Block Dato
-DocType: Crop,Crop,Avling
-DocType: Purchase Receipt,Supplier Delivery Note,Leverandørleverans Note
-apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +70,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: Purchase Invoice,E-commerce GSTIN,E-handel GSTIN
-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 Schedule,Fee Structure,Avgiftsstruktur struktur~~POS=HEADCOMP
-DocType: Timesheet Detail,Costing Amount,Costing Beløp
-DocType: Student Admission Program,Application Fee,Påmeldingsavgift
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +52,Submit Salary Slip,Send Lønn Slip
-apps/erpnext/erpnext/controllers/selling_controller.py +136,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: Agriculture Analysis Criteria,Agriculture Analysis Criteria,Landbruk Analyse Kriterier
-DocType: POS Profile,[Select],[Velg]
-DocType: Vital Signs,Blood Pressure (diastolic),Blodtrykk (diastolisk)
-DocType: SMS Log,Sent To,Sendt til
-DocType: Agriculture Task,Holiday Management,Holiday Management
-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 +51,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/healthcare/doctype/patient_appointment/patient_appointment.js +99,Physician {0} not available on {1},Lege {0} ikke tilgjengelig på {1}
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2565,Select Batch No,Velg batchnummer
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +61,Invalid {0}: {1},Ugyldig {0}: {1}
-,GSTR-1,GSTR-en
-DocType: Purchase Invoice,PINV-RET-,PINV-RET-
-DocType: Fee Validity,Reference Inv,Referanse Inv
-DocType: Sales Invoice Advance,Advance Amount,Forskuddsbeløp
-DocType: Manufacturing Settings,Capacity Planning,Kapasitetsplanlegging
-DocType: Supplier Quotation,Rounding Adjustment (Company Currency,Avrundingsjustering (Bedriftsvaluta
-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 +127,No Item with Barcode {0},Ingen Element med Barcode {0}
-DocType: Normal Test Items,Require Result Value,Krever resultatverdi
-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 +527,Boms,Boms
-apps/erpnext/erpnext/stock/doctype/item/item.py +161,Stores,Butikker
-DocType: Project Type,Projects Manager,Prosjekter manager
-DocType: Serial No,Delivery Time,Leveringstid
-apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +27,Ageing Based On,Aldring Based On
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +66,Appointment cancelled,Avtale kansellert
-DocType: Item,End of Life,Slutten av livet
-apps/erpnext/erpnext/demo/setup/setup_data.py +331,Travel,Reise
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +182,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
-apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +1,Recurring,Gjentakende
-DocType: Cash Flow Mapping Template Details,Cash Flow Mapping Template Details,Kontantstrøm kartlegging detaljer
-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 +72,Update Cost,Oppdater Cost
-DocType: Item Reorder,Item Reorder,Sak Omgjøre
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +463,Show Salary Slip,Vis Lønn Slip
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +849,Transfer Material,Transfer Material
-DocType: Fees,Send Payment Request,Send betalingsforespørsel
-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."
-DocType: Water Analysis,Origin,Opprinnelse
-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 +1154,Please set recurring after saving,Vennligst sett gjentakende etter lagring
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +769,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
-DocType: Soil Texture,Clay,Leire
-DocType: Topic,Topic,Emne
-apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +45,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 +78,"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: Cash Flow Mapping,Is Income Tax Liability,Er skatt på inntektsskatt
-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: Sales Invoice, Shipping Bill Number,Fraktregningsnummer
-apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +34,Traceability,Sporbarhet
-DocType: Asset Maintenance Log,Actions performed,Handlinger utført
-DocType: Cash Flow Mapper,Section Leader,Seksjonsleder
-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 +418,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: Supplier Scorecard Scoring Standing,Employee,Ansatt
-DocType: Asset Repair,Failure Date,Feil dato
-DocType: Sample Collection,Collected Time,Samlet tid
-DocType: Company,Sales Monthly History,Salg Månedlig historie
-DocType: Asset Maintenance Task,Next Due Date,neste frist
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +214,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
-apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.js +47,Vital Signs,Livstegn
-DocType: Training Event,End Time,Sluttid
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +63,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
-DocType: Soil Analysis,Soil Analysis Criterias,Jordanalysekriterier
-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/healthcare/doctype/patient_appointment/patient_appointment.js +195,Are you sure you want to cancel this appointment?,Er du sikker på at du vil avbryte denne avtalen?
-DocType: Hotel Room Pricing Package,Hotel Room Pricing Package,Hotellrom Prispakke
-apps/erpnext/erpnext/config/crm.py +6,Sales Pipeline,salgs~~POS=TRUNC
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +201,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 +200,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 +289,Specified BOM {0} does not exist for Item {1},Spesifisert BOM {0} finnes ikke for Element {1}
-DocType: Soil Texture,Sandy Loam,Sandy Loam
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +232,Maintenance Schedule {0} must be cancelled before cancelling this Sales Order,Vedlikeholdsplan {0} må avbestilles før den avbryter denne salgsordre
-DocType: POS Profile,Applicable for Users,Gjelder for brukere
-DocType: Notification Control,Expense Claim Approved,Expense krav Godkjent
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +320,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/operations/install_fixtures.py +155,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/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +46,PieceDate,PieceDate
-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: Supplier Scorecard,Warn for new Purchase Orders,Varsle om nye innkjøpsordrer
-DocType: Quality Inspection Reading,Reading 9,Lese 9
-DocType: Supplier,Is Frozen,Er Frozen
-apps/erpnext/erpnext/stock/utils.py +224,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: Request for Quotation Supplier,No Quote,Ingen sitat
-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 +909,Please specify Company to proceed,Vennligst oppgi selskapet å fortsette
-apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +27,Net Change in Accounts Receivable,Netto endring i kundefordringer
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +88,Compensatory Off,Kompenserende Off
-DocType: Job Offer,Accepted,Akseptert
-DocType: Grant Application,Organization,Organisasjon
-DocType: BOM Update Tool,BOM Update Tool,BOM Update Tool
-DocType: SG Creation Tool Course,Student Group Name,Student Gruppenavn
-apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.js +17,Show exploded view,Vis eksplodert visning
-apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +7,Creating Fees,Opprette avgifter
-apps/erpnext/erpnext/setup/doctype/company/company.js +91,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.
-apps/erpnext/erpnext/templates/pages/product_search.html +21,Search Results,Søkeresultater
-DocType: Room,Room Number,Romnummer
-apps/erpnext/erpnext/utilities/transaction_base.py +103,Invalid reference {0} {1},Ugyldig referanse {0} {1}
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +187,{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
-DocType: Journal Entry Account,Payroll Entry,Lønninngang
-apps/erpnext/erpnext/setup/doctype/company/company.js +35,Make Tax Template,Lag skatteremne
-apps/erpnext/erpnext/public/js/conf.js +28,User Forum,bruker~~POS=TRUNC
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +318,Raw Materials cannot be blank.,Råvare kan ikke være blank.
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +498,"Could not update stock, invoice contains drop shipping item.","Kunne ikke oppdatere lager, inneholder faktura slippe frakt element."
-DocType: Lab Test Sample,Lab Test Sample,Lab Test prøve
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +491,Quick Journal Entry,Hurtig Journal Entry
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +200,You can not change rate if BOM mentioned agianst any item,Du kan ikke endre prisen dersom BOM nevnt agianst ethvert element
-DocType: Restaurant,Invoice Series Prefix,Faktura Serie Prefiks
-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 +205,Please enter Planned Qty for Item {0} at row {1},Skriv inn Planned Antall for Element {0} på rad {1}
-apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +93,Google Maps integration is not enabled,Integrasjon med Google Maps er ikke aktivert
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +241,{0} {1} is not submitted,{0} {1} ikke er sendt
-DocType: Member,Membership Expiry Date,Medlemskapets utløpsdato
-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 +109,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/manufacturing/doctype/bom_update_tool/bom_update_tool.js +30,Latest price updated in all BOMs,Siste pris oppdatert i alle BOMs
-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 +446,The following Production Orders were created:,Følgende produksjonsordrer ble opprettet:
-DocType: Student Admission Program,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 +68,Total Absent,Total Fraværende
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +848,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 +191,Unit of Measure,Måleenhet
-DocType: Fiscal Year,Year End Date,År Sluttdato
-DocType: Task Depends On,Task Depends On,Task Avhenger
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1026,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?
-apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +58,Total Collected: {0},Samlet samlet: {0}
-DocType: Purchase Receipt,Get Current Stock,Få Current Stock
-DocType: Purchase Invoice,ineligible,ikke kvalifisert
-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
-DocType: Share Balance,Current State,Nåværende situasjon
-apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +152,Mark Present,Mark Present
-DocType: Share Transfer,From Shareholder,Fra Aksjonær
-DocType: Project,% Complete Method,% Komplett Method
-apps/erpnext/erpnext/healthcare/setup.py +181,Drug,Legemiddel
-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: Cash Flow Mapping,Is Finance Cost Adjustment,Er finansieringskostnadsjustering
-DocType: BOM,Operating Cost (Company Currency),Driftskostnader (Selskap Valuta)
-DocType: Purchase Invoice,PINV-,PINV-
-DocType: Authorization Rule,Applicable To (Role),Gjelder til (Role)
-DocType: BOM Update Tool,Replace BOM,Erstatt BOM
-apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.py +110,Code {0} already exist,Kode {0} finnes allerede
-DocType: Employee Advance,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
-apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +14,Assessment Group: ,Bedømmelsesgruppe:
-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 +245,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 +796,Please supply the specified items at the best possible rates,Vennligst oppgi de angitte elementene på de best mulige priser
-DocType: Membership,USD,USD
-apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +28,Make Invoice,Gjør Faktura
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +80,Remaining Balance,Gjenværende balanse
-DocType: Selling Settings,Auto close Opportunity after 15 days,Auto nær mulighet etter 15 dager
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +86,Purchase Orders are not allowed for {0} due to a scorecard standing of {1}.,Innkjøpsordrer er ikke tillatt for {0} på grunn av et scorecard som står på {1}.
-apps/erpnext/erpnext/stock/doctype/item/item.py +497,Barcode {0} is not a valid {1} code,Strekkode {0} er ikke en gyldig {1} kode
-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 +124,Contract End Date must be greater than Date of Joining,Kontraktssluttdato må være større enn tidspunktet for inntreden
-DocType: Driver,Driver,Sjåfør
-DocType: Vital Signs,Nutrition Values,Ernæringsverdier
-DocType: Lab Test Template,Is billable,Er fakturerbart
-DocType: Delivery Note,DN-,DN-
-apps/erpnext/erpnext/healthcare/doctype/physician/physician.py +44,"Both ""Physician Schedule"" and Time Per Appointment"" must be set for Dr {0}",Både &quot;Physician Schedule&quot; og Time Per Appointment &quot;må settes til Dr {0}
-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: Patient,Patient Demographics,Pasientdemografi
-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
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +210,Total advance amount cannot be greater than total claimed amount,Samlet forskuddsbeløp kan ikke være større enn totalt beløp
-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
-apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +71,Select Physician...,Velg lege ...
-DocType: Grant Application,Grant Application Details ,Gi søknadsdetaljer
-DocType: Purchase Receipt Item,Recd Quantity,Recd Antall
-apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py +65,Fee Records Created - {0},Fee Records Laget - {0}
-DocType: Asset Category Account,Asset Category Account,Asset Kategori konto
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +913,Row #{0} (Payment Table): Amount must be positive,Row # {0} (Betalingstabell): Beløpet må være positivt
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +44,CompteNum,CompteNum
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +137,Cannot produce more Item {0} than Sales Order quantity {1},Kan ikke produsere mer Element {0} enn Salgsordre kvantitet {1}
-apps/erpnext/erpnext/stock/doctype/item/item.js +362,Select Attribute Values,Velg Attributtverdier
-DocType: Purchase Invoice,Reason For Issuing document,Årsak til utstedelse av dokument
-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 +45,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/non_profit.py +58,Donor information.,Donorinformasjon.
-apps/erpnext/erpnext/config/accounts.py +330,"e.g. Bank, Cash, Credit Card","f.eks Bank, Cash, Kredittkort"
-DocType: Lead Source,Source Name,Source Name
-DocType: Vital Signs,"Normal resting blood pressure in an adult is approximately 120 mmHg systolic, and 80 mmHg diastolic, abbreviated ""120/80 mmHg""","Normal hvilende blodtrykk hos en voksen er ca. 120 mmHg systolisk og 80 mmHg diastolisk, forkortet &quot;120/80 mmHg&quot;"
-apps/erpnext/erpnext/stock/doctype/batch/batch.py +119,"Set items shelf life in days, to set expiry based on manufacturing_date plus self life","Angi gjenstander holdbarhet om dager, for å angi utløp basert på manufacturing_date pluss selvtid"
-DocType: Journal Entry,Credit Note,Kreditnota
-DocType: Projects Settings,Ignore Employee Time Overlap,Ignorer arbeidstakertidoverlapping
-DocType: Warranty Claim,Service Address,Tjenesten Adresse
-DocType: Asset Maintenance Task,Calibration,kalibrering
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +102,{0} is a company holiday,{0} er en firmas ferie
-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/utilities/user_progress.py +24,Setup Company,Oppsett Company
-,Lab Test Report,Lab Test Report
-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
-DocType: Crop,Planting Area,Planteområde
-apps/erpnext/erpnext/controllers/trends.py +19,Total(Qty),Total (Stk)
-DocType: Installation Note Item,Installed Qty,Installert antall
-apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +4,This could be because of some invalid Email Addresses in the,Dette kan skyldes noen ugyldige e-postadresser i
-apps/erpnext/erpnext/utilities/user_progress.py +28,You added ,Du har lagt til
-DocType: Purchase Taxes and Charges,Parenttype,Parenttype
-apps/erpnext/erpnext/hr/doctype/training_event/training_event.js +10,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: Products Settings,Products per Page,Produkter per side
-DocType: Stock Ledger Entry,Outgoing Rate,Utgående Rate
-apps/erpnext/erpnext/config/hr.py +233,Organization branch master.,Organisering gren mester.
-apps/erpnext/erpnext/controllers/accounts_controller.py +312, 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 +247,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: Supplier Scorecard Criteria,Criteria Weight,Kriterier Vekt
-DocType: Buying Settings,Default Buying Price List,Standard Kjøpe Prisliste
-DocType: Payroll Entry,Salary Slip Based on Timesheet,Lønn Slip Basert på Timeregistrering
-apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +43,Buying Rate,Kjøpspris
-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 +240,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 +240,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: Hub Category,Parent Category,Foreldrekategori
-DocType: Payroll Entry,Select Employees,Velg Medarbeidere
-DocType: Opportunity,Potential Sales Deal,Potensielle Sales Deal
-DocType: Complaint,Complaints,klager
-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
-,sales-browser,salg-browser
-apps/erpnext/erpnext/accounts/doctype/account/account.js +79,Ledger,Ledger
-DocType: Patient Medical Record,PMR-,PMR-
-DocType: Drug Prescription,Drug Code,Legemiddelkode
-DocType: Target Detail,Target  Amount,Target Beløp
-DocType: POS Profile,Print Format for Online,Utskriftsformat for Internett
-DocType: Shopping Cart Settings,Shopping Cart Settings,Handlevogn Innstillinger
-DocType: Journal Entry,Accounting Entries,Regnskaps Entries
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +17,"If selected Pricing Rule is made for 'Rate', it will overwrite Price List. Pricing Rule rate is the final rate, so no further discount should be applied. Hence, in transactions like Sales Order, Purchase Order etc, it will be fetched in 'Rate' field, rather than 'Price List Rate' field.","Hvis valgt prismodell er laget for «Rate», vil den overskrive Prisliste. Prissetting Regelsats er sluttprisen, så ingen ytterligere rabatt skal brukes. Derfor, i transaksjoner som salgsordre, innkjøpsordre osv., Blir det hentet i feltet &#39;Rate&#39;, i stedet for &#39;Prislistefrekvens&#39;."
-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}
-DocType: Journal Entry Account,Reference Due Date,Referansedato
-DocType: Purchase Order,Ref SQ,Ref SQ
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +55,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 +340,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 +196,"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 +101,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: Volunteer Skill,Volunteer Skill,Frivillig ferdighet
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +780,Please select an item in the cart,Vennligst velg et element i handlekurven
-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/operations/install_fixtures.py +74,Arrear,etterskudd
-apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +158,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 +43,Disabled template must not be default template,Funksjonshemmede malen må ikke være standardmal
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py +313,For row {0}: Enter planned qty,For rad {0}: Skriv inn planlagt antall
-DocType: Shareholder,SH-,SH
-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 +825,Delivery,Levering
-DocType: Volunteer,Weekdays,hver~~POS=TRUNC
-DocType: Stock Reconciliation Item,Current Qty,Nåværende Antall
-DocType: Restaurant Menu,Restaurant Menu,Restaurantmeny
-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 +127,"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 +151,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/payroll_entry/payroll_entry.py +252,Accural Journal Entry for salaries from {0} to {1},Accural dagboken til lønninger fra {0} i {1}
-apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.js +17,Send Grant Review Email,Send Grant Review Email
-apps/erpnext/erpnext/accounts/page/pos/pos.js +848,"LocalStorage is full, did not save","Localstorage er full, ikke redde"
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +99,Row {0}: UOM Conversion Factor is mandatory,Rad {0}: målenheter omregningsfaktor er obligatorisk
-apps/erpnext/erpnext/utilities/user_progress.py +232,Room Capacity,Romkapasitet
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +90,Ref,Ref
-DocType: Lab Test,LP-,LP-
-DocType: Healthcare Settings,Registration Fee,Registreringsavgift
-DocType: Budget,Cost Center,Kostnadssted
-apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +45,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/operations/install_fixtures.py +134,Head of Marketing and Sales,Head of Marketing and Sales
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +72,Income Tax,Inntektsskatt
-apps/erpnext/erpnext/config/selling.py +174,Track Leads by Industry Type.,Spor Leads etter bransje Type.
-apps/erpnext/erpnext/utilities/user_progress.py +98,Go to Letterheads,Gå til Letterheads
-DocType: Item Supplier,Item Supplier,Sak Leverandør
-apps/erpnext/erpnext/public/js/controllers/transaction.js +1255,Please enter Item Code to get batch no,Skriv inn Element kode for å få batch no
-apps/erpnext/erpnext/selling/doctype/quotation/quotation.js +880,Please select a value for {0} quotation_to {1},Velg en verdi for {0} quotation_to {1}
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +414,No Items selected for transfer,Ingen elementer valgt for overføring
-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 +183,"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
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +117,Account number for account {0} is not available.<br> Please setup your Chart of Accounts correctly.,Kontonummer for konto {0} er ikke tilgjengelig. <br> Vennligst konfigurer kontoregnskapet ditt riktig.
-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: Normal Test Items,Result Value,Resultat Verdi
-DocType: Hotel Room,Hotels,hoteller
-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: Volunteer,Volunteer Skills,Frivillig Ferdigheter
-DocType: Appraisal,HR User,HR User
-DocType: Purchase Invoice,Taxes and Charges Deducted,Skatter og avgifter fratrukket
-apps/erpnext/erpnext/hooks.py +142,Issues,Problemer
-apps/erpnext/erpnext/controllers/status_updater.py +12,Status must be one of {0},Status må være en av {0}
-apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +64,Reminder to update GSTIN Sent,Påminnelse om å oppdatere GSTIN Sendt
-DocType: Sales Invoice,Debit To,Debet Å
-DocType: Restaurant Menu Item,Restaurant Menu Item,Restaurant menyelement
-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 +79,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/education/doctype/student_admission/student_admission.py +35,Student Admissions,student Opptak
-apps/erpnext/erpnext/accounts/party.py +389,{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/operations/install_fixtures.py +200,Extra Large,Extra large
-DocType: Crop,Scientific Name,Vitenskapelig navn
-apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68,Total Leaves,Totalt Leaves
-DocType: Customer,"Reselect, if the chosen contact is edited after save",Velg hvis den valgte kontakten redigeres etter lagre
-DocType: Consultation,In print,I papirutgave
-,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/utilities/user_progress_utils.py +66,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/operations/install_fixtures.py +199,Large,Stor
-DocType: Homepage Featured Product,Homepage Featured Product,Hjemmeside Aktuelle produkter
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +247,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 +257,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/education/doctype/student/student_dashboard.py +26,Fee,Avgift
-apps/erpnext/erpnext/setup/doctype/company/company.js +154,Update in progress. It might take a while.,Oppdatering pågår. Det kan ta en stund.
-DocType: Production Plan Item,Produced Qty,Produsert antall
-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 +267,Close Balance Sheet and book Profit or Loss.,Lukk Balanse og bok resultatet.
-DocType: Student Applicant,Application Status,søknad Status
-DocType: Sensitivity Test Items,Sensitivity Test Items,Sensitivitetstestelementer
-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 +159,Quotation {0} is cancelled,Sitat {0} er kansellert
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +114,Total Outstanding Amount,Totalt utestående beløp
-DocType: Sales Partner,Targets,Targets
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].js +54,Please register the SIREN number in the company information file,Vennligst registrer SIREN-nummeret i bedriftsinformasjonsfilen
-DocType: Price List,Price List Master,Prisliste Master
-DocType: GST Account,CESS Account,CESS-konto
-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 +241,Please create Customer from Lead {0},Opprett Customer fra Lead {0}
-apps/erpnext/erpnext/healthcare/page/medical_record/patient_select.html +3,Select Patient,Velg Pasient
-DocType: Price List,Applicable for Countries,Gjelder for Land
-DocType: Supplier Scorecard Scoring Variable,Parameter Name,Parameternavn
-apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +52,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: Student,AB-,AB-
-DocType: POS Profile,Ignore Pricing Rule,Ignorer Pricing Rule
-DocType: Employee Education,Graduate,Utdannet
-DocType: Leave Block List,Block Days,Block Days
-apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +83,"Shipping Address does not have country, which is required for this Shipping Rule","Fraktadresse har ikke land, som kreves for denne leveringsregelen"
-DocType: Journal Entry,Excise Entry,Vesenet Entry
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +65,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: Issue,Issue Type,Utgave type
-DocType: Attendance,Leave Type,La Type
-DocType: Purchase Invoice,Supplier Invoice Details,Leverandør Fakturadetaljer
-DocType: Agriculture Task,Ignore holidays,Ignorer ferier
-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/projects/doctype/timesheet/timesheet.py +340,Invoice already created for all billing hours,Faktura som allerede er opprettet for alle faktureringstimer
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +96,Name error: {0},Navn feil: {0}
-DocType: Cash Flow Mapping,Is Finance Cost,Er finansieringskostnad
-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)
-apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +27,Please set default customer in Restaurant Settings,Vennligst sett standardkunden i Restaurantinnstillinger
-,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 +546,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 +168,Define various loan types,Definere ulike typer lån
-DocType: Bin,FCFS Rate,FCFS Rate
-DocType: Opening Invoice Creation Tool Item,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 +127,Financial Year,Regnskapsår
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +46,{0} does not belong to Company {1},{0} ikke tilhører selskapet {1}
-apps/erpnext/erpnext/buying/doctype/supplier_scorecard_period/supplier_scorecard_period.py +66,Could not solve criteria score function for {0}. Make sure the formula is valid.,Kunne ikke løse kriterier score funksjon for {0}. Pass på at formelen er gyldig.
-apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +122,Cost as on,Koste så på
-DocType: Healthcare Settings,Out Patient Settings,Ut pasientinnstillinger
-DocType: Account,Round Off,Avrunde
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +259,Quantity must be positive,Mengden må være positiv
-DocType: Material Request Plan Item,Requested Qty,Spurt Antall
-apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +96,The fields From Shareholder and To Shareholder cannot be blank,Feltene fra Aksjonær og Til Aksjonær kan ikke være tomme
-DocType: Tax Rule,Use for Shopping Cart,Brukes til handlekurv
-apps/erpnext/erpnext/controllers/item_variant.py +98,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 +79,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"
-DocType: Membership,Membership Status,Medlemskapsstatus
-,Requested,Spurt
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +93,No Remarks,Nei Anmerkninger
-DocType: Asset,In Maintenance,Ved vedlikehold
-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 +84,Root Account must be a group,Root-kontoen må være en gruppe
-DocType: Consultation,Drug Prescription,Drug Prescription
-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
-apps/erpnext/erpnext/stock/stock_ledger.py +477,"Valuation rate not found for the Item {0}, which is required to do accounting entries for {1} {2}. If the item is transacting as a zero valuation rate item in the {1}, please mention that in the {1} Item table. Otherwise, please create an incoming stock transaction for the item or mention valuation rate in the Item record, and then try submiting/cancelling this entry","Verdsettelsesraten ikke funnet for elementet {0}, som er nødvendig for å gjøre regnskapsposter for {1} {2}. Hvis varen er transaksjon som nullverdieringsgrad i {1}, må du nevne det i {1} elementtabellen. Ellers kan du opprette en inntektsaksjonstransaksjon for varen eller nevne verdsettelsesraten i vareoppføringen, og prøv deretter å sende inn / avbryte denne oppføringen"
-DocType: Course,Course Code,Kurskode
-apps/erpnext/erpnext/controllers/stock_controller.py +337,Quality Inspection required for Item {0},Quality Inspection nødvendig for Element {0}
-DocType: POS Settings,Use POS in Offline Mode,Bruk POS i frakoblet modus
-DocType: Supplier Scorecard,Supplier Variables,Leverandørvariabler
-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
-DocType: Cash Flow Mapper,Section Subtotal,Seksjon Subtotal
-apps/erpnext/erpnext/accounts/page/pos/pos.js +498,Please select Apply Discount On,Vennligst velg Bruk rabatt på
-DocType: Stock Settings,Sample Retention Warehouse,Prøvebehandlingslager
-DocType: Company,Default Receivable Account,Standard fordringer konto
-DocType: Physician,Physician Schedule,Legerplan
-DocType: Purchase Invoice,Deemed Export,Gjeldende eksport
-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: Subscription,Half-yearly,Halvårs
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +407,Accounting Entry for Stock,Regnskap Entry for Stock
-DocType: Lab Test,LabTest Approver,LabTest Approver
-apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py +61,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/stock/doctype/item/item.py +546,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/accounts/doctype/share_transfer/share_transfer.py +192,The folio numbers are not matching,Folio tallene stemmer ikke overens
-apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +124,Row {0}: Completed Qty must be greater than zero.,Rad {0}: Fullført Antall må være større enn null.
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +249,Payment Request for {0},Betalingsforespørsel om {0}
-DocType: Item Barcode,Barcode Type,Strekkode Type
-DocType: Antibiotic,Antibiotic Name,Antibiotisk navn
-DocType: Purchase Invoice,Apply Additional Discount On,Påfør Ytterligere rabatt på
-apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +69,Select Type...,Velg type ...
-DocType: Crop Cycle,A link to all the Land Units in which the Crop is growing,En kobling til alle arealene der grøften vokser
-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/healthcare/page/appointment_analytic/appointment_analytic.js +45,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 +164,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 +397,Add Employees,Legg Medarbeidere
-DocType: Purchase Invoice Item,Quality Inspection,Quality Inspection
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +196,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 +806,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/data/industry_type.py +29,"Food, Beverage & Tobacco","Mat, drikke og tobakk"
-DocType: Account,Account Number,Kontonummer
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +720,Can only make payment against unbilled {0},Kan bare gjøre betaling mot fakturert {0}
-apps/erpnext/erpnext/controllers/selling_controller.py +101,Commission rate cannot be greater than 100,Kommisjon kan ikke være større enn 100
-DocType: Volunteer,Volunteer,Frivillig
-DocType: Stock Entry,Subcontract,Underentrepriser
-apps/erpnext/erpnext/public/js/utils/party.js +166,Please enter {0} first,Fyll inn {0} først
-apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py +104,No replies from,Ingen svar fra
-DocType: Production Order Operation,Actual End Time,Faktisk Sluttid
-DocType: Item,Manufacturer Part Number,Produsentens varenummer
-DocType: Production Order Operation,Estimated Time and Cost,Estimert leveringstid og pris
-DocType: Bin,Bin,Bin
-DocType: Crop,Crop Name,Beskjære navn
-DocType: SMS Log,No of Sent SMS,Ingen av Sendte SMS
-DocType: Antibiotic,Healthcare Administrator,Helseadministrator
-apps/erpnext/erpnext/utilities/user_progress.py +44,Set a Target,Angi et mål
-DocType: Dosage Strength,Dosage Strength,Doseringsstyrke
-DocType: Account,Expense Account,Expense konto
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +49,Software,Programvare
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +203,Colour,Farge
-DocType: Assessment Plan Criteria,Assessment Plan Criteria,Assessment Plan Kriterier
-apps/erpnext/erpnext/stock/doctype/batch/batch.py +118,Expiry date is mandatory for selected item,Utløpsdato er obligatorisk for valgt element
-DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,Forhindre innkjøpsordrer
-apps/erpnext/erpnext/healthcare/setup.py +258,Susceptible,utsatt
-DocType: Patient Appointment,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"
-apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.js +148,Select Customer,Velg kunde
-DocType: Student Log,Academic,akademisk
-DocType: Patient,Personal and Social History,Personlig og sosial historie
-apps/erpnext/erpnext/education/doctype/guardian/guardian.py +51,User {0} created,Bruker {0} opprettet
-DocType: Fee Schedule,Fee Breakup for each student,Fee Breakup for hver student
-apps/erpnext/erpnext/controllers/accounts_controller.py +540,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.
-apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +78,Change Code,Endre kode
-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 +388,Price List Currency not selected,Prisliste Valuta ikke valgt
-DocType: Purchase Invoice,Availed ITC Cess,Benyttet ITC Cess
-,Student Monthly Attendance Sheet,Student Månedlig Oppmøte Sheet
-apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +96,Shipping rule only applicable for Selling,Fraktregel gjelder kun for salg
-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 +18,Until,Inntil
-DocType: Rename Tool,Rename Log,Rename Logg
-apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py +27,Student Group or Course Schedule is mandatory,Studentgruppe eller kursplan er obligatorisk
-apps/erpnext/erpnext/education/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/utilities/user_progress.py +214,Go to Instructors,Gå til Instruktører
-apps/erpnext/erpnext/config/selling.py +110,Manage Sales Partners.,Administrer Salgs Partners.
-DocType: Quality Inspection,Inspection Type,Inspeksjon Type
-DocType: Fee Validity,Visited yet,Besøkt ennå
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +135,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 +117,Add Students,Legg Studenter
-apps/erpnext/erpnext/public/js/utils.js +270,Please select {0},Vennligst velg {0}
-DocType: C-Form,C-Form No,C-Form Nei
-DocType: BOM,Exploded_items,Exploded_items
-apps/erpnext/erpnext/utilities/user_progress.py +136,List your products or services that you buy or sell.,Oppgi produktene eller tjenestene du kjøper eller selger.
-DocType: Water Analysis,Storage Temperature,Lager temperatur
-DocType: Employee Attendance Tool,Unmarked Attendance,Umerket Oppmøte
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +137,Researcher,Forsker
-DocType: Program Enrollment Tool Student,Program Enrollment Tool Student,Program Påmelding Tool Student
-apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.py +16,Start date should be less than end date for task {0},Startdato bør være mindre enn sluttdato for oppgaven {0}
-apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py +25,Name or Email is mandatory,Navn eller E-post er obligatorisk
-DocType: Member,MEM-,med-
-DocType: Instructor,Instructor Log,Instruktørlogg
-DocType: Purchase Order Item,Returned Qty,Returnerte Stk
-DocType: Student,Exit,Utgang
-apps/erpnext/erpnext/accounts/doctype/account/account.py +156,Root Type is mandatory,Root Type er obligatorisk
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +29,Failed to install presets,Kunne ikke installere forhåndsinnstillinger
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +44,"{0} currently has a {1} Supplier Scorecard standing, and RFQs to this supplier should be issued with caution.","{0} har for øyeblikket en {1} leverandør scorecard, og RFQs til denne leverandøren skal utstedes med forsiktighet."
-DocType: Chapter,Non Profit Manager,Non Profit Manager
-DocType: BOM,Total Cost(Company Currency),Totalkostnad (Selskap Valuta)
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +315,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
-apps/erpnext/erpnext/accounts/report/financial_statements.py +172,Could not retrieve information for {0}.,Kunne ikke hente informasjon for {0}.
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +134,Opening Entry Journal,Åpningsoppføring Journal
-DocType: Sales Invoice,Time Sheet List,Timeregistrering List
-DocType: Employee,You can enter any date manually,Du kan legge inn noen dato manuelt
-DocType: Healthcare Settings,Result Printed,Resultat Trykt
-DocType: Asset Category Account,Depreciation Expense Account,Avskrivninger konto
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +232,Probationary Period,Prøvetid
-apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js +32,View {0},Se {0}
-DocType: Customer Group,Only leaf nodes are allowed in transaction,Bare bladnoder er tillatt i transaksjonen
-DocType: Project,Total Costing Amount (via Timesheets),Totalt kostende beløp (via tidsskrifter)
-DocType: Employee Advance,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 +89,Non-Group to Group,Non-gruppe til gruppe
-apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +58,Batch is mandatory in row {0},Batch er obligatorisk i rad {0}
-apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +58,Batch is mandatory in row {0},Batch er obligatorisk i rad {0}
-DocType: Purchase Receipt Item Supplied,Purchase Receipt Item Supplied,Kvitteringen Sak Leveres
-apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py +24,To Datetime,Til Datetime
-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 +218,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
-DocType: Patient Appointment,Reminded,minnet
-DocType: Patient,PID-,PID-
-DocType: Chapter Member,Chapter Member,Kapittelmedlem
-DocType: Material Request Plan Item,Minimum Order Quantity,Minimum antall
-apps/erpnext/erpnext/public/js/setup_wizard.js +106,Your Organization,Din organisasjon
-DocType: Fee Component,Fees Category,avgifter Kategori
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +134,Please enter relieving date.,Skriv inn lindrende dato.
-apps/erpnext/erpnext/controllers/trends.py +149,Amt,Amt
-DocType: Supplier Scorecard,Notify Employee,Informer medarbeider
-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/data/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 +115,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 +352,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 +128,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 +87,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 +516,[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
-apps/erpnext/erpnext/assets/doctype/asset_repair/asset_repair.py +14,Please select Completion Date for Completed Repair,Vennligst velg Fullføringsdato for fullført reparasjon
-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/education/report/assessment_plan_status/assessment_plan_status.js +22,Scheduled Upto,Planlagt Upto
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +55,Venture Capital,Venture Capital
-apps/erpnext/erpnext/education/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.
-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: Purchase 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
-apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +51,Reserved for sub contracting,Reservert for underentreprise
-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 +285,Please select a batch,Vennligst velg en batch
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +42,JournalLib,JournalLib
-DocType: Assessment Group,Assessment Group Name,Assessment Gruppenavn
-DocType: Manufacturing Settings,Material Transferred for Manufacture,Materialet Overført for Produksjon
-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: Antibiotic,Healthcare,Helsetjenester
-DocType: Target Detail,Target Detail,Target Detalj
-apps/erpnext/erpnext/stock/doctype/item/item.js +65,Single Variant,Enkelt variant
-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/healthcare/page/appointment_analytic/appointment_analytic.js +75,Select Department...,Velg avdeling ...
-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 +367,Amount {0} {1} {2} {3},Mengden {0} {1} {2} {3}
-DocType: Account,Depreciation,Avskrivninger
-apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +102,The number of shares and the share numbers are inconsistent,Antall aksjer og aksjenumrene er inkonsekvente
-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
-apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +70,Avg. Selling Price List Rate,Nr. Selge prisliste rate
-DocType: Salary Component,Salary Component,lønn Component
-apps/erpnext/erpnext/accounts/utils.py +495,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 +550,Material Requests {0} created,Materielle Forespørsler {0} er opprettet
-DocType: Restaurant Reservation,No of People,Ingen av mennesker
-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 +276,Stock cannot be updated against Purchase Receipt {0},Stock kan ikke oppdateres mot Kjøpskvittering {0}
-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 +318,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/education/doctype/program/program.js +8,Student Applicant,student Søker
-DocType: Purchase Invoice,ORIGINAL FOR RECIPIENT,ORIGINAL FOR RECIPIENT
-DocType: Asset Category Account,Accumulated Depreciation Account,Akkumulerte avskrivninger konto
-apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +11,This email is autogenerated,Denne e-posten er autogenerert
-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 +518,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/regional/france/utils.py +30,Deletion is not permitted for country {0},Sletting er ikke tillatt for land {0}
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +105,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 +414,{0} {1} is cancelled or closed,{0} {1} er kansellert eller lukket
-DocType: Asset,Calculate Depreciation,Beregn Avskrivninger
-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 +35,Net Cash from Investing,Netto kontantstrøm fra investerings
-DocType: Production Order,Work-in-Progress Warehouse,Work-in-progress Warehouse
-apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +111,Asset {0} must be submitted,Asset {0} må fremlegges
-DocType: Fee Schedule Program,Total Students,Totalt studenter
-apps/erpnext/erpnext/education/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 +164,Depreciation Eliminated due to disposal of assets,Avskrivninger Slått på grunn av salg av eiendeler
-DocType: Member,Member,Medlem
-apps/erpnext/erpnext/templates/includes/cart/cart_address.html +15,Manage Addresses,Administrer Adresser
-DocType: Pricing Rule,Item Code,Sak Kode
-DocType: Serial No,Warranty / AMC Details,Garanti / AMC Detaljer
-apps/erpnext/erpnext/education/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
-DocType: Agriculture Analysis Criteria,Agriculture Manager,Landbruksansvarlig
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +950,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: Supplier Scorecard Period,Variables,variabler
-DocType: Employee Internal Work History,Employee Internal Work History,Ansatt Intern Work History
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +249,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: Education Settings,Current Academic Year,Nåværende akademisk år
-DocType: Education 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: Employee Education,School/University,Skole / universitet
-DocType: Payment Request,Reference Details,Referanse Detaljer
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +56,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: Share Transfer,(including),(gjelder også)
-DocType: Asset,Double Declining Balance,Dobbel degressiv
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +180,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 +626,'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/stock/doctype/item/item.js +368,Select at least one value from each of the attributes.,Velg minst én verdi fra hver av attributter.
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +166,Material Request {0} is cancelled or stopped,Materialet Request {0} blir kansellert eller stoppet
-apps/erpnext/erpnext/config/hr.py +310,Leave Management,La Ledelse
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +106,Group by Account,Grupper etter Account
-apps/erpnext/erpnext/education/doctype/instructor/instructor.py +21,Please select Employee,Vennligst velg Medarbeider
-DocType: Sales Order,Fully Delivered,Fullt Leveres
-DocType: Lead,Lower Income,Lavere inntekt
-DocType: Restaurant Order Entry,Current Order,Nåværende ordre
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +183,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 +243,"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/utilities/user_progress.py +173,Go to Programs,Gå til Programmer
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +203,Row {0}# Allocated amount {1} cannot be greater than unclaimed amount {2},Row {0} # Tilordnet mengde {1} kan ikke være større enn uanmeldt beløp {2}
-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 +945,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/education/doctype/student_applicant/student_applicant.py +39,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
-DocType: Item Barcode,UPC-A,UPC-A
-,Stock Projected Qty,Lager Antall projiserte
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +444,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 +73,"Quotations are proposals, bids you have sent to your customers","Sitater er forslag, bud du har sendt til dine kunder"
-DocType: Sales Invoice,Customer's Purchase Order,Kundens innkjøpsordre
-DocType: Consultation,Patient,Pasient
-apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +47,Bypass credit check at Sales Order ,Bypass kreditt sjekk på salgsordre
-DocType: Land Unit,Check if it is a hydroponic unit,Sjekk om det er en hydroponisk enhet
-apps/erpnext/erpnext/config/stock.py +109,Serial No and Batch,Serial No og Batch
-DocType: Warranty Claim,From Company,Fra Company
-apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py +52,Sum of Scores of Assessment Criteria needs to be {0}.,Summen av Resultater av vurderingskriterier må være {0}.
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +77,Please set Number of Depreciations Booked,Vennligst sett Antall Avskrivninger bestilt
-DocType: Supplier Scorecard Period,Calculations,beregninger
-apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +89,Value or Qty,Verdi eller Stk
-DocType: Payment Terms Template,Payment Terms,Betalingsbetingelser
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +448,Productions Orders cannot be raised for:,Productions Bestillinger kan ikke heves for:
-apps/erpnext/erpnext/utilities/user_progress.py +144,Minute,Minutt
-DocType: Purchase Invoice,Purchase Taxes and Charges,Kjøpe skatter og avgifter
-DocType: Chapter,Meetup Embed HTML,Meetup Embed HTML
-apps/erpnext/erpnext/utilities/user_progress.py +118,Go to Suppliers,Gå til Leverandører
-,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 +115,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: Donor,Donor,donor
-DocType: Global Defaults,Disable In Words,Deaktiver I Ord
-apps/erpnext/erpnext/stock/doctype/item/item.py +59,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 +98,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
-apps/erpnext/erpnext/education/doctype/fees/fees.js +105,Please set the Email ID for the Student to send the Payment Request,Vennligst still inn e-post-IDen for studenten for å sende betalingsanmodningen
-DocType: Production Order,PRO-,PRO-
-DocType: Patient,Medical History,Medisinsk historie
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +157,Bank Overdraft Account,Kassekreditt konto
-DocType: Patient,Patient ID,Pasient ID
-DocType: Physician Schedule,Schedule Name,Planleggingsnavn
-apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js +48,Make Salary Slip,Gjør Lønn Slip
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +840,Add All Suppliers,Legg til alle leverandører
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +89,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 +75,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/assets/doctype/asset/depreciation.py +101,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: Lab Test Groups,Normal Range,Normal rekkevidde
-DocType: Academic Term,Academic Year,Studieår
-apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +72,Available Selling,Tilgjengelig salg
-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: Purchase Invoice,N,N
-apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +175,Remaining,Gjenværende værende~~POS=HEADCOMP
-DocType: Appraisal,Appraisal,Appraisal
-DocType: Purchase Invoice,GST Details,GST-detaljer
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +156,Email sent to supplier {0},E-post sendt til leverandøren {0}
-DocType: Item,Default Sales Unit of Measure,Standard salgsmengde av mål
-apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +9,Academic Year: ,Studieår:
-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/education/doctype/fee_schedule/fee_schedule.js +67,Create Fees,Opprett gebyrer
-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 +400,Select Quantity,Velg Antall
-DocType: Customs Tariff Number,Customs Tariff Number,Tolltariffen nummer
-DocType: Patient Appointment,Patient Appointment,Pasientavtale
-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 +64,Unsubscribe from this Email Digest,Melde deg ut av denne e-post Digest
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +830,Get Suppliers By,Få leverandører av
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +172,{0} not found for Item {1},{0} ikke funnet for element {1}
-apps/erpnext/erpnext/utilities/user_progress.py +194,Go to Courses,Gå til kurs
-DocType: Accounts Settings,Show Inclusive Tax In Print,Vis inklusiv skatt i utskrift
-apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +17,"Bank Account, From Date and To Date are Mandatory","Bankkonto, fra dato og til dato er obligatorisk"
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +28,Message Sent,Melding Sendt
-apps/erpnext/erpnext/accounts/doctype/account/account.py +98,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)
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +213,Total advance amount cannot be greater than total sanctioned amount,Samlet forskuddbeløp kan ikke være større enn total sanksjonert beløp
-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 +41,Account {0} does not exists,Konto {0} ikke eksisterer
-DocType: Project,Project Type,Prosjekttype
-apps/erpnext/erpnext/projects/doctype/task/task.py +142,Child Task exists for this Task. You can not delete this Task.,Barneoppgave eksisterer for denne oppgaven. Du kan ikke slette denne oppgaven.
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +48,DateLet,DateLet
-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 +51,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 +163,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: BOM,Inspection Required,Inspeksjon påkrevd
-DocType: Purchase Invoice Item,PR Detail,PR Detalj
-DocType: Driving License Category,Class,Klasse
-DocType: Sales Order,Fully Billed,Fullt Fakturert
-apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +101,Shipping rule only applicable for Buying,Fraktregel gjelder kun for kjøp
-DocType: Vital Signs,BMI,BMI
-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 +137,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)
-DocType: Assessment Plan,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
-DocType: Healthcare Settings,Laboratory SMS Alerts,Laboratory SMS Alerts
-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:"
-DocType: Plant Analysis Criteria,Plant Analysis Criteria,Plantanalyse Kriterier
-DocType: Cheque Print Template,Cheque Height,sjekk Høyde
-DocType: Supplier,Supplier Details,Leverandør Detaljer
-DocType: Setup Progress,Setup Progress,Oppsett Progress
-DocType: Hub Settings,Publish Items to Hub,Publiser varer i Hub
-apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +35,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/operations/install_fixtures.py +182,Wire Transfer,Wire Transfer
-apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +92,Check all,Sjekk alt
-DocType: Vehicle Log,Invoice Ref,faktura~~POS=TRUNC Ref
-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: Lab Test Template,Change In Item,Endre i element
-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/accounts/report/general_ledger/general_ledger.py +338,Balance ({0}),Balanse ({0})
-apps/erpnext/erpnext/config/accounts.py +134,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/regional/doctype/gst_settings/gst_settings.py +34,Email Reminders will be sent to all parties with email contacts,E-mail påminnelser vil bli sendt til alle parter med e-postkontakter
-DocType: Patient,A Negative,En negativ
-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 +327,Calls,Samtaler
-apps/erpnext/erpnext/utilities/user_progress.py +140,A Product,Et produkt
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +207,Batches,batcher
-apps/erpnext/erpnext/education/doctype/fee_structure/fee_structure.js +34,Make Fee Schedule,Lag avgiftsplan
-DocType: Purchase Order Item Supplied,Stock UOM,Stock målenheter
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +233,Purchase Order {0} is not submitted,Purchase Order {0} ikke er sendt
-DocType: Vital Signs,Normal reference range for an adult is 16–20 breaths/minute (RCP 2012),Normalt referanseområde for en voksen er 16-20 puste / minutt (RCP 2012)
-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/healthcare/doctype/patient/patient.js +86,Please save the patient first,Vennligst lagre pasienten først
-apps/erpnext/erpnext/education/api.py +80,Attendance has been marked successfully.,Oppmøte er merket med hell.
-DocType: Program Enrollment,Public Transport,Offentlig transport
-DocType: Soil Texture,Silt Composition (%),Siltkomposisjon (%)
-DocType: Journal Entry,Remark,Bemerkning
-DocType: Healthcare Settings,Avoid Confirmation,Unngå bekreftelse
-DocType: Purchase Receipt Item,Rate and Amount,Rate og Beløp
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +171,Account Type for {0} must be {1},Kontotype for {0} må være {1}
-DocType: Healthcare Settings,Default income accounts to be used if not set in Physician to book Consultation charges.,Standard inntektsregnskap som skal brukes dersom ikke settes i Lege for å bestille Konsultasjonsgebyrer.
-apps/erpnext/erpnext/config/hr.py +55,Leaves and Holiday,Blader og Holiday
-DocType: Education Settings,Current Academic Term,Nåværende faglig term
-DocType: Education Settings,Current Academic Term,Nåværende faglig term
-DocType: Sales Order,Not Billed,Ikke Fakturert
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +77,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
-,Item Balance (Simple),Varebalanse (Enkel)
-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 +210,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/setup/setup_wizard/setup_wizard.py +61,Failed to set defaults,Kunne ikke angi standardinnstillinger
-apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +56,Relation with Guardian1,Relasjon med Guardian1
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +787,Please select BOM against item {0},Vennligst velg BOM mot element {0}
-apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +18,Make Invoices,Lag fakturaer
-apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +23,Net Cash from Operations,Netto kontantstrøm fra driften
-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 +30,Sub-contracting,Underleverandører
-DocType: Journal Entry Account,Journal Entry Account,Journal Entry konto
-apps/erpnext/erpnext/education/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 +57,"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"
-DocType: Soil Analysis Criteria,Soil Analysis Criteria,Jordanalyse Kriterier
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2039,Please select customer,Velg kunde
-DocType: C-Form,I,Jeg
-DocType: Company,Asset Depreciation Cost Center,Asset Avskrivninger kostnadssted
-DocType: Production Plan Sales Order,Sales Order Date,Salgsordre Dato
-DocType: Sales Invoice Item,Delivered Qty,Leveres Antall
-DocType: Assessment Plan,Assessment Plan,Assessment Plan
-apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +93,Customer {0} is created.,Kunden {0} er opprettet.
-DocType: Stock Settings,Limit Percent,grense Prosent
-apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +82, Currently no stock available in any warehouse,Foreløpig ingen lager tilgjengelig i varehus
-,Payment Period Based On Invoice Date,Betaling perioden basert på Fakturadato
-DocType: Sample Collection,No. of print,Antall utskrifter
-DocType: Hotel Room Reservation Item,Hotel Room Reservation Item,Hotel Room Reservation Item
-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
-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
-DocType: Share Balance,Share Type,Del Type
-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 +378,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 +74,Gross Profit %,Bruttofortjeneste%
-DocType: Appraisal Goal,Weightage (%),Weightage (%)
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +499,Change POS Profile,Endre POS-profil
-DocType: Bank Reconciliation Detail,Clearance Date,Klaring Dato
-apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +7,Assessment Report,Vurderingsrapport
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +59,Gross Purchase Amount is mandatory,Bruttobeløpet er obligatorisk
-apps/erpnext/erpnext/setup/doctype/company/company.js +95,Company name not same,Firmanavn ikke det samme
-DocType: Lead,Address Desc,Adresse Desc
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +108,Party is mandatory,Party er obligatorisk
-DocType: Journal Entry,JV-,JV-
-apps/erpnext/erpnext/controllers/accounts_controller.py +707,Rows with duplicate due dates in other rows were found: {list},Rader med dupliserte forfallsdatoer i andre rader ble funnet: {list}
-DocType: Topic,Topic Name,emne Name
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +37,Atleast one of the Selling or Buying must be selected,Minst én av de selge eller kjøpe må velges
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +290,Select an employee to get the employee advance.,Velg en ansatt for å få ansatt på forhånd.
-apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +56,Please select a valid Date,Vennligst velg en gyldig dato
-apps/erpnext/erpnext/public/js/setup_wizard.js +36,Select the nature of your business.,Velg formålet med virksomheten.
-DocType: Lab Test Template,"Single for results which require only a single input, result UOM and normal value 
-<br>
-Compound for results which require multiple input fields with corresponding event names, result UOMs and normal values
-<br>
-Descriptive for tests which have multiple result components and corresponding result entry fields. 
-<br>
-Grouped for test templates which are a group of other test templates.
-<br>
-No Result for tests with no results. Also, no Lab Test is created. e.g.. Sub Tests for Grouped results.","Enkelt for resultater som krever bare ett enkelt inngang, resultat UOM og normal verdi <br> Sammensatt for resultater som krever flere inntastingsfelter med tilsvarende hendelsesnavn, resulterer UOM og normale verdier <br> Beskrivende for tester som har flere resultatkomponenter og tilhørende resultatoppføringsfelter. <br> Gruppert for testmaler som er en gruppe andre testmaler. <br> Ingen resultat for tester uten resultater. Også, ingen Lab Test er opprettet. f.eks. Delprøver for grupperte resultater."
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +81,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.
-apps/erpnext/erpnext/education/doctype/instructor/instructor.js +18,As Examiner,Som eksaminator
-DocType: Asset Movement,Source Warehouse,Kilde Warehouse
-DocType: Installation Note,Installation Date,Installasjonsdato
-apps/erpnext/erpnext/accounts/doctype/shareholder/shareholder.js +30,Share Ledger,Del Ledger
-apps/erpnext/erpnext/controllers/accounts_controller.py +605,Row #{0}: Asset {1} does not belong to company {2},Row # {0}: Asset {1} ikke tilhører selskapet {2}
-apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +206,Sales Invoice {0} created,Salgsfaktura {0} opprettet
-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 +50,Min Qty can not be greater than Max Qty,Min Antall kan ikke være større enn Max Antall
-DocType: Soil Texture,Silty Clay,Silty Clay
-DocType: Account,Accumulated Depreciation,akkumulerte avskrivninger
-DocType: Supplier Scorecard Scoring Standing,Standing Name,Stående navn
-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: Production Plan,Sales Orders Detail,Salgsordre detalj
-DocType: Bin,Requested Quantity,Requested Antall
-DocType: Patient,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-
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +50,Idevise,Idevise
-DocType: Salary Slip,Gross Pay - Total Deduction - Loan Repayment,Brutto lønn - Totalt Fradrag - Loan Nedbetaling
-apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +29,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 +45,Salary Slip ID,Lønn Slip ID
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +118,Date Of Retirement must be greater than Date of Joining,Pensjoneringstidspunktet må være større enn tidspunktet for inntreden
-apps/erpnext/erpnext/stock/doctype/item/item.js +68,Multiple Variants,Flere variasjoner
-DocType: Sales Invoice,Against Income Account,Mot Inntekt konto
-apps/erpnext/erpnext/controllers/website_list_for_contact.py +117,{0}% Delivered,{0}% Leveres
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +107,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
-apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +49,Please login as another user.,Vennligst logg inn som en annen bruker.
-DocType: Daily Work Summary Group User,Daily Work Summary Group User,Daglig arbeidsoppsummeringsgruppebruker
-DocType: Territory,Territory Targets,Terri Targets
-DocType: Soil Analysis,Ca/Mg,Ca / Mg
-DocType: Delivery Note,Transporter Info,Transporter Info
-apps/erpnext/erpnext/accounts/utils.py +502,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 +33,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
-,Warehouse wise Item Balance Age and Value,Lagerbetraktet Varebalanse Alder og verdi
-DocType: Purchase Order Item Supplied,Purchase Order Item Supplied,Innkjøpsordre Sak Leveres
-apps/erpnext/erpnext/public/js/setup_wizard.js +94,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
-DocType: Member,Member Name,Medlemsnavn
-DocType: Stock Settings,Use Naming Series,Bruk Naming Series
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +218,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/templates/emails/recurring_document_failed.html +10,in the subscription,i abonnementet
-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.
-DocType: Membership,Payment Details,Betalingsinformasjon
-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 +472,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: Supplier Scorecard Scoring Standing,Supplier Scorecard Scoring Standing,Leverandør Scorecard Scoring Standing
-DocType: Manufacturer,Manufacturers used in Items,Produsenter som brukes i Items
-apps/erpnext/erpnext/accounts/general_ledger.py +168,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
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +332,Credit ({0}),Kreditt ({0})
-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
-DocType: Land Unit,Land Unit,Land Unit
-,Purchase Analytics,Kjøps Analytics
-DocType: Sales Invoice Item,Delivery Note Item,Levering Note Element
-DocType: Asset Maintenance Log,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."
-DocType: Asset Settings,Number of Days in Fiscal Year,Antall dager i regnskapsåret
-,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 +92,Purpose must be one of {0},Hensikten må være en av {0}
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +100,Fill the form and save it,Fyll ut skjemaet og lagre det
-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 +52,Actual qty in stock,Faktisk antall på lager
-apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +52,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
-apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +46,Send SMS,Send SMS
-DocType: Supplier Scorecard Criteria,Max Score,Max score
-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: Hotel Room Amenity,Billable,Fakturerbare
-DocType: Lab Test Template,Standard Selling Rate,Standard salgskurs
-DocType: Account,Rate at which this tax is applied,Hastigheten som denne skatten er brukt
-DocType: Cash Flow Mapper,Section Name,Seksjonsnavn
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +77,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/manufacturing/doctype/bom_update_tool/bom_update_tool.py +60,Queued for updating latest price in all Bill of Materials. It may take a few minutes.,I kø for å oppdatere siste pris i alle Materialebevis. Det kan ta noen minutter.
-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
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +201,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
-apps/erpnext/erpnext/config/setup.py +37,Country wise default Address Templates,Country klok standardadresse Maler
-DocType: Water Analysis,Appearance,Utseende
-apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +70,Avg. Buying Price List Rate,Nr. Kjøpe prisliste rate
-DocType: Sales Order Item,Supplier delivers to Customer,Leverandør leverer til kunden
-apps/erpnext/erpnext/config/non_profit.py +23,Member information.,Medlemsinformasjon.
-apps/erpnext/erpnext/utilities/bot.py +34,[{0}](#Form/Item/{0}) is out of stock,[{0}] (# Form / post / {0}) er utsolgt
-apps/erpnext/erpnext/assets/doctype/asset/asset.js +58,Asset Maintenance,Asset Maintenance
-,Sales Payment Summary,Salgsbetalingssammendrag
-DocType: Restaurant,Restaurant,Restaurant
-apps/erpnext/erpnext/accounts/party.py +321,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
-DocType: Patient,Account Details,kontodetaljer
-DocType: Crop,Materials Required,Materialer som kreves
-apps/erpnext/erpnext/education/doctype/student_group/student_group.py +76,No students Found,Ingen studenter Funnet
-DocType: Medical Department,Medical Department,Medisinsk avdeling
-DocType: Supplier Scorecard Scoring Criteria,Supplier Scorecard Scoring Criteria,Leverandør Scorecard Scoring Criteria
-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: Purchase Invoice,Rounded Total,Avrundet Total
-DocType: Product Bundle,List items that form the package.,Listeelementer som danner pakken.
-apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.py +39,Not permitted. Please disable the Test Template,Ikke tillatt. Vennligst deaktiver testmalen
-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%
-DocType: Crop Cycle,Linked Land Unit,Tilknyttet landsenhet
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +584,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/assets/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 +222,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 +62,Company (not Customer or Supplier) master.,Company (ikke kunde eller leverandør) mester.
-apps/erpnext/erpnext/education/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/education/doctype/student_attendance_tool/student_attendance_tool.js +178,No Students in,Ingen studenter i
-apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +179,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 +212,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/utilities/user_progress.py +256,Go to Users,Gå til Brukere
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +85,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 +131,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 +16,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: Fee Schedule,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/projects/doctype/task/task.js +91,Cannot convert it to non-group. Child Tasks exist.,Kan ikke konvertere det til ikke-gruppe. Barnoppgaver eksisterer.
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +112,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/education/doctype/student/student.py +38,Student {0} exist against student applicant {1},Student {0} eksistere mot student Søkeren {1}
-DocType: Purchase Invoice,Rounding Adjustment (Company Currency),Avrundingsjustering (Bedriftsvaluta)
-apps/erpnext/erpnext/projects/doctype/task/task.js +39,Timesheet,Tids skjema
-DocType: Volunteer,Afternoon,Ettermiddag
-apps/erpnext/erpnext/controllers/accounts_controller.py +257,{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
-DocType: Customer,Credit Limit and Payment Terms,Kredittgrense og betalingsbetingelser
-apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +20,Item 3,Sak 3
-apps/erpnext/erpnext/restaurant/doctype/restaurant/restaurant.js +6,Order Entry,Bestillingsinngang
-DocType: Purchase Order,Customer Contact Email,Kundekontakt E-post
-DocType: Warranty Claim,Item and Warranty Details,Element og Garanti Detaljer
-DocType: Chapter,Chapter Members,Kapittelmedlemmer
-DocType: Sales Team,Contribution (%),Bidrag (%)
-apps/erpnext/erpnext/controllers/accounts_controller.py +101,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/projects/doctype/project/project.py +69,Project {0} already exists,Prosjektet {0} eksisterer allerede
-DocType: Medical Department,Nursing User,Sykepleier Bruker
-DocType: Plant Analysis,Plant Analysis Criterias,Plant Analyse Kriterier
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +238,Responsibilities,Ansvarsområder
-apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +125,Validity period of this quotation has ended.,Gyldighetsperioden for dette sitatet er avsluttet.
-DocType: Expense Claim Account,Expense Claim Account,Expense krav konto
-DocType: Accounts Settings,Allow Stale Exchange Rates,Tillat uaktuelle valutakurser
-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/utilities/user_progress.py +244,Add Users,Legg til brukere
-DocType: POS Item Group,Item Group,Varegruppe
-apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +16,Student Group: ,Studentgruppe:
-DocType: Item,Safety Stock,Safety Stock
-DocType: Healthcare Settings,Healthcare Settings,Helseinstitusjoner
-apps/erpnext/erpnext/projects/doctype/task/task.py +54,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 +475,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/assets/doctype/asset/asset.py +43,Item {0} must be a Fixed Asset Item,Element {0} må være et driftsmiddel element
-apps/erpnext/erpnext/stock/doctype/item/item.js +343,Make Variants,Lag variasjoner
-DocType: Item,Default BOM,Standard BOM
-DocType: Project,Total Billed Amount (via Sales Invoices),Sum fakturert beløp (via salgsfakturaer)
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +113,Debit Note Amount,Debet Note Beløp
-apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +106,"There are inconsistencies between the rate, no of shares and the amount calculated","Det er uoverensstemmelser mellom rente, antall aksjer og beregnet beløp"
-apps/erpnext/erpnext/setup/doctype/company/company.js +89,Please re-type company name to confirm,Vennligst re-type firmanavn for å bekrefte
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +211,Total Outstanding Amt,Total Outstanding Amt
-DocType: Journal Entry,Printing Settings,Utskriftsinnstillinger
-DocType: Employee Advance,Advance Account,Forhåndskonto
-DocType: Job Offer,Job Offer Terms,Jobbtilbudsbetingelser
-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/data/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 +414,Variable,variabel
-apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.js +47,From Delivery Note,Fra følgeseddel
-DocType: Chapter,Members,medlemmer
-DocType: Student,Student Email Address,Student e-postadresse
-DocType: Item,Hub Warehouse,Hub lager
-DocType: Assessment Plan,From Time,Fra Time
-DocType: Hotel Settings,Hotel Settings,Hotellinnstillinger
-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/data/industry_type.py +33,Investment Banking,Investment Banking
-DocType: Purchase Invoice,input,inngang
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +79,Cash or Bank Account is mandatory for making payment entry,Kontanter eller bankkontoen er obligatorisk for å gjøre betaling oppføring
-apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +54,Student Address,Studentadresse
-apps/erpnext/erpnext/education/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
-apps/erpnext/erpnext/accounts/doctype/account/account.py +251,Account Number {0} already used in account {1},Kontonummer {0} som allerede er brukt i konto {1}
-DocType: POS Profile,POS Profile Name,POS profilnavn
-DocType: Hotel Room Reservation,Booked,bestilt
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +45,CompAuxLib,CompAuxLib
-DocType: Purchase Invoice Item,Rate,Rate
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +104,Intern,Intern
-DocType: Delivery Stop,Address Name,Adressenavn
-DocType: Stock Entry,From BOM,Fra BOM
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +639,Splitting {0} units of {1},Splitting {0} enheter av {1}
-DocType: Assessment Code,Assessment Code,Assessment Kode
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +73,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/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/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py +37,Error evaluating the criteria formula,Feil ved vurdering av kriterieformelen
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +115,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/data/industry_type.py +9,Airline,Flyselskap
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +853,Issue Material,Issue Material
-apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +3,An error occured while creating recurring,Det oppstod en feil under oppretting
-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 +735,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/education/doctype/student_group_creation_tool/student_group_creation_tool.py +47,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 +56,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: Sales Invoice,Customer PO Details,Kunde PO Detaljer
-DocType: Subscription,Next Schedule Date,Neste planleggingsdato
-DocType: Stock Entry,Including items for sub assemblies,Inkludert elementer for sub samlinger
-DocType: Opening Invoice Creation Tool Item,Temporary Opening Account,Midlertidig åpningskonto
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1962,Enter value must be positive,Oppgi verdien skal være positiv
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/pos.py +446,All Territories,Alle Territories
-DocType: Purchase Invoice,Items,Elementer
-apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py +34,Student is already enrolled.,Student er allerede registrert.
-DocType: Fiscal Year,Year Name,År Navn
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +240,There are more holidays than working days this month.,Det er mer ferie enn virkedager denne måneden.
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +78,PDC/LC Ref,PDC / LC Ref
-DocType: Product Bundle Item,Product Bundle Item,Produktet Bundle Element
-DocType: Sales Partner,Sales Partner Name,Sales Partner Name
-apps/erpnext/erpnext/hooks.py +136,Request for Quotations,Forespørsel om Sitater
-DocType: Payment Reconciliation,Maximum Invoice Amount,Maksimal Fakturert beløp
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +50,Montantdevise,Montantdevise
-apps/erpnext/erpnext/healthcare/setup.py +210,Haematology,hematologi
-DocType: Normal Test Items,Normal Test Items,Normale testelementer
-DocType: Student Language,Student Language,student Språk
-apps/erpnext/erpnext/config/selling.py +23,Customers,kunder
-DocType: Cash Flow Mapping,Is Working Capital,Er arbeidskapital
-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%
-apps/erpnext/erpnext/config/healthcare.py +25,Record Patient Vitals,Opptak Pasient Vitals
-DocType: Fee Schedule,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/data/industry_type.py +46,Securities & Commodity Exchanges,Verdipapirer og råvarebørser
-apps/erpnext/erpnext/stock/doctype/item/item.py +688,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/hr/doctype/payroll_entry/payroll_entry.py +59,No employees for the mentioned criteria,Ingen ansatte for de nevnte kriteriene
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +946,No Items with Bill of Materials to Manufacture,Ingen elementer med Bill of Materials til Manufacture
-DocType: Hotel Settings,Default Customer,Standardkund
-DocType: Assessment Plan,Supervisor Name,Supervisor Name
-DocType: Healthcare Settings,Do not confirm if appointment is created for the same day,Bekreft ikke om avtalen er opprettet for samme dag
-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
-apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py +11,Scorecards,målstyring
-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 +24,Cash Flow from Operations,Kontantstrøm fra driften
-DocType: Purchase Invoice,Shipping Rule,Shipping Rule
-DocType: Patient Relation,Spouse,Ektefelle
-DocType: Lab Test Groups,Add Test,Legg til test
-DocType: Manufacturer,Limited to 12 characters,Begrenset til 12 tegn
-DocType: Journal Entry,Print Heading,Print Overskrift
-apps/erpnext/erpnext/config/stock.py +146,Delivery Trip service tours to customers.,Leveringsturtjenesten til kunder.
-apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +57,Total cannot be zero,Totalt kan ikke være null
-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: Plant Analysis Criteria,Maximum Permissible Value,Maksimal tillatelig verdi
-DocType: Journal Entry Account,Employee Advance,Ansattes fremskritt
-DocType: Payroll Entry,Payroll Frequency,lønn Frequency
-DocType: Lab Test Template,Sensitivity,Følsomhet
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +932,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/controllers/buying_controller.py +457,Please enter Reqd by Date,Vennligst skriv inn reqd etter dato
-DocType: Payment Entry,Internal Transfer,Internal Transfer
-DocType: Asset Maintenance,Maintenance Tasks,Vedlikeholdsoppgaver
-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/accounts/doctype/journal_entry/journal_entry.js +366,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.
-DocType: Crop Cycle,Detected Disease,Oppdaget sykdom
-,Produced,Produsert
-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 +372,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/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 +144,Match Payments with Invoices,Match Betalinger med Fakturaer
-DocType: Journal Entry,Bank Entry,Bank Entry
-DocType: Authorization Rule,Applicable To (Designation),Gjelder til (Betegnelse)
-,Profitability Analysis,lønnsomhets~~POS=TRUNC
-DocType: Fees,Student Email,Student e-post
-DocType: Supplier,Prevent POs,Forhindre PO&#39;er
-DocType: Patient,"Allergies, Medical and Surgical History","Allergier, medisinsk og kirurgisk historie"
-apps/erpnext/erpnext/templates/generators/item.html +77,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 +298,Enable / disable currencies.,Aktivere / deaktivere valutaer.
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +110,Dr {0} on Half day Leave on {1},Dr {0} på halv dag permisjon på {1}
-DocType: Production Plan,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/data/industry_type.py +26,Entertainment & Leisure,Entertainment &amp; Leisure
-,Item Variant Details,Varevarianter Detaljer
-DocType: Quality Inspection,Item Serial No,Sak Serial No
-apps/erpnext/erpnext/utilities/activation.py +135,Create Employee Records,Lag Medarbeider Records
-apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68,Total Present,Total Present
-apps/erpnext/erpnext/config/accounts.py +105,Accounting Statements,regnskaps~~POS=TRUNC Uttalelser
-DocType: Drug Prescription,Hour,Time
-DocType: Restaurant Order Entry,Last Sales Invoice,Siste salgsfaktura
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +789,Please select Qty against item {0},Vennligst velg antall til elementet {0}
-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 +115,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 +392,All these items have already been invoiced,Alle disse elementene er allerede blitt fakturert
-DocType: Company,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: Hotel Room,Hotel Room Type,Hotellromtype
-DocType: Item,Default Material Request Type,Standard Material Request Type
-DocType: Supplier Scorecard,Evaluation Period,Evalueringsperiode
-apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_list.js +13,Unknown,Ukjent
-DocType: Shipping Rule,Shipping Rule Conditions,Frakt Regel betingelser
-DocType: Purchase Invoice,Export Type,Eksporttype
-DocType: Salary Slip Loan,Salary Slip Loan,Lønnsslipplån
-DocType: BOM Update Tool,The new BOM after replacement,Den nye BOM etter utskiftning
-,Point of Sale,Utsalgssted
-DocType: Payment Entry,Received Amount,mottatt beløp
-DocType: Patient,Widow,Enke
-DocType: GST Settings,GSTIN Email Sent On,GSTIN Email Sent On
-DocType: Program Enrollment,Pick/Drop by Guardian,Pick / Drop av Guardian
-DocType: Crop,Planting UOM,Planting UOM
-DocType: Account,Tax,Skatte
-apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py +45,Not Marked,ikke Merket
-apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html +1,Opening Invoices Summary,Åpning av fakturaoversikt
-DocType: Education Settings,Education Manager,Utdannelsesleder
-DocType: Crop Cycle,The minimum length between each plant in the field for optimum growth,Minimale lengde mellom hver plante i feltet for optimal vekst
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +152,"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 +152,"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: Water Analysis,Type of Sample,Type prøve
-DocType: Batch,Source Document Name,Kilde dokumentnavn
-DocType: Batch,Source Document Name,Kilde dokumentnavn
-DocType: Production Plan,Get Raw Materials For Production,Få råmaterialer til produksjon
-DocType: Job Opening,Job Title,Jobbtittel
-apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py +84,"{0} indicates that {1} will not provide a quotation, but all items \
-					have been quoted. Updating the RFQ quote status.","{0} indikerer at {1} ikke vil gi et tilbud, men alle elementer \ er blitt sitert. Oppdaterer RFQ sitatstatus."
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1012,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,Maksimale prøver - {0} har allerede blitt beholdt for Batch {1} og Item {2} i Batch {3}.
-apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +125,Please Set Supplier Type in Buying Settings.,Vennligst sett Leverandør Type i Kjøpsinnstillinger.
-DocType: Manufacturing Settings,Update BOM Cost Automatically,Oppdater BOM Kostnad automatisk
-DocType: Lab Test,Test Name,Testnavn
-apps/erpnext/erpnext/utilities/activation.py +99,Create Users,Lag brukere
-apps/erpnext/erpnext/utilities/user_progress.py +144,Gram,Gram
-DocType: Supplier Scorecard,Per Month,Per måned
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +433,Quantity to Manufacture must be greater than 0.,Antall å Manufacture må være større enn 0.
-DocType: Asset Settings,Calculate Prorated Depreciation Schedule Based on Fiscal Year,Beregn Prorated Depreciation Schedule Basert på Skatteår
-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 +128,New Batch ID (Optional),Ny batch-ID (valgfritt)
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +128,New Batch ID (Optional),Ny batch-ID (valgfritt)
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +201,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 +47,Net Change in Equity,Netto endring i egenkapital
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +220,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 +871,Receipt,Kvittering
-,Sales Register,Salg Register
-DocType: Daily Work Summary Group,Send Emails At,Send e-post til
-DocType: Quotation,Quotation Lost Reason,Sitat av Lost Reason
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +374,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 +116,Summary for this month and pending activities,Oppsummering for denne måneden og ventende aktiviteter
-apps/erpnext/erpnext/utilities/user_progress.py +245,"Add users to your organization, other than yourself.","Legg til brukere i organisasjonen din, bortsett fra deg selv."
-DocType: Customer Group,Customer Group Name,Kundegruppenavn
-apps/erpnext/erpnext/public/js/pos/pos.html +98,No Customers yet!,Ingen kunder ennå!
-apps/erpnext/erpnext/public/js/financial_statements.js +56,Cash Flow Statement,Kontantstrømoppstilling
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py +472,No material request created,Ingen materiell forespørsel opprettet
-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 +491,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: Physician,Phone (R),Telefon (R)
-apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +50,Time slots added,Tidsluker lagt til
-DocType: Item,Attributes,Egenskaper
-apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +31,Enable Template,Aktiver mal
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +226,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
-DocType: Patient,B Negative,B Negativ
-apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +25,Maintenance Status has to be Cancelled or Completed to Submit,Vedlikeholdsstatus må avbrytes eller fullføres for å sende inn
-DocType: Hotel Room,Hotel Room,Hotellrom
-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 +884,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: Agriculture Task,Start Day,Start dag
-DocType: Vehicle,Chassis No,chassis Nei
-DocType: Payment Request,Initiated,Initiert
-DocType: Production Order,Planned Start Date,Planlagt startdato
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +613,Please select a BOM,Vennligst velg en BOM
-DocType: Purchase Invoice,Availed ITC Integrated Tax,Benyttet ITC Integrated Tax
-DocType: Serial No,Creation Document Type,Creation dokumenttype
-DocType: Project Task,View Timesheet,Se tidsskema
-apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +54,End date must be greater than start date,Sluttdato må være større enn startdato
-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
-apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +30,End on,Slutt på
-DocType: Project,Expected End Date,Forventet sluttdato
-DocType: Budget Account,Budget Amount,budsjett~~POS=TRUNC
-DocType: Donor,Donor Name,Donornavn
-DocType: Appraisal Template,Appraisal Template Title,Appraisal Mal Tittel
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +39,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/utilities/user_progress_utils.py +29,Commercial,Commercial
-DocType: Patient,Alcohol Current Use,Alkoholstrømbruk
-DocType: Student Admission Program,Student Admission Program,Studentopptaksprogram
-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/hr/doctype/payroll_entry/payroll_entry.py +461,"Could not submit any Salary Slip <br>\
-			Possible reasons: <br>\
-			1. Net pay is less than 0. <br>\
-			2. Company Email Address specified in employee master is not valid. <br>","Kunne ikke sende inn Lønnsslipp <br> \ Mulige årsaker: <br> \ 1. Netto lønn er mindre enn 0. <br> \ 2. Firmaets e-postadresse som er oppgitt i ansattmesteren, er ikke gyldig. <br>"
-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 +695,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/templates/emails/recurring_document_failed.html +6,and unchcked Disabled in the,og unchcked Disabled in the
-apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +46,Series is mandatory,Serien er obligatorisk
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +28,Financial Services,Finansielle Tjenester
-DocType: Student Sibling,Student ID,Student ID
-apps/erpnext/erpnext/config/projects.py +46,Types of activities for Time Logs,Typer aktiviteter for Tid Logger
-DocType: Opening Invoice Creation Tool,Sales,Salgs
-DocType: Stock Entry Detail,Basic Amount,Grunnbeløp
-DocType: Training Event,Exam,Eksamen
-DocType: Complaint,Complaint,Klage
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +462,Warehouse required for stock Item {0},Warehouse nødvendig for lager Element {0}
-DocType: Leave Allocation,Unused leaves,Ubrukte blader
-DocType: Patient,Alcohol Past Use,Alkohol Tidligere Bruk
-DocType: Fertilizer Content,Fertilizer Content,Gjødselinnhold
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +187,Cr,Cr
-DocType: Tax Rule,Billing State,Billing State
-DocType: Share Transfer,Transfer,Transfer
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +917,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 +136,Due Date is mandatory,Due Date er obligatorisk
-apps/erpnext/erpnext/controllers/item_variant.py +82,Increment for Attribute {0} cannot be 0,Økning for Egenskap {0} kan ikke være 0
-apps/erpnext/erpnext/hotels/report/hotel_room_occupancy/hotel_room_occupancy.py +19,Rooms Booked,Rom bestilles
-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: Shareholder,Contact HTML,Kontakt HTML
-apps/erpnext/erpnext/healthcare/doctype/healthcare_settings/healthcare_settings.py +19,Registration fee can not be Zero,Registreringsavgift kan ikke være null
-DocType: Disease,Treatment Period,Behandlingsperiode
-apps/erpnext/erpnext/education/api.py +338,Result already Submitted,Resultat allerede sendt
-apps/erpnext/erpnext/controllers/buying_controller.py +169,Reserved Warehouse is mandatory for Item {0} in Raw Materials supplied,Reservert lager er obligatorisk for vare {0} i råvarer som leveres
-,Inactive Customers,inaktive kunder
-DocType: Student Admission Program,Maximum Age,Maksimal alder
-apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +28,Please wait 3 days before resending the reminder.,Vennligst vent 3 dager før du sender påminnelsen på nytt.
-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: Cheque Print Template,Message to show,Melding for visning
-apps/erpnext/erpnext/public/js/setup_wizard.js +28,Retail,Retail
-DocType: Student Attendance,Absent,Fraværende
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +591,Product Bundle,Produktet Bundle
-apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +38,Unable to find score starting at {0}. You need to have standing scores covering 0 to 100,Kan ikke finne poeng som starter ved {0}. Du må ha stående poeng som dekker 0 til 100
-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: 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: Hotel Room Amenity,Hotel Room Amenity,Hotel Romfasiliteter
-DocType: Payment Entry,Account Paid From,Konto betalt fra
-DocType: Purchase Order Item Supplied,Raw Material Item Code,Raw Material Elementkode
-DocType: Task,Parent Task,Foreldreoppgave
-DocType: Journal Entry,Write Off Based On,Skriv Off basert på
-apps/erpnext/erpnext/utilities/activation.py +65,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 +809,Send Supplier Emails,Send Leverandør e-post
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +97,"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."
-DocType: Chapter Member,Leave Reason,Legg igjen grunn
-DocType: Guardian Interest,Guardian Interest,Guardian Rente
-DocType: Volunteer,Availability,Tilgjengelighet
-apps/erpnext/erpnext/config/accounts.py +319,Setup default values for POS Invoices,Oppsett standardverdier for POS-fakturaer
-apps/erpnext/erpnext/config/hr.py +182,Training,Opplæring
-DocType: Timesheet,Employee Detail,Medarbeider Detalj
-apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +58,Guardian1 Email ID,Guardian1 Email ID
-apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +58,Guardian1 Email ID,Guardian1 Email ID
-apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +68,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
-DocType: Lab Prescription,Test Code,Testkode
-apps/erpnext/erpnext/config/website.py +11,Settings for website homepage,Innstillinger for nettstedet hjemmeside
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +40,RFQs are not allowed for {0} due to a scorecard standing of {1},RFQ er ikke tillatt for {0} på grunn av et resultatkort som står for {1}
-DocType: Job Offer,Awaiting Response,Venter på svar
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +60,Above,Fremfor
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1462,Total Amount {0},Totalt beløp {0}
-apps/erpnext/erpnext/controllers/item_variant.py +303,Invalid attribute {0} {1},Ugyldig egenskap {0} {1}
-DocType: Supplier,Mention if non-standard payable account,Nevn hvis ikke-standard betalingskonto
-apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.py +25,Please select the assessment group other than 'All Assessment Groups',Vennligst velg vurderingsgruppen annet enn &#39;Alle vurderingsgrupper&#39;
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +67,Row {0}: Cost center is required for an item {1},Row {0}: Kostnadsstedet kreves for et element {1}
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +43,EcritureDate,EcritureDate
-DocType: Training Event Employee,Optional,Valgfri
-DocType: Salary Slip,Earning & Deduction,Tjene &amp; Fradrag
-DocType: Agriculture Analysis Criteria,Water Analysis,Vannanalyse
-DocType: Chapter,Region,Region
-apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +38,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 +110,Negative Valuation Rate is not allowed,Negative Verdivurdering Rate er ikke tillatt
-DocType: Holiday List,Weekly Off,Ukentlig Off
-apps/erpnext/erpnext/agriculture/doctype/crop_cycle/crop_cycle.js +7,Reload Linked Analysis,Last inn sammenkoblet analyse
-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: Patient,Other Risk Factors,Andre risikofaktorer
-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/healthcare/report/lab_test_report/lab_test_report.py +15,No record found,Ingen rekord funnet
-apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +140,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 +686,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 +72,Split,Dele
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +72,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 +156,Please enter 'Is Subcontracted' as Yes or No,Skriv inn &#39;Er underleverandør&#39; som Ja eller Nei
-DocType: Item,Default Purchase Unit of Measure,Standard innkjøpsenhet for mål
-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: Land Unit,Land Unit Details,Land Enhet Detaljer
-DocType: Land Unit,Latitude,Breddegrad
-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
-DocType: Program Enrollment Tool,Get Students From,Få studenter fra
-apps/erpnext/erpnext/config/learn.py +263,Publish Items on Website,Publiser Elementer på nettstedet
-apps/erpnext/erpnext/utilities/activation.py +126,Group your students in batches,Gruppe elevene i grupper
-DocType: Authorization Rule,Authorization Rule,Autorisasjon Rule
-DocType: POS Profile,Offline POS Section,Frakoblet POS-seksjon
-DocType: Sales Invoice,Terms and Conditions Details,Vilkår og betingelser Detaljer
-apps/erpnext/erpnext/templates/generators/item.html +100,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 +122,New Batch Qty,Ny batch Antall
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +122,New Batch Qty,Ny batch Antall
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +10,Apparel & Accessories,Klær og tilbehør
-apps/erpnext/erpnext/buying/doctype/supplier_scorecard_period/supplier_scorecard_period.py +91,Could not solve weighted score function. Make sure the formula is valid.,Kunne ikke løse vektet poengsumfunksjon. Pass på at formelen er gyldig.
-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: Program Enrollment,Institute's Bus,Instituttets buss
-DocType: Accounts Settings,Role Allowed to Set Frozen Accounts & Edit Frozen Entries,Rolle lov til å sette Frosne Kontoer og Rediger Frosne Entries
-DocType: Supplier Scorecard Scoring Variable,Path,Sti
-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
-DocType: Production Plan,Total Planned Qty,Totalt planlagt antall
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +68,Opening Value,åpning Verdi
-DocType: Salary Detail,Formula,Formel
-apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +47,Serial #,Serial #
-DocType: Lab Test Template,Lab Test Template,Lab Test Template
-apps/erpnext/erpnext/setup/doctype/company/company.py +181,Sales Account,Salgskonto
-DocType: Purchase Invoice Item,Total Weight,Total vekt
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +94,Commission on Sales,Provisjon på salg
-DocType: Job Offer Term,Value / Description,Verdi / beskrivelse
-apps/erpnext/erpnext/controllers/accounts_controller.py +629,"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
-DocType: Restaurant Order Entry,Restaurant Order Entry,Restaurant Bestillingsinngang
-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}.
-DocType: Asset Maintenance Task,Assign To Name,Tilordne til navn
-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 +98,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 +222,Sales Invoice {0} must be cancelled before cancelling this Sales Order,Salg Faktura {0} må slettes før den sletter denne salgsordre
-DocType: Consultation,Age,Alder
-DocType: Sales Invoice Timesheet,Billing Amount,Faktureringsbeløp
-DocType: Cash Flow Mapping,Select Maximum Of 1,Velg Maksimum 1
-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.
-DocType: Company,Default Employee Advance Account,Standard ansattskonto
-apps/erpnext/erpnext/config/hr.py +60,Applications for leave.,Søknader om permisjon.
-apps/erpnext/erpnext/accounts/doctype/account/account.py +164,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 +140,Please select quantity on row ,Vennligst velg antall på rad
-apps/erpnext/erpnext/config/accounts.py +277,Make Opening Sales and Purchase Invoices,Lag åpne salgs- og kjøpsfakturaer
-DocType: Purchase Invoice,Posting Time,Postering Tid
-DocType: Timesheet,% Amount Billed,% Mengde Fakturert
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +130,"""Time Per Appointment"" hasn""t been set for Dr {0}. Add it in Physician master.",&quot;Tid per ansettelse&quot; har ikke blitt satt til Dr {0}. Legg det i Leger mester.
-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 +131,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/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/accounts/doctype/subscription/subscription.py +50,Add custom field Subscription in the doctype {0},Legg til egendefinert felt Abonnement i doktypen {0}
-apps/erpnext/erpnext/controllers/accounts_controller.py +813,Account: {0} with currency: {1} can not be selected,Konto: {0} med valuta: {1} kan ikke velges
-DocType: Purchase Receipt Item,Sample Quantity,Prøvekvantitet
-DocType: Manufacturing Settings,"Update BOM cost automatically via Scheduler, based on latest valuation rate / price list rate / last purchase rate of raw materials.","Oppdater BOM kostnad automatisk via Scheduler, basert på siste verdivurdering / prisliste rate / siste kjøpshastighet av råvarer."
-DocType: Bank Reconciliation Detail,Cheque Date,Sjekk Dato
-apps/erpnext/erpnext/accounts/doctype/account/account.py +50,Account {0}: Parent account {1} does not belong to company: {2},Konto {0}: Parent konto {1} ikke tilhører selskapet: {2}
-apps/erpnext/erpnext/setup/doctype/company/company.js +106,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
-DocType: Healthcare Settings,Out Patient SMS Alerts,Ut Patient SMS Alerts
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +100,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 +811,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 +112,Total Paid Amount,Totalt innbetalt beløp
-DocType: GST Settings,B2C Limit,B2C Limit
-DocType: Production Order Item,Transferred Qty,Overført Antall
-apps/erpnext/erpnext/config/learn.py +11,Navigating,Navigere
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +188,Planning,Planlegging
-DocType: Share Balance,Issued,Utstedt
-apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +14,Student Activity,Studentaktivitet
-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 +277,Quantity should be greater than 0,Mengden skal være større enn 0
-DocType: Journal Entry,Cash Entry,Cash Entry
-DocType: Production Plan,Get Items For Production Order,Få varer for produksjonsordre
-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 +280,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: Plant Analysis,Collection Datetime,Samling Datetime
-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 +71,Company Abbreviation,Firma Forkortelse
-apps/erpnext/erpnext/healthcare/doctype/physician/physician.py +57,User {0} does not exist,Bruker {0} finnes ikke
-DocType: Payment Term,Day(s) after invoice date,Dag (er) etter faktura dato
-DocType: Payment Schedule,Payment Schedule,Nedbetalingsplan
-DocType: Subscription,SUB-,UNDER-
-DocType: Item Attribute Value,Abbreviation,Forkortelse
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +182,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.
-apps/erpnext/erpnext/healthcare/setup.py +241,Pathology,Patologi
-DocType: Restaurant Order Entry,Restaurant Table,Restaurantbord
-DocType: Hotel Room,Hotel Manager,Hotell sjef
-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 +49,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/operations/install_fixtures.py +143,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 +774,{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 +43,Tax Template is mandatory.,Skatt Mal er obligatorisk.
-apps/erpnext/erpnext/accounts/doctype/account/account.py +44,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
-,Item Price Stock,Varen Pris Lager
-DocType: Lab Prescription,Test Created,Test laget
-DocType: Healthcare Settings,Custom Signature in Print,Tilpasset signatur i utskrift
-DocType: Account,Temporary,Midlertidig
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +102,Customer LPO No.,Kunde LPO nr.
-DocType: Program,Courses,kurs
-DocType: Monthly Distribution Percentage,Percentage Allocation,Prosentvis Allocation
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +128,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
-DocType: Supplier Scorecard Criteria,Criteria Name,Kriterium Navn
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1295,Please set Company,Vennligst sett selskap
-DocType: Pricing Rule,Buying,Kjøpe
-apps/erpnext/erpnext/config/agriculture.py +24,Diseases & Fertilizers,Sykdommer og gjødsel
-DocType: HR Settings,Employee Records to be created by,Medarbeider Records å være skapt av
-DocType: Patient,AB Negative,AB Negativ
-DocType: Sample Collection,SMPL-,SMPL-
-DocType: POS Profile,Apply Discount On,Påfør rabatt på
-DocType: Member,Membership Type,Medlemskapstype
-,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/accounts/report/accounts_receivable/accounts_receivable.js +88,Show PDC in Print,Vis PDC i Print
-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/hr/doctype/job_applicant/job_applicant.js +13,Job Offer,Jobbtilbud
-apps/erpnext/erpnext/public/js/setup_wizard.js +71,Institute Abbreviation,Institute forkortelse
-,Item-wise Price List Rate,Element-messig Prisliste Ranger
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1073,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 +160,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 +160,Quantity ({0}) cannot be a fraction in row {1},Antall ({0}) kan ikke være en brøkdel i rad {1}
-DocType: Consultation,C-,C-
-DocType: Attendance,ATT-,ATT-
-apps/erpnext/erpnext/stock/doctype/item/item.py +491,Barcode {0} already used in Item {1},Barcode {0} allerede brukt i Element {1}
-apps/erpnext/erpnext/config/selling.py +86,Rules for adding shipping costs.,Regler for å legge til fraktkostnader.
-DocType: Hotel Room,Extra Bed Capacity,Ekstra seng kapasitet
-DocType: Item,Opening Stock,åpning Stock
-apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +20,Customer is required,Kunden må
-DocType: Lab Test,Result Date,Resultatdato
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +77,PDC/LC Date,PDC / LC-dato
-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/utilities/user_progress.py +249,user@example.com,user@example.com
-DocType: Asset,Asset Owner,Asset Eier
-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/data/industry_type.py +15,Brokerage,Brokerage
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +196,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 +567,POS Profile required to make POS Entry,POS Profile nødvendig å foreta POS Entry
-DocType: Program Enrollment Tool,Enroll Students,Meld Studenter
-DocType: Lab Test,Approved Date,Godkjent dato
-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 +152,Atleast one warehouse is mandatory,Minst én lageret er obligatorisk
-DocType: Serial No,Out of Warranty,Ut av Garanti
-DocType: BOM Update 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: Antibiotic,Laboratory User,Laboratoriebruker
-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 +229,Human Resource,Menneskelig Resurs
-DocType: Payment Reconciliation Payment,Payment Reconciliation Payment,Betaling Avstemming Betaling
-DocType: Disease,Treatment Task,Behandlingsoppgave
-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 +653,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 Update 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: Asset,Maintenance Required,Vedlikehold kreves
-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 +45,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 +599,Row #{0}: Asset is mandatory for fixed asset purchase/sale,Row # {0}: Asset er obligatorisk for anleggsmiddel kjøp / salg
-DocType: Asset Maintenance Team,Maintenance Team Name,Vedlikehold Lagnavn
-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/crm/doctype/opportunity/opportunity.py +197,Customer is mandatory if 'Opportunity From' is selected as Customer,Kunden er obligatorisk dersom &#39;Mulighet Fra&#39; er valgt som kunde
-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 +137,Types of Expense Claim.,Typer av Expense krav.
-apps/erpnext/erpnext/controllers/selling_controller.py +147,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
-DocType: Purchase Invoice,capital goods,kapitalvarer
-DocType: Purchase Invoice Item,Weight Per Unit,Vekt pr. Enhet
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +344,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/data/industry_type.py +42,Private Equity,Private Equity
-DocType: Supplier Scorecard Variable,Supplier Scorecard Variable,Leverandør Scorecard Variable
-DocType: Employee Loan,Fully Disbursed,fullt utbetalt
-DocType: Maintenance Visit,Customer Feedback,Customer Feedback
-DocType: Account,Expense,Expense
-apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.js +54,Score cannot be greater than Maximum Score,Score kan ikke være større enn Maksimal poengsum
-apps/erpnext/erpnext/utilities/user_progress.py +126,Customers and Suppliers,Kunder og leverandører
-DocType: Item Attribute,From Range,Fra Range
-DocType: BOM,Set rate of sub-assembly item based on BOM,Angi hastighet på underenhetens element basert på BOM
-DocType: Hotel Room Reservation,Invoiced,fakturert
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +98,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 +125,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 +109,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: Payment Term,Day(s) after the end of the invoice month,Dag (er) etter slutten av faktura måneden
-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
-apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +51,The 'From Package No.' field must neither be empty nor it's value less than 1.,Fra pakke nr. feltet må verken være tomt eller det er mindre enn 1.
-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
-DocType: Stock Entry Detail,Additional Cost,Tilleggs Cost
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +48,"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 +918,Make Supplier Quotation,Gjør Leverandør sitat
-DocType: Quality Inspection,Incoming,Innkommende
-apps/erpnext/erpnext/setup/doctype/company/company.js +70,Default tax templates for sales and purchase are created.,Standard skattemaler for salg og kjøp opprettes.
-apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.py +57,Assessment Result record {0} already exists.,Vurderingsresultatrekord {0} eksisterer allerede.
-DocType: BOM,Materials Required (Exploded),Materialer som er nødvendige (Exploded)
-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/templates/emails/recurring_document_failed.html +10,for generating the recurring,for å generere de tilbakevendende
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +86,Casual Leave,Casual La
-DocType: Agriculture Task,End Day,Endedag
-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 +112,This Week's Summary,Denne ukens oppsummering
-apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py +22,In Stock Qty,På lager Antall
-DocType: Delivery Trip,Calculate Estimated Arrival Times,Beregn anslåtte ankomsttider
-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
-DocType: Healthcare Settings,Patient Name,Pasientnavn
-DocType: Variant Field,Variant Field,Variantfelt
-DocType: Sales Order,Delivery Date,Leveringsdato
-DocType: Opportunity,Opportunity Date,Opportunity Dato
-DocType: Purchase Receipt,Return Against Purchase Receipt,Tilbake Against Kjøpskvittering
-DocType: Water Analysis,Person Responsible,Ansvarlig person
-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: Education 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.
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +103,Piecework,Akkord
-apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +70,Avg. Buying Rate,Avg. Kjøpe Rate
-DocType: Share Balance,From No,Fra nr
-DocType: Task,Actual Time (in Hours),Virkelig tid (i timer)
-DocType: Employee,History In Company,Historie I selskapet
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +270,New Message from {sender},Ny melding fra {avsender}
-DocType: Customer,Customer Primary Address,Kunde hovedadresse
-apps/erpnext/erpnext/config/learn.py +107,Newsletters,Nyhetsbrev
-DocType: Drug Prescription,Description/Strength,Beskrivelse / styrke
-DocType: Share Balance,Is Company,Er selskapet
-DocType: Stock Ledger Entry,Stock Ledger Entry,Stock Ledger Entry
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +83,Same item has been entered multiple times,Samme element er angitt flere ganger
-DocType: Department,Leave Block List,La Block List
-DocType: Purchase 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/education/doctype/student_applicant/student_applicant.js +11,Approve,Vedta
-apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +69,"Malformatted address for {0}, please fix to continue.","Malformatted adresse for {0}, vær så snill å fikse for å fortsette."
-apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +28,"Number of new Account, it will be included in the account name as a prefix","Antall ny konto, den vil bli inkludert i kontonavnet som prefiks"
-DocType: Maintenance Team Member,Team Member,Teammedlem
-apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js +151,No Result to submit,Ingen resultat å sende inn
-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 +79,"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 +377,{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
-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/operations/install_fixtures.py +207,Black,Svart
-DocType: BOM Explosion Item,BOM Explosion Item,BOM Explosion Element
-DocType: Shareholder,Contact List,Kontaktliste
-DocType: Account,Auditor,Revisor
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +132,{0} items produced,{0} elementer produsert
-apps/erpnext/erpnext/utilities/user_progress.py +55,Learn More,Lære mer
-DocType: Cheque Print Template,Distance from top edge,Avstand fra øvre kant
-apps/erpnext/erpnext/stock/get_item_details.py +367,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 +178,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/public/js/utils/item_quick_entry.js +14,"Edit in full page for more options like assets, serial nos, batches etc.","Rediger på full side for flere alternativer som eiendeler, serienummer, batcher etc."
-apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +10,Appointments and Consultations,Utnevnelser og konsultasjoner
-apps/erpnext/erpnext/education/doctype/student_group/student_group.py +41,{0} - {1} is not enrolled in the Batch {2},{0} - {1} er ikke påmeldt i batch {2}
-apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +113,"Asset {0} cannot be scrapped, as it is already {1}","Asset {0} kan ikke bli vraket, som det er allerede {1}"
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +72,Cheques Required,Sjekker påkrevd
-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/setup/setup_wizard/setup_wizard.py +40,Failed to setup company,Kunne ikke opprette selskapet
-DocType: Asset Repair,Asset Repair,Asset Repair
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +142,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
-DocType: Patient,Additional information regarding the patient,Ytterligere informasjon om pasienten
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +585,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 +204,Fleet Management,Flåtestyring
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1071,Add items from,Legg elementer fra
-apps/erpnext/erpnext/config/agriculture.py +7,Crops & Lands,Crops &amp; Lands
-DocType: Cheque Print Template,Regular,Regelmessig
-DocType: Fertilizer,Density (if liquid),Tetthet (hvis flytende)
-apps/erpnext/erpnext/education/doctype/course/course.py +20,Total Weightage of all Assessment Criteria must be 100%,Totalt weightage av alle vurderingskriteriene må være 100%
-DocType: Purchase Order Item,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
-DocType: Lab Test,Mobile,Mobil
-,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 +74,Warehouse {0} does not exist,Warehouse {0} finnes ikke
-DocType: Monthly Distribution,Monthly Distribution Percentages,Månedlig Distribusjonsprosent
-apps/erpnext/erpnext/stock/doctype/batch/batch.py +110,The selected item cannot have Batch,Den valgte elementet kan ikke ha Batch
-DocType: Delivery Note,% of materials delivered against this Delivery Note,% Av materialer leveres mot denne følgeseddel
-DocType: Asset Maintenance Log,Has Certificate,Har sertifikat
-DocType: Project,Customer Details,Kunde Detaljer
-DocType: Asset,Check if Asset requires Preventive Maintenance or Calibration,Sjekk om Asset krever forebyggende vedlikehold eller kalibrering
-apps/erpnext/erpnext/public/js/setup_wizard.js +87,Company Abbreviation cannot have more than 5 characters,Selskapets forkortelse kan ikke inneholde mer enn 5 tegn
-DocType: Employee,Reports to,Rapporter til
-,Unpaid Expense Claim,Ubetalte Expense krav
-DocType: Payment Entry,Paid Amount,Innbetalt beløp
-apps/erpnext/erpnext/utilities/user_progress.py +155,Explore Sales Cycle,Utforsk salgssyklusen
-DocType: Assessment Plan,Supervisor,Supervisor
-apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +869,Retention Stock Entry,Beholdningsinngang
-,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
-apps/erpnext/erpnext/education/doctype/instructor/instructor.js +24,As Supervisor,Som veileder
-DocType: BOM Scrap Item,BOM Scrap Item,BOM Scrap Element
-apps/erpnext/erpnext/accounts/page/pos/pos.js +895,Submitted orders can not be deleted,Innsendte bestillinger kan ikke slettes
-apps/erpnext/erpnext/accounts/doctype/account/account.py +114,"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/operations/install_fixtures.py +118,Quality Management,Kvalitetsstyring
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +41,Item {0} has been disabled,Element {0} har blitt deaktivert
-DocType: Project,Total Billable Amount (via Timesheets),Totalt fakturerbart beløp (via tidsskrifter)
-DocType: Agriculture Task,Previous Business Day,Tidligere arbeidsdag
-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 +210,Credit Note Amt,Kreditt notat Amt
-DocType: Employee External Work History,Employee External Work History,Ansatt Ekstern Work History
-DocType: Opening Invoice Creation Tool,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
-apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.js +15,Enrolling students,Registrering av studenter
-DocType: Item Group,Parent Item Group,Parent varegruppe
-DocType: Appointment Type,Appointment Type,Avtale Type
-apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +21,{0} for {1},{0} for {1}
-DocType: Healthcare Settings,Valid number of days,Gyldig antall dager
-apps/erpnext/erpnext/setup/doctype/company/company.js +39,Cost Centers,Kostnadssteder
-DocType: Land Unit,Linked Plant Analysis,Linked Plant Analysis
-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 +177,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
-apps/erpnext/erpnext/config/accounts.py +308,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/accounts/doctype/payment_terms_template/payment_terms_template.py +25,Combined invoice portion must equal 100%,Kombinert fakturaport må være 100%
-DocType: Item Group,Default Expense Account,Standard kostnadskonto
-DocType: GST Account,CGST Account,CGST-konto
-apps/erpnext/erpnext/education/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 +2494,Select items to save the invoice,Velg elementer for å lagre fakturaen
-DocType: Employee,Encashment Date,Encashment Dato
-DocType: Training Event,Internet,Internett
-DocType: Special Test Template,Special Test Template,Spesiell testmal
-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/config/accounts.py +471,List of all share transactions,Liste over alle aksje transaksjoner
-apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +18,Opp Count,Opptelling
-apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +244,Please find attached {0} #{1},Vedlagt {0} # {1}
-apps/erpnext/erpnext/accounts/report/share_balance/share_balance.py +52,Average Rate,Gjennomsnittlig rente
-apps/erpnext/erpnext/controllers/accounts_controller.py +721,Total Payment Amount in Payment Schedule must be equal to Grand / Rounded Total,Totalt betalingsbeløp i betalingsplan må være lik Grand / Rounded Total
-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: Buying Settings,"If enabled, last purchase details of items will not be fetched from previous purchase order or purchase receipt","Hvis aktivert, vil siste kjøpsdetaljer for elementer ikke bli hentet fra tidligere innkjøpsordre eller kjøpskvittering"
-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
-apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +28,Opening {0} Invoice created,Åpning {0} Faktura opprettet
-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 Update Tool,Current BOM,Nåværende BOM
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html +25,Balance (Dr - Cr),Balanse (Dr - Cr)
-apps/erpnext/erpnext/public/js/utils.js +55,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/assets/doctype/asset_movement/asset_movement.py +18,{0} asset cannot be transferred,{0} eiendelen kan ikke overføres
-DocType: Hotel Room Pricing,Hotel Room Pricing,Hotellrompriser
-apps/erpnext/erpnext/stock/doctype/item/item.js +80,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
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +84,Customer LPO,Kunde LPO
-DocType: Education 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.
-apps/erpnext/erpnext/public/js/setup_wizard.js +25,Distribution,Distribusjon
-DocType: Expense Claim Advance,Expense Claim Advance,Kostnadskrav Advance
-DocType: Lab Test,Report Preference,Rapportpreferanse
-apps/erpnext/erpnext/config/non_profit.py +43,Volunteer information.,Frivillig informasjon.
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +133,Project Manager,Prosjektleder
-,Quoted Item Comparison,Sitert Element Sammenligning
-apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +34,Overlap in scoring between {0} and {1},Overlappe i scoring mellom {0} og {1}
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +114,Dispatch,Dispatch
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +74,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 +176,Net Asset value as on,Net Asset verdi som på
-DocType: Crop,Produce,Produsere
-DocType: Hotel Settings,Default Taxes and Charges,Standard Skatter og avgifter
-DocType: Account,Receivable,Fordring
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +308,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 +980,Select Items to Manufacture,Velg delbetaling Produksjon
-DocType: Delivery Stop,Delivery Stop,Leveringsstopp
-apps/erpnext/erpnext/accounts/page/pos/pos.js +963,"Master data syncing, it might take some time","Master data synkronisering, kan det ta litt tid"
-DocType: Item,Material Issue,Material Issue
-DocType: Employee Education,Qualification,Kvalifisering
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +42,View Salary Slips,Se Lønnsslipp
-DocType: Item Price,Item Price,Sak Pris
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +48,Soap & Detergent,Såpe og vaskemiddel
-DocType: BOM,Show Items,Vis Items
-apps/erpnext/erpnext/education/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/stock/doctype/delivery_trip/delivery_trip.js +92,Do you want to notify all the customers by email?,Vil du varsle alle kundene via e-post?
-apps/erpnext/erpnext/setup/setup_wizard/data/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
-apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js +51,Resume,Gjenoppta
-DocType: Salary Detail,Component,Komponent
-DocType: Assessment Criteria,Assessment Criteria Group,Vurderingskriterier Gruppe
-DocType: Healthcare Settings,Patient Name By,Pasientnavn Av
-apps/erpnext/erpnext/assets/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/education/doctype/student_attendance_tool/student_attendance_tool.js +102,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 +231,Cannot cancel because submitted Stock Entry {0} exists,Kan ikke avbryte fordi innsendt Stock Entry {0} finnes
-DocType: Employee Loan,Disbursement Date,Innbetalingsdato
-apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +80,'Recipients' not specified,&#39;Mottakere&#39; ikke spesifisert
-DocType: BOM Update Tool,Update latest price in all BOMs,Oppdater siste pris i alle BOMs
-apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.js +39,Medical Record,Pasientjournal
-DocType: Vehicle,Vehicle,Kjøretøy
-DocType: Purchase Invoice,In Words,I Words
-apps/erpnext/erpnext/hr/doctype/training_result/training_result.py +15,{0} must be submitted,{0} må sendes
-DocType: POS Profile,Item Groups,varegruppene
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +221,Today is {0}'s birthday!,I dag er {0} s bursdag!
-DocType: Sales Order Item,For Production,For Production
-DocType: Payment Request,payment_url,payment_url
-apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +186,Please add a Temporary Opening account in Chart of Accounts,Vennligst legg til en midlertidig åpningskonto i kontoplan
-DocType: Customer,Customer Primary Contact,Kundens primære kontakt
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +154,Period Closing Journal,Periode avsluttende journal
-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-
-DocType: Payment Schedule,Invoice Portion,Fakturaandel
-,Asset Depreciations and Balances,Asset Avskrivninger og Balanserer
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +363,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 +498,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;"
-DocType: Production Plan,Include Subcontracted Items,Inkluder underleverte varer
-apps/erpnext/erpnext/projects/doctype/project/project.py +218,Join,Bli med
-apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +21,Shortage Qty,Mangel Antall
-apps/erpnext/erpnext/stock/doctype/item/item.py +671,Cannot change Variant properties after stock transction. You will have to make a new Item to do this.,Kan ikke endre Variantegenskaper etter lageroverføring. Du må lage en ny gjenstand for å gjøre dette.
-apps/erpnext/erpnext/stock/doctype/item/item.py +713,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 +347,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
-apps/erpnext/erpnext/utilities/user_progress.py +218,Student Batches,Studentbatcher
-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
-DocType: Stock Settings,Convert Item Description to Clean HTML,Konverter elementbeskrivelse for å rydde HTML
-DocType: Patient,Dormant,Sovende
-DocType: Salary Slip,Total Interest Amount,Totalt rentebeløp
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +125,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: Accounts Settings,Stale Days,Foreldede dager
-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: Crop,Row Spacing UOM,Row Spacing UOM
-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 +53,Duplicate item group found in the item group table,Duplicate varegruppe funnet i varegruppen bordet
-DocType: Land Unit,Parent Land Unit,Moderselskap
-apps/erpnext/erpnext/public/js/controllers/transaction.js +1113,It is needed to fetch Item Details.,Det er nødvendig å hente Element detaljer.
-DocType: Fertilizer,Fertilizer Name,Navn på gjødsel
-DocType: Salary Slip,Net Pay,Netto Lønn
-DocType: Cash Flow Mapping Accounts,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: Vital Signs,Presence of a fever (temp &gt; 38.5 °C/101.3 °F or sustained temp &gt; 38 °C/100.4 °F),"Tilstedeværelse av feber (temp&gt; 38,5 ° C eller vedvarende temp&gt; 38 ° C / 100,4 ° F)"
-DocType: Customer,Sales Team Details,Salgsteam Detaljer
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1351,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.
-DocType: Shareholder,Folio no.,Folio nr.
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +246,Invalid {0},Ugyldig {0}
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +90,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/data/industry_type.py +22,Department Stores,Varehus
-,Item Delivery Date,Leveringsdato for vare
-DocType: Production Plan,Material Requested,Materiale som kreves
-DocType: Warehouse,PIN,PIN
-apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +116,Error '{0}' occured. Arguments {1}.,Feil &#39;{0}&#39; oppstod. Argumenter {1}.
-DocType: Bin,Reserved Qty for sub contract,Reservert antall for kontrakt
-DocType: Sales Invoice,Base Change Amount (Company Currency),Base Endre Beløp (Selskap Valuta)
-apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +304,No accounting entries for the following warehouses,Ingen regnskapspostene for følgende varehus
-apps/erpnext/erpnext/projects/doctype/project/project.js +111,Save the document first.,Lagre dokumentet først.
-apps/erpnext/erpnext/shopping_cart/cart.py +74,Only {0} in stock for item {1},Kun {0} på lager for varen {1}
-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/accounts/doctype/payment_terms_template/payment_terms_template.py +30,Credit Days cannot be a negative number,Kredittdager kan ikke være et negativt nummer
-apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +70,Last Order Amount,Siste ordrebeløp
-DocType: Cash Flow Mapper,e.g Adjustments for:,f.eks. justeringer for:
-apps/erpnext/erpnext/stock/doctype/item/item.py +274," {0} Retain Sample is based on batch, please check Has Batch No to retain sample of item","{0} Behold prøve er basert på batch, vennligst sjekk Har batch nr for å beholde prøve av element"
-DocType: Task,Is Milestone,Er Milestone
-DocType: Delivery Stop,Email Sent To,E-post sendt Å
-DocType: Budget,Warn,Advare
-apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +81,Are you sure you want to unregister?,Er du sikker på at du vil avregistrere?
-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: Asset Maintenance,Manufacturing User,Manufacturing User
-DocType: Purchase Invoice,Raw Materials Supplied,Råvare Leveres
-DocType: C-Form,Series,Series
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +283,Currency of the price list {0} must be {1} or {2},Valuta på prislisten {0} må være {1} eller {2}
-DocType: Appraisal,Appraisal Template,Appraisal Mal
-DocType: Soil Texture,Ternary Plot,Ternary Plot
-DocType: Item Group,Item Classification,Sak Klassifisering
-DocType: Driver,License Number,Lisensnummer
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +131,Business Development Manager,Business Development Manager
-DocType: Maintenance Visit Purpose,Maintenance Visit Purpose,Vedlikehold Besøk Formål
-apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +19,Invoice Patient Registration,Faktura Pasientregistrering
-DocType: Crop,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 +1043,Please select {0} first,Vennligst velg {0} først
-DocType: Appointment Type,Physician,lege
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +858,Batch {0} of Item {1} has expired.,Batch {0} av Element {1} er utløpt.
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment_dashboard.py +11,Consultations,konsultasjoner
-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: Physician,Charges,kostnader
-DocType: Salary Detail,Default Amount,Standard Beløp
-DocType: Lab Test Template,Descriptive,beskrivende
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +95,Warehouse not found in the system,Warehouse ikke funnet i systemet
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +115,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 +25,`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
-apps/erpnext/erpnext/utilities/user_progress.py +45,Set a sales goal you'd like to achieve for your company.,Sett et salgsmål du vil oppnå for din bedrift.
-,Project wise Stock Tracking,Prosjektet klok Stock Tracking
-DocType: GST HSN Code,Regional,Regional
-apps/erpnext/erpnext/config/healthcare.py +40,Laboratory,Laboratorium
-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/accounts/doctype/pos_profile/pos_profile.py +75,Customer Group is Required in POS Profile,Kundegruppe er påkrevd i POS-profil
-apps/erpnext/erpnext/config/hr.py +12,Employee records.,Medarbeider poster.
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +98,Please set Next Depreciation Date,Vennligst sett Neste Avskrivninger Dato
-DocType: HR Settings,Payroll Settings,Lønn Innstillinger
-apps/erpnext/erpnext/config/accounts.py +146,Match non-linked Invoices and Payments.,Matche ikke bundet fakturaer og betalinger.
-DocType: POS Settings,POS Settings,POS-innstillinger
-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/public/js/setup_wizard.js +32,Non Profit (beta),Ikke-profitt (beta)
-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 +152,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 +438,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: Shareholder,Address and Contacts,Adresse og Kontakt
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +67,Failed to create website,Kunne ikke opprette nettside
-DocType: Soil Analysis,Mg/K,Mg / K
-DocType: UOM Conversion Detail,UOM Conversion Detail,Målenheter Conversion Detalj
-apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +924,Retention Stock Entry already created or Sample Quantity not provided,Retention Stock Entry allerede opprettet eller Sample Quantity ikke oppgitt
-DocType: Program,Program Abbreviation,program forkortelse
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +426,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 +46,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 +72,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
-DocType: Sample Collection,Collected By,Samlet inn
-apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.js +35,Assessment Result,Assessment Resultat
-DocType: Hotel Room Package,Hotel Room Package,Hotellromspakke
-apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +13,Hours,Timer
-DocType: Project,Expected Start Date,Tiltredelse
-DocType: Purchase Invoice,04-Correction in Invoice,04-korreksjon i faktura
-apps/erpnext/erpnext/stock/doctype/item/item.js +60,Variant Details Report,Variant Detaljer Report
-DocType: Setup Progress Action,Setup Progress Action,Oppsett Progress Action
-apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +36,Buying Price List,Kjøpe prisliste
-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
-apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +21,Please select Maintenance Status as Completed or remove Completion Date,"Vennligst velg Vedlikeholdsstatus som Fullført, eller fjern sluttdato"
-DocType: Supplier,Default Payment Terms Template,Standard betalingsbetingelser mal
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +34,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: Subscription,Submit on creation,Send inn på skapelse
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +476,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 +509,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 +99,"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 +16,Training Feedback,trening Tilbakemelding
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +495,Production Order {0} must be submitted,Produksjonsordre {0} må sendes
-DocType: Supplier Scorecard Criteria,Supplier Scorecard Criteria,Leverandør Scorecard Kriterier
-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/education/doctype/student_group_creation_tool/student_group_creation_tool.py +55,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
-DocType: Cash Flow Mapper,Section Footer,Seksjon Footer
-apps/erpnext/erpnext/stock/doctype/item/item.js +275,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
-DocType: Lab Test Template,Sample Collection,Eksempel Innsamling
-,Requested Items To Be Ordered,Etterspør Elementer bestilles
-apps/erpnext/erpnext/public/js/hub/hub_page.js +137,My Orders,Mine bestillinger
-DocType: Price List,Price List Name,Prisliste Name
-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 +106,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 +275,Sales Invoice {0} has already been submitted,Salg Faktura {0} er allerede innsendt
-DocType: Supplier Scorecard Scoring Criteria,Score,Score
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +25,Fiscal Year {0} does not exist,Regnskapsåret {0} finnes ikke
-DocType: Asset Maintenance Log,Completion Date,Ferdigstillelse Dato
-DocType: Purchase Invoice Item,Amount (Company Currency),Beløp (Selskap Valuta)
-DocType: Agriculture Analysis Criteria,Agriculture User,Landbruker Bruker
-apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +38,Valid till date cannot be before transaction date,Gyldig til dato kan ikke være før transaksjonsdato
-apps/erpnext/erpnext/stock/stock_ledger.py +381,{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 Schedule,Student Category,student Kategori
-DocType: Announcement,Student,Student
-apps/erpnext/erpnext/config/hr.py +238,Organization unit (department) master.,Organisasjonsenhet (departement) mester.
-DocType: Shipping Rule,Shipping Rule Type,Forsendelsestype
-apps/erpnext/erpnext/utilities/user_progress.py +236,Go to Rooms,Gå til rom
-apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +75,Please enter message before sending,Skriv inn meldingen før du sender
-DocType: Purchase Invoice,DUPLICATE FOR SUPPLIER,DUPLIKATE FOR LEVERANDØR
-DocType: Email Digest,Pending Quotations,Avventer Sitater
-apps/erpnext/erpnext/config/accounts.py +318,Point-of-Sale Profile,Point-of-Sale Profile
-apps/erpnext/erpnext/agriculture/doctype/soil_texture/soil_texture.py +24,{0} should be a value between 0 and 100,{0} skal være en verdi mellom 0 og 100
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +94,Next Depreciation Date cannot be before Available-for-use Date,Neste avskrivningsdato kan ikke være før Tilgjengelig-til-bruk-dato
-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: Student,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 +209,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
-DocType: Hub Settings,Company and Seller Profile,Bedrift og selgerprofil
-,GST Itemised Sales Register,GST Artized Sales Register
-DocType: Soil Texture,Silt Loam,Silt Loam
-,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: Vital Signs,Adults' pulse rate is anywhere between 50 and 80 beats per minute.,Voksnes pulsrate er hvor som helst mellom 50 og 80 slag per minutt.
-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/utilities/user_progress.py +106,Your Suppliers,Dine Leverandører
-apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +6,Please correct the,Vennligst korrigér
-apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +80,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 +382,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 +370,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/accounts/doctype/purchase_invoice/purchase_invoice.py +222,"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 +167,Row #{0}: Set Supplier for item {1},Row # {0}: Sett Leverandør for elementet {1}
-apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +121,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 +194,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
-DocType: Asset,Assets,Eiendeler
-apps/erpnext/erpnext/setup/setup_wizard/data/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.
-DocType: Payment Term,Due Date Based On,Forfallsdato basert på
-apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +85,Please set default customer group and territory in Selling Settings,Vennligst angi standard kundegruppe og territorium i salgsinnstillinger
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +209,{0} {1} does not exist,{0} {1} finnes ikke
-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 +87,Item: {0} does not exist in the system,Sak: {0} finnes ikke i systemet
-apps/erpnext/erpnext/accounts/doctype/account/account.py +106,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
-DocType: Healthcare Settings,Laboratory Settings,Laboratorieinnstillinger
-apps/erpnext/erpnext/buying/report/quoted_item_comparison/quoted_item_comparison.js +97,Successfully Set Supplier,Vellykket sett leverandør
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +75,Leave Encashment,La Encashment
-apps/erpnext/erpnext/public/js/setup_wizard.js +114,What does it do?,Hva gjør det?
-DocType: Crop,Byproducts,biprodukter
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +84,To Warehouse,Til Warehouse
-apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +26,All Student Admissions,Alle Student Opptak
-,Average Commission Rate,Gjennomsnittlig kommisjon
-DocType: Share Balance,No of Shares,Antall aksjer
-apps/erpnext/erpnext/stock/doctype/item/item.py +447,'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/healthcare/page/appointment_analytic/appointment_analytic.js +62,Select Status,Velg Status
-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: Fee Schedule,Total Amount per Student,Totalt beløp per student
-DocType: Purchase Taxes and Charges,Account Head,Account Leder
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +153,Electrical,Elektrisk
-apps/erpnext/erpnext/utilities/activation.py +100,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 -)
-DocType: Grant Application,Requested Amount,Ønsket beløp
-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: Crop Cycle,Detected Diseases,Detekterte sykdommer
-DocType: Stock Entry,Default Source Warehouse,Standardkilde Warehouse
-DocType: Item,Customer Code,Kunden Kode
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +220,Birthday Reminder for {0},Bursdag Påminnelse for {0}
-DocType: Asset Maintenance Task,Last Completion Date,Siste sluttdato
-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 +365,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: Restaurant,Active Menu,Aktiv meny
-DocType: Target Detail,Target Qty,Target Antall
-DocType: Shopping Cart Settings,Checkout Settings,Kasse Innstillinger
-DocType: Student Attendance,Present,Present
-apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +37,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 +324,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: Production Plan Item,Ordered Qty,Bestilte Antall
-apps/erpnext/erpnext/stock/doctype/item/item.py +743,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 +930,BOM does not contain any stock item,BOM inneholder ikke lagervare
-DocType: Chapter,Chapter Head,Kapittelhode
-DocType: Payment Term,Month(s) after the end of the invoice month,Måned (e) etter slutten av faktura måneden
-apps/erpnext/erpnext/config/projects.py +19,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/agriculture/doctype/water_analysis/water_analysis.py +24,Lab result datetime cannot be before testing datetime,Lab-resultat datetime kan ikke være før testing av datetime
-DocType: POS Profile,Allow user to edit Discount,Tillat brukeren å redigere rabatt
-apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +55,Get customers from,Få kunder fra
-DocType: Production Plan Item,Include Exploded Items,Inkluder eksploderte elementer
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +45,"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
-DocType: Shipping Rule,Restrict to Countries,Begrens til land
-DocType: Purchase Invoice,Write Off Amount (Company Currency),Skriv Off Beløp (Selskap Valuta)
-DocType: Sales Invoice Timesheet,Billing Hours,fakturerings~~POS=TRUNC Timer
-DocType: Project,Total Sales Amount (via Sales Order),Total salgsbeløp (via salgsordre)
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +548,Default BOM for {0} not found,Standard BOM for {0} ikke funnet
-apps/erpnext/erpnext/stock/doctype/item/item.py +513,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: Share Transfer,To Folio No,Til Folio nr
-DocType: Landed Cost Voucher,Landed Cost Voucher,Landed Cost Voucher
-apps/erpnext/erpnext/public/js/queries.js +39,Please set {0},Vennligst sett {0}
-apps/erpnext/erpnext/education/doctype/student_group/student_group.py +37,{0} - {1} is inactive student,{0} - {1} er inaktiv student
-apps/erpnext/erpnext/education/doctype/student_group/student_group.py +37,{0} - {1} is inactive student,{0} - {1} er inaktiv student
-DocType: Employee,Health Details,Helse Detaljer
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +24,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 +24,To create a Payment Request reference document is required,For å opprette en betalingsforespørsel kreves referansedokument
-DocType: Soil Texture,Sandy Clay,Sandy Clay
-DocType: Grant Application,Assessment  Manager,Vurderingsleder
-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: Sales Order,Partly Delivered,Delvis Leveres
-DocType: Item Variant Settings,Do not update variants on save,Ikke oppdater varianter på lagre
-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
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +231,"{0} {1} is associated with {2}, but Party Account is {3}","{0} {1} er knyttet til {2}, men partikonto er {3}"
-apps/erpnext/erpnext/healthcare/doctype/sample_collection/sample_collection.js +7,View Lab Tests,Se labtester
-DocType: Purchase Invoice,Y,Y
-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/selling/doctype/customer/customer.py +129,Please mention the Lead Name in Lead {0},Vennligst nevne Lead Name in Lead {0}
-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 +571,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/setup/setup_wizard/setup_wizard.py +28,Installing presets,Installere forhåndsinnstillinger
-apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +85,No Delivery Note selected for Customer {},Ingen leveringsnotering valgt for kunden {}
-apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +25,BOM replaced,BOM erstattet
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1043,Select Items based on Delivery Date,Velg elementer basert på leveringsdato
-DocType: Grant Application,Has any past Grant Record,Har noen tidligere Grant Record
-,Sales Analytics,Salgs Analytics
-apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +127,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/education/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 +106,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 +109,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 +90,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
-DocType: Hotel Room Reservation,Hotel Room Reservation,Hotellrombestilling
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +115,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: Land Unit,Linked Soil Analysis,Koblet jordanalyse
-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 +288,Default settings for accounting transactions.,Standardinnstillingene for regnskapsmessige transaksjoner.
-DocType: Maintenance Visit,MV,MV
-DocType: Restaurant,Default Tax Template,Standardskattemall
-apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +66,{0} Students have been enrolled,{0} Studentene har blitt registrert
-DocType: Fees,Student Details,Studentdetaljer
-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/operations/install_fixtures.py +126,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 +171,Item Code required at Row No {0},Elementkode kreves ved Row Nei {0}
-DocType: GST Account,SGST Account,SGST-konto
-apps/erpnext/erpnext/utilities/user_progress.py +151,Go to Items,Gå til elementer
-DocType: Sales Partner,Partner Type,Partner Type
-DocType: Purchase Taxes and Charges,Actual,Faktiske
-DocType: Restaurant Menu,Restaurant Manager,Restaurantsjef
-DocType: Authorization Rule,Customerwise Discount,Customerwise Rabatt
-apps/erpnext/erpnext/config/projects.py +41,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 +282,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: BOM,Raw Material Cost,Raw Material Cost
-DocType: Item Reorder,Re-Order Level,Re-Order nivå
-apps/erpnext/erpnext/projects/doctype/project/project.js +64,Gantt Chart,Gantt
-DocType: Crop Cycle,Cycle Type,Syklus type
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +99,Part-time,Deltid
-DocType: Employee,Applicable Holiday List,Gjelder Holiday List
-DocType: Employee,Cheque,Cheque
-DocType: Training Event,Employee Emails,Medarbeider e-post
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +59,Series Updated,Serien Oppdatert
-apps/erpnext/erpnext/accounts/doctype/account/account.py +159,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/data/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}
-DocType: Projects Settings,Ignore User Time Overlap,Ignorer brukstidens overlapping
-apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +97,Clearance Date updated,Lagersalg oppdatert
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +146,Split Batch,Split Batch
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +146,Split Batch,Split Batch
-DocType: Stock Settings,Batch Identification,Batchidentifikasjon
-apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +132,Successfully Reconciled,Vellykket Forsonet
-DocType: Request for Quotation Supplier,Download PDF,Last ned PDF
-DocType: Production Order,Planned End Date,Planlagt sluttdato
-DocType: Shareholder,Hidden list maintaining the list of contacts linked to Shareholder,Skjult liste opprettholder listen over kontakter knyttet til Aksjonær
-apps/erpnext/erpnext/config/non_profit.py +63,Donor Type information.,Donor Type informasjon.
-DocType: Request for Quotation,Supplier Detail,Leverandør Detalj
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +100,Error in formula or condition: {0},Feil i formel eller betingelse: {0}
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +94,Invoiced Amount,Fakturert beløp
-apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +47,Criteria weights must add up to 100%,Kriterievekter må legge opp til 100%
-apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.js +7,Attendance,Oppmøte
-apps/erpnext/erpnext/public/js/pos/pos.html +104,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/opening_invoice_creation_tool/opening_invoice_creation_tool.py +111,Creating {0},Opprette {0}
-apps/erpnext/erpnext/assets/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 +573,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
-DocType: Consultation,Review Details,Gjennomgå detaljer
-apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +185,The shareholder does not belong to this company,Aksjonæren tilhører ikke dette firmaet
-DocType: Dosage Form,Dosage Form,Doseringsform
-apps/erpnext/erpnext/config/selling.py +67,Price List master.,Prisliste mester.
-DocType: Task,Review Date,Omtale Dato
-DocType: Company,Series for Asset Depreciation Entry (Journal Entry),Serie for Asset Depreciation Entry (Journal Entry)
-DocType: Membership,Member Since,Medlem siden
-DocType: Purchase Invoice,Advance Payments,Forskudd
-DocType: Purchase Taxes and Charges,On Net Total,On Net Total
-apps/erpnext/erpnext/controllers/item_variant.py +92,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 +175,Target warehouse in row {0} must be same as Production Order,Target lager i rad {0} må være samme som produksjonsordre
-DocType: Restaurant Reservation,Waitlisted,ventelisten
-apps/erpnext/erpnext/accounts/doctype/account/account.py +124,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: Shipping Rule,Fixed,fast
-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/data/industry_type.py +18,Consulting,Consulting
-DocType: Customer Group,Parent Customer Group,Parent Kundegruppe
-DocType: Journal Entry,Subscription,Abonnement
-DocType: Purchase Invoice,Contact Email,Kontakt Epost
-apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +11,Fee Creation Pending,Avgiftskapasitet venter
-DocType: Appraisal Goal,Score Earned,Resultat tjent
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +240,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: Asset Maintenance Task,Preventive Maintenance,Forebyggende vedlikehold
-DocType: Delivery Note Item,Against Sales Invoice,Mot Salg Faktura
-DocType: Purchase Invoice,07-Others,07-Andre
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +151,Please enter serial numbers for serialized item ,Vennligst skriv inn serienumre for serialisert element
-DocType: Bin,Reserved Qty for Production,Reservert Antall for produksjon
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +43,EcritureNum,EcritureNum
-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 +500,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
-DocType: Lab Test,Test Group,Testgruppe
-DocType: Payment Reconciliation,Receivable / Payable Account,Fordringer / gjeld konto
-DocType: Delivery Note Item,Against Sales Order Item,Mot kundeordreposisjon
-DocType: Company,Company Logo,Firmalogo
-apps/erpnext/erpnext/stock/doctype/item/item.py +708,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}
-DocType: Healthcare Settings,Patient Registration,Pasientregistrering
-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
-DocType: Donor,Donor Type,Donor Type
-apps/erpnext/erpnext/stock/doctype/item/item.js +27,Balance,Balanse
-apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +66,Please select the Company,Vennligst velg firmaet
-DocType: Room,Seating Capacity,Antall seter
-DocType: Issue,ISS-,ISS-
-DocType: Lab Test Groups,Lab Test Groups,Lab Test Grupper
-DocType: Project,Total Expense Claim (via Expense Claims),Total Expense krav (via Utgifts Krav)
-DocType: GST Settings,GST Summary,GST Sammendrag
-apps/erpnext/erpnext/hr/doctype/daily_work_summary_group/daily_work_summary_group.py +16,Please enable default incoming account before creating Daily Work Summary Group,Vennligst aktiver standard innkommende konto før du oppretter Daglig arbeidsoppsummeringsgruppe
-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
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +49,ValidDate,Gyldig dato
-DocType: Student Log,Achievement,Oppnåelse
-DocType: Batch,Source Document Type,Kilde dokumenttype
-DocType: Batch,Source Document Type,Kilde dokumenttype
-apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +24,Following course schedules were created,Følgende kursplaner ble opprettet
-DocType: Journal Entry,Total Debit,Total debet
-DocType: Manufacturing Settings,Default Finished Goods Warehouse,Standardferdigvarelageret
-apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.js +124,Please select Patient,Vennligst velg Pasient
-apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +76,Sales Person,Sales Person
-DocType: Hotel Room Package,Amenities,fasiliteter
-apps/erpnext/erpnext/config/accounts.py +233,Budget and Cost Center,Budsjett og kostnadssted
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +65,Multiple default mode of payment is not allowed,Flere standard betalingsmåter er ikke tillatt
-apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +5,for the,for
-,Appointment Analytics,Avtale Analytics
-DocType: Vehicle Service,Half Yearly,Halvårlig
-DocType: Lead,Blog Subscriber,Blogg Subscriber
-DocType: Guardian,Alternate Number,Alternativ nummer
-DocType: Healthcare Settings,Consultations in valid days,Konsultasjoner i gyldige dager
-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.
-DocType: Cash Flow Mapping Accounts,Cash Flow Mapping Accounts,Kontantstrømmappekontoer
-apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +49, Group Roll No,Grupperulle nr
-DocType: Batch,Manufacturing Date,Produksjonsdato
-apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +9,Fee Creation Failed,Fee Creation mislyktes
-DocType: Opening Invoice Creation Tool,Create Missing Party,Opprett manglende parti
-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/healthcare/doctype/lab_test_template/lab_test_template.js +27,Change Template Code,Endre malkode
-apps/erpnext/erpnext/education/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
-DocType: Employee Advance,EA-,EA
-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 +173,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
-apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +162,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}
-DocType: Program Enrollment Tool,New Academic Term,Ny faglig term
-,Course wise Assessment Report,Kursbasert vurderingsrapport
-DocType: Purchase Invoice,Availed ITC State/UT Tax,Availed ITC State / UT skatt
-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/healthcare/doctype/patient_appointment/patient_appointment.py +120,Dr {0} does not have a Physician Schedule. Add it in Physician master,Dr {0} har ikke en legeplan. Legg det i lege master
-apps/erpnext/erpnext/public/js/pos/pos.html +87,Customers in Queue,Kunder i kø
-DocType: Driver,Issuing Date,Utstedelsesdato
-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 +1384,Select or add new customer,Velg eller legg til ny kunde
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +171,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
-DocType: Assessment Result,Summary,Sammendrag
-apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +112,Mark Attendance,Mark Attendance
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +494,Debit Account,Debet konto
-DocType: Fiscal Year,Year Start Date,År Startdato
-DocType: Attendance,Employee Name,Ansattes Navn
-DocType: Restaurant Order Entry Item,Restaurant Order Entry Item,Restaurant Bestillingsinngang
-DocType: Purchase Invoice,Rounded Total (Company Currency),Avrundet Total (Selskap Valuta)
-apps/erpnext/erpnext/accounts/doctype/account/account.py +96,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 +260,{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.
-DocType: Asset Maintenance Team,Maintenance Team Members,Vedlikeholdsteammedlemmer
-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 +261,Supplier Quotation {0} created,Leverandør sitat {0} er opprettet
-apps/erpnext/erpnext/accounts/report/financial_statements.py +101,End Year cannot be before Start Year,Slutt År kan ikke være før start År
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +233,Employee Benefits,Ytelser til ansatte
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +264,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
-apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +78,The shares don't exist with the {0},Aksjene eksisterer ikke med {0}
-apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +64,Invoice Created,Faktura er opprettet
-DocType: Asset,Out of Order,I ustand
-DocType: Purchase Receipt Item,Accepted Quantity,Akseptert Antall
-DocType: Projects Settings,Ignore Workstation Time Overlap,Ignorer arbeidsstasjonstidoverlapping
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +242,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 +31,{0}: {1} does not exists,{0}: {1} ikke eksisterer
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +76,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: Assessment Plan,Schedule,Tidsplan
-DocType: Account,Parent Account,Parent konto
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +266,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 +1716,Price List not found or disabled,Prisliste ikke funnet eller deaktivert
-DocType: Student Applicant,Approved,Godkjent
-apps/erpnext/erpnext/public/js/pos/pos_selected_item.html +15,Price,Pris
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +266,Employee relieved on {0} must be set as 'Left',Ansatt lettet på {0} må være angitt som &quot;venstre&quot;
-DocType: Hub Settings,Last Sync On,Sist synk på
-DocType: Guardian,Guardian,Guardian
-DocType: Opening Invoice Creation Tool,Create missing customer or supplier.,Opprett manglende kunde eller leverandør.
-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: Academic Term,Education,Utdanning
-apps/erpnext/erpnext/public/js/pos/pos.html +78,Del,del
-DocType: Selling Settings,Campaign Naming By,Kampanje Naming Av
-DocType: Employee,Current Address Is,Gjeldende adresse Er
-apps/erpnext/erpnext/utilities/user_progress.py +48,Monthly Sales Target (,Månedlig salgsmål (
-apps/erpnext/erpnext/templates/includes/projects/project_tasks.html +9,modified,modifisert
-apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +43,"Optional. Sets company's default currency, if not specified.","Valgfritt. Setter selskapets standardvaluta, hvis ikke spesifisert."
-DocType: Sales Invoice,Customer GSTIN,Kunde GSTIN
-DocType: Crop Cycle,List of diseases detected on the field. When selected it'll automatically add a list of tasks to deal with the disease ,"Liste over sykdommer oppdaget på feltet. Når den er valgt, vil den automatisk legge til en liste over oppgaver for å håndtere sykdommen"
-DocType: Asset Repair,Repair Status,Reparasjonsstatus
-apps/erpnext/erpnext/config/accounts.py +67,Accounting journal entries.,Regnskap posteringer.
-DocType: Delivery Note Item,Available Qty at From Warehouse,Tilgjengelig Antall på From Warehouse
-DocType: POS Profile,Account for Change Amount,Konto for Change Beløp
-DocType: Purchase Invoice,input service,inntjeningstjeneste
-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}
-DocType: Maintenance Team Member,Maintenance Team Member,Vedlikeholdsteammedlem
-DocType: Agriculture Analysis Criteria,Soil Analysis,Jordanalyse
-apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +13,Course Code: ,Bankkode:
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +240,Please enter Expense Account,Skriv inn Expense konto
-DocType: Account,Stock,Lager
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1068,"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 +329,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: Lab Test,Prescription,Resept
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +98,Not Available,Ikke Tilgjengelig
-DocType: Pricing Rule,Min Qty,Min Antall
-apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +36,Disable Template,Deaktiver mal
-DocType: GL Entry,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 +191,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/education/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."
-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/accounts/doctype/pos_profile/pos_profile.py +62,Set default mode of payment,Angi standard betalingsmåte
-DocType: Grant Application,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 +260,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: Purchase Invoice,Without Payment of Tax,Uten betaling av skatt
-DocType: BOM Operation,BOM Operation,BOM Operation
-apps/erpnext/erpnext/config/stock.py +141,Fulfilment,Oppfyllelse
-DocType: Purchase Taxes and Charges,On Previous Row Amount,På Forrige Row Beløp
-DocType: Item,Has Expiry Date,Har utløpsdato
-apps/erpnext/erpnext/assets/doctype/asset/asset.js +282,Transfer Asset,Transfer Asset
-DocType: POS Profile,POS Profile,POS Profile
-DocType: Training Event,Event Name,Aktivitetsnavn
-DocType: Physician,Phone (Office),Telefon (kontor)
-apps/erpnext/erpnext/hooks.py +151,Admission,Adgang
-apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +29,Admissions for {0},Innleggelser for {0}
-apps/erpnext/erpnext/config/accounts.py +257,"Seasonality for setting budgets, targets etc.","Sesong for å sette budsjetter, mål etc."
-DocType: Supplier Scorecard Scoring Variable,Variable Name,Variabelt navn
-apps/erpnext/erpnext/stock/get_item_details.py +144,"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/hr/doctype/salary_structure/salary_structure.py +31,Net pay cannot be negative,Nettolønn kan ikke være negativ
-DocType: Purchase Order,Advance Paid,Advance Betalt
-DocType: Item,Item Tax,Sak Skatte
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +874,Material to Supplier,Materiale til Leverandør
-DocType: Soil Texture,Loamy Sand,Loamy Sand
-DocType: Production Plan,Material Request Planning,Material Request Planning
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +630,Excise Invoice,Vesenet Faktura
-apps/erpnext/erpnext/education/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: Patient,A Positive,En positiv
-DocType: Program,Program Name,Programnavn
-DocType: Purchase Taxes and Charges,Consider Tax or Charge for,Tenk Skatte eller Charge for
-DocType: Driver,Driving License Category,Kjørelisens kategori
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +158,No Reference,Ingen referanse
-apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +57,Actual Qty is mandatory,Selve Antall er obligatorisk
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +92,"{0} currently has a {1} Supplier Scorecard standing, and Purchase Orders to this supplier should be issued with caution.","{0} har for øyeblikket en {1} leverandør scorecard, og innkjøpsordre til denne leverandøren skal utstedes med forsiktighet."
-DocType: Asset Maintenance Team,Asset Maintenance Team,Asset Maintenance Team
-DocType: Employee Loan,Loan Type,låne~~POS=TRUNC
-DocType: Scheduling Tool,Scheduling Tool,planlegging Tool
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +180,Credit Card,Kredittkort
-DocType: BOM,Item to be manufactured or repacked,Elementet som skal produseres eller pakkes
-DocType: Employee Education,Major/Optional Subjects,Store / valgfrie emner
-DocType: Sales Invoice Item,Drop Ship,Drop Ship
-DocType: Driver,Suspended,suspendert
-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: 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 +113,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 +56,Attach Logo,Fest Logo
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +51,Stock Levels,lagernivåer
-DocType: Customer,Commission Rate,Kommisjon
-apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +187,Created {0} scorecards for {1} between: ,Lagde {0} scorecards for {1} mellom:
-apps/erpnext/erpnext/stock/doctype/item/item.js +475,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 +150,"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 +25,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
-DocType: Soil Texture,Clay Loam,Clay Loam
-apps/erpnext/erpnext/accounts/doctype/account/account.py +81,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 Invoice,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: Restaurant Reservation,Reservation Time,Reservasjonstid
-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
-DocType: Healthcare Settings,Result Emailed,Resultat sendt
-apps/erpnext/erpnext/controllers/buying_controller.py +87,"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: Supplier Scorecard,Indicator Color,Indikatorfarge
-DocType: Purchase Order,To Receive and Bill,Å motta og Bill
-apps/erpnext/erpnext/controllers/buying_controller.py +455,Row #{0}: Reqd by Date cannot be before Transaction Date,Row # {0}: Reqd by Date kan ikke være før transaksjonsdato
-apps/erpnext/erpnext/templates/pages/home.html +14,Featured Products,Utvalgte produkter
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +136,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 +495,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: Driver,Expiry Date,Utløpsdato
-DocType: Healthcare Settings,Employee name and designation in print,Ansattes navn og betegnelse på trykk
-,accounts-browser,kontoer-browser
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +368,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 +431, (Half Day),(Halv Dag)
-DocType: Payment Term,Credit Days,Kreditt Days
-apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +145,Please select Patient to get Lab Tests,Vennligst velg Pasient for å få Lab Tests
-apps/erpnext/erpnext/utilities/activation.py +128,Make Student Batch,Gjør Student Batch
-DocType: Fee Schedule,FRQ.,FRQ.
-DocType: Leave Type,Is Carry Forward,Er fremføring
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +841,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
-DocType: Cash Flow Mapping,Is Income Tax Expense,Er inntektsskatt utgift
-apps/erpnext/erpnext/controllers/accounts_controller.py +620,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 +125,Please enter Sales Orders in the above table,Fyll inn salgsordrer i tabellen ovenfor
-,Stock Summary,Stock oppsummering
-apps/erpnext/erpnext/config/assets.py +54,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 +105,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: Item,Shelf Life In Days,Holdbarhet i dager
-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}
-DocType: Journal Entry,Subscription Section,Abonnementsseksjon
-apps/erpnext/erpnext/accounts/doctype/account/account.py +177,Account {0} does not exist,Konto {0} finnes ikke
-DocType: Training Event,Training Program,Treningsprogram
-DocType: Account,Cash,Kontanter
-DocType: Employee,Short biography for website and other publications.,Kort biografi for hjemmeside og andre publikasjoner.
+b'DocType: Employee',b'Salary Mode',b'L\xc3\xb8nn Mode'
+b'DocType: Patient',b'Divorced',b'Skilt'
+b'DocType: Buying Settings',b'Allow Item to be added multiple times in a transaction',b'Tillat Element som skal legges flere ganger i en transaksjon'
+b'apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +33',b'Cancel Material Visit {0} before cancelling this Warranty Claim',b'Avbryt Material Bes\xc3\xb8k {0} f\xc3\xb8r den avbryter denne garantikrav'
+b'apps/erpnext/erpnext/config/education.py +118',b'Assessment Reports',b'Evalueringsrapporter'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +19',b'Consumer Products',b'Forbrukerprodukter'
+b'DocType: Purchase Receipt',b'Subscription Detail',b'Abonnementsdetaljer'
+b'DocType: Supplier Scorecard',b'Notify Supplier',b'Informer Leverand\xc3\xb8r'
+b'DocType: Item',b'Customer Items',b'Kunde Items'
+b'DocType: Project',b'Costing and Billing',b'Kalkulasjon og fakturering'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +48',b'Account {0}: Parent account {1} can not be a ledger',b'Konto {0}: Parent konto {1} kan ikke v\xc3\xa6re en hovedbok'
+b'DocType: Item',b'Publish Item to hub.erpnext.com',b'Publiser varen til hub.erpnext.com'
+b'apps/erpnext/erpnext/config/setup.py +88',b'Email Notifications',b'E-postvarsling'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +26',b'Evaluation',b'evaluering'
+b'DocType: Item',b'Default Unit of Measure',b'Standard m\xc3\xa5leenhet'
+b'DocType: SMS Center',b'All Sales Partner Contact',b'All Sales Partner Kontakt'
+b'DocType: Employee',b'Leave Approvers',b'La godkjennere'
+b'DocType: Sales Partner',b'Dealer',b'Dealer'
+b'DocType: Work Order',b'WO-',b'WO-'
+b'DocType: Consultation',b'Investigations',b'unders\xc3\xb8kelser'
+b'DocType: Restaurant Order Entry',b'Click Enter To Add',b'Klikk p\xc3\xa5 Enter for \xc3\xa5 legge til'
+b'DocType: Employee',b'Rented',b'Leide'
+b'DocType: Purchase Order',b'PO-',b'PO-'
+b'DocType: Vehicle Service',b'Mileage',b'Kilometer'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.js +253',b'Do you really want to scrap this asset?',b'Har du virkelig \xc3\xb8nsker \xc3\xa5 hugge denne eiendelen?'
+b'DocType: Drug Prescription',b'Update Schedule',b'Oppdater plan'
+b'apps/erpnext/erpnext/buying/report/quoted_item_comparison/quoted_item_comparison.js +44',b'Select Default Supplier',b'Velg Standard Leverand\xc3\xb8r'
+b'apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +37',b'Currency is required for Price List {0}',b'Valuta er n\xc3\xb8dvendig for Prisliste {0}'
+b'DocType: Sales Taxes and Charges Template',b'* Will be calculated in the transaction.',b'* Vil bli beregnet i transaksjonen.'
+b'DocType: Purchase Order',b'Customer Contact',b'Kundekontakt'
+b'DocType: Patient Appointment',b'Check availability',b'Sjekk tilgjengelighet'
+b'DocType: Job Applicant',b'Job Applicant',b'Jobbs\xc3\xb8ker'
+b'apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py +6',b'This is based on transactions against this Supplier. See timeline below for details',b'Dette er basert p\xc3\xa5 transaksjoner mot denne leverand\xc3\xb8ren. Se tidslinjen nedenfor for detaljer'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +120',b'Legal',b'Juridisk'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +191',b'Actual type tax cannot be included in Item rate in row {0}',b'Faktiske typen skatt kan ikke inkluderes i Element rente i rad {0}'
+b'DocType: Bank Guarantee',b'Customer',b'Kunde'
+b'DocType: Purchase Receipt Item',b'Required By',b'Kreves av'
+b'DocType: Delivery Note',b'Return Against Delivery Note',b'Tilbake mot f\xc3\xb8lgeseddel'
+b'DocType: Purchase Order',b'% Billed',b'% Fakturert'
+b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +43',b'Exchange Rate must be same as {0} {1} ({2})',b'Exchange Rate m\xc3\xa5 v\xc3\xa6re samme som {0} {1} ({2})'
+b'DocType: Sales Invoice',b'Customer Name',b'Kundenavn'
+b'DocType: Vehicle',b'Natural Gas',b'Naturgass'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/company_setup.py +64',b'Bank account cannot be named as {0}',b'Bankkonto kan ikke bli navngitt som {0}'
+b'DocType: Account',b'Heads (or groups) against which Accounting Entries are made and balances are maintained.',b'Hoder (eller grupper) mot hvilke regnskapspostene er laget og balanserer opprettholdes.'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +196',b'Outstanding for {0} cannot be less than zero ({1})',b'Enest\xc3\xa5ende for {0} kan ikke v\xc3\xa6re mindre enn null ({1})'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +348',b'There are no submitted Salary Slips to process.',b'Det er ingen innsendte l\xc3\xb8nnslister \xc3\xa5 behandle.'
+b'DocType: Manufacturing Settings',b'Default 10 mins',b'Standard 10 minutter'
+b'DocType: Leave Type',b'Leave Type Name',b'La Type Navn'
+b'apps/erpnext/erpnext/templates/pages/projects.js +62',b'Show open',b'Vis \xc3\xa5pen'
+b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +8',b'It is necessary to take this action today itself for the above mentioned recurring',b'Det er n\xc3\xb8dvendig \xc3\xa5 ta denne handlingen i dag selv for ovennevnte tilbakevendende'
+b'apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +156',b'Series Updated Successfully',b'Serien er oppdatert'
+b'apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html +6',b'Checkout',b'Sjekk ut'
+b'DocType: Pricing Rule',b'Apply On',b'P\xc3\xa5f\xc3\xb8r p\xc3\xa5'
+b'DocType: Item Price',b'Multiple Item prices.',b'Flere varepriser.'
+,b'Purchase Order Items To Be Received',b'Purchase Order Elementer som skal mottas'
+b'DocType: SMS Center',b'All Supplier Contact',b'All Leverand\xc3\xb8r Kontakt'
+b'DocType: Support Settings',b'Support Settings',b'st\xc3\xb8tte~~POS=TRUNC Innstillinger'
+b'apps/erpnext/erpnext/projects/doctype/project/project.py +75',b'Expected End Date can not be less than Expected Start Date',b'Forventet Sluttdato kan ikke v\xc3\xa6re mindre enn Tiltredelse'
+b'apps/erpnext/erpnext/utilities/transaction_base.py +121',b'Row #{0}: Rate must be same as {1}: {2} ({3} / {4}) ',b'Row # {0}: Pris m\xc3\xa5 v\xc3\xa6re samme som {1}: {2} ({3} / {4})'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +241',b'New Leave Application',b'New La Application'
+,b'Batch Item Expiry Status',b'Batch Element Utl\xc3\xb8ps Status'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +184',b'Bank Draft',b'Bank Draft'
+b'DocType: Membership',b'membership validaty section',b'medlemskapsvaliditetsseksjon'
+b'DocType: Mode of Payment Account',b'Mode of Payment Account',b'Modus for betaling konto'
+b'DocType: Consultation',b'Consultation',b'Konsultasjon'
+b'DocType: Accounts Settings',b'Show Payment Schedule in Print',b'Vis betalingsplan i utskrift'
+b'apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py +19',b'Sales and Returns',b'Salg og retur'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +56',b'Show Variants',b'Vis Varianter'
+b'DocType: Academic Term',b'Academic Term',b'semester'
+b'apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py +14',b'Material',b'Materiale'
+b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +66',b'Making website',b'\xc3\x85 lage nettside'
+b'DocType: Opening Invoice Creation Tool Item',b'Quantity',b'Antall'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +546',b'Accounts table cannot be blank.',b'Regnskap bordet kan ikke v\xc3\xa6re tomt.'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +154',b'Loans (Liabilities)',b'L\xc3\xa5n (gjeld)'
+b'DocType: Employee Education',b'Year of Passing',b'Year of Passing'
+b'DocType: Item',b'Country of Origin',b'Opprinnelsesland'
+b'DocType: Soil Texture',b'Soil Texture Criteria',b'Kriterier for jordstruktur'
+b'apps/erpnext/erpnext/templates/includes/product_page.js +25',b'In Stock',b'P\xc3\xa5 Lager'
+b'apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js +16',b'Primary Contact Details',b'Prim\xc3\xa6r kontaktdetaljer'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +46',b'Open Issues',b'\xc3\xa5pne sp\xc3\xb8rsm\xc3\xa5l'
+b'DocType: Production Plan Item',b'Production Plan Item',b'Produksjonsplan Sak'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +149',b'User {0} is already assigned to Employee {1}',b'Bruker {0} er allerede tildelt Employee {1}'
+b'DocType: Lab Test Groups',b'Add new line',b'Legg til ny linje'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +31',b'Health Care',b'Helsevesen'
+b'apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +65',b'Delay in payment (Days)',b'Forsinket betaling (dager)'
+b'DocType: Payment Terms Template Detail',b'Payment Terms Template Detail',b'Betalingsvilk\xc3\xa5r Maledetaljer'
+b'DocType: Hotel Room Reservation',b'Guest Name',b'Gjestenavn'
+b'DocType: Lab Prescription',b'Lab Prescription',b'Lab Prescription'
+,b'Delay Days',b'Forsinkelsesdager'
+b'apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py +26',b'Service Expense',b'tjenesten Expense'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +899',b'Serial Number: {0} is already referenced in Sales Invoice: {1}',b'Serienummer: {0} er allerede referert i salgsfaktura: {1}'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +889',b'Invoice',b'Faktura'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +145',b'Make Retention Stock Entry',b'Lag Retention Stock Entry'
+b'DocType: Purchase Invoice Item',b'Item Weight Details',b'Vektdetaljer'
+b'DocType: Asset Maintenance Log',b'Periodicity',b'Periodisitet'
+b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +21',b'Fiscal Year {0} is required',b'Regnskaps\xc3\xa5r {0} er n\xc3\xb8dvendig'
+b'DocType: Crop Cycle',b'The minimum distance between rows of plants for optimum growth',b'Minimumsavstanden mellom rader av planter for optimal vekst'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +21',b'Defense',b'Forsvars'
+b'DocType: Salary Component',b'Abbr',b'Abbr'
+b'DocType: Appraisal Goal',b'Score (0-5)',b'Score (0-5)'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +225',b'Row {0}: {1} {2} does not match with {3}',b'Rad {0}: {1} {2} samsvarer ikke med {3}'
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +77',b'Row # {0}:',b'Row # {0}:'
+b'DocType: Timesheet',b'Total Costing Amount',b'Total koster Bel\xc3\xb8p'
+b'DocType: Delivery Note',b'Vehicle No',b'Vehicle Nei'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +163',b'Please select Price List',b'Vennligst velg Prisliste'
+b'DocType: Accounts Settings',b'Currency Exchange Settings',b'Valutavekslingsinnstillinger'
+b'apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +94',b'Row #{0}: Payment document is required to complete the trasaction',b'Row # {0}: Betaling dokumentet er n\xc3\xb8dvendig for \xc3\xa5 fullf\xc3\xb8re trasaction'
+b'DocType: Work Order Operation',b'Work In Progress',b'Arbeid P\xc3\xa5 G\xc3\xa5r'
+b'apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py +13',b'Please select date',b'Vennligst velg dato'
+b'DocType: Daily Work Summary Group',b'Holiday List',b'Holiday List'
+b'apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +88',b'Please setup numbering series for Attendance via Setup &gt; Numbering Series',b'Vennligst oppsett nummereringsserie for Tilstedev\xc3\xa6relse via Oppsett&gt; Nummereringsserie'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +127',b'Accountant',b'Accountant'
+b'DocType: Hub Settings',b'Selling Price List',b'Selge prisliste'
+b'DocType: Patient',b'Tobacco Current Use',b'N\xc3\xa5v\xc3\xa6rende bruk av tobakk'
+b'apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +56',b'Selling Rate',b'Selgingsfrekvens'
+b'DocType: Cost Center',b'Stock User',b'Stock User'
+b'DocType: Soil Analysis',b'(Ca+Mg)/K',b'(Ca + Mg) / K'
+b'DocType: Company',b'Phone No',b'Telefonnr'
+b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +239',b'New {0}: #{1}',b'New {0} # {1}'
+b'DocType: Delivery Trip',b'Initial Email Notification Sent',b'Innledende e-postvarsling sendt'
+,b'Sales Partners Commission',b'Sales Partners Commission'
+b'DocType: Soil Texture',b'Sandy Clay Loam',b'Sandy Clay Loam'
+b'DocType: Purchase Invoice',b'Rounding Adjustment',b'Avrundingsjustering'
+b'apps/erpnext/erpnext/setup/doctype/company/company.py +46',b'Abbreviation cannot have more than 5 characters',b'Forkortelse kan ikke ha mer enn fem tegn'
+b'DocType: Physician Schedule Time Slot',b'Physician Schedule Time Slot',b'Leger Schedule Time Slot'
+b'DocType: Payment Request',b'Payment Request',b'Betaling Request'
+b'DocType: Asset',b'Value After Depreciation',b'Verdi etter avskrivninger'
+b'DocType: Student',b'O+',b'O +'
+b'apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan_dashboard.py +8',b'Related',b'I slekt'
+b'apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +43',"b""Attendance date can not be less than employee's joining date""",b'Oppm\xc3\xb8te dato kan ikke v\xc3\xa6re mindre enn ansattes bli dato'
+b'DocType: Grading Scale',b'Grading Scale Name',b'Grading Scale Name'
+b'DocType: Subscription',b'Repeat on Day',b'Gjenta p\xc3\xa5 dagen'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.js +41',b'This is a root account and cannot be edited.',b'Dette er en rot konto og kan ikke redigeres.'
+b'DocType: Sales Invoice',b'Company Address',b'Firma adresse'
+b'DocType: BOM',b'Operations',b'Operasjoner'
+b'apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +38',b'Cannot set authorization on basis of Discount for {0}',b'Kan ikke sette autorisasjon p\xc3\xa5 grunnlag av Rabatt for {0}'
+b'DocType: Rename Tool',"b'Attach .csv file with two columns, one for the old name and one for the new name'","b'Fest CSV-fil med to kolonner, en for det gamle navnet og en for det nye navnet'"
+b'apps/erpnext/erpnext/accounts/utils.py +73',b'{0} {1} not in any active Fiscal Year.',b'{0} {1} ikke i noen aktiv regnskaps\xc3\xa5ret.'
+b'DocType: Packed Item',b'Parent Detail docname',b'Parent Detail docname'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +69',"b'Reference: {0}, Item Code: {1} and Customer: {2}'","b'Henvisning: {0}, Varenummer: {1} og kunde: {2}'"
+b'apps/erpnext/erpnext/utilities/user_progress.py +146',b'Kg',b'Kg'
+b'apps/erpnext/erpnext/config/hr.py +45',b'Opening for a Job.',b'\xc3\x85pning for en jobb.'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +114',b'BOM is not specified for subcontracting item {0} at row {1}',b'BOM er ikke spesifisert for underleverand\xc3\xb8relementet {0} p\xc3\xa5 rad {1}'
+b'apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js +149',b'{0} Result submittted',b'{0} Resultat sendt'
+b'DocType: Item Attribute',b'Increment',b'Tilvekst'
+b'apps/erpnext/erpnext/utilities/page/leaderboard/leaderboard.js +74',b'Timespan',b'Tidsrom'
+b'apps/erpnext/erpnext/public/js/stock_analytics.js +58',b'Select Warehouse...',b'Velg Warehouse ...'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +6',b'Advertising',b'Annonsering'
+b'apps/erpnext/erpnext/accounts/doctype/mode_of_payment/mode_of_payment.py +22',b'Same Company is entered more than once',b'Samme firma er angitt mer enn \xc3\xa9n gang'
+b'DocType: Patient',b'Married',b'Gift'
+b'apps/erpnext/erpnext/accounts/party.py +41',b'Not permitted for {0}',b'Ikke tillatt for {0}'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +593',b'Get items from',b'F\xc3\xa5 elementer fra'
+b'DocType: Price List',b'Price Not UOM Dependant',b'Pris Ikke UOM Avhengig'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +467',b'Stock cannot be updated against Delivery Note {0}',b'Stock kan ikke oppdateres mot f\xc3\xb8lgeseddel {0}'
+b'apps/erpnext/erpnext/templates/pages/home.py +25',b'Product {0}',b'Produkt {0}'
+b'apps/erpnext/erpnext/templates/generators/item_group.html +43',b'No items listed',b'Ingen elementer oppf\xc3\xb8rt'
+b'DocType: Asset Repair',b'Error Description',b'Feilbeskrivelse'
+b'DocType: Payment Reconciliation',b'Reconcile',b'Forsone'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +30',b'Grocery',b'Dagligvare'
+b'DocType: Quality Inspection Reading',b'Reading 1',b'Lesing 1'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +40',b'Pension Funds',b'Pensjonsfondene'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +91',b'Next Depreciation Date cannot be before Purchase Date',b'Neste Avskrivninger Datoen kan ikke v\xc3\xa6re f\xc3\xb8r Kj\xc3\xb8psdato'
+b'DocType: Crop',b'Perennial',b'Fler\xc3\xa5rig'
+b'DocType: Consultation',b'Consultation Date',b'H\xc3\xb8ringsdato'
+b'DocType: Accounts Settings',b'Use Custom Cash Flow Format',b'Bruk tilpasset kontantstr\xc3\xb8mformat'
+b'DocType: SMS Center',b'All Sales Person',b'All Sales Person'
+b'DocType: Monthly Distribution',b'**Monthly Distribution** helps you distribute the Budget/Target across months if you have seasonality in your business.',b'** M\xc3\xa5nedlig Distribusjon ** hjelper deg distribuere Budsjett / Target over m\xc3\xa5neder hvis du har sesongvariasjoner i din virksomhet.'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +1753',b'Not items found',b'Ikke elementer funnet'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +184',b'Salary Structure Missing',b'L\xc3\xb8nn Struktur Missing'
+b'DocType: Lead',b'Person Name',b'Person Name'
+b'DocType: Sales Invoice Item',b'Sales Invoice Item',b'Salg Faktura Element'
+b'DocType: Account',b'Credit',b'Credit'
+b'DocType: POS Profile',b'Write Off Cost Center',b'Skriv Av kostnadssted'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +117',"b'e.g. ""Primary School"" or ""University""'",b'for eksempel &quot;Primary School&quot; eller &quot;University&quot;'
+b'apps/erpnext/erpnext/config/stock.py +28',b'Stock Reports',b'lager rapporter'
+b'DocType: Warehouse',b'Warehouse Detail',b'Warehouse Detalj'
+b'apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +33',b'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.',"b'Begrepet Sluttdato kan ikke v\xc3\xa6re senere enn \xc3\xa5ret sluttdato av studie\xc3\xa5ret som begrepet er knyttet (studie\xc3\xa5ret {}). Korriger datoene, og pr\xc3\xb8v igjen.'"
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +269',"b'""Is Fixed Asset"" cannot be unchecked, as Asset record exists against the item'","b'&quot;Er Fixed Asset&quot; ikke kan v\xc3\xa6re ukontrollert, som Asset post eksisterer mot elementet'"
+b'DocType: Delivery Trip',b'Departure Time',b'Avgangstid'
+b'DocType: Vehicle Service',b'Brake Oil',b'bremse~~POS=TRUNC Oil'
+b'DocType: Tax Rule',b'Tax Type',b'Skatt Type'
+,b'Completed Work Orders',b'Fullf\xc3\xb8rte arbeidsordrer'
+b'apps/erpnext/erpnext/controllers/taxes_and_totals.py +581',b'Taxable Amount',b'Skattepliktig bel\xc3\xb8p'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +160',b'You are not authorized to add or update entries before {0}',b'Du er ikke autorisert til \xc3\xa5 legge til eller oppdatere bloggen f\xc3\xb8r {0}'
+b'DocType: BOM',b'Item Image (if not slideshow)',b'Sak Image (hvis ikke show)'
+b'DocType: Work Order Operation',b'(Hour Rate / 60) * Actual Operation Time',b'(Timepris / 60) * Faktisk Operation Tid'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1103',b'Row #{0}: Reference Document Type must be one of Expense Claim or Journal Entry',b'Row # {0}: Referansedokumenttype m\xc3\xa5 v\xc3\xa6re en av kostnadskrav eller journaloppf\xc3\xb8ring'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +975',b'Select BOM',b'Velg BOM'
+b'DocType: SMS Log',b'SMS Log',b'SMS Log'
+b'apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +27',b'Cost of Delivered Items',b'Kostnad for leverte varer'
+b'apps/erpnext/erpnext/config/hr.py +127',b'Manage advance amount given to the Employee',b'Administrer forh\xc3\xa5ndsbel\xc3\xb8p gitt til Medarbeider'
+b'apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +38',b'The holiday on {0} is not between From Date and To Date',b'Ferien p\xc3\xa5 {0} er ikke mellom Fra dato og Til dato'
+b'DocType: Student Log',b'Student Log',b'student Log'
+b'apps/erpnext/erpnext/config/buying.py +165',b'Templates of supplier standings.',b'Maler av leverand\xc3\xb8rstillinger.'
+b'DocType: Lead',b'Interested',b'Interessert'
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +216',b'Opening',b'\xc3\x85pning'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +32',b'From {0} to {1}',b'Fra {0} til {1}'
+b'apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +234',b'Program: ',b'Program:'
+b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +50',b'Failed to setup taxes',b'Kunne ikke sette opp skatt'
+b'DocType: Item',b'Copy From Item Group',b'Kopier fra varegruppe'
+b'DocType: Delivery Trip',b'Delivery Notification',b'Leveringsvarsling'
+b'DocType: Journal Entry',b'Opening Entry',b'\xc3\x85pning Entry'
+b'apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +25',b'Account Pay Only',b'Bare konto Pay'
+b'DocType: Employee Loan',b'Repay Over Number of Periods',b'Betale tilbake over antall perioder'
+b'DocType: Stock Entry',b'Additional Costs',b'Tilleggskostnader'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +138',b'Account with existing transaction can not be converted to group.',b'Konto med eksisterende transaksjon kan ikke konverteres til gruppen.'
+b'DocType: Lead',b'Product Enquiry',b'Produkt Foresp\xc3\xb8rsel'
+b'DocType: Education Settings',b'Validate Batch for Students in Student Group',b'Valider batch for studenter i studentgruppen'
+b'apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +35',b'No leave record found for employee {0} for {1}',b'Ingen forlater plate funnet for ansatt {0} og {1}'
+b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +23',b'Please enter company first',b'Skriv inn et selskap f\xc3\xb8rst'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +365',b'Please select Company first',b'Vennligst velg selskapet f\xc3\xb8rst'
+b'DocType: Employee Education',b'Under Graduate',b'Under Graduate'
+b'apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.js +27',b'Target On',b'Target P\xc3\xa5'
+b'DocType: BOM',b'Total Cost',b'Totalkostnad'
+b'DocType: Soil Analysis',b'Ca/K',b'Ca / K'
+b'DocType: Journal Entry Account',b'Employee Loan',b'Medarbeider Loan'
+b'DocType: Fee Schedule',b'Send Payment Request Email',b'Send betalingsanmodning e-post'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +268',b'Item {0} does not exist in the system or has expired',b'Element {0} finnes ikke i systemet eller er utl\xc3\xb8pt'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +44',b'Real Estate',b'Eiendom'
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html +1',b'Statement of Account',b'Kontoutskrift'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +41',b'Pharmaceuticals',b'Farmasi'
+b'DocType: Purchase Invoice Item',b'Is Fixed Asset',b'Er Fast Asset'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +273',"b'Available qty is {0}, you need {1}'","b'Tilgjengelig stk er {0}, m\xc3\xa5 du {1}'"
+b'DocType: Expense Claim Detail',b'Claim Amount',b'Krav Bel\xc3\xb8p'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +653',b'Work Order has been {0}',b'Arbeidsordre har v\xc3\xa6rt {0}'
+b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +56',b'Duplicate customer group found in the cutomer group table',b'Duplicate kundegruppen funnet i cutomer gruppetabellen'
+b'apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +31',b'Supplier Type / Supplier',b'Leverand\xc3\xb8r Type / leverand\xc3\xb8r'
+b'DocType: Naming Series',b'Prefix',b'Prefix'
+b'apps/erpnext/erpnext/hr/email_alert/training_scheduled/training_scheduled.html +7',b'Event Location',b'Hendelsessted'
+b'DocType: Asset Settings',b'Asset Settings',b'Asset Settings'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +68',b'Consumable',b'Konsum'
+b'DocType: Student',b'B-',b'B-'
+b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +98',b'Successfully unregistered.',b'Helt uregistrert.'
+b'DocType: Assessment Result',b'Grade',b'grade'
+b'DocType: Restaurant Table',b'No of Seats',b'Antall plasser'
+b'DocType: Subscription',"b'To add dynamic subject, use jinja tags like\n\n<div><pre><code>New {{ doc.doctype }} #{{ doc.name }}</code></pre></div>'","b'For \xc3\xa5 legge til dynamisk emne, bruk jinja-koder som <div><pre> <code>New {{ doc.doctype }} #{{ doc.name }}</code> </pre> </div>'"
+b'DocType: Sales Invoice Item',b'Delivered By Supplier',b'Levert av Leverand\xc3\xb8r'
+b'DocType: Asset Maintenance Task',b'Asset Maintenance Task',b'Asset Maintenance Task'
+b'DocType: SMS Center',b'All Contact',b'All kontakt'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +232',b'Annual Salary',b'\xc3\x85rsl\xc3\xb8nn'
+b'DocType: Daily Work Summary',b'Daily Work Summary',b'Daglig arbeid Oppsummering'
+b'DocType: Period Closing Voucher',b'Closing Fiscal Year',b'Lukke regnskaps\xc3\xa5r'
+b'apps/erpnext/erpnext/accounts/party.py +392',b'{0} {1} is frozen',b'{0} {1} er frosset'
+b'apps/erpnext/erpnext/setup/doctype/company/company.py +140',b'Please select Existing Company for creating Chart of Accounts',b'Velg eksisterende selskap for \xc3\xa5 skape Konto'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +80',b'Stock Expenses',b'Aksje Utgifter'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +111',b'Select Target Warehouse',b'Velg Target Warehouse'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +111',b'Select Target Warehouse',b'Velg Target Warehouse'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.js +80',b'Please enter Preferred Contact Email',b'Fyll inn foretrukne e-'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +45',b'CompAuxNum',b'CompAuxNum'
+b'DocType: Journal Entry',b'Contra Entry',b'Contra Entry'
+b'DocType: Journal Entry Account',b'Credit in Company Currency',b'Kreditt i selskapet Valuta'
+b'DocType: Lab Test UOM',b'Lab Test UOM',b'Lab Test UOM'
+b'DocType: Delivery Note',b'Installation Status',b'Installasjon Status'
+b'DocType: BOM',b'Quality Inspection Template',b'Kvalitetskontrollmaler'
+b'apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +135',b'Do you want to update attendance?<br>Present: {0}\\\n\t\t\t\t\t<br>Absent: {1}',b'\xc3\x98nsker du \xc3\xa5 oppdatere oppm\xc3\xb8te? <br> Present: {0} \\ <br> Frav\xc3\xa6rende: {1}'
+b'apps/erpnext/erpnext/controllers/buying_controller.py +334',b'Accepted + Rejected Qty must be equal to Received quantity for Item {0}',b'Akseptert + Avvist Antall m\xc3\xa5 v\xc3\xa6re lik mottatt kvantum for Element {0}'
+b'DocType: Request for Quotation',b'RFQ-',b'RFQ-'
+b'DocType: Item',b'Supply Raw Materials for Purchase',b'Leverer r\xc3\xa5vare til Purchase'
+b'DocType: Agriculture Analysis Criteria',b'Fertilizer',b'Gj\xc3\xb8dsel'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +152',b'At least one mode of payment is required for POS invoice.',b'I det minste \xc3\xa9n modus av betaling er n\xc3\xb8dvendig for POS faktura.'
+b'DocType: Products Settings',b'Show Products as a List',b'Vis produkter p\xc3\xa5 en liste'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +532',b'Item {0} is not active or end of life has been reached',b'Element {0} er ikke aktiv eller slutten av livet er n\xc3\xa5dd'
+b'DocType: Student Admission Program',b'Minimum Age',b'Minimumsalder'
+b'apps/erpnext/erpnext/utilities/user_progress.py +190',b'Example: Basic Mathematics',b'Eksempel: Grunnleggende matematikk'
+b'DocType: Customer',b'Primary Address',b'hoved adresse'
+b'DocType: Production Plan',b'Material Request Detail',b'Material Request Detail'
+b'DocType: Selling Settings',b'Default Quotation Validity Days',b'Standard Quotation Gyldighetsdager'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +800',"b'To include tax in row {0} in Item rate, taxes in rows {1} must also be included'","b'For \xc3\xa5 inkludere skatt i rad {0} i Element rente, skatt i rader {1} m\xc3\xa5 ogs\xc3\xa5 inkluderes'"
+b'apps/erpnext/erpnext/config/hr.py +223',b'Settings for HR Module',b'Innstillinger for HR Module'
+b'DocType: SMS Center',b'SMS Center',b'SMS-senter'
+b'DocType: Sales Invoice',b'Change Amount',b'endring Bel\xc3\xb8p'
+b'DocType: GST Settings',b'Set Invoice Value for B2C. B2CL and B2CS calculated based on this invoice value.',b'Angi fakturaverdi for B2C. B2CL og B2CS beregnet ut fra denne fakturaverdien.'
+b'DocType: BOM Update Tool',b'New BOM',b'New BOM'
+b'apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js +36',b'Show only POS',b'Vis bare POS'
+b'DocType: Driver',b'Driving License Categories',b'Kj\xc3\xb8relisenskategorier'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +118',b'Please enter Delivery Date',b'Vennligst oppgi Leveringsdato'
+b'DocType: Depreciation Schedule',b'Make Depreciation Entry',b'Gj\xc3\xb8r Avskrivninger Entry'
+b'DocType: Appraisal Template Goal',b'KRA',b'KRA'
+b'DocType: Lead',b'Request Type',b'Foresp\xc3\xb8rsel Type'
+b'apps/erpnext/erpnext/hr/doctype/job_offer/job_offer.js +17',b'Make Employee',b'Gj\xc3\xb8r Employee'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +14',b'Broadcasting',b'Kringkasting'
+b'apps/erpnext/erpnext/config/accounts.py +313',b'Setup mode of POS (Online / Offline)',b'Oppsettmodus for POS (Online / Offline)'
+b'DocType: Manufacturing Settings',b'Disables creation of time logs against Work Orders. Operations shall not be tracked against Work Order',b'Deaktiverer opprettelse av tidslogger mot arbeidsordre. Operasjoner skal ikke spores mot arbeidsordre'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +191',b'Execution',b'Execution'
+b'apps/erpnext/erpnext/config/manufacturing.py +62',b'Details of the operations carried out.',b'Detaljene for operasjonen utf\xc3\xb8res.'
+b'DocType: Asset Maintenance Log',b'Maintenance Status',b'Vedlikehold Status'
+b'apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py +10',b'Membership Details',b'Medlemskapsdetaljer'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +56',b'{0} {1}: Supplier is required against Payable account {2}',b'{0} {1}: Leverand\xc3\xb8r er n\xc3\xb8dvendig mot Betales konto {2}'
+b'apps/erpnext/erpnext/config/selling.py +52',b'Items and Pricing',b'Elementer og priser'
+b'apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +2',b'Total hours: {0}',b'Antall timer: {0}'
+b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +43',b'From Date should be within the Fiscal Year. Assuming From Date = {0}',b'Fra dato b\xc3\xb8r v\xc3\xa6re innenfor regnskaps\xc3\xa5ret. Antar Fra Date = {0}'
+b'DocType: Drug Prescription',b'Interval',b'intervall'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +253',b'Preference',b'Preference'
+b'DocType: Grant Application',b'Individual',b'Individuell'
+b'DocType: Academic Term',b'Academics User',b'akademikere Bruker'
+b'DocType: Cheque Print Template',b'Amount In Figure',b'Bel\xc3\xb8p I figur'
+b'DocType: Employee Loan Application',b'Loan Info',b'l\xc3\xa5n info'
+b'apps/erpnext/erpnext/config/maintenance.py +12',b'Plan for maintenance visits.',b'Plan for vedlikeholdsbes\xc3\xb8k.'
+b'DocType: Supplier Scorecard Period',b'Supplier Scorecard Period',b'Leverand\xc3\xb8r Scorecard Periode'
+b'DocType: Share Transfer',b'Share Transfer',b'Del overf\xc3\xb8ring'
+b'DocType: POS Profile',b'Customer Groups',b'kunde~~POS=TRUNC grupper~~POS=HEADCOMP'
+b'apps/erpnext/erpnext/public/js/financial_statements.js +51',b'Financial Statements',b'\xc3\x85rsregnskap'
+b'DocType: Guardian',b'Students',b'studenter'
+b'apps/erpnext/erpnext/config/selling.py +91',b'Rules for applying pricing and discount.',b'Regler for bruk av prising og rabatt.'
+b'DocType: Daily Work Summary',b'Daily Work Summary Group',b'Daglig arbeidsoppsummeringsgruppe'
+b'DocType: Physician Schedule',b'Time Slots',b'Tidsluker'
+b'apps/erpnext/erpnext/stock/doctype/price_list/price_list.py +14',b'Price List must be applicable for Buying or Selling',b'Prisliste m\xc3\xa5 v\xc3\xa6re aktuelt for \xc3\xa5 kj\xc3\xb8pe eller selge'
+b'apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +79',b'Installation date cannot be before delivery date for Item {0}',b'Installasjonsdato kan ikke v\xc3\xa6re f\xc3\xb8r leveringsdato for Element {0}'
+b'DocType: Pricing Rule',b'Discount on Price List Rate (%)',b'Rabatt p\xc3\xa5 Prisliste Rate (%)'
+b'apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +112',b'Item Template',b'Artikkelmal'
+b'apps/erpnext/erpnext/healthcare/setup.py +215',b'Biochemistry',b'biokjemi'
+b'DocType: Job Offer',b'Select Terms and Conditions',b'Velg Vilk\xc3\xa5r'
+b'apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +72',b'Out Value',b'ut Verdi'
+b'DocType: Production Plan',b'Sales Orders',b'Salgsordrer'
+b'DocType: Purchase Taxes and Charges',b'Valuation',b'Verdivurdering'
+b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +390',b'Set as Default',b'Satt som standard'
+b'DocType: Production Plan',b'PLN-',b'PLN-'
+,b'Purchase Order Trends',b'Innkj\xc3\xb8psordre Trender'
+b'apps/erpnext/erpnext/utilities/user_progress.py +78',b'Go to Customers',b'G\xc3\xa5 til Kunder'
+b'DocType: Hotel Room Reservation',b'Late Checkin',b'Sen innsjekk'
+b'apps/erpnext/erpnext/templates/emails/request_for_quotation.html +7',b'The request for quotation can be accessed by clicking on the following link',b'Anmodningen om sitatet kan n\xc3\xa5s ved \xc3\xa5 klikke p\xc3\xa5 f\xc3\xb8lgende link'
+b'apps/erpnext/erpnext/config/hr.py +81',b'Allocate leaves for the year.',b'Bevilge blader for \xc3\xa5ret.'
+b'DocType: SG Creation Tool Course',b'SG Creation Tool Course',b'SG Creation Tool Course'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +275',b'Insufficient Stock',b'utilstrekkelig Stock'
+b'DocType: Manufacturing Settings',b'Disable Capacity Planning and Time Tracking',b'Deaktiver kapasitetsplanlegging og Time Tracking'
+b'DocType: Email Digest',b'New Sales Orders',b'Nye salgsordrer'
+b'DocType: Bank Guarantee',b'Bank Account',b'Bankkonto'
+b'DocType: Leave Type',b'Allow Negative Balance',b'Tillat negativ saldo'
+b'apps/erpnext/erpnext/projects/doctype/project_type/project_type.py +13',"b""You cannot delete Project Type 'External'""",b'Du kan ikke slette Project Type &#39;External&#39;'
+b'DocType: Employee',b'Create User',b'Opprett bruker'
+b'DocType: Selling Settings',b'Default Territory',b'Standard Territory'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +53',b'Television',b'TV'
+b'DocType: Work Order Operation',"b""Updated via 'Time Log'""",b'Oppdatert via &#39;Time Logg&#39;'
+b'apps/erpnext/erpnext/controllers/taxes_and_totals.py +430',b'Advance amount cannot be greater than {0} {1}',b'Advance bel\xc3\xb8pet kan ikke v\xc3\xa6re st\xc3\xb8rre enn {0} {1}'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +42',b'JournalCode',b'JournalCode'
+b'DocType: Naming Series',b'Series List for this Transaction',b'Serien Liste for denne transaksjonen'
+b'DocType: Company',b'Enable Perpetual Inventory',b'Aktiver evigvarende beholdning'
+b'DocType: Company',b'Default Payroll Payable Account',b'Standard L\xc3\xb8nn betales konto'
+b'apps/erpnext/erpnext/education/doctype/student_group/student_group.js +51',b'Update Email Group',b'Oppdater E-postgruppe'
+b'DocType: Sales Invoice',b'Is Opening Entry',b'\xc3\x85pner Entry'
+b'DocType: Lab Test Template',"b'If unchecked, the item wont be appear in Sales Invoice, but can be used in group test creation. '","b'Hvis ikke merket, vil varen ikke vises i salgsfaktura, men kan brukes i gruppetestopprettelse.'"
+b'DocType: Customer Group',b'Mention if non-standard receivable account applicable',b'Nevn hvis ikke-standard fordring konto aktuelt'
+b'DocType: Course Schedule',b'Instructor Name',b'instrukt\xc3\xb8r Name'
+b'DocType: Supplier Scorecard',b'Criteria Setup',b'Kriterieoppsett'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +206',b'For Warehouse is required before Submit',b'For Warehouse er n\xc3\xb8dvendig f\xc3\xb8r Send'
+b'apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +8',b'Received On',b'Mottatt On'
+b'DocType: Sales Partner',b'Reseller',b'Reseller'
+b'DocType: Codification Table',b'Medical Code',b'Medisinsk kode'
+b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +20',b'Please enter Company',b'Skriv inn Firma'
+b'DocType: Delivery Note Item',b'Against Sales Invoice Item',b'Mot Salg Faktura Element'
+b'DocType: Agriculture Analysis Criteria',b'Linked Doctype',b'Tilknyttet doktype'
+b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +44',b'Net Cash from Financing',b'Netto kontantstr\xc3\xb8m fra finansierings'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +2375',"b'LocalStorage is full , did not save'","b'Localstorage er full, ikke spare'"
+b'DocType: Lead',b'Address & Contact',b'Adresse og kontakt'
+b'DocType: Leave Allocation',b'Add unused leaves from previous allocations',b'Legg ubrukte blader fra tidligere bevilgninger'
+b'DocType: Sales Partner',b'Partner website',b'partner nettstedet'
+b'DocType: Restaurant Order Entry',b'Add Item',b'Legg til element'
+b'DocType: Lab Test',b'Custom Result',b'Tilpasset resultat'
+b'DocType: Delivery Stop',b'Contact Name',b'Kontakt Navn'
+b'DocType: Course Assessment Criteria',b'Course Assessment Criteria',b'Kursvurderingskriteriene'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +18',b'Tax Id: ',b'Skatte-ID:'
+b'apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +216',b'Student ID: ',b'Student ID:'
+b'DocType: POS Customer Group',b'POS Customer Group',b'POS Kundegruppe'
+b'DocType: Land Unit',b'Land Unit describing various land assets',b'Land Enhet som beskriver ulike eiendeler'
+b'DocType: Cheque Print Template',b'Line spacing for amount in words',b'Linjeavstand for bel\xc3\xb8pet i ord'
+b'DocType: Vehicle',b'Additional Details',b'ekstra detaljer'
+b'apps/erpnext/erpnext/templates/generators/bom.html +85',b'No description given',b'Ingen beskrivelse gitt'
+b'apps/erpnext/erpnext/config/buying.py +13',b'Request for purchase.',b'Be for kj\xc3\xb8p.'
+b'DocType: Lab Test',b'Submitted Date',b'Innleveringsdato'
+b'apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py +6',b'This is based on the Time Sheets created against this project',b'Dette er basert p\xc3\xa5 timelister som er opprettet mot dette prosjektet'
+,b'Open Work Orders',b'\xc3\x85pne arbeidsordre'
+b'DocType: Payment Term',b'Credit Months',b'Kredittm\xc3\xa5neder'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +409',b'Net Pay cannot be less than 0',b'Nettol\xc3\xb8nn kan ikke v\xc3\xa6re mindre enn 0'
+b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +5',"b'To stop sending repetitive error notifications from the system, we have checked Disabled field in the subscription'","b'For \xc3\xa5 slutte \xc3\xa5 sende gjentatte feilmeldinger fra systemet, har vi sjekket deaktivert felt i abonnementet'"
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +121',b'Relieving Date must be greater than Date of Joining',b'Lindrende Dato m\xc3\xa5 v\xc3\xa6re st\xc3\xb8rre enn tidspunktet for inntreden'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +240',b'Leaves per Year',b'Later per \xc3\xa5r'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +130',"b""Row {0}: Please check 'Is Advance' against Account {1} if this is an advance entry.""",b'Rad {0}: Vennligst sjekk &#39;Er Advance &quot;mot Account {1} hvis dette er et forskudd oppf\xc3\xb8ring.'
+b'apps/erpnext/erpnext/stock/utils.py +219',b'Warehouse {0} does not belong to company {1}',b'Warehouse {0} ikke tilh\xc3\xb8rer selskapet {1}'
+b'DocType: Email Digest',b'Profit & Loss',b'Profitt tap'
+b'apps/erpnext/erpnext/utilities/user_progress.py +147',b'Litre',b'liter'
+b'DocType: Task',b'Total Costing Amount (via Time Sheet)',b'Total Costing Bel\xc3\xb8p (via Timeregistrering)'
+b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.py +76',b'Please setup Students under Student Groups',b'Vennligst oppsett Studentene under Student Grupper'
+b'DocType: Item Website Specification',b'Item Website Specification',b'Sak Nettsted Spesifikasjon'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +449',b'Leave Blocked',b'La Blokkert'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +740',b'Item {0} has reached its end of life on {1}',b'Element {0} har n\xc3\xa5dd slutten av livet p\xc3\xa5 {1}'
+b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +83',b'Bank Entries',b'Bank Entries'
+b'DocType: Crop',b'Annual',b'\xc3\x85rlig'
+b'DocType: Stock Reconciliation Item',b'Stock Reconciliation Item',b'Stock Avstemming Element'
+b'DocType: Stock Entry',b'Sales Invoice No',b'Salg Faktura Nei'
+b'DocType: Material Request Item',b'Min Order Qty',b'Min Bestill Antall'
+b'DocType: Student Group Creation Tool Course',b'Student Group Creation Tool Course',b'Student Gruppe Creation Tool Course'
+b'DocType: Lead',b'Do Not Contact',b'Ikke kontakt'
+b'apps/erpnext/erpnext/utilities/user_progress.py +210',b'People who teach at your organisation',b'Folk som underviser i organisasjonen'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +135',b'Software Developer',b'Programvareutvikler'
+b'DocType: Item',b'Minimum Order Qty',b'Minimum Antall'
+b'DocType: Pricing Rule',b'Supplier Type',b'Leverand\xc3\xb8r Type'
+b'DocType: Course Scheduling Tool',b'Course Start Date',b'Kursstart'
+,b'Student Batch-Wise Attendance',b'Student Batch-Wise Oppm\xc3\xb8te'
+b'DocType: POS Profile',b'Allow user to edit Rate',b'Tillater brukeren \xc3\xa5 redigere Ranger'
+b'DocType: Item',b'Publish in Hub',b'Publisere i Hub'
+b'DocType: Student Admission',b'Student Admission',b'student Entre'
+,b'Terretory',b'Terretory'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +762',b'Item {0} is cancelled',b'Element {0} er kansellert'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1064',b'Material Request',b'Materialet Request'
+b'DocType: Bank Reconciliation',b'Update Clearance Date',b'Oppdater Lagersalg Dato'
+,b'GSTR-2',b'GSTR-2'
+b'DocType: Item',b'Purchase Details',b'Kj\xc3\xb8ps Detaljer'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +407',"b""Item {0} not found in 'Raw Materials Supplied' table in Purchase Order {1}""",b'Element {0} ble ikke funnet i &#39;R\xc3\xa5vare Leveres&#39; bord i innkj\xc3\xb8psordre {1}'
+b'DocType: Salary Slip',b'Total Principal Amount',b'Sum hovedbel\xc3\xb8p'
+b'DocType: Student Guardian',b'Relation',b'Relasjon'
+b'DocType: Student Guardian',b'Mother',b'Mor'
+b'DocType: Restaurant Reservation',b'Reservation End Time',b'Reservasjons sluttid'
+b'DocType: Crop',b'Biennial',b'Biennial'
+b'apps/erpnext/erpnext/config/selling.py +18',b'Confirmed orders from Customers.',b'Bekreftede bestillinger fra kunder.'
+b'DocType: Purchase Receipt Item',b'Rejected Quantity',b'Avvist Antall'
+b'apps/erpnext/erpnext/education/doctype/fees/fees.py +80',b'Payment request {0} created',b'Betalingsforesp\xc3\xb8rsel {0} opprettet'
+b'apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +72',b'Open Orders',b'\xc3\x85pne bestillinger'
+b'apps/erpnext/erpnext/healthcare/setup.py +255',b'Low Sensitivity',b'Lav f\xc3\xb8lsomhet'
+b'DocType: Notification Control',b'Notification Control',b'Varsling kontroll'
+b'apps/erpnext/erpnext/templates/emails/training_event.html +17',b'Please confirm once you have completed your training',b'Vennligst bekreft n\xc3\xa5r du har fullf\xc3\xb8rt treningen'
+b'DocType: Lead',b'Suggestions',b'Forslag'
+b'DocType: Territory',b'Set Item Group-wise budgets on this Territory. You can also include seasonality by setting the Distribution.',b'Set varegruppe-messig budsjetter p\xc3\xa5 dette territoriet. Du kan ogs\xc3\xa5 inkludere sesongvariasjoner ved \xc3\xa5 sette Distribution.'
+b'DocType: Payment Term',b'Payment Term Name',b'Betalingsnavn'
+b'DocType: Healthcare Settings',b'Create documents for sample collection',b'Lag dokumenter for pr\xc3\xb8veinnsamling'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +276',b'Payment against {0} {1} cannot be greater than Outstanding Amount {2}',b'Betaling mot {0} {1} kan ikke v\xc3\xa6re st\xc3\xb8rre enn utest\xc3\xa5ende bel\xc3\xb8p {2}'
+b'DocType: Shareholder',b'Address HTML',b'Adresse HTML'
+b'DocType: Lead',b'Mobile No.',b'Mobile No.'
+b'DocType: Maintenance Schedule',b'Generate Schedule',b'Generere Schedule'
+b'DocType: Purchase Invoice Item',b'Expense Head',b'Expense Leder'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +138',b'Please select Charge Type first',b'Vennligst velg Charge Type f\xc3\xb8rst'
+b'DocType: Crop',"b'You can define all the tasks which need to carried out for this crop here. The day field is used to mention the day on which the task needs to be carried out, 1 being the 1st day, etc.. '","b'Du kan definere alle oppgavene som m\xc3\xa5 utf\xc3\xb8res for denne avlingen her. Dagfeltet brukes til \xc3\xa5 nevne hvilken dag oppgaven m\xc3\xa5 utf\xc3\xb8res, 1 er 1. dag, osv.'"
+b'DocType: Student Group Student',b'Student Group Student',b'Student Gruppe Student'
+b'apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41',b'Latest',b'Siste'
+b'DocType: Asset Maintenance Task',b'2 Yearly',b'2 \xc3\xa5rlig'
+b'DocType: Education Settings',b'Education Settings',b'Utdanning Innstillinger'
+b'DocType: Vehicle Service',b'Inspection',b'Unders\xc3\xb8kelse'
+b'DocType: Supplier Scorecard Scoring Standing',b'Max Grade',b'Maksimal karakter'
+b'DocType: Email Digest',b'New Quotations',b'Nye Sitater'
+b'DocType: HR Settings',b'Emails salary slip to employee based on preferred email selected in Employee',b'E-poster l\xc3\xb8nn slip til ansatte basert p\xc3\xa5 foretrukne e-post valgt i Employee'
+b'DocType: Employee',b'The first Leave Approver in the list will be set as the default Leave Approver',b'Den f\xc3\xb8rste La Godkjenner i listen vil bli definert som standard La Godkjenner'
+b'DocType: Tax Rule',b'Shipping County',b'Shipping fylke'
+b'apps/erpnext/erpnext/config/desktop.py +167',b'Learn',b'L\xc3\xa6re'
+b'DocType: Asset',b'Next Depreciation Date',b'Neste Avskrivninger Dato'
+b'apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js +3',b'Activity Cost per Employee',b'Aktivitet Kostnad per Employee'
+b'DocType: Accounts Settings',b'Settings for Accounts',b'Innstillinger for kontoer'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +673',b'Supplier Invoice No exists in Purchase Invoice {0}',b'Leverand\xc3\xb8r Faktura Ingen eksisterer i fakturaen {0}'
+b'apps/erpnext/erpnext/config/selling.py +118',b'Manage Sales Person Tree.',b'Administrer Sales Person treet.'
+b'DocType: Job Applicant',b'Cover Letter',b'Cover Letter'
+b'apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +37',b'Outstanding Cheques and Deposits to clear',b'Utest\xc3\xa5ende Sjekker og Innskudd \xc3\xa5 t\xc3\xb8mme'
+b'DocType: Item',b'Synced With Hub',b'Synkronisert Med Hub'
+b'DocType: Driver',b'Fleet Manager',b'Fl\xc3\xa5tesjef'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +542',b'Row #{0}: {1} can not be negative for item {2}',b'Rad # {0}: {1} ikke kan v\xc3\xa6re negativ for elementet {2}'
+b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +59',b'Wrong Password',b'Feil Passord'
+b'DocType: Item',b'Variant Of',b'Variant av'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +406',"b""Completed Qty can not be greater than 'Qty to Manufacture'""",b'Fullf\xc3\xb8rt Antall kan ikke v\xc3\xa6re st\xc3\xb8rre enn &quot;Antall \xc3\xa5 Manufacture &#39;'
+b'DocType: Period Closing Voucher',b'Closing Account Head',b'Lukke konto Leder'
+b'DocType: Employee',b'External Work History',b'Ekstern Work History'
+b'apps/erpnext/erpnext/projects/doctype/task/task.py +111',b'Circular Reference Error',b'Rundskriv Reference Error'
+b'apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +206',b'Student Report Card',b'Studentrapportkort'
+b'DocType: Appointment Type',b'Is Inpatient',b'Er pasient'
+b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +55',b'Guardian1 Name',b'Guardian1 Name'
+b'DocType: Delivery Note',b'In Words (Export) will be visible once you save the Delivery Note.',b'I Words (eksport) vil v\xc3\xa6re synlig n\xc3\xa5r du lagrer f\xc3\xb8lgeseddel.'
+b'DocType: Cheque Print Template',b'Distance from left edge',b'Avstand fra venstre kant'
+b'apps/erpnext/erpnext/utilities/bot.py +29',b'{0} units of [{1}](#Form/Item/{1}) found in [{2}](#Form/Warehouse/{2})',b'{0} enheter av [{1}] (# Form / post / {1}) finnes i [{2}] (# Form / Lager / {2})'
+b'DocType: Lead',b'Industry',b'Industry'
+b'DocType: Employee',b'Job Profile',b'Job Profile'
+b'DocType: BOM Item',b'Rate & Amount',b'Pris og bel\xc3\xb8p'
+b'apps/erpnext/erpnext/setup/doctype/company/company_dashboard.py +6',b'This is based on transactions against this Company. See timeline below for details',b'Dette er basert p\xc3\xa5 transaksjoner mot dette selskapet. Se tidslinjen nedenfor for detaljer'
+b'DocType: Stock Settings',b'Notify by Email on creation of automatic Material Request',b'Varsle p\xc3\xa5 e-post om opprettelse av automatisk Material Request'
+b'apps/erpnext/erpnext/healthcare/setup.py +259',b'Resistant',b'Resistant'
+b'apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.py +77',b'Please set Hotel Room Rate on {}',b'Vennligst sett inn hotellrenten p\xc3\xa5 {}'
+b'DocType: Journal Entry',b'Multi Currency',b'Multi Valuta'
+b'DocType: Opening Invoice Creation Tool',b'Invoice Type',b'Faktura Type'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +939',b'Delivery Note',b'Levering Note'
+b'DocType: Consultation',b'Encounter Impression',b'Encounter Impression'
+b'apps/erpnext/erpnext/config/learn.py +82',b'Setting up Taxes',b'Sette opp skatter'
+b'apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +134',b'Cost of Sold Asset',b'Cost of Selges Asset'
+b'DocType: Volunteer',b'Morning',b'Morgen'
+b'apps/erpnext/erpnext/accounts/utils.py +350',b'Payment Entry has been modified after you pulled it. Please pull it again.',b'Betaling Entry har blitt endret etter at du trakk den. Kan trekke det igjen.'
+b'DocType: Program Enrollment Tool',b'New Student Batch',b'Ny studentbatch'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +479',b'{0} entered twice in Item Tax',b'{0} registrert to ganger i pkt Skatte'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +113',b'Summary for this week and pending activities',b'Oppsummering for denne uken og ventende aktiviteter'
+b'DocType: Student Applicant',b'Admitted',b'innr\xc3\xb8mmet'
+b'DocType: Workstation',b'Rent Cost',b'Rent Cost'
+b'apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +81',b'Amount After Depreciation',b'Mengde etter avskrivninger'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +97',b'Upcoming Calendar Events',b'Kommende kalenderhendelser'
+b'apps/erpnext/erpnext/public/js/templates/item_quick_entry.html +1',b'Variant Attributes',b'Variant attributter'
+b'apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +85',b'Please select month and year',b'Velg m\xc3\xa5ned og \xc3\xa5r'
+b'DocType: Employee',b'Company Email',b'Selskapet E-post'
+b'DocType: GL Entry',b'Debit Amount in Account Currency',b'Debet bel\xc3\xb8p p\xc3\xa5 kontoen Valuta'
+b'DocType: Supplier Scorecard',b'Scoring Standings',b'Scoring Steder'
+b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +21',b'Order Value',b'Bestillingsverdi'
+b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +21',b'Order Value',b'Bestillingsverdi'
+b'apps/erpnext/erpnext/config/accounts.py +27',b'Bank/Cash transactions against party or for internal transfer',b'Bank / kontanter transaksjoner mot part eller for intern overf\xc3\xb8ring'
+b'DocType: Shipping Rule',b'Valid for Countries',b'Gyldig for Land'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +55',"b""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""","b'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'"
+b'DocType: Grant Application',b'Grant Application',b'Grant s\xc3\xb8knad'
+b'apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +69',b'Total Order Considered',b'Total Bestill Regnes'
+b'apps/erpnext/erpnext/config/hr.py +243',"b'Employee designation (e.g. CEO, Director etc.).'","b'Ansatt betegnelse (f.eks CEO, direkt\xc3\xb8r etc.).'"
+b'DocType: Sales Invoice',"b""Rate at which Customer Currency is converted to customer's base currency""",b'Hastigheten som Kunden Valuta omdannes til kundens basisvaluta'
+b'DocType: Course Scheduling Tool',b'Course Scheduling Tool',b'Kurs Planlegging Tool'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +623',b'Row #{0}: Purchase Invoice cannot be made against an existing asset {1}',b'Row # {0}: Kj\xc3\xb8p Faktura kan ikke gj\xc3\xb8res mot en eksisterende eiendel {1}'
+b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +257',b'[Urgent] Error while creating recurring %s for %s',b'[Urgent] Feil mens du oppretter tilbakevendende% s for% s'
+b'DocType: Land Unit',b'LInked Analysis',b'Analyse'
+b'DocType: Item Tax',b'Tax Rate',b'Skattesats'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +73',b'Application period cannot be across two allocation records',b'S\xc3\xb8knadsperioden kan ikke v\xc3\xa6re over to allokeringsregister'
+b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +59',b'{0} already allocated for Employee {1} for period {2} to {3}',b'{0} allerede bevilget for Employee {1} for perioden {2} til {3}'
+b'apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +141',b'Purchase Invoice {0} is already submitted',b'Fakturaen {0} er allerede sendt'
+b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +92',b'Row # {0}: Batch No must be same as {1} {2}',b'Row # {0}: Batch No m\xc3\xa5 v\xc3\xa6re samme som {1} {2}'
+b'DocType: Material Request Plan Item',b'Material Request Plan Item',b'Materialforesp\xc3\xb8rselsplan'
+b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +52',b'Convert to non-Group',b'Konverter til ikke-konsernet'
+b'DocType: Project Update',b'Good/Steady',b'Good / Steady'
+b'DocType: C-Form Invoice Detail',b'Invoice Date',b'Fakturadato'
+b'DocType: GL Entry',b'Debit Amount',b'Debet Bel\xc3\xb8p'
+b'apps/erpnext/erpnext/accounts/party.py +248',b'There can only be 1 Account per Company in {0} {1}',b'Det kan bare v\xc3\xa6re en konto per Company i {0} {1}'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +426',b'Please see attachment',b'Vennligst se vedlegg'
+b'DocType: Purchase Order',b'% Received',b'% Mottatt'
+b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js +3',b'Create Student Groups',b'Opprett studentgrupper'
+b'DocType: Volunteer',b'Weekends',b'helger'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +118',b'Credit Note Amount',b'Kreditt Note Bel\xc3\xb8p'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +187',b'{0} ({1}) cannot be greater than planned quanitity ({2}) in Work Order {3}',b'{0} ({1}) kan ikke v\xc3\xa6re st\xc3\xb8rre enn planlagt quanitity ({2}) i Work Order {3}'
+b'DocType: Setup Progress Action',b'Action Document',b'Handlingsdokument'
+b'DocType: Chapter Member',b'Website URL',b'Website URL'
+,b'Finished Goods',b'Ferdigvarer'
+b'DocType: Delivery Note',b'Instructions',b'Bruksanvisning'
+b'DocType: Quality Inspection',b'Inspected By',b'Inspisert av'
+b'DocType: Asset Maintenance Log',b'Maintenance Type',b'Vedlikehold Type'
+b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +45',b'{0} - {1} is not enrolled in the Course {2}',b'{0} - {1} er ikke p\xc3\xa5meldt kurset {2}'
+b'apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +225',b'Student Name: ',b'Student navn:'
+b'apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +59',b'Serial No {0} does not belong to Delivery Note {1}',b'Serial No {0} tilh\xc3\xb8rer ikke f\xc3\xb8lgeseddel {1}'
+b'apps/erpnext/erpnext/erpnext_integrations/doctype/gocardless_settings/gocardless_settings.py +97',"b""There seems to be an issue with the server's GoCardless configuration. Don't worry, in case of failure, the amount will get refunded to your account.""","b'Det ser ut til \xc3\xa5 v\xc3\xa6re et problem med serverens GoCardless-konfigurasjon. Ikke bekymre deg, i tilfelle feil, vil bel\xc3\xb8pet bli refundert til kontoen din.'"
+b'apps/erpnext/erpnext/templates/pages/demo.html +47',b'ERPNext Demo',b'ERPNext Demo'
+b'apps/erpnext/erpnext/public/js/utils/item_selector.js +20',b'Add Items',b'Legg varer'
+b'DocType: Item Quality Inspection Parameter',b'Item Quality Inspection Parameter',b'Sak Quality Inspection Parameter'
+b'DocType: Depreciation Schedule',b'Schedule Date',b'Schedule Date'
+b'apps/erpnext/erpnext/config/hr.py +116',"b'Earnings, Deductions and other Salary components'","b'Inntjening, fradrag og andre L\xc3\xb8nn komponenter'"
+b'DocType: Packed Item',b'Packed Item',b'Pakket Element'
+b'DocType: Job Offer Term',b'Job Offer Term',b'Jobbtilbudsperiode'
+b'apps/erpnext/erpnext/config/buying.py +65',b'Default settings for buying transactions.',b'Standardinnstillingene for \xc3\xa5 kj\xc3\xb8pe transaksjoner.'
+b'apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +29',b'Activity Cost exists for Employee {0} against Activity Type - {1}',b'Aktivitet Kostnad finnes for Employee {0} mot Activity Type - {1}'
+b'apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +15',b'Mandatory field - Get Students From',b'Obligatorisk felt - F\xc3\xa5 studenter fra'
+b'apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +15',b'Mandatory field - Get Students From',b'Obligatorisk felt - F\xc3\xa5 studenter fra'
+b'DocType: Program Enrollment',b'Enrolled courses',b'P\xc3\xa5meldte kurs'
+b'DocType: Program Enrollment',b'Enrolled courses',b'P\xc3\xa5meldte kurs'
+b'DocType: Currency Exchange',b'Currency Exchange',b'Valutaveksling'
+b'DocType: Opening Invoice Creation Tool Item',b'Item Name',b'Navn'
+b'DocType: Authorization Rule',b'Approving User  (above authorized value)',b'Godkjenne Bruker (ovenfor autorisert verdi)'
+b'DocType: Email Digest',b'Credit Balance',b'Credit Balance'
+b'DocType: Employee',b'Widowed',b'Enke'
+b'DocType: Request for Quotation',b'Request for Quotation',b'Foresp\xc3\xb8rsel om kostnadsoverslag'
+b'DocType: Healthcare Settings',b'Require Lab Test Approval',b'Krever godkjenning av laboratorietest'
+b'DocType: Salary Slip Timesheet',b'Working Hours',b'Arbeidstid'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +59',b'Total Outstanding',b'Totalt Utest\xc3\xa5ende'
+b'DocType: Naming Series',b'Change the starting / current sequence number of an existing series.',b'Endre start / str\xc3\xb8m sekvensnummer av en eksisterende serie.'
+b'DocType: Dosage Strength',b'Strength',b'Styrke'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +1534',b'Create a new Customer',b'Opprett en ny kunde'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +59',"b'If multiple Pricing Rules continue to prevail, users are asked to set Priority manually to resolve conflict.'","b'Hvis flere Pris Regler fortsette \xc3\xa5 r\xc3\xa5de, blir brukerne bedt om \xc3\xa5 sette Priority manuelt for \xc3\xa5 l\xc3\xb8se konflikten.'"
+b'apps/erpnext/erpnext/utilities/activation.py +90',b'Create Purchase Orders',b'Opprette innkj\xc3\xb8psordrer'
+,b'Purchase Register',b'Kj\xc3\xb8p Register'
+b'apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +116',b'Patient not found',b'Pasient ikke funnet'
+b'DocType: Scheduling Tool',b'Rechedule',b'Rechedule'
+b'DocType: Landed Cost Item',b'Applicable Charges',b'Gjeldende avgifter'
+b'DocType: Workstation',b'Consumable Cost',b'Forbrukskostnads'
+b'DocType: Purchase Receipt',b'Vehicle Date',b'Vehicle Dato'
+b'DocType: Student Log',b'Medical',b'Medisinsk'
+b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +175',b'Reason for losing',b'Grunnen for \xc3\xa5 tape'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.js +52',b'Update Account Number',b'Oppdater kontonummer'
+b'apps/erpnext/erpnext/crm/doctype/lead/lead.py +44',b'Lead Owner cannot be same as the Lead',b'Bly Eier kan ikke v\xc3\xa6re det samme som Lead'
+b'apps/erpnext/erpnext/accounts/utils.py +356',b'Allocated amount can not greater than unadjusted amount',b'Avsatt bel\xc3\xb8p kan ikke st\xc3\xb8rre enn ujustert bel\xc3\xb8p'
+b'DocType: Announcement',b'Receiver',b'mottaker'
+b'apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +83',b'Workstation is closed on the following dates as per Holiday List: {0}',b'Workstation er stengt p\xc3\xa5 f\xc3\xb8lgende datoer som per Holiday Liste: {0}'
+b'apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +32',b'Opportunities',b'Muligheter'
+b'DocType: Lab Test Template',b'Single',b'Enslig'
+b'DocType: Salary Slip',b'Total Loan Repayment',b'Total Loan Nedbetaling'
+b'DocType: Account',b'Cost of Goods Sold',b'Varekostnad'
+b'DocType: Subscription',b'Yearly',b'\xc3\x85rlig'
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +230',b'Please enter Cost Center',b'Skriv inn kostnadssted'
+b'DocType: Drug Prescription',b'Dosage',b'Dosering'
+b'DocType: Journal Entry Account',b'Sales Order',b'Salgsordre'
+b'apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +69',b'Avg. Selling Rate',b'Avg. Salgskurs'
+b'DocType: Assessment Plan',b'Examiner Name',b'Examiner Name'
+b'DocType: Lab Test Template',b'No Result',b'Ingen resultater'
+b'DocType: Purchase Invoice Item',b'Quantity and Rate',b'Kvantitet og Rate'
+b'DocType: Delivery Note',b'% Installed',b'% Installert'
+b'apps/erpnext/erpnext/utilities/user_progress.py +230',b'Classrooms/ Laboratories etc where lectures can be scheduled.',b'Klasserom / Laboratorier etc hvor forelesningene kan planlegges.'
+b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +46',b'Please enter company name first',b'Skriv inn firmanavn f\xc3\xb8rst'
+b'DocType: Purchase Invoice',b'Supplier Name',b'Leverand\xc3\xb8r Name'
+b'apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +25',b'Read the ERPNext Manual',b'Les ERPNext Manual'
+b'DocType: Purchase Invoice',b'01-Sales Return',b'01-salgs retur'
+b'DocType: Account',b'Is Group',b'Is Gruppe'
+b'DocType: Email Digest',b'Pending Purchase Orders',b'Avventer innkj\xc3\xb8psordrer'
+b'DocType: Stock Settings',b'Automatically Set Serial Nos based on FIFO',b'Automatisk Sett Serial Nos basert p\xc3\xa5 FIFO'
+b'DocType: Accounts Settings',b'Check Supplier Invoice Number Uniqueness',b'Sjekk Leverand\xc3\xb8r fakturanummer Unikhet'
+b'apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js +34',b'Primary Address Details',b'Prim\xc3\xa6radresse detaljer'
+b'DocType: Vehicle Service',b'Oil Change',b'Oljeskift'
+b'DocType: Asset Maintenance Log',b'Asset Maintenance Log',b'Asset Maintenance Log'
+b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +57',"b""'To Case No.' cannot be less than 'From Case No.'""",b'&#39;Til sak nr&#39; kan ikke v\xc3\xa6re mindre enn &quot;From sak nr &#39;'
+b'DocType: Chapter',b'Non Profit',b'Non Profit'
+b'DocType: Production Plan',b'Not Started',b'Ikke i gang'
+b'DocType: Lead',b'Channel Partner',b'Channel Partner'
+b'DocType: Account',b'Old Parent',b'Gammel Parent'
+b'apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +19',b'Mandatory field - Academic Year',b'Obligatorisk felt - akademisk \xc3\xa5r'
+b'apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +19',b'Mandatory field - Academic Year',b'Obligatorisk felt - akademisk \xc3\xa5r'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +220',b'{0} {1} is not associated with {2} {3}',b'{0} {1} er ikke knyttet til {2} {3}'
+b'DocType: Notification Control',b'Customize the introductory text that goes as a part of that email. Each transaction has a separate introductory text.',b'Tilpass innledende tekst som g\xc3\xa5r som en del av e-posten. Hver transaksjon har en egen innledende tekst.'
+b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +176',b'Please set default payable account for the company {0}',b'Vennligst angi standard betalbar konto for selskapet {0}'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +511',b'Transaction not allowed against stopped Work Order {0}',b'Transaksjon ikke tillatt mot stoppet Arbeidsordre {0}'
+b'DocType: Setup Progress Action',b'Min Doc Count',b'Min Doc-tall'
+b'apps/erpnext/erpnext/config/manufacturing.py +84',b'Global settings for all manufacturing processes.',b'Globale innstillinger for alle produksjonsprosesser.'
+b'DocType: Accounts Settings',b'Accounts Frozen Upto',b'Regnskap Frozen Opp'
+b'DocType: SMS Log',b'Sent On',b'Sendte P\xc3\xa5'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +700',b'Attribute {0} selected multiple times in Attributes Table',b'Attributtet {0} valgt flere ganger i attributter Table'
+b'DocType: HR Settings',b'Employee record is created using selected field. ',b'Ansatt posten er opprettet ved hjelp av valgte feltet.'
+b'DocType: Sales Order',b'Not Applicable',b'Gjelder ikke'
+b'apps/erpnext/erpnext/config/hr.py +70',b'Holiday master.',b'Holiday mester.'
+b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +85',b'Opening Invoice Item',b'\xc3\x85pning av fakturaelement'
+b'DocType: Request for Quotation Item',b'Required Date',b'N\xc3\xb8dvendig Dato'
+b'DocType: Delivery Note',b'Billing Address',b'Fakturaadresse'
+b'DocType: BOM',b'Costing',b'Costing'
+b'DocType: Tax Rule',b'Billing County',b'Billings County'
+b'DocType: Purchase Taxes and Charges',"b'If checked, the tax amount will be considered as already included in the Print Rate / Print Amount'","b'Hvis det er merket, vil skattebel\xc3\xb8pet betraktes som allerede er inkludert i Print Rate / Print Bel\xc3\xb8p'"
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +46',b'PieceRef',b'PieceRef'
+b'DocType: Request for Quotation',b'Message for Supplier',b'Beskjed til Leverand\xc3\xb8r'
+b'apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js +40',b'Work Order',b'Arbeidsordre'
+b'DocType: Driver',b'DRIVER-.#####',b'SJ\xc3\x85F\xc3\x98R-.#####'
+b'DocType: Sales Invoice',b'Total Qty',b'Total Antall'
+b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +62',b'Guardian2 Email ID',b'Guardian2 Email ID'
+b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +62',b'Guardian2 Email ID',b'Guardian2 Email ID'
+b'DocType: Item',b'Show in Website (Variant)',b'Vis i Website (Variant)'
+b'DocType: Employee',b'Health Concerns',b'Helse Bekymringer'
+b'DocType: Payroll Entry',b'Select Payroll Period',b'Velg L\xc3\xb8nn Periode'
+b'DocType: Purchase Invoice',b'Unpaid',b'Ubetalte'
+b'apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +49',b'Reserved for sale',b'Reservert for salg'
+b'DocType: Packing Slip',b'From Package No.',b'Fra Package No.'
+b'DocType: Item Attribute',b'To Range',b'Range'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +29',b'Securities and Deposits',b'Verdipapirer og innskudd'
+b'apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +46',"b""Can't change valuation method, as there are transactions against some items which does not have it's own valuation method""","b'Kan ikke endre verdsettelsesmetoden, da det er transaksjoner mot enkelte poster som ikke har egen verdsettelsesmetode'"
+b'DocType: Student Report Generation Tool',b'Attended by Parents',b'Deltatt av foreldre'
+b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +82',b'Total leaves allocated is mandatory',b'Totalt blader tildelte er obligatorisk'
+b'DocType: Patient',b'AB Positive',b'AB Positiv'
+b'DocType: Job Opening',b'Description of a Job Opening',b'Beskrivelse av en ledig jobb'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +110',b'Pending activities for today',b'Ventende aktiviteter for i dag'
+b'apps/erpnext/erpnext/config/hr.py +24',b'Attendance record.',b'Tilskuerrekord.'
+b'DocType: Salary Structure',b'Salary Component for timesheet based payroll.',b'L\xc3\xb8nn Component for timebasert l\xc3\xb8nn.'
+b'DocType: Sales Order Item',b'Used for Production Plan',b'Brukes for Produksjonsplan'
+b'DocType: Employee Loan',b'Total Payment',b'totalt betaling'
+b'DocType: Manufacturing Settings',b'Time Between Operations (in mins)',b'Time Between Operations (i minutter)'
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +132',b'{0} {1} is cancelled so the action cannot be completed',"b'{0} {1} er kansellert, slik at handlingen ikke kan fullf\xc3\xb8res'"
+b'DocType: Customer',b'Buyer of Goods and Services.',b'Kj\xc3\xb8per av varer og tjenester.'
+b'DocType: Journal Entry',b'Accounts Payable',b'Leverand\xc3\xb8rgjeld'
+b'DocType: Patient',b'Allergies',b'allergi'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +33',b'The selected BOMs are not for the same item',b'De valgte stykklister er ikke for den samme varen'
+b'DocType: Supplier Scorecard Standing',b'Notify Other',b'Varsle Andre'
+b'DocType: Vital Signs',b'Blood Pressure (systolic)',b'Blodtrykk (systolisk)'
+b'DocType: Pricing Rule',b'Valid Upto',b'Gyldig Opp'
+b'DocType: Training Event',b'Workshop',b'Verksted'
+b'DocType: Supplier Scorecard Scoring Standing',b'Warn Purchase Orders',b'Varsle innkj\xc3\xb8psordrer'
+b'apps/erpnext/erpnext/utilities/user_progress.py +67',b'List a few of your customers. They could be organizations or individuals.',b'Liste noen av kundene dine. De kan v\xc3\xa6re organisasjoner eller enkeltpersoner.'
+b'apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py +23',b'Enough Parts to Build',b'Nok Deler bygge'
+b'DocType: POS Profile User',b'POS Profile User',b'POS Profil Bruker'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +128',b'Direct Income',b'Direkte Inntekt'
+b'DocType: Patient Appointment',b'Date TIme',b'Dato tid'
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +45',"b'Can not filter based on Account, if grouped by Account'","b'Kan ikke filtrere basert p\xc3\xa5 konto, hvis gruppert etter konto'"
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +130',b'Administrative Officer',b'Administrative Officer'
+b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +39',b'Setting up company and taxes',b'Sette opp selskap og skatter'
+b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +22',b'Please select Course',b'Vennligst velg Kurs'
+b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +22',b'Please select Course',b'Vennligst velg Kurs'
+b'DocType: Codification Table',b'Codification Table',b'Kodifiseringstabell'
+b'DocType: Timesheet Detail',b'Hrs',b'timer'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +349',b'Please select Company',b'Vennligst velg selskapet'
+b'DocType: Stock Entry Detail',b'Difference Account',b'Forskjellen konto'
+b'DocType: Purchase Invoice',b'Supplier GSTIN',b'Leverand\xc3\xb8r GSTIN'
+b'apps/erpnext/erpnext/projects/doctype/task/task.py +47',b'Cannot close task as its dependant task {0} is not closed.',b'Kan ikke lukke oppgaven som sin avhengige oppgave {0} er ikke lukket.'
+b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +435',b'Please enter Warehouse for which Material Request will be raised',b'Skriv inn Warehouse hvor Material Request vil bli hevet'
+b'DocType: Work Order',b'Additional Operating Cost',b'Ekstra driftskostnader'
+b'DocType: Lab Test Template',b'Lab Routine',b'Lab Rutine'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +20',b'Cosmetics',b'Kosmetikk'
+b'apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +18',b'Please select Completion Date for Completed Asset Maintenance Log',b'Vennligst velg sluttdato for fullf\xc3\xb8rt aktivitetsvedlikeholdslogg'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +552',"b'To merge, following properties must be same for both items'","b'\xc3\x85 fusjonere, m\xc3\xa5 f\xc3\xb8lgende egenskaper v\xc3\xa6re lik for begge elementene'"
+b'DocType: Shipping Rule',b'Net Weight',b'Netto Vekt'
+b'DocType: Employee',b'Emergency Phone',b'Emergency Phone'
+b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +82',b'{0} {1} does not exist.',b'{0} {1} eksisterer ikke.'
+b'apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +29',b'Buy',b'Kj\xc3\xb8pe'
+,b'Serial No Warranty Expiry',b'Ingen garanti Utl\xc3\xb8psserie'
+b'DocType: Sales Invoice',b'Offline POS Name',b'Offline POS Name'
+b'apps/erpnext/erpnext/utilities/user_progress.py +180',b'Student Application',b'Student s\xc3\xb8knad'
+b'apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py +20',b'Please define grade for Threshold 0%',b'Vennligst definer karakter for Terskel 0%'
+b'apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py +20',b'Please define grade for Threshold 0%',b'Vennligst definer karakter for Terskel 0%'
+b'DocType: Sales Order',b'To Deliver',b'\xc3\x85 Levere'
+b'DocType: Purchase Invoice Item',b'Item',b'Sak'
+b'apps/erpnext/erpnext/healthcare/setup.py +256',b'High Sensitivity',b'H\xc3\xb8y f\xc3\xb8lsomhet'
+b'apps/erpnext/erpnext/config/non_profit.py +48',b'Volunteer Type information.',b'Frivillig Type informasjon.'
+b'DocType: Cash Flow Mapping Template',b'Cash Flow Mapping Template',b'Cash Flow Mapping Template'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +2555',b'Serial no item cannot be a fraction',b'Serie ingen element kan ikke v\xc3\xa6re en br\xc3\xb8kdel'
+b'DocType: Journal Entry',b'Difference (Dr - Cr)',b'Forskjellen (Dr - Cr)'
+b'DocType: Account',b'Profit and Loss',b'Gevinst og tap'
+b'apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +104',"b'Not permitted, configure Lab Test Template as required'","b'Ikke tillatt, konfigurer Lab Test Template etter behov'"
+b'DocType: Patient',b'Risk Factors',b'Risikofaktorer'
+b'DocType: Patient',b'Occupational Hazards and Environmental Factors',b'Arbeidsfare og milj\xc3\xb8faktorer'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +239',b'Stock Entries already created for Work Order ',b'Lageroppf\xc3\xb8ringer allerede opprettet for arbeidsordre'
+b'DocType: Vital Signs',b'Respiratory rate',b'Respirasjonsfrekvens'
+b'apps/erpnext/erpnext/config/stock.py +334',b'Managing Subcontracting',b'Administrerende Underleverand\xc3\xb8rer'
+b'DocType: Vital Signs',b'Body Temperature',b'Kroppstemperatur'
+b'DocType: Project',b'Project will be accessible on the website to these users',b'Prosjektet vil v\xc3\xa6re tilgjengelig p\xc3\xa5 nettstedet til disse brukerne'
+b'DocType: Detected Disease',b'Disease',b'Sykdom'
+b'apps/erpnext/erpnext/config/projects.py +29',b'Define Project type.',b'Definer Prosjekttype.'
+b'DocType: Supplier Scorecard',b'Weighting Function',b'Vekting Funksjon'
+b'DocType: Physician',b'OP Consulting Charge',b'OP-konsulentkostnad'
+b'apps/erpnext/erpnext/utilities/user_progress.py +28',b'Setup your ',b'Oppsett din'
+b'DocType: Student Report Generation Tool',b'Show Marks',b'Vis karakterer'
+b'DocType: Quotation',"b""Rate at which Price list currency is converted to company's base currency""",b'Hastigheten som Prisliste valuta er konvertert til selskapets hovedvaluta'
+b'apps/erpnext/erpnext/setup/doctype/company/company.py +70',b'Account {0} does not belong to company: {1}',b'Konto {0} tilh\xc3\xb8rer ikke selskapet: {1}'
+b'apps/erpnext/erpnext/setup/doctype/company/company.py +52',b'Abbreviation already used for another company',b'Forkortelse allerede brukt for et annet selskap'
+b'DocType: Selling Settings',b'Default Customer Group',b'Standard Kundegruppe'
+b'DocType: Asset Repair',b'ARLOG-',b'ARLOG-'
+b'DocType: Global Defaults',"b""If disable, 'Rounded Total' field will not be visible in any transaction""","b'Hvis deaktivere, &#39;Rounded Total-feltet ikke vil v\xc3\xa6re synlig i enhver transaksjon'"
+b'DocType: BOM',b'Operating Cost',b'Driftskostnader'
+b'DocType: Crop',b'Produced Items',b'Produserte varer'
+b'DocType: Sales Order Item',b'Gross Profit',b'Bruttofortjeneste'
+b'apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +49',b'Increment cannot be 0',b'Tilveksten kan ikke v\xc3\xa6re 0'
+b'DocType: Company',b'Delete Company Transactions',b'Slett transaksjoner'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +364',b'Reference No and Reference Date is mandatory for Bank transaction',b'Referansenummer og Reference Date er obligatorisk for Bank transaksjon'
+b'DocType: Purchase Receipt',b'Add / Edit Taxes and Charges',b'Legg til / Rediger skatter og avgifter'
+b'DocType: Payment Entry Reference',b'Supplier Invoice No',b'Leverand\xc3\xb8r Faktura Nei'
+b'DocType: Territory',b'For reference',b'For referanse'
+b'DocType: Healthcare Settings',b'Appointment Confirmation',b'Avtalebekreftelse'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +158',"b'Cannot delete Serial No {0}, as it is used in stock transactions'","b'Kan ikke slette Serial No {0}, slik det brukes i aksjetransaksjoner'"
+b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +256',b'Closing (Cr)',b'Lukking (Cr)'
+b'apps/erpnext/erpnext/hr/email_alert/training_feedback/training_feedback.html +1',b'Hello',b'Hallo'
+b'apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +118',b'Move Item',b'Flytt element'
+b'DocType: Serial No',b'Warranty Period (Days)',b'Garantiperioden (dager)'
+b'DocType: Installation Note Item',b'Installation Note Item',b'Installasjon Merk Element'
+b'DocType: Production Plan Item',b'Pending Qty',b'Venter Stk'
+b'DocType: Budget',b'Ignore',b'Ignorer'
+b'apps/erpnext/erpnext/accounts/party.py +396',b'{0} {1} is not active',b'{0} {1} er ikke aktiv'
+b'apps/erpnext/erpnext/config/accounts.py +272',b'Setup cheque dimensions for printing',b'Oppsett sjekk dimensjoner for utskrift'
+b'DocType: Salary Slip',b'Salary Slip Timesheet',b'L\xc3\xb8nn Slip Timeregistrering'
+b'apps/erpnext/erpnext/controllers/buying_controller.py +160',b'Supplier Warehouse mandatory for sub-contracted Purchase Receipt',b'Leverand\xc3\xb8r Warehouse obligatorisk for underleverand\xc3\xb8r Kj\xc3\xb8pskvittering'
+b'DocType: Pricing Rule',b'Valid From',b'Gyldig Fra'
+b'DocType: Sales Invoice',b'Total Commission',b'Total Commission'
+b'DocType: Pricing Rule',b'Sales Partner',b'Sales Partner'
+b'apps/erpnext/erpnext/config/buying.py +150',b'All Supplier scorecards.',b'Alle leverand\xc3\xb8rens scorecards.'
+b'DocType: Buying Settings',b'Purchase Receipt Required',b'Kvitteringen P\xc3\xa5krevd'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +188',b'Target warehouse in row {0} must be same as Work Order',b'M\xc3\xa5llager i rad {0} m\xc3\xa5 v\xc3\xa6re det samme som Arbeidsordre'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +155',b'Valuation Rate is mandatory if Opening Stock entered',b'Verdsettelse Rate er obligatorisk hvis \xc3\x85pning Stock oppgitt'
+b'apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +143',b'No records found in the Invoice table',b'Ingen poster ble funnet i Faktura tabellen'
+b'apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js +34',b'Please select Company and Party Type first',b'Vennligst velg f\xc3\xb8rst selskapet og Party Type'
+b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +31',"b'Already set default in pos profile {0} for user {1}, kindly disabled default'","b'Sett allerede standard i pos profil {0} for bruker {1}, vennligst deaktivert standard'"
+b'apps/erpnext/erpnext/config/accounts.py +293',b'Financial / accounting year.',b'Finansiell / regnskap \xc3\xa5r.'
+b'apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.js +9',b'Accumulated Values',b'akkumulerte verdier'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +162',"b'Sorry, Serial Nos cannot be merged'","b'Sorry, kan Serial Nos ikke bli sl\xc3\xa5tt sammen'"
+b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +72',b'Territory is Required in POS Profile',b'Omr\xc3\xa5de er p\xc3\xa5krevd i POS-profil'
+b'DocType: Supplier',b'Prevent RFQs',b'Forhindre RFQs'
+b'apps/erpnext/erpnext/utilities/activation.py +83',b'Make Sales Order',b'Gj\xc3\xb8r Salgsordre'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +168',b'Salary Slip submitted for period from {0} to {1}',b'L\xc3\xb8nnsslipp legges inn for perioden fra {0} til {1}'
+b'DocType: Project Task',b'Project Task',b'Prosjektet Task'
+,b'Lead Id',b'Lead Id'
+b'DocType: C-Form Invoice Detail',b'Grand Total',b'Grand Total'
+b'DocType: Assessment Plan',b'Course',b'Kurs'
+b'DocType: Timesheet',b'Payslip',b'payslip'
+b'apps/erpnext/erpnext/public/js/pos/pos.html +4',b'Item Cart',b'Sak Handlekurv'
+b'apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +38',b'Fiscal Year Start Date should not be greater than Fiscal Year End Date',b'Regnskaps\xc3\xa5r Startdato b\xc3\xb8r ikke v\xc3\xa6re st\xc3\xb8rre enn regnskaps\xc3\xa5ret Sluttdato'
+b'DocType: Issue',b'Resolution',b'Oppl\xc3\xb8sning'
+b'DocType: C-Form',b'IV',b'IV'
+b'apps/erpnext/erpnext/templates/pages/order.html +76',b'Delivered: {0}',b'Levering: {0}'
+b'DocType: Expense Claim',b'Payable Account',b'Betales konto'
+b'DocType: Payment Entry',b'Type of Payment',b'Type Betaling'
+b'DocType: Sales Order',b'Billing and Delivery Status',b'Fakturering og levering Status'
+b'DocType: Job Applicant',b'Resume Attachment',b'Fortsett Vedlegg'
+b'apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +58',b'Repeat Customers',b'Gjenta kunder'
+b'DocType: Leave Control Panel',b'Allocate',b'Bevilge'
+b'apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +108',b'Create Variant',b'Opprett variant'
+b'DocType: Sales Invoice',b'Shipping Bill Date',b'Fraktregningsdato'
+b'DocType: Production Plan',b'Production Plan',b'Produksjonsplan'
+b'DocType: Opening Invoice Creation Tool',b'Opening Invoice Creation Tool',b'\xc3\x85pning av fakturaopprettingsverkt\xc3\xb8y'
+b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +853',b'Sales Return',b'Sales Return'
+b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +96',"b""Note: Total allocated leaves {0} shouldn't be less than already approved leaves {1} for the period""",b'Merk: Totalt tildelte blader {0} b\xc3\xb8r ikke v\xc3\xa6re mindre enn allerede innvilgede permisjoner {1} for perioden'
+,b'Total Stock Summary',b'Totalt lageroppsummering'
+b'DocType: Announcement',b'Posted By',b'Postet av'
+b'DocType: Item',b'Delivered by Supplier (Drop Ship)',b'Levert av Leverand\xc3\xb8r (Drop Ship)'
+b'DocType: Healthcare Settings',b'Confirmation Message',b'Bekreftelsesmelding'
+b'apps/erpnext/erpnext/config/crm.py +12',b'Database of potential customers.',b'Database med potensielle kunder.'
+b'DocType: Authorization Rule',b'Customer or Item',b'Kunden eller Element'
+b'apps/erpnext/erpnext/config/selling.py +28',b'Customer database.',b'Kundedatabase.'
+b'DocType: Quotation',b'Quotation To',b'Sitat \xc3\x85'
+b'DocType: Lead',b'Middle Income',b'Middle Income'
+b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +228',b'Opening (Cr)',b'\xc3\x85pning (Cr)'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +872',b'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.',b'Standard Enhet for Element {0} kan ikke endres direkte fordi du allerede har gjort noen transaksjon (er) med en annen m\xc3\xa5lenheter. Du m\xc3\xa5 opprette et nytt element for \xc3\xa5 bruke et annet standardm\xc3\xa5lenheter.'
+b'apps/erpnext/erpnext/accounts/utils.py +354',b'Allocated amount can not be negative',b'Bevilget bel\xc3\xb8pet kan ikke v\xc3\xa6re negativ'
+b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +11',b'Please set the Company',b'Vennligst sett selskapet'
+b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +11',b'Please set the Company',b'Vennligst sett selskapet'
+b'DocType: Share Balance',b'Share Balance',b'Andelsbalanse'
+b'DocType: Purchase Order Item',b'Billed Amt',b'Billed Amt'
+b'DocType: Training Result Employee',b'Training Result Employee',b'Trening Resultat Medarbeider'
+b'DocType: Warehouse',b'A logical Warehouse against which stock entries are made.',b'En logisk Warehouse mot som lager oppf\xc3\xb8ringer er gjort.'
+b'DocType: Repayment Schedule',b'Principal Amount',b'hovedstol'
+b'DocType: Employee Loan Application',b'Total Payable Interest',b'Total skyldige renter'
+b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +57',b'Total Outstanding: {0}',b'Totalt utest\xc3\xa5ende: {0}'
+b'DocType: Sales Invoice Timesheet',b'Sales Invoice Timesheet',b'Salg Faktura Timeregistrering'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +118',b'Reference No & Reference Date is required for {0}',b'Referansenummer og Reference Date er n\xc3\xb8dvendig for {0}'
+b'DocType: Payroll Entry',b'Select Payment Account to make Bank Entry',b'Velg betalingskonto \xc3\xa5 lage Bank Entry'
+b'DocType: Hotel Settings',b'Default Invoice Naming Series',b'Standard Faktura Naming Series'
+b'apps/erpnext/erpnext/utilities/activation.py +136',"b'Create Employee records to manage leaves, expense claims and payroll'","b'Lag personalregistre for \xc3\xa5 h\xc3\xa5ndtere blader, refusjonskrav og l\xc3\xb8nn'"
+b'DocType: Restaurant Reservation',b'Restaurant Reservation',b'Restaurantreservasjon'
+b'DocType: Land Unit',b'Land Unit Name',b'Land Enhetsnavn'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +190',b'Proposal Writing',b'Forslaget Writing'
+b'DocType: Payment Entry Deduction',b'Payment Entry Deduction',b'Betaling Entry Fradrag'
+b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +14',b'Wrapping up',b'Innpakning'
+b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +35',b'Notify Customers via Email',b'Meld kundene via e-post'
+b'apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +35',b'Another Sales Person {0} exists with the same Employee id',b'En annen Sales Person {0} finnes med samme Employee id'
+b'DocType: Employee Advance',b'Claimed Amount',b'P\xc3\xa5krevd bel\xc3\xb8p'
+b'apps/erpnext/erpnext/config/education.py +180',b'Masters',b'Masters'
+b'DocType: Assessment Plan',b'Maximum Assessment Score',b'Maksimal Assessment Score'
+b'apps/erpnext/erpnext/config/accounts.py +138',b'Update Bank Transaction Dates',b'Oppdater Banktransaksjons Datoer'
+b'apps/erpnext/erpnext/config/projects.py +41',b'Time Tracking',b'Time Tracking'
+b'DocType: Purchase Invoice',b'DUPLICATE FOR TRANSPORTER',b'DUPLIKERER FOR TRANSPORTER'
+b'apps/erpnext/erpnext/hr/doctype/employee_advance/employee_advance.py +49',b'Row {0}# Paid Amount cannot be greater than requested advance amount',b'R\xc3\xa5 {0} # Betalt bel\xc3\xb8p kan ikke v\xc3\xa6re st\xc3\xb8rre enn \xc3\xb8nsket bel\xc3\xb8p'
+b'DocType: Fiscal Year Company',b'Fiscal Year Company',b'Regnskaps\xc3\xa5ret selskapet'
+b'DocType: Packing Slip Item',b'DN Detail',b'DN Detalj'
+b'DocType: Training Event',b'Conference',b'Konferanse'
+b'DocType: Timesheet',b'Billed',b'Fakturert'
+b'DocType: Batch',b'Batch Description',b'Batch Beskrivelse'
+b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js +12',b'Creating student groups',b'Opprette studentgrupper'
+b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js +12',b'Creating student groups',b'Opprette studentgrupper'
+b'apps/erpnext/erpnext/accounts/utils.py +727',"b'Payment Gateway Account not created, please create one manually.'","b'Betaling Gateway konto ikke opprettet, kan du opprette en manuelt.'"
+b'DocType: Supplier Scorecard',b'Per Year',b'Per \xc3\xa5r'
+b'apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +51',b'Not eligible for the admission in this program as per DOB',b'Ikke kvalifisert for opptak i dette programmet i henhold til DOB'
+b'DocType: Sales Invoice',b'Sales Taxes and Charges',b'Salgs Skatter og avgifter'
+b'DocType: Employee',b'Organization Profile',b'Organisasjonsprofil'
+b'DocType: Vital Signs',b'Height (In Meter)',b'H\xc3\xb8yde (i meter)'
+b'DocType: Student',b'Sibling Details',b's\xc3\xb8sken Detaljer'
+b'DocType: Vehicle Service',b'Vehicle Service',b'Vehicle service'
+b'apps/erpnext/erpnext/config/setup.py +101',b'Automatically triggers the feedback request based on conditions.',b'Automatisk utl\xc3\xb8ser tilbakemeldinger foresp\xc3\xb8rsel basert p\xc3\xa5 forholdene.'
+b'DocType: Employee',b'Reason for Resignation',b'Grunnen til Resignasjon'
+b'apps/erpnext/erpnext/config/hr.py +152',b'Template for performance appraisals.',b'Mal for medarbeidersamtaler.'
+b'DocType: Sales Invoice',b'Credit Note Issued',b'Kreditnota Utstedt'
+b'DocType: Project Task',b'Weight',b'Vekt'
+b'DocType: Payment Reconciliation',b'Invoice/Journal Entry Details',b'Faktura / Journal Entry Detaljer'
+b'apps/erpnext/erpnext/accounts/utils.py +83',"b""{0} '{1}' not in Fiscal Year {2}""",b'{0} {1} ikke i regnskaps\xc3\xa5ret {2}'
+b'DocType: Buying Settings',b'Settings for Buying Module',b'Innstillinger for kj\xc3\xb8p Module'
+b'apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +21',b'Asset {0} does not belong to company {1}',b'Asset {0} tilh\xc3\xb8rer ikke selskapet {1}'
+b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +70',b'Please enter Purchase Receipt first',b'Skriv inn Kj\xc3\xb8pskvittering f\xc3\xb8rst'
+b'DocType: Buying Settings',b'Supplier Naming By',b'Leverand\xc3\xb8r Naming Av'
+b'DocType: Activity Type',b'Default Costing Rate',b'Standard Koster Rate'
+b'DocType: Maintenance Schedule',b'Maintenance Schedule',b'Vedlikeholdsplan'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +36',"b'Then Pricing Rules are filtered out based on Customer, Customer Group, Territory, Supplier, Supplier Type, Campaign, Sales Partner etc.'","b'Da reglene for prissetting filtreres ut basert p\xc3\xa5 Kunden, Kundens Group, Territory, leverand\xc3\xb8r, leverand\xc3\xb8r Type, Kampanje, Sales Partner etc.'"
+b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +29',b'Net Change in Inventory',b'Netto endring i varelager'
+b'apps/erpnext/erpnext/config/hr.py +162',b'Employee Loan Management',b'Ansattes l\xc3\xa5n Ledelse'
+b'DocType: Employee',b'Passport Number',b'Passnummer'
+b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +60',b'Relation with Guardian2',b'Relasjon med Guardian2'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +124',b'Manager',b'Manager'
+b'DocType: Payment Entry',b'Payment From / To',b'Betaling fra / til'
+b'apps/erpnext/erpnext/selling/doctype/customer/customer.py +170',b'New credit limit is less than current outstanding amount for the customer. Credit limit has to be atleast {0}',b'Ny kredittgrensen er mindre enn dagens utest\xc3\xa5ende bel\xc3\xb8p for kunden. Kredittgrense m\xc3\xa5 v\xc3\xa6re atleast {0}'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +428',b'Please set account in Warehouse {0}',b'Vennligst sett inn konto i Lager {0}'
+b'apps/erpnext/erpnext/controllers/trends.py +39',"b""'Based On' and 'Group By' can not be same""",b'&quot;Based On&quot; og &quot;Grupper etter&quot; ikke kan v\xc3\xa6re det samme'
+b'DocType: Sales Person',b'Sales Person Targets',b'Sales Person Targets'
+b'DocType: Installation Note',b'IN-',b'I-'
+b'DocType: Work Order Operation',b'In minutes',b'I l\xc3\xb8pet av minutter'
+b'DocType: Issue',b'Resolution Date',b'Oppl\xc3\xb8sning Dato'
+b'DocType: Lab Test Template',b'Compound',b'forbindelse'
+b'DocType: Student Batch Name',b'Batch Name',b'batch Name'
+b'DocType: Fee Validity',b'Max number of visit',b'Maks antall bes\xc3\xb8k'
+,b'Hotel Room Occupancy',b'Hotellrom Occupancy'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +358',b'Timesheet created:',b'Timeregistrering opprettet:'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +931',b'Please set default Cash or Bank account in Mode of Payment {0}',b'Vennligst angi standard kontanter eller bankkontoen i modus for betaling {0}'
+b'apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +24',b'Enroll',b'Registrere'
+b'DocType: GST Settings',b'GST Settings',b'GST-innstillinger'
+b'DocType: Selling Settings',b'Customer Naming By',b'Kunden Naming Av'
+b'DocType: Student Leave Application',b'Will show the student as Present in Student Monthly Attendance Report',b'Vil vise studenten som Tilstede i Student M\xc3\xa5nedlig fremm\xc3\xb8terapport'
+b'DocType: Depreciation Schedule',b'Depreciation Amount',b'avskrivninger Bel\xc3\xb8p'
+b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +56',b'Convert to Group',b'Konverter til konsernet'
+b'DocType: Delivery Trip',b'TOUR-.#####',b'TOUR -. #####'
+b'DocType: Activity Cost',b'Activity Type',b'Aktivitetstype'
+b'DocType: Request for Quotation',b'For individual supplier',b'For enkelte leverand\xc3\xb8r'
+b'DocType: BOM Operation',b'Base Hour Rate(Company Currency)',b'Base Hour Rate (Selskap Valuta)'
+b'apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +47',b'Delivered Amount',b'Leveres Bel\xc3\xb8p'
+b'DocType: Quotation Item',b'Item Balance',b'Sak Balance'
+b'DocType: Sales Invoice',b'Packing List',b'Pakkeliste'
+b'apps/erpnext/erpnext/config/buying.py +28',b'Purchase Orders given to Suppliers.',b'Innkj\xc3\xb8psordrer gis til leverand\xc3\xb8rer.'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +43',b'Publishing',b'Publisering'
+b'DocType: Accounts Settings',b'Report Settings',b'Rapporter innstillinger'
+b'DocType: Activity Cost',b'Projects User',b'Prosjekter User'
+b'apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +40',b'Consumed',b'Forbrukes'
+b'apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +158',b'{0}: {1} not found in Invoice Details table',b'{0}: {1} ble ikke funnet i Fakturadetaljer tabellen'
+b'DocType: Asset',b'Asset Owner Company',b'Asset Owner Company'
+b'DocType: Company',b'Round Off Cost Center',b'Rund av kostnadssted'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +242',b'Maintenance Visit {0} must be cancelled before cancelling this Sales Order',b'Vedlikehold Bes\xc3\xb8k {0} m\xc3\xa5 avbestilles f\xc3\xb8r den avbryter denne salgsordre'
+b'DocType: Asset Maintenance Log',b'AML-',b'AML-'
+b'DocType: Item',b'Material Transfer',b'Material Transfer'
+b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard_variable/supplier_scorecard_variable.py +24',b'Could not find path for ',b'Kunne ikke finne banen for'
+b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +221',b'Opening (Dr)',b'\xc3\x85pning (Dr)'
+b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +39',b'Posting timestamp must be after {0}',b'Oppslaget tidsstempel m\xc3\xa5 v\xc3\xa6re etter {0}'
+b'apps/erpnext/erpnext/config/accounts.py +39',b'To make recurring documents',b'\xc3\x85 gj\xc3\xb8re gjentatte dokumenter'
+,b'GST Itemised Purchase Register',b'GST Artized Purchase Register'
+b'DocType: Course Scheduling Tool',b'Reschedule',b'Planlegge p\xc3\xa5 nytt'
+b'DocType: Employee Loan',b'Total Interest Payable',b'Total rentekostnader'
+b'DocType: Landed Cost Taxes and Charges',b'Landed Cost Taxes and Charges',b'Landed Cost skatter og avgifter'
+b'DocType: Work Order Operation',b'Actual Start Time',b'Faktisk Starttid'
+b'DocType: BOM Operation',b'Operation Time',b'Operation Tid'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +316',b'Finish',b'Bli ferdig'
+b'apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +412',b'Base',b'Utgangspunkt'
+b'DocType: Timesheet',b'Total Billed Hours',b'Totalt fakturert timer'
+b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1530',b'Write Off Amount',b'Skriv Off Bel\xc3\xb8p'
+b'DocType: Leave Block List Allow',b'Allow User',b'Tillat User'
+b'DocType: Journal Entry',b'Bill No',b'Bill Nei'
+b'DocType: Company',b'Gain/Loss Account on Asset Disposal',b'Gevinst / tap-konto p\xc3\xa5 Asset Avhending'
+b'DocType: Vehicle Log',b'Service Details',b'Servicedetaljer'
+b'DocType: Vehicle Log',b'Service Details',b'Servicedetaljer'
+b'DocType: Subscription',b'Quarterly',b'Quarterly'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +47',b'EcritureLib',b'EcritureLib'
+b'DocType: Lab Test Template',b'Grouped',b'gruppert'
+b'DocType: Selling Settings',b'Delivery Note Required',b'Levering Note P\xc3\xa5krevd'
+b'DocType: Bank Guarantee',b'Bank Guarantee Number',b'Bankgaranti nummer'
+b'DocType: Bank Guarantee',b'Bank Guarantee Number',b'Bankgaranti nummer'
+b'DocType: Assessment Criteria',b'Assessment Criteria',b'Vurderingskriterier'
+b'DocType: BOM Item',b'Basic Rate (Company Currency)',b'Basic Rate (Company Valuta)'
+b'DocType: Student Attendance',b'Student Attendance',b'student Oppm\xc3\xb8te'
+b'DocType: Sales Invoice Timesheet',b'Time Sheet',b'Tids skjema'
+b'DocType: Manufacturing Settings',b'Backflush Raw Materials Based On',b'Spylings R\xc3\xa5vare basert p\xc3\xa5'
+b'DocType: Sales Invoice',b'Port Code',b'Portkode'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +957',b'Reserve Warehouse',b'Reserve Warehouse'
+b'DocType: Lead',b'Lead is an Organization',b'Bly er en organisasjon'
+b'DocType: Guardian Interest',b'Interest',b'Renter'
+b'apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +10',b'Pre Sales',b'F\xc3\xb8r salg'
+b'DocType: Instructor Log',b'Other Details',b'Andre detaljer'
+b'apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +18',b'Suplier',b'suplier'
+b'DocType: Lab Test',b'Test Template',b'Testmal'
+b'DocType: Restaurant Order Entry Item',b'Served',b'serveres'
+b'apps/erpnext/erpnext/config/non_profit.py +13',b'Chapter information.',b'Kapittelinformasjon.'
+b'DocType: Account',b'Accounts',b'Kontoer'
+b'DocType: Vehicle',b'Odometer Value (Last)',b'Kilometerstand (Siste)'
+b'apps/erpnext/erpnext/config/buying.py +160',b'Templates of supplier scorecard criteria.',b'Maler med leverand\xc3\xb8rpoengkriterier.'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +109',b'Marketing',b'Markedsf\xc3\xb8ring'
+b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +303',b'Payment Entry is already created',b'Betaling Entry er allerede opprettet'
+b'DocType: Request for Quotation',b'Get Suppliers',b'F\xc3\xa5 leverand\xc3\xb8rer'
+b'DocType: Purchase Receipt Item Supplied',b'Current Stock',b'N\xc3\xa5v\xc3\xa6rende Stock'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +610',b'Row #{0}: Asset {1} does not linked to Item {2}',b'Row # {0}: Asset {1} ikke knyttet til Element {2}'
+b'apps/erpnext/erpnext/education/doctype/instructor/instructor.py +15',b'Please setup Instructor Naming System in Education &gt; Education Settings',b'Vennligst oppsett Instrukt\xc3\xb8r Navngivningssystem under utdanning&gt; Utdanningsinnstillinger'
+b'apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +394',b'Preview Salary Slip',b'Forh\xc3\xa5ndsvisning L\xc3\xb8nn Slip'
+b'apps/erpnext/erpnext/accounts/doctype/budget/budget.py +54',b'Account {0} has been entered multiple times',b'Konto {0} er angitt flere ganger'
+b'DocType: Account',b'Expenses Included In Valuation',b'Kostnader som inng\xc3\xa5r i verdivurderings'
+b'apps/erpnext/erpnext/non_profit/doctype/membership/membership.py +37',b'You can only renew if your membership expires within 30 days',b'Du kan bare fornye hvis medlemskapet ditt utl\xc3\xb8per innen 30 dager'
+b'DocType: Land Unit',b'Longitude',b'lengde~~POS=TRUNC'
+,b'Absent Student Report',b'Frav\xc3\xa6rende Student Rapporter'
+b'DocType: Crop',b'Crop Spacing UOM',b'Beskj\xc3\xa6re plassering UOM'
+b'DocType: Accounts Settings',b'Only select if you have setup Cash Flow Mapper documents',b'Bare velg hvis du har installert Cash Flow Mapper-dokumenter'
+b'DocType: Email Digest',b'Next email will be sent on:',b'Neste post vil bli sendt p\xc3\xa5:'
+b'DocType: Supplier Scorecard',b'Per Week',b'Per uke'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +666',b'Item has variants.',b'Elementet har varianter.'
+b'apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +154',b'Total Student',b'Totalt Student'
+b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +65',b'Item {0} not found',b'Element {0} ikke funnet'
+b'DocType: Bin',b'Stock Value',b'Stock Verdi'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +239',b'Company {0} does not exist',b'Selskapet {0} finnes ikke'
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +40',b'{0} has fee validity till {1}',b'{0} har gebyrgyldighet til {1}'
+b'apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +54',b'Tree Type',b'Tre Type'
+b'DocType: BOM Explosion Item',b'Qty Consumed Per Unit',b'Antall som forbrukes per enhet'
+b'DocType: GST Account',b'IGST Account',b'IGST-konto'
+b'DocType: Serial No',b'Warranty Expiry Date',b'Garantiutl\xc3\xb8psdato'
+b'DocType: Material Request Item',b'Quantity and Warehouse',b'Kvantitet og Warehouse'
+b'DocType: Hub Settings',b'Unregister',b'Avregistrer'
+b'DocType: Sales Invoice',b'Commission Rate (%)',b'Kommisjonen Rate (%)'
+b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +24',b'Please select Program',b'Vennligst velg Program'
+b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +24',b'Please select Program',b'Vennligst velg Program'
+b'DocType: Project',b'Estimated Cost',b'ansl\xc3\xa5tt pris'
+b'DocType: Purchase Order',b'Link to material requests',b'Lenke til materiale foresp\xc3\xb8rsler'
+b'DocType: Hub Settings',b'Publish',b'publisere'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +7',b'Aerospace',b'Aerospace'
+,b'Fichier des Ecritures Comptables [FEC]',b'Fichier des Ecritures Comptables [FEC]'
+b'DocType: Journal Entry',b'Credit Card Entry',b'Kredittkort Entry'
+b'apps/erpnext/erpnext/config/accounts.py +57',b'Company and Accounts',b'Selskapet og regnskap'
+b'apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +70',b'In Value',b'i Verdi'
+b'DocType: Asset Settings',b'Depreciation Options',b'Avskrivningsalternativer'
+b'apps/erpnext/erpnext/utilities/transaction_base.py +35',b'Invalid Posting Time',b'Ugyldig innleggstid'
+b'DocType: Lead',b'Campaign Name',b'Kampanjenavn'
+b'DocType: Hotel Room',b'Capacity',b'Kapasitet'
+b'DocType: Selling Settings',b'Close Opportunity After Days',b'Lukk mulighet da Days'
+,b'Reserved',b'Reservert'
+b'DocType: Driver',b'License Details',b'Lisensdetaljer'
+b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +85',b'The field From Shareholder cannot be blank',b'Feltet fra Aksjon\xc3\xa6r kan ikke v\xc3\xa6re tomt'
+b'DocType: Purchase Order',b'Supply Raw Materials',b'Leverer r\xc3\xa5vare'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +10',b'Current Assets',b'Oml\xc3\xb8psmidler'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +121',b'{0} is not a stock Item',b'{0} er ikke en lagervare'
+b'apps/erpnext/erpnext/hr/email_alert/training_feedback/training_feedback.html +6',"b""Please share your feedback to the training by clicking on 'Training Feedback' and then 'New'""",b'Vennligst del din tilbakemelding til treningen ved \xc3\xa5 klikke p\xc3\xa5 &#39;Trenings tilbakemelding&#39; og deretter &#39;Ny&#39;'
+b'DocType: Mode of Payment Account',b'Default Account',b'Standard konto'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +273',b'Please select Sample Retention Warehouse in Stock Settings first',b'Vennligst velg Sample Retention Warehouse i lagerinnstillinger f\xc3\xb8rst'
+b'DocType: Payment Entry',b'Received Amount (Company Currency)',b'Mottatt bel\xc3\xb8p (Selskap Valuta)'
+b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +192',b'Lead must be set if Opportunity is made from Lead',b'Lead m\xc3\xa5 stilles inn hvis Opportunity er laget av Lead'
+b'apps/erpnext/erpnext/erpnext_integrations/doctype/gocardless_settings/gocardless_settings.py +136',b'Payment Cancelled. Please check your GoCardless Account for more details',b'Betaling avbrutt. Vennligst sjekk din GoCardless-konto for mer informasjon'
+b'apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +29',b'Please select weekly off day',b'Vennligst velg ukentlig off dag'
+b'DocType: Patient',b'O Negative',b'O Negativ'
+b'DocType: Work Order Operation',b'Planned End Time',b'Planlagt Sluttid'
+,b'Sales Person Target Variance Item Group-Wise',b'Sales Person Target Avviks varegruppe-Wise'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +93',b'Account with existing transaction cannot be converted to ledger',b'Konto med eksisterende transaksjon kan ikke konverteres til Ledger'
+b'apps/erpnext/erpnext/config/non_profit.py +33',b'Memebership Type Details',b'Memebership Type Detaljer'
+b'DocType: Delivery Note',"b""Customer's Purchase Order No""",b'Kundens innkj\xc3\xb8psordre Nei'
+b'DocType: Budget',b'Budget Against',b'budsjett Against'
+b'DocType: Employee',b'Cell Number',b'Cell Number'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +450',"b""There's no employee for the given criteria. Check that Salary Slips have not already been created.""",b'Det er ingen ansatt for de oppgitte kriteriene. Sjekk at L\xc3\xb8nnslister ikke allerede er opprettet.'
+b'apps/erpnext/erpnext/stock/reorder_item.py +194',b'Auto Material Requests Generated',b'Auto Materiell Foresp\xc3\xb8rsler Generert'
+b'apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js +7',b'Lost',b'Mistet'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +152',"b""You can not enter current voucher in 'Against Journal Entry' column""",b'Du kan ikke legge inn dagens kupong i &quot;Against Journal Entry-kolonnen'
+b'apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +50',b'Reserved for manufacturing',b'Reservert for produksjon'
+b'DocType: Soil Texture',b'Sand',b'Sand'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +25',b'Energy',b'Energy'
+b'DocType: Opportunity',b'Opportunity From',b'Opportunity Fra'
+b'apps/erpnext/erpnext/config/hr.py +98',b'Monthly salary statement.',b'M\xc3\xa5nedsl\xc3\xb8nn uttalelse.'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +887',b'Row {0}: {1} Serial numbers required for Item {2}. You have provided {3}.',b'Row {0}: {1} Serienummer som kreves for element {2}. Du har oppgitt {3}.'
+b'apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +79',b'Please select a table',b'Vennligst velg en tabell'
+b'DocType: BOM',b'Website Specifications',b'Nettstedet Spesifikasjoner'
+b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +78',"b""{0} is an invalid email address in 'Recipients'""",b'{0} er en ugyldig e-postadresse i &quot;Mottakere&quot;'
+b'DocType: Special Test Items',b'Particulars',b'opplysninger'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +24',b'{0}: From {0} of type {1}',b'{0}: Fra {0} av typen {1}'
+b'DocType: Warranty Claim',b'CI-',b'CI-'
+b'apps/erpnext/erpnext/controllers/buying_controller.py +300',b'Row {0}: Conversion Factor is mandatory',b'Rad {0}: Omregningsfaktor er obligatorisk'
+b'DocType: Student',b'A+',b'A +'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +344',"b'Multiple Price Rules exists with same criteria, please resolve conflict by assigning priority. Price Rules: {0}'","b'Flere Pris regler eksisterer med samme kriteriene, kan du l\xc3\xb8se konflikten ved \xc3\xa5 prioritere. Pris Regler: {0}'"
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +519',b'Cannot deactivate or cancel BOM as it is linked with other BOMs',b'Kan ikke deaktivere eller kansellere BOM som det er forbundet med andre stykklister'
+b'DocType: Asset',b'Maintenance',b'Vedlikehold'
+b'DocType: Item Attribute Value',b'Item Attribute Value',b'Sak data Verdi'
+b'apps/erpnext/erpnext/projects/doctype/project/project.py +406',b'Please Update your Project Status',b'Vennligst oppdater prosjektstatusen din'
+b'DocType: Item',b'Maximum sample quantity that can be retained',b'Maksimal pr\xc3\xb8vemengde som kan beholdes'
+b'DocType: Project Update',b'How is the Project Progressing Right Now?',b'Hvordan foreg\xc3\xa5r prosjektet akkurat n\xc3\xa5?'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +418',b'Row {0}# Item {1} cannot be transferred more than {2} against Purchase Order {3}',b'Row {0} # Item {1} kan ikke overf\xc3\xb8res mer enn {2} mot innkj\xc3\xb8psordre {3}'
+b'apps/erpnext/erpnext/config/selling.py +158',b'Sales campaigns.',b'Salgskampanjer.'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +117',b'Make Timesheet',b'Gj\xc3\xb8r Timeregistrering'
+b'DocType: Sales Taxes and Charges Template',"b'Standard tax template that can be applied to all Sales Transactions. This template can contain list of tax heads and also other expense / income heads like ""Shipping"", ""Insurance"", ""Handling"" etc.\n\n#### Note\n\nThe tax rate you define here will be the standard tax rate for all **Items**. If there are **Items** that have different rates, they must be added in the **Item Tax** table in the **Item** master.\n\n#### Description of Columns\n\n1. Calculation Type: \n    - This can be on **Net Total** (that is the sum of basic amount).\n    - **On Previous Row Total / Amount** (for cumulative taxes or charges). If you select this option, the tax will be applied as a percentage of the previous row (in the tax table) amount or total.\n    - **Actual** (as mentioned).\n2. Account Head: The Account ledger under which this tax will be booked\n3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.\n4. Description: Description of the tax (that will be printed in invoices / quotes).\n5. Rate: Tax rate.\n6. Amount: Tax amount.\n7. Total: Cumulative total to this point.\n8. Enter Row: If based on ""Previous Row Total"" you can select the row number which will be taken as a base for this calculation (default is the previous row).\n9. Is this Tax included in Basic Rate?: If you check this, it means that this tax will not be shown below the item table, but will be included in the Basic Rate in your main item table. This is useful where you want give a flat price (inclusive of all taxes) price to customers.'","b'Standard skatt mal som kan brukes p\xc3\xa5 alle salgstransaksjoner. Denne malen kan inneholde liste over skatte hoder og ogs\xc3\xa5 andre utgifter / inntekter hoder som &quot;Shipping&quot;, &quot;Forsikring&quot;, &quot;H\xc3\xa5ndtering&quot; osv #### Note Skattesatsen du definerer her vil v\xc3\xa6re standard skattesats for alle ** Elementer **. Hvis det er ** Elementer ** som har forskjellige priser, m\xc3\xa5 de legges i ** Sak Skatt ** bord i ** Sak ** mester. #### Beskrivelse av kolonner 1. Beregning Type: - Dette kan v\xc3\xa6re p\xc3\xa5 ** Net Total ** (som er summen av grunnbel\xc3\xb8pet). - ** P\xc3\xa5 Forrige Row Total / Bel\xc3\xb8p ** (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\xc3\xb8rt 3. Cost Center: Hvis skatt / avgift er en inntekt (som frakt) eller utgifter det m\xc3\xa5 bestilles mot et kostnadssted. 4. Beskrivelse: Beskrivelse av skatt (som vil bli skrevet ut i fakturaer / sitater). 5. Ranger: skattesats. 6. Bel\xc3\xb8p: Skatt bel\xc3\xb8p. 7. Totalt: Akkumulert total til dette punktet. 8. Angi Row: Dersom basert p\xc3\xa5 &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\xc3\xa5 i grunnbel\xc3\xb8pet i din viktigste elementet tabellen. Dette er nyttig n\xc3\xa5r du vil gi en flat pris (inklusive alle avgifter) pris til kundene.'"
+b'DocType: Employee',b'Bank A/C No.',b'Bank A / C No.'
+b'DocType: Bank Guarantee',b'Project',b'Prosjekt'
+b'DocType: Quality Inspection Reading',b'Reading 7',b'Reading 7'
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js +9',b'Partially Ordered',b'delvis Bestilt'
+b'DocType: Lab Test',b'Lab Test',b'Lab Test'
+b'DocType: Student Report Generation Tool',b'Student Report Generation Tool',b'Generasjonsverkt\xc3\xb8y for Student Report'
+b'DocType: Expense Claim Detail',b'Expense Claim Type',b'Expense krav Type'
+b'DocType: Shopping Cart Settings',b'Default settings for Shopping Cart',b'Standardinnstillingene for handlekurv'
+b'apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +27',b'Add Timeslots',b'Legg til Timeslots'
+b'apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +138',b'Asset scrapped via Journal Entry {0}',b'Asset kasserte via bilagsregistrering {0}'
+b'DocType: Employee Loan',b'Interest Income Account',b'Renteinntekter konto'
+b'apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.py +58',b'Review Invitation Sent',b'Gjennomg\xc3\xa5 invitasjon sendt'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +13',b'Biotechnology',b'Bioteknologi'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +109',b'Office Maintenance Expenses',b'Kontor Vedlikehold Utgifter'
+b'apps/erpnext/erpnext/utilities/user_progress.py +54',b'Go to ',b'G\xc3\xa5 til'
+b'apps/erpnext/erpnext/config/learn.py +47',b'Setting up Email Account',b'Sette opp e-postkonto'
+b'apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js +21',b'Please enter Item first',b'Skriv inn Sak f\xc3\xb8rst'
+b'DocType: Asset Repair',b'Downtime',b'nedetid'
+b'DocType: Account',b'Liability',b'Ansvar'
+b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +220',b'Sanctioned Amount cannot be greater than Claim Amount in Row {0}.',b'Sanksjonert Bel\xc3\xb8pet kan ikke v\xc3\xa6re st\xc3\xb8rre enn krav Bel\xc3\xb8p i Rad {0}.'
+b'apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +11',b'Academic Term: ',b'Faglig semester:'
+b'DocType: Salary Detail',b'Do not include in total',b'Ikke inkluder i alt'
+b'apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +206',b'Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series',b'Vennligst still inn navngivningsserien for {0} via Setup&gt; Settings&gt; Naming Series'
+b'DocType: Company',b'Default Cost of Goods Sold Account',b'Standard varekostnader konto'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1019',b'Sample quantity {0} cannot be more than received quantity {1}',b'Pr\xc3\xb8vekvantitet {0} kan ikke v\xc3\xa6re mer enn mottatt mengde {1}'
+b'apps/erpnext/erpnext/stock/get_item_details.py +369',b'Price List not selected',b'Prisliste ikke valgt'
+b'DocType: Employee',b'Family Background',b'Familiebakgrunn'
+b'DocType: Request for Quotation Supplier',b'Send Email',b'Send E-Post'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +228',b'Warning: Invalid Attachment {0}',b'Advarsel: Ugyldig Vedlegg {0}'
+b'DocType: Item',b'Max Sample Quantity',b'Maks antall pr\xc3\xb8ver'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +766',b'No Permission',b'Ingen tillatelse'
+b'DocType: Vital Signs',b'Heart Rate / Pulse',b'Hjertefrekvens / puls'
+b'DocType: Company',b'Default Bank Account',b'Standard Bank Account'
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +59',"b'To filter based on Party, select Party Type first'","b'Hvis du vil filtrere basert p\xc3\xa5 partiet, velger partiet Skriv inn f\xc3\xb8rst'"
+b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +48',"b""'Update Stock' can not be checked because items are not delivered via {0}""",b'&#39;Oppdater Stock&#39; kan ikke kontrolleres fordi elementene ikke er levert via {0}'
+b'DocType: Vehicle',b'Acquisition Date',b'Innkj\xc3\xb8psdato'
+b'apps/erpnext/erpnext/utilities/user_progress.py +146',b'Nos',b'Nos'
+b'DocType: Item',b'Items with higher weightage will be shown higher',b'Elementer med h\xc3\xb8yere weightage vil bli vist h\xc3\xb8yere'
+b'apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +14',b'Lab Tests and Vital Signs',b'Lab Tests og Vital Signs'
+b'DocType: Bank Reconciliation Detail',b'Bank Reconciliation Detail',b'Bankavstemming Detalj'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +614',b'Row #{0}: Asset {1} must be submitted',b'Row # {0}: Asset {1} m\xc3\xa5 fremlegges'
+b'apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +40',b'No employee found',b'Ingen ansatte funnet'
+b'DocType: Subscription',b'Stopped',b'Stoppet'
+b'DocType: Item',b'If subcontracted to a vendor',b'Dersom underleverand\xc3\xb8r til en leverand\xc3\xb8r'
+b'apps/erpnext/erpnext/education/doctype/student_group/student_group.js +111',b'Student Group is already updated.',b'Studentgruppen er allerede oppdatert.'
+b'apps/erpnext/erpnext/education/doctype/student_group/student_group.js +111',b'Student Group is already updated.',b'Studentgruppen er allerede oppdatert.'
+b'apps/erpnext/erpnext/config/projects.py +18',b'Project Update.',b'Prosjektoppdatering.'
+b'DocType: SMS Center',b'All Customer Contact',b'All Kundekontakt'
+b'DocType: Land Unit',b'Tree Details',b'Tree Informasjon'
+b'DocType: Training Event',b'Event Status',b'Hendelses Status'
+b'DocType: Volunteer',b'Availability Timeslot',b'Tilgjengelighet Timeslot'
+,b'Support Analytics',b'St\xc3\xb8tte Analytics'
+b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +365',"b'If you have any questions, please get back to us.'","b'Hvis du har sp\xc3\xb8rsm\xc3\xa5l, kan du komme tilbake til oss.'"
+b'DocType: Cash Flow Mapper',b'Cash Flow Mapper',b'Cash Flow Mapper'
+b'DocType: Item',b'Website Warehouse',b'Nettsted Warehouse'
+b'DocType: Payment Reconciliation',b'Minimum Invoice Amount',b'Minimum Fakturert bel\xc3\xb8p'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +111',b'{0} {1}: Cost Center {2} does not belong to Company {3}',b'{0} {1}: Kostnadssted {2} ikke tilh\xc3\xb8rer selskapet {3}'
+b'apps/erpnext/erpnext/utilities/user_progress.py +92',b'Upload your letter head (Keep it web friendly as 900px by 100px)',b'Last opp brevhodet ditt (Hold det nettvennlig som 900px ved 100px)'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +88',b'{0} {1}: Account {2} cannot be a Group',b'{0} {1}: Account {2} kan ikke v\xc3\xa6re en gruppe'
+b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +63',"b""Item Row {idx}: {doctype} {docname} does not exist in above '{doctype}' table""",b'Sak Row {idx}: {doctype} {DOCNAME} finnes ikke i oven {doctype} tabellen'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +295',b'Timesheet {0} is already completed or cancelled',b'Timeregistrering {0} er allerede gjennomf\xc3\xb8rt eller kansellert'
+b'apps/erpnext/erpnext/templates/pages/projects.html +42',b'No tasks',b'ingen oppgaver'
+b'DocType: Item Variant Settings',b'Copy Fields to Variant',b'Kopier felt til variant'
+b'DocType: Asset',b'Opening Accumulated Depreciation',b'\xc3\x85pning akkumulerte avskrivninger'
+b'apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.js +49',b'Score must be less than or equal to 5',b'Score m\xc3\xa5 v\xc3\xa6re mindre enn eller lik 5'
+b'DocType: Program Enrollment Tool',b'Program Enrollment Tool',b'Program P\xc3\xa5melding Tool'
+b'apps/erpnext/erpnext/config/accounts.py +335',b'C-Form records',b'C-Form poster'
+b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +73',b'The shares already exist',b'Aksjene eksisterer allerede'
+b'apps/erpnext/erpnext/config/selling.py +316',b'Customer and Supplier',b'Kunde og leverand\xc3\xb8r'
+b'DocType: Email Digest',b'Email Digest Settings',b'E-post Digest Innstillinger'
+b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +367',b'Thank you for your business!',b'Takk for handelen!'
+b'apps/erpnext/erpnext/config/support.py +12',b'Support queries from customers.',b'St\xc3\xb8tte henvendelser fra kunder.'
+b'DocType: Setup Progress Action',b'Action Doctype',b'Handling Doctype'
+b'DocType: HR Settings',b'Retirement Age',b'Pensjonsalder'
+b'DocType: Bin',b'Moving Average Rate',b'Moving Gjennomsnittlig pris'
+b'DocType: Production Plan',b'Select Items',b'Velg Items'
+b'DocType: Share Transfer',b'To Shareholder',b'Til Aksjon\xc3\xa6r'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +372',b'{0} against Bill {1} dated {2}',b'{0} mot Bill {1} datert {2}'
+b'apps/erpnext/erpnext/utilities/user_progress.py +27',b'Setup Institution',b'Oppsettinstitusjon'
+b'DocType: Program Enrollment',b'Vehicle/Bus Number',b'Kj\xc3\xb8ret\xc3\xb8y / bussnummer'
+b'apps/erpnext/erpnext/education/doctype/course/course.js +17',b'Course Schedule',b'Kursplan'
+b'DocType: Request for Quotation Supplier',b'Quote Status',b'Sitatstatus'
+b'DocType: GoCardless Settings',b'Webhooks Secret',b'Webhooks Secret'
+b'DocType: Maintenance Visit',b'Completion Status',b'Completion Status'
+b'DocType: Daily Work Summary Group',b'Select Users',b'Velg Brukere'
+b'DocType: Hotel Room Pricing Item',b'Hotel Room Pricing Item',b'Hotellromprisepris'
+b'DocType: HR Settings',b'Enter retirement age in years',b'Skriv inn pensjonsalder i \xc3\xa5r'
+b'DocType: Crop',b'Target Warehouse',b'Target Warehouse'
+b'DocType: Payroll Employee Detail',b'Payroll Employee Detail',b'L\xc3\xb8nnspersonelldetaljer'
+b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +128',b'Please select a warehouse',b'Vennligst velg et lager'
+b'DocType: Cheque Print Template',b'Starting location from left edge',b'Starter plassering fra venstre kant'
+b'DocType: Item',b'Allow over delivery or receipt upto this percent',b'Tillat l\xc3\xb8pet levering eller mottak opp denne prosent'
+b'DocType: Stock Entry',b'STE-',b'an- drogene'
+b'DocType: Upload Attendance',b'Import Attendance',b'Import Oppm\xc3\xb8te'
+b'apps/erpnext/erpnext/public/js/pos/pos.html +124',b'All Item Groups',b'Alle varegrupper'
+b'apps/erpnext/erpnext/config/setup.py +89',b'Automatically compose message on submission of transactions.',b'Skriv melding automatisk ved innlevering av transaksjoner.'
+b'DocType: Work Order',b'Item To Manufacture',b'Element for \xc3\xa5 produsere'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +44',b'CompteLib',b'CompteLib'
+b'apps/erpnext/erpnext/buying/utils.py +80',b'{0} {1} status is {2}',b'{0} {1} status er {2}'
+b'DocType: Water Analysis',b'Collection Temperature ',b'Samlingstemperatur'
+b'DocType: Employee',b'Provide Email Address registered in company',b'Gi e-postadresse som er registrert i selskapets'
+b'DocType: Shopping Cart Settings',b'Enable Checkout',b'aktiver kassen'
+b'apps/erpnext/erpnext/config/learn.py +202',b'Purchase Order to Payment',b'Bestilling til betaling'
+b'apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +48',b'Projected Qty',b'Ansl\xc3\xa5tt Antall'
+b'DocType: Sales Invoice',b'Payment Due Date',b'Betalingsfrist'
+b'DocType: Drug Prescription',b'Interval UOM',b'Intervall UOM'
+b'DocType: Customer',"b'Reselect, if the chosen address is edited after save'",b'Velg hvis den valgte adressen redigeres etter lagre'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +522',b'Item Variant {0} already exists with same attributes',b'Sak Variant {0} finnes allerede med samme attributtene'
+b'DocType: Item',b'Hub Publishing Details',b'Hub Publishing Detaljer'
+b'apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +117',"b""'Opening'""",b'&quot;Opening&quot;'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +130',b'Open To Do',b'\xc3\x85pne for \xc3\xa5 gj\xc3\xb8re'
+b'DocType: Notification Control',b'Delivery Note Message',b'Levering Note Message'
+b'DocType: Lab Test Template',b'Result Format',b'Resultatformat'
+b'DocType: Expense Claim',b'Expenses',b'Utgifter'
+b'DocType: Item Variant Attribute',b'Item Variant Attribute',b'Sak Variant Egenskap'
+,b'Purchase Receipt Trends',b'Kvitteringen Trender'
+b'DocType: Payroll Entry',b'Bimonthly',b'annenhver m\xc3\xa5ned'
+b'DocType: Vehicle Service',b'Brake Pad',b'Bremsekloss'
+b'DocType: Fertilizer',b'Fertilizer Contents',b'Innhold av gj\xc3\xb8dsel'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +119',b'Research & Development',b'Forskning Og Utvikling'
+b'apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py +20',b'Amount to Bill',b'Bel\xc3\xb8p til Bill'
+b'DocType: Company',b'Registration Details',b'Registrering Detaljer'
+b'DocType: Timesheet',b'Total Billed Amount',b'Total Fakturert bel\xc3\xb8p'
+b'DocType: Item Reorder',b'Re-Order Qty',b'Re-Order Antall'
+b'DocType: Leave Block List Date',b'Leave Block List Date',b'La Block List Dato'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +94',b'BOM #{0}: Raw material cannot be same as main Item',b'BOM # {0}: R\xc3\xa5materiale kan ikke v\xc3\xa6re det samme som hovedelementet'
+b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +92',b'Total Applicable Charges in Purchase Receipt Items table must be same as Total Taxes and Charges',b'Totalt gjeldende avgifter i kvitteringen Elementer tabellen m\xc3\xa5 v\xc3\xa6re det samme som total skatter og avgifter'
+b'DocType: Sales Team',b'Incentives',b'Motivasjon'
+b'DocType: SMS Log',b'Requested Numbers',b'Ettersp\xc3\xb8r Numbers'
+b'DocType: Volunteer',b'Evening',b'Kveld'
+b'DocType: Customer',b'Bypass credit limit check at Sales Order',b'Bypass kredittgrense sjekke p\xc3\xa5 salgsordre'
+b'apps/erpnext/erpnext/config/hr.py +147',b'Performance appraisal.',b'Medarbeidersamtaler.'
+b'apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +100',"b""Enabling 'Use for Shopping Cart', as Shopping Cart is enabled and there should be at least one Tax Rule for Shopping Cart""","b'Aktivering av \xc2\xabBruk for handlekurven&quot;, som Handlevogn er aktivert, og det b\xc3\xb8r v\xc3\xa6re minst en skatteregel for Handlekurv'"
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +412',"b'Payment Entry {0} is linked against Order {1}, check if it should be pulled as advance in this invoice.'","b'Betaling Entry {0} er knyttet mot Bestill {1}, sjekk om det b\xc3\xb8r trekkes som forskudd i denne fakturaen.'"
+b'DocType: Sales Invoice Item',b'Stock Details',b'Stock Detaljer'
+b'apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +29',b'Project Value',b'Prosjektet Verdi'
+b'apps/erpnext/erpnext/config/selling.py +326',b'Point-of-Sale',b'Utsalgssted'
+b'DocType: Fee Schedule',b'Fee Creation Status',b'Fee Creation Status'
+b'DocType: Vehicle Log',b'Odometer Reading',b'Kilometerteller Reading'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +116',"b""Account balance already in Credit, you are not allowed to set 'Balance Must Be' as 'Debit'""","b'Saldo allerede i Credit, har du ikke lov til \xc3\xa5 sette &quot;Balance m\xc3\xa5 v\xc3\xa6re &#39;som&#39; debet &#39;'"
+b'DocType: Account',b'Balance must be',b'Balansen m\xc3\xa5 v\xc3\xa6re'
+b'DocType: Hub Settings',b'Publish Pricing',b'Publiser Priser'
+b'DocType: Notification Control',b'Expense Claim Rejected Message',b'Expense krav Avvist Message'
+,b'Available Qty',b'Tilgjengelig Antall'
+b'DocType: Purchase Taxes and Charges',b'On Previous Row Total',b'P\xc3\xa5 Forrige Row Total'
+b'DocType: Purchase Invoice Item',b'Rejected Qty',b'avvist Antall'
+b'DocType: Setup Progress Action',b'Action Field',b'Handlingsfelt'
+b'DocType: Healthcare Settings',b'Manage Customer',b'Administrer kunde'
+b'DocType: Delivery Trip',b'Delivery Stops',b'Levering stopper'
+b'DocType: Salary Slip',b'Working Days',b'Arbeidsdager'
+b'DocType: Serial No',b'Incoming Rate',b'Innkommende Rate'
+b'DocType: Packing Slip',b'Gross Weight',b'Bruttovekt'
+,b'Final Assessment Grades',b'Final Assessment Grades'
+b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +47',b'Enable Hub',b'Aktiver nav'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +110',b'The name of your company for which you are setting up this system.',b'Navnet p\xc3\xa5 firmaet som du setter opp dette systemet.'
+b'DocType: HR Settings',b'Include holidays in Total no. of Working Days',b'Inkluder ferier i Total no. arbeidsdager'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/sample_data.py +108',b'Setup your Institute in ERPNext',b'Oppsett ditt institutt i ERPNext'
+b'DocType: Agriculture Analysis Criteria',b'Plant Analysis',b'Plantanalyse'
+b'DocType: Job Applicant',b'Hold',b'Hold'
+b'DocType: Project Update',b'Progress Details',b'Fremdriftsdetaljer'
+b'DocType: Employee',b'Date of Joining',b'Dato for Delta'
+b'DocType: Naming Series',b'Update Series',b'Update-serien'
+b'DocType: Supplier Quotation',b'Is Subcontracted',b'Er underleverand\xc3\xb8r'
+b'DocType: Restaurant Table',b'Minimum Seating',b'Minimum sitteplasser'
+b'DocType: Item Attribute',b'Item Attribute Values',b'Sak attributtverdier'
+b'DocType: Examination Result',b'Examination Result',b'Sensur'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +845',b'Purchase Receipt',b'Kvitteringen'
+,b'Received Items To Be Billed',b'Mottatte elementer \xc3\xa5 bli fakturert'
+b'apps/erpnext/erpnext/config/accounts.py +303',b'Currency exchange rate master.',b'Valutakursen mester.'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +209',b'Reference Doctype must be one of {0}',b'Referanse DOCTYPE m\xc3\xa5 v\xc3\xa6re en av {0}'
+b'apps/erpnext/erpnext/stock/report/warehouse_wise_item_balance_age_and_value/warehouse_wise_item_balance_age_and_value.js +46',b'Filter Total Zero Qty',b'Filter totalt null antall'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +341',b'Unable to find Time Slot in the next {0} days for Operation {1}',b'\xc3\x85 finne tidsluke i de neste {0} dager for Operation klarer {1}'
+b'DocType: Work Order',b'Plan material for sub-assemblies',b'Plan materiale for sub-assemblies'
+b'apps/erpnext/erpnext/config/selling.py +97',b'Sales Partners and Territory',b'Salgs Partnere og Territory'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +600',b'BOM {0} must be active',b'BOM {0} m\xc3\xa5 v\xc3\xa6re aktiv'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +414',b'No Items available for transfer',b'Ingen elementer tilgjengelig for overf\xc3\xb8ring'
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +218',b'Closing (Opening + Total)',b'Avslutning (\xc3\x85pning + Totalt)'
+b'DocType: Journal Entry',b'Depreciation Entry',b'avskrivninger Entry'
+b'apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +32',b'Please select the document type first',b'Velg dokumenttypen f\xc3\xb8rst'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py +65',b'Cancel Material Visits {0} before cancelling this Maintenance Visit',b'Avbryt Material Bes\xc3\xb8k {0} f\xc3\xb8r den sletter denne Maintenance Visit'
+b'DocType: Crop Cycle',b'ISO 8016 standard',b'ISO 8016 standard'
+b'DocType: Pricing Rule',b'Rate or Discount',b'Pris eller rabatt'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +213',b'Serial No {0} does not belong to Item {1}',b'Serial No {0} tilh\xc3\xb8rer ikke Element {1}'
+b'DocType: Purchase Receipt Item Supplied',b'Required Qty',b'P\xc3\xa5krevd antall'
+b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +126',b'Warehouses with existing transaction can not be converted to ledger.',b'N\xc3\xa6ringslokaler med eksisterende transaksjon kan ikke konverteres til hovedbok.'
+b'DocType: Bank Reconciliation',b'Total Amount',b'Totalbel\xc3\xb8p'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +32',b'Internet Publishing',b'Internett Publisering'
+b'DocType: Prescription Duration',b'Number',b'Antall'
+b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +25',b'Creating {0} Invoice',b'Opprette {0} faktura'
+b'DocType: Medical Code',b'Medical Code Standard',b'Medisinskode Standard'
+b'DocType: Soil Texture',b'Clay Composition (%)',b'Leirekomposisjon (%)'
+b'apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js +81',b'Please save before assigning task.',b'Vennligst lagre f\xc3\xb8r du tilordner oppgaven.'
+b'apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +74',b'Balance Value',b'Balanse Verdi'
+b'DocType: Lab Test',b'Lab Technician',b'Lab tekniker'
+b'apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +38',b'Sales Price List',b'Salg Prisliste'
+b'DocType: Healthcare Settings',"b'If checked, a customer will be created, mapped to Patient.\nPatient Invoices will be created against this Customer. You can also select existing Customer while creating Patient.'","b'Hvis det er merket, vil en kunde bli opprettet, kartlagt til Pasient. Pasientfakturaer vil bli opprettet mot denne kunden. Du kan ogs\xc3\xa5 velge eksisterende kunde mens du oppretter pasient.'"
+b'DocType: Bank Reconciliation',b'Account Currency',b'Account Valuta'
+b'DocType: Lab Test',b'Sample ID',b'Eksempel ID'
+b'apps/erpnext/erpnext/accounts/general_ledger.py +167',b'Please mention Round Off Account in Company',b'Vennligst oppgi Round Off-konto i selskapet'
+b'DocType: Purchase Receipt',b'Range',b'Omr\xc3\xa5de'
+b'DocType: Supplier',b'Default Payable Accounts',b'Standard Leverand\xc3\xb8rgjeld'
+b'apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +49',b'Employee {0} is not active or does not exist',b'Ansatt {0} er ikke aktiv eller ikke eksisterer'
+b'DocType: Fee Structure',b'Components',b'komponenter'
+b'DocType: Item Barcode',b'Item Barcode',b'Sak Barcode'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +329',b'Please enter Asset Category in Item {0}',b'Fyll inn Asset kategori i Element {0}'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +661',b'Item Variants {0} updated',b'Sak Varianter {0} oppdatert'
+b'DocType: Quality Inspection Reading',b'Reading 6',b'Reading 6'
+b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +9',"b'to be generated. If delayed, you will have to manually change the ""Repeat on Day of Month"" field\nof this'","b'\xc3\xa5 bli generert. Hvis forsinket, m\xc3\xa5 du manuelt endre feltet Repeter p\xc3\xa5 dag i m\xc3\xa5neden av dette'"
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +961',b'Cannot {0} {1} {2} without any negative outstanding invoice',b'Kan ikke {0} {1} {2} uten noen negativ utest\xc3\xa5ende faktura'
+b'DocType: Share Transfer',b'From Folio No',b'Fra Folio nr'
+b'DocType: Purchase Invoice Advance',b'Purchase Invoice Advance',b'Fakturaen Advance'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +199',b'Row {0}: Credit entry can not be linked with a {1}',b'Rad {0}: Credit oppf\xc3\xb8ring kan ikke v\xc3\xa6re knyttet til en {1}'
+b'apps/erpnext/erpnext/config/accounts.py +246',b'Define budget for a financial year.',b'Definer budsjett for et regnskaps\xc3\xa5r.'
+b'DocType: Lead',b'LEAD-',b'LEDE-'
+b'DocType: Employee',b'Permanent Address Is',b'Permanent Adresse Er'
+b'DocType: Work Order Operation',b'Operation completed for how many finished goods?',b'Operasjonen gjennomf\xc3\xb8rt for hvor mange ferdigvarer?'
+b'DocType: Payment Terms Template',b'Payment Terms Template',b'Betalingsbetingelser mal'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +51',b'The Brand',b'The Brand'
+b'DocType: Employee',b'Exit Interview Details',b'Exit Intervju Detaljer'
+b'DocType: Item',b'Is Purchase Item',b'Er Purchase Element'
+b'DocType: Journal Entry Account',b'Purchase Invoice',b'Fakturaen'
+b'DocType: Stock Ledger Entry',b'Voucher Detail No',b'Kupong Detail Ingen'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +789',b'New Sales Invoice',b'Ny salgsfaktura'
+b'DocType: Stock Entry',b'Total Outgoing Value',b'Total Utg\xc3\xa5ende verdi'
+b'DocType: Physician',b'Appointments',b'avtaler'
+b'apps/erpnext/erpnext/public/js/account_tree_grid.js +223',b'Opening Date and Closing Date should be within same Fiscal Year',b'\xc3\x85pningsdato og sluttdato skal v\xc3\xa6re innenfor samme regnskaps\xc3\xa5r'
+b'DocType: Lead',b'Request for Information',b'Sp\xc3\xb8r etter informasjon'
+,b'LeaderBoard',b'Leaderboard'
+b'DocType: Sales Invoice Item',b'Rate With Margin (Company Currency)',b'Vurder med margin (Bedriftsvaluta)'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +802',b'Sync Offline Invoices',b'Synkroniser Offline Fakturaer'
+b'DocType: Payment Request',b'Paid',b'Betalt'
+b'DocType: Program Fee',b'Program Fee',b'program Fee'
+b'DocType: BOM Update Tool',"b'Replace a particular BOM in all other BOMs where it is used. It will replace the old BOM link, update cost and regenerate ""BOM Explosion Item"" table as per new BOM.\nIt also updates latest price in all the BOMs.'","b'Bytt ut en bestemt BOM i alle andre BOM-er der den brukes. Det vil erstatte den gamle BOM-lenken, oppdatere kostnadene og regenerere &quot;BOM Explosion Item&quot; -tabellen som per ny BOM. Det oppdaterer ogs\xc3\xa5 siste pris i alle BOMene.'"
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +447',b'The following Work Orders were created:',b'F\xc3\xb8lgende arbeidsordrer ble opprettet:'
+b'DocType: Salary Slip',b'Total in words',b'Totalt i ord'
+b'DocType: Material Request Item',b'Lead Time Date',b'Lead Tid Dato'
+,b'Employee Advance Summary',b'Ansattsperspektiv'
+b'DocType: Asset',b'Available-for-use Date',b'Tilgjengelig dato for bruk'
+b'DocType: Guardian',b'Guardian Name',b'Guardian navn'
+b'DocType: Cheque Print Template',b'Has Print Format',b'Har Print Format'
+b'DocType: Employee Loan',b'Sanctioned',b'sanksjonert'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +75',b' is mandatory. Maybe Currency Exchange record is not created for ',b'er obligatorisk. Kanskje Valutaveksling posten ikke er skapt for'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +139',b'Row #{0}: Please specify Serial No for Item {1}',b'Row # {0}: Vennligst oppgi serienummer for varen {1}'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +54',b'Supplier &gt; Supplier Type',b'Leverand\xc3\xb8r&gt; Leverand\xc3\xb8r Type'
+b'DocType: Crop Cycle',b'Crop Cycle',b'Beskj\xc3\xa6ringssyklus'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +633',"b""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.""","b'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.'"
+b'DocType: Student Admission',b'Publish on website',b'Publiser p\xc3\xa5 nettstedet'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +651',b'Supplier Invoice Date cannot be greater than Posting Date',b'Leverand\xc3\xb8r Fakturadato kan ikke v\xc3\xa6re st\xc3\xb8rre enn konteringsdato'
+b'DocType: Purchase Invoice Item',b'Purchase Order Item',b'Innkj\xc3\xb8psordre Element'
+b'DocType: Agriculture Task',b'Agriculture Task',b'Landbruk Oppgave'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +132',b'Indirect Income',b'Indirekte inntekt'
+b'DocType: Student Attendance Tool',b'Student Attendance Tool',b'Student Oppm\xc3\xb8te Tool'
+b'DocType: Restaurant Menu',b'Price List (Auto created)',b'Prisliste (automatisk opprettet)'
+b'DocType: Cheque Print Template',b'Date Settings',b'Dato Innstillinger'
+b'apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +48',b'Variance',b'Varians'
+,b'Company Name',b'Selskapsnavn'
+b'DocType: SMS Center',b'Total Message(s)',b'Total melding (er)'
+b'DocType: Share Balance',b'Purchased',b'kj\xc3\xb8pt'
+b'DocType: Item Variant Settings',b'Rename Attribute Value in Item Attribute.',b'Endre navn p\xc3\xa5 Attribute Value i Item Attribute.'
+b'DocType: Purchase Invoice',b'Additional Discount Percentage',b'Ekstra rabatt Prosent'
+b'apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +24',b'View a list of all the help videos',b'Vis en liste over alle hjelpevideoer'
+b'DocType: Agriculture Analysis Criteria',b'Soil Texture',b'Jordstruktur'
+b'DocType: Bank Reconciliation',b'Select account head of the bank where cheque was deposited.',b'Velg kontoen leder av banken der sjekken ble avsatt.'
+b'DocType: Selling Settings',b'Allow user to edit Price List Rate in transactions',b'Tillater brukeren \xc3\xa5 redigere Prisliste Rate i transaksjoner'
+b'DocType: Pricing Rule',b'Max Qty',b'Max Antall'
+b'apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.js +25',b'Print Report Card',b'Skriv ut rapportkort'
+b'apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +30',"b'Row {0}: Invoice {1} is invalid, it might be cancelled / does not exist. \\\n\t\t\t\t\t\tPlease enter a valid Invoice'","b'Rad {0}: Faktura {1} er ugyldig, kan det bli kansellert / finnes ikke. \\ Vennligst skriv inn en gyldig faktura'"
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +132',b'Row {0}: Payment against Sales/Purchase Order should always be marked as advance',b'Rad {0}: Betaling mot Salg / innkj\xc3\xb8psordre skal alltid merkes som forskudd'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +16',b'Chemical',b'Kjemisk'
+b'DocType: Salary Component Account',b'Default Bank / Cash account will be automatically updated in Salary Journal Entry when this mode is selected.',b'Standard Bank / minibank konto vil bli automatisk oppdatert i L\xc3\xb8nn bilagsregistrering n\xc3\xa5r denne modusen er valgt.'
+b'DocType: BOM',b'Raw Material Cost(Company Currency)',b'Raw Material Cost (Selskap Valuta)'
+b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +88',b'Row # {0}: Rate cannot be greater than the rate used in {1} {2}',b'Row # {0}: Prisen kan ikke v\xc3\xa6re st\xc3\xb8rre enn frekvensen som brukes i {1} {2}'
+b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +88',b'Row # {0}: Rate cannot be greater than the rate used in {1} {2}',b'Row # {0}: Prisen kan ikke v\xc3\xa6re st\xc3\xb8rre enn frekvensen som brukes i {1} {2}'
+b'apps/erpnext/erpnext/utilities/user_progress.py +147',b'Meter',b'M\xc3\xa5ler'
+b'DocType: Workstation',b'Electricity Cost',b'Elektrisitet Cost'
+b'apps/erpnext/erpnext/agriculture/doctype/water_analysis/water_analysis.py +23',b'Lab testing datetime cannot be before collection datetime',b'Labtesting datetime kan ikke v\xc3\xa6re f\xc3\xb8r datetime samling'
+b'DocType: HR Settings',"b""Don't send Employee Birthday Reminders""",b'Ikke send Employee bursdagsp\xc3\xa5minnelser'
+b'DocType: Expense Claim',b'Total Advance Amount',b'Total forh\xc3\xa5ndsbel\xc3\xb8p'
+b'DocType: Delivery Stop',b'Estimated Arrival',b'forventet ankomst'
+b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +34',b'Save Settings',b'Lagre innstillinger'
+b'DocType: Delivery Stop',b'Notified by Email',b'Meldes via e-post'
+b'DocType: Item',b'Inspection Criteria',b'Inspeksjon Kriterier'
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js +14',b'Transfered',b'Overf\xc3\xb8rt'
+b'DocType: BOM Website Item',b'BOM Website Item',b'BOM Nettstedet Element'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +52',b'Upload your letter head and logo. (you can edit them later).',b'Last opp din brevhode og logo. (Du kan redigere dem senere).'
+b'DocType: Timesheet Detail',b'Bill',b'Regning'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +88',b'Next Depreciation Date is entered as past date',b'Neste avskrivningsdato legges inn som siste dato'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +208',b'White',b'Hvit'
+b'DocType: SMS Center',b'All Lead (Open)',b'All Lead (Open)'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +270',b'Row {0}: Qty not available for {4} in warehouse {1} at posting time of the entry ({2} {3})',b'Rad {0}: Antall ikke tilgjengelig for {4} i lageret {1} ved \xc3\xa5 legge tidspunktet for innreise ({2} {3})'
+b'apps/erpnext/erpnext/accounts/doctype/cash_flow_mapping/cash_flow_mapping.py +18',b'You can only select a maximum of one option from the list of check boxes.',b'Du kan bare velge maksimalt ett alternativ fra listen med avmerkingsbokser.'
+b'DocType: Purchase Invoice',b'Get Advances Paid',b'F\xc3\xa5 utbetalt forskudd'
+b'DocType: Item',b'Automatically Create New Batch',b'Opprett automatisk ny batch automatisk'
+b'DocType: Item',b'Automatically Create New Batch',b'Opprett automatisk ny batch automatisk'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +635',b'Assigning {0} to {1} (row {2})',b'Tilordne {0} til {1} (rad {2})'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +810',b'Make ',b'Gj\xc3\xb8re'
+b'DocType: Student Admission',b'Admission Start Date',b'Opptak Startdato'
+b'DocType: Journal Entry',b'Total Amount in Words',b'Totalbel\xc3\xb8p i Words'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee_tree.js +29',b'New Employee',b'Ny ansatt'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +7',"b""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.""",b'Det var en feil. En mulig \xc3\xa5rsak kan v\xc3\xa6re at du ikke har lagret skjemaet. Ta kontakt support@erpnext.com hvis problemet vedvarer.'
+b'apps/erpnext/erpnext/templates/pages/cart.html +5',b'My Cart',b'Handlekurv'
+b'apps/erpnext/erpnext/controllers/selling_controller.py +130',b'Order Type must be one of {0}',b'Ordretype m\xc3\xa5 v\xc3\xa6re en av {0}'
+b'DocType: Lead',b'Next Contact Date',b'Neste Kontakt Dato'
+b'apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +36',b'Opening Qty',b'Antall \xc3\xa5pne'
+b'DocType: Healthcare Settings',b'Appointment Reminder',b'Avtale p\xc3\xa5minnelse'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +478',b'Please enter Account for Change Amount',b'Vennligst oppgi konto for Change Bel\xc3\xb8p'
+b'DocType: Program Enrollment Tool Student',b'Student Batch Name',b'Student Batch Name'
+b'DocType: Consultation',b'Doctor',b'Doktor'
+b'DocType: Holiday List',b'Holiday List Name',b'Holiday Listenavn'
+b'DocType: Repayment Schedule',b'Balance Loan Amount',b'Balanse L\xc3\xa5nebel\xc3\xb8p'
+b'apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +14',b'Schedule Course',b'Schedule Course'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +236',b'Stock Options',b'Aksjeopsjoner'
+b'DocType: Buying Settings',b'Disable Fetching Last Purchase Details in Purchase Order',b'Deaktiver Henting av siste innkj\xc3\xb8psdetaljer i innkj\xc3\xb8psordre'
+b'DocType: Journal Entry Account',b'Expense Claim',b'Expense krav'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.js +267',b'Do you really want to restore this scrapped asset?',b'Har du virkelig \xc3\xb8nsker \xc3\xa5 gjenopprette dette skrotet ressurs?'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +381',b'Qty for {0}',b'Antall for {0}'
+b'DocType: Leave Application',b'Leave Application',b'La Application'
+b'DocType: Patient',b'Patient Relation',b'Pasientrelasjon'
+b'apps/erpnext/erpnext/config/hr.py +80',b'Leave Allocation Tool',b'La Allocation Tool'
+b'DocType: Item',b'Hub Category to Publish',b'Hub kategori for publisering'
+b'DocType: Leave Block List',b'Leave Block List Dates',b'La Block List Datoer'
+b'DocType: Sales Invoice',b'Billing Address GSTIN',b'Faktureringsadresse GSTIN'
+b'DocType: Assessment Plan',b'Evaluate',b'Evaluere'
+b'DocType: Workstation',b'Net Hour Rate',b'Netto timepris'
+b'DocType: Landed Cost Purchase Receipt',b'Landed Cost Purchase Receipt',b'Landed Cost Kj\xc3\xb8pskvittering'
+b'DocType: Company',b'Default Terms',b'Standard Terms'
+b'DocType: Supplier Scorecard Period',b'Criteria',b'kriterier'
+b'DocType: Packing Slip Item',b'Packing Slip Item',b'Pakking Slip Element'
+b'DocType: Purchase Invoice',b'Cash/Bank Account',b'Cash / Bank Account'
+b'apps/erpnext/erpnext/public/js/queries.js +96',b'Please specify a {0}',b'Vennligst oppgi en {0}'
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +73',b'Removed items with no change in quantity or value.',b'Fjernet elementer med ingen endring i mengde eller verdi.'
+b'DocType: Delivery Note',b'Delivery To',b'Levering \xc3\x85'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +415',b'Variant creation has been queued.',b'Variantskaping har v\xc3\xa6rt i k\xc3\xb8.'
+b'apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py +100',b'Work Summary for {0}',b'Arbeidssammendrag for {0}'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +696',b'Attribute table is mandatory',b'Attributt tabellen er obligatorisk'
+b'DocType: Production Plan',b'Get Sales Orders',b'F\xc3\xa5 salgsordrer'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +68',b'{0} can not be negative',b'{0} kan ikke v\xc3\xa6re negativ'
+b'DocType: Training Event',b'Self-Study',b'Selvstudium'
+b'apps/erpnext/erpnext/agriculture/doctype/soil_texture/soil_texture.py +27',b'Soil compositions do not add up to 100',b'Jordblandinger legger ikke opp til 100'
+b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +558',b'Discount',b'Rabatt'
+b'DocType: Membership',b'Membership',b'Medlemskap'
+b'DocType: Asset',b'Total Number of Depreciations',b'Totalt antall Avskrivninger'
+b'DocType: Sales Invoice Item',b'Rate With Margin',b'Vurder med margin'
+b'DocType: Sales Invoice Item',b'Rate With Margin',b'Vurder med margin'
+b'DocType: Workstation',b'Wages',b'L\xc3\xb8nn'
+b'DocType: Asset Maintenance',b'Maintenance Manager Name',b'Vedlikeholdsansvarlig navn'
+b'DocType: Agriculture Task',b'Urgent',b'Haster'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +174',b'Please specify a valid Row ID for row {0} in table {1}',b'Vennligst oppgi en gyldig Row ID for rad {0} i tabellen {1}'
+b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py +84',b'Unable to find variable: ',b'Kan ikke finne variabel:'
+b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +794',b'Please select a field to edit from numpad',b'Vennligst velg et felt for \xc3\xa5 redigere fra numpad'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +264',b'Cannot be a fixed asset item as Stock Ledger is created.',b'Kan ikke v\xc3\xa6re en fast eiendelsobjekt n\xc3\xa5r lagerboksen er opprettet.'
+b'apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +23',b'Go to the Desktop and start using ERPNext',b'G\xc3\xa5 til skrivebordet og begynne \xc3\xa5 bruke ERPNext'
+b'DocType: Item',b'Manufacturer',b'Produsent'
+b'DocType: Landed Cost Item',b'Purchase Receipt Item',b'Kvitteringen Element'
+b'DocType: Purchase Receipt',b'PREC-RET-',b'PREC-RET-'
+b'DocType: POS Profile',b'Sales Invoice Payment',b'Salg Faktura Betaling'
+b'DocType: Quality Inspection Template',b'Quality Inspection Template Name',b'Kvalitetsinspeksjonsmalnavn'
+b'DocType: Project',b'First Email',b'F\xc3\xb8rste e-post'
+b'DocType: Production Plan Item',b'Reserved Warehouse in Sales Order / Finished Goods Warehouse',b'Reservert Industribygg i salgsordre / ferdigvarelageret'
+b'apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +71',b'Selling Amount',b'Selge Bel\xc3\xb8p'
+b'DocType: Repayment Schedule',b'Interest Amount',b'rente~~POS=TRUNC'
+b'DocType: Serial No',b'Creation Document No',b'Creation Dokument nr'
+b'DocType: Share Transfer',b'Issue',b'Problem'
+b'apps/erpnext/erpnext/healthcare/doctype/consultation/consultation_dashboard.py +11',b'Records',b'Records'
+b'DocType: Asset',b'Scrapped',b'skrotet'
+b'DocType: Purchase Invoice',b'Returns',b'returer'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order_calendar.js +42',b'WIP Warehouse',b'WIP Warehouse'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +195',b'Serial No {0} is under maintenance contract upto {1}',b'Serial No {0} er under vedlikeholdskontrakt opp {1}'
+b'apps/erpnext/erpnext/config/hr.py +35',b'Recruitment',b'Rekruttering'
+b'DocType: Lead',b'Organization Name',b'Organization Name'
+b'DocType: Tax Rule',b'Shipping State',b'Shipping State'
+,b'Projected Quantity as Source',b'Ansl\xc3\xa5tt Antall som kilde'
+b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +61',"b""Item must be added using 'Get Items from Purchase Receipts' button""",b'Elementet m\xc3\xa5 legges til med &quot;Get Elementer fra innkj\xc3\xb8ps Receipts &#39;knappen'
+b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +858',b'Delivery Trip',b'Leveringsreise'
+b'DocType: Student',b'A-',b'EN-'
+b'DocType: Share Transfer',b'Transfer Type',b'Overf\xc3\xb8ringstype'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +117',b'Sales Expenses',b'Salgs Utgifter'
+b'DocType: Consultation',b'Diagnosis',b'Diagnose'
+b'apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py +18',b'Standard Buying',b'Standard Kj\xc3\xb8pe'
+b'DocType: GL Entry',b'Against',b'Against'
+b'DocType: Item',b'Default Selling Cost Center',b'Standard Selling kostnadssted'
+b'apps/erpnext/erpnext/public/js/pos/pos.html +85',b'Disc',b'Plate'
+b'DocType: Sales Partner',b'Implementation Partner',b'Gjennomf\xc3\xb8ring Partner'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +1624',b'ZIP Code',b'Post kode'
+b'apps/erpnext/erpnext/controllers/selling_controller.py +252',b'Sales Order {0} is {1}',b'Salgsordre {0} er {1}'
+b'DocType: Opportunity',b'Contact Info',b'Kontaktinfo'
+b'apps/erpnext/erpnext/config/stock.py +319',b'Making Stock Entries',b'Making Stock Entries'
+b'DocType: Packing Slip',b'Net Weight UOM',b'Vekt m\xc3\xa5lenheter'
+b'DocType: Item',b'Default Supplier',b'Standard Leverand\xc3\xb8r'
+b'DocType: Manufacturing Settings',b'Over Production Allowance Percentage',b'Over Produksjon Fradrag Prosent'
+b'DocType: Employee Loan',b'Repayment Schedule',b'tilbakebetaling Schedule'
+b'DocType: Shipping Rule Condition',b'Shipping Rule Condition',b'Shipping Rule Tilstand'
+b'DocType: Holiday List',b'Get Weekly Off Dates',b'F\xc3\xa5 Ukentlig Off Datoer'
+b'apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +33',b'End Date can not be less than Start Date',b'Sluttdato kan ikke v\xc3\xa6re mindre enn startdato'
+b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +337',"b""Invoice can't be made for zero billing hour""",b'Fakturaen kan ikke gj\xc3\xb8res for null faktureringstid'
+b'DocType: Sales Person',b'Select company name first.',b'Velg firmanavn f\xc3\xb8rst.'
+b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +189',b'Email sent to {0}',b'E-post sendt til {0}'
+b'apps/erpnext/erpnext/config/buying.py +23',b'Quotations received from Suppliers.',b'Sitater mottatt fra leverand\xc3\xb8rer.'
+b'apps/erpnext/erpnext/config/manufacturing.py +74',b'Replace BOM and update latest price in all BOMs',b'Erstatt BOM og oppdater siste pris i alle BOMs'
+b'apps/erpnext/erpnext/controllers/selling_controller.py +27',b'To {0} | {1} {2}',b'Til {0} | {1} {2}'
+b'DocType: Delivery Trip',b'Driver Name',b'Drivernavn'
+b'apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +40',b'Average Age',b'Gjennomsnittsalder'
+b'DocType: Education Settings',b'Attendance Freeze Date',b'Deltagelsesfrysedato'
+b'DocType: Education Settings',b'Attendance Freeze Date',b'Deltagelsesfrysedato'
+b'apps/erpnext/erpnext/utilities/user_progress.py +110',b'List a few of your suppliers. They could be organizations or individuals.',b'Liste noen av dine leverand\xc3\xb8rer. De kan v\xc3\xa6re organisasjoner eller enkeltpersoner.'
+b'apps/erpnext/erpnext/templates/pages/home.html +31',b'View All Products',b'Se alle produkter'
+b'apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +20',b'Minimum Lead Age (Days)',b'Minimum levealder (dager)'
+b'apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +20',b'Minimum Lead Age (Days)',b'Minimum levealder (dager)'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +60',b'All BOMs',b'alle stykklister'
+b'apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.py +35',b'Hotel Rooms of type {0} are unavailable on {1}',b'Hotellrom av typen {0} er utilgjengelig p\xc3\xa5 {1}'
+b'DocType: Patient',b'Default Currency',b'Standard Valuta'
+b'DocType: Expense Claim',b'From Employee',b'Fra Employee'
+b'DocType: Driver',b'Cellphone Number',b'Mobiltelefonnummer'
+b'DocType: Project',b'Monitor Progress',b'Monitor Progress'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +472',b'Warning: System will not check overbilling since amount for Item {0} in {1} is zero',b'Advarsel: System vil ikke sjekke billing siden bel\xc3\xb8pet for varen {0} i {1} er null'
+b'DocType: Journal Entry',b'Make Difference Entry',b'Gj\xc3\xb8r forskjell Entry'
+b'DocType: Upload Attendance',b'Attendance From Date',b'Oppm\xc3\xb8te Fra dato'
+b'DocType: Appraisal Template Goal',b'Key Performance Area',b'Key Performance-omr\xc3\xa5det'
+b'DocType: Program Enrollment',b'Transportation',b'Transport'
+b'apps/erpnext/erpnext/controllers/item_variant.py +94',b'Invalid Attribute',b'Ugyldig Egenskap'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +240',b'{0} {1} must be submitted',b'{0} {1} m\xc3\xa5 sendes'
+b'apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +159',b'Quantity must be less than or equal to {0}',b'Antall m\xc3\xa5 v\xc3\xa6re mindre enn eller lik {0}'
+b'DocType: SMS Center',b'Total Characters',b'Totalt tegn'
+b'DocType: Employee Advance',b'Claimed',b'hevdet'
+b'DocType: Crop',b'Row Spacing',b'Row Spacing'
+b'apps/erpnext/erpnext/controllers/buying_controller.py +164',b'Please select BOM in BOM field for Item {0}',b'Vennligst velg BOM i BOM felt for Element {0}'
+b'DocType: C-Form Invoice Detail',b'C-Form Invoice Detail',b'C-Form Faktura Detalj'
+b'DocType: Payment Reconciliation Invoice',b'Payment Reconciliation Invoice',b'Betaling Avstemming Faktura'
+b'apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +38',b'Contribution %',b'Bidrag%'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +215',"b""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}""","b'I henhold til kj\xc3\xb8psinnstillingene hvis innkj\xc3\xb8psordre er p\xc3\xa5krevd == &#39;JA&#39; og deretter for \xc3\xa5 opprette Kj\xc3\xb8pfaktura, m\xc3\xa5 brukeren opprette innkj\xc3\xb8psordre f\xc3\xb8rst for element {0}'"
+b'DocType: Company',b'Company registration numbers for your reference. Tax numbers etc.',b'Firmaregistreringsnumre som referanse. Skatte tall osv'
+b'DocType: Sales Partner',b'Distributor',b'Distribut\xc3\xb8r'
+b'DocType: Shopping Cart Shipping Rule',b'Shopping Cart Shipping Rule',b'Handlevogn Shipping Rule'
+b'apps/erpnext/erpnext/public/js/controllers/transaction.js +71',"b""Please set 'Apply Additional Discount On'""",b'Vennligst sett &#39;Apply Ytterligere rabatt p\xc3\xa5&#39;'
+,b'Ordered Items To Be Billed',b'Bestilte varer til \xc3\xa5 bli fakturert'
+b'apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +46',b'From Range has to be less than To Range',b'Fra Range m\xc3\xa5 v\xc3\xa6re mindre enn til kolleksjonen'
+b'DocType: Global Defaults',b'Global Defaults',b'Global Defaults'
+b'apps/erpnext/erpnext/projects/doctype/project/project.py +230',b'Project Collaboration Invitation',b'Prosjekt Samarbeid Invitasjon'
+b'DocType: Salary Slip',b'Deductions',b'Fradrag'
+b'DocType: Leave Allocation',b'LAL/',b'LAL /'
+b'DocType: Setup Progress Action',b'Action Name',b'Handlingsnavn'
+b'apps/erpnext/erpnext/public/js/financial_statements.js +75',b'Start Year',b'start-\xc3\xa5r'
+b'apps/erpnext/erpnext/regional/india/utils.py +25',b'First 2 digits of GSTIN should match with State number {0}',b'De to f\xc3\xb8rste sifrene i GSTIN skal samsvare med statens nummer {0}'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +68',b'PDC/LC',b'PDC / LC'
+b'DocType: Purchase Invoice',"b""Start date of current invoice's period""",b'Startdato for n\xc3\xa5v\xc3\xa6rende fakturaperiode'
+b'DocType: Salary Slip',b'Leave Without Pay',b'La Uten Pay'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +385',b'Capacity Planning Error',b'Kapasitetsplanlegging Error'
+,b'Trial Balance for Party',b'Trial Balance for partiet'
+b'DocType: Lead',b'Consultant',b'Konsulent'
+b'apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +356',b'Parents Teacher Meeting Attendance',b'Foreldres l\xc3\xa6rerm\xc3\xb8te'
+b'DocType: Salary Slip',b'Earnings',b'Inntjeningen'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +441',b'Finished Item {0} must be entered for Manufacture type entry',b'Ferdig Element {0} m\xc3\xa5 angis for Produksjon typen oppf\xc3\xb8ring'
+b'apps/erpnext/erpnext/config/learn.py +87',b'Opening Accounting Balance',b'\xc3\x85pning Regnskap Balanse'
+,b'GST Sales Register',b'GST salgsregistrering'
+b'DocType: Sales Invoice Advance',b'Sales Invoice Advance',b'Salg Faktura Advance'
+b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +552',b'Nothing to request',b'Ingenting \xc3\xa5 be om'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +18',b'Select your Domains',b'Velg domenene dine'
+b'apps/erpnext/erpnext/accounts/doctype/budget/budget.py +34',"b""Another Budget record '{0}' already exists against {1} '{2}' for fiscal year {3}""",b'En annen Budsjett record &#39;{0} finnes allerede mot {1} {2} for regnskaps\xc3\xa5ret {3}'
+b'DocType: Item Variant Settings',b'Fields will be copied over only at time of creation.',b'Feltene vil bli kopiert bare p\xc3\xa5 tidspunktet for opprettelsen.'
+b'DocType: Setup Progress Action',b'Domains',b'Domener'
+b'apps/erpnext/erpnext/projects/doctype/task/task.py +41',"b""'Actual Start Date' can not be greater than 'Actual End Date'""",b'&#39;Faktisk startdato&#39; ikke kan v\xc3\xa6re st\xc3\xb8rre enn &quot;Actual End Date &#39;'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +117',b'Management',b'Ledelse'
+b'DocType: Cheque Print Template',b'Payer Settings',b'Payer Innstillinger'
+b'DocType: Item Attribute Value',"b'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""'","b'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\xc3\xa6re &quot;T-SHIRT-SM&quot;'"
+b'DocType: Salary Slip',b'Net Pay (in words) will be visible once you save the Salary Slip.',b'Nettol\xc3\xb8nn (i ord) vil v\xc3\xa6re synlig n\xc3\xa5r du lagrer L\xc3\xb8nn Slip.'
+b'DocType: Purchase Invoice',b'Is Return',b'Er Return'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +92',b'Caution',b'Forsiktighet'
+b'apps/erpnext/erpnext/agriculture/doctype/disease/disease.py +17',"b""Start day is greater than end day in task '{0}'""",b'Startdagen er st\xc3\xb8rre enn sluttdagen i oppgaven &#39;{0}&#39;'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +815',b'Return / Debit Note',b'Retur / debitnota'
+b'DocType: Price List Country',b'Price List Country',b'Prisliste Land'
+b'DocType: Item',b'UOMs',b'UOMs'
+b'apps/erpnext/erpnext/stock/utils.py +212',b'{0} valid serial nos for Item {1}',b'{0} gyldig serie nos for Element {1}'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +57',b'Item Code cannot be changed for Serial No.',b'Elementkode kan ikke endres for Serial No.'
+b'DocType: Purchase Invoice Item',b'UOM Conversion Factor',b'M\xc3\xa5lenheter Omregningsfaktor'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +40',b'Please enter Item Code to get Batch Number',b'Fyll inn Element kode for \xc3\xa5 f\xc3\xa5 Batch Number'
+b'DocType: Stock Settings',b'Default Item Group',b'Standard varegruppe'
+b'DocType: Employee Loan',b'Partially Disbursed',b'delvis Utbetalt'
+b'apps/erpnext/erpnext/config/non_profit.py +73',b'Grant information.',b'Gi informasjon.'
+b'apps/erpnext/erpnext/config/buying.py +38',b'Supplier database.',b'Leverand\xc3\xb8r database.'
+b'DocType: Account',b'Balance Sheet',b'Balanse'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +750',"b""Cost Center For Item with Item Code '""",b'Koste Center For Element med Element kode &#39;'
+b'DocType: Fee Validity',b'Valid Till',b'Gyldig til'
+b'DocType: Student Report Generation Tool',b'Total Parents Teacher Meeting',b'Totalt foreldres l\xc3\xa6rerm\xc3\xb8te'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +2516',"b'Payment Mode is not configured. Please check, whether account has been set on Mode of Payments or on POS Profile.'","b'Betaling Mode er ikke konfigurert. Kontroller, om kontoen er satt p\xc3\xa5 modus for betalinger eller p\xc3\xa5 POS-profil.'"
+b'apps/erpnext/erpnext/buying/utils.py +74',b'Same item cannot be entered multiple times.',b'Samme elementet kan ikke legges inn flere ganger.'
+b'apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +30',"b'Further accounts can be made under Groups, but entries can be made against non-Groups'","b'Ytterligere kontoer kan gj\xc3\xb8res under grupper, men oppf\xc3\xb8ringene kan gj\xc3\xb8res mot ikke-grupper'"
+b'DocType: Lead',b'Lead',b'Lead'
+b'DocType: Email Digest',b'Payables',b'Gjeld'
+b'DocType: Course',b'Course Intro',b'kurs Intro'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +105',b'Stock Entry {0} created',b'Stock Entry {0} er opprettet'
+b'apps/erpnext/erpnext/controllers/buying_controller.py +306',b'Row #{0}: Rejected Qty can not be entered in Purchase Return',b'Row # {0}: Avvist Antall kan ikke legges inn i innkj\xc3\xb8psliste'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +182',b'Changing Customer Group for the selected Customer is not allowed.',b'Endring av kundegruppe for den valgte kunden er ikke tillatt.'
+,b'Purchase Order Items To Be Billed',b'Purchase Order Elementer som skal faktureres'
+b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +63',b'Updating estimated arrival times.',b'Oppdaterer estimerte ankomsttider.'
+b'DocType: Program Enrollment Tool',b'Enrollment Details',b'Registreringsdetaljer'
+b'DocType: Purchase Invoice Item',b'Net Rate',b'Net Rate'
+b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +152',b'Please select a customer',b'Vennligst velg en kunde'
+b'DocType: Purchase Invoice Item',b'Purchase Invoice Item',b'Fakturaen Element'
+b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +58',b'Stock Ledger Entries and GL Entries are reposted for the selected Purchase Receipts',b'Arkiv Ledger Oppf\xc3\xb8ringer og GL Oppf\xc3\xb8ringer repostes for de valgte Kj\xc3\xb8ps Receipts'
+b'DocType: Student Report Generation Tool',b'Assessment Terms',b'Vurderingsbetingelser'
+b'apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +8',b'Item 1',b'Sak 1'
+b'DocType: Holiday',b'Holiday',b'Ferie'
+b'DocType: Support Settings',b'Close Issue After Days',b'Lukk Issue Etter dager'
+b'DocType: Leave Control Panel',b'Leave blank if considered for all branches',b'La st\xc3\xa5 tom hvis vurderes for alle grener'
+b'DocType: Bank Guarantee',b'Validity in Days',b'Gyldighet i dager'
+b'DocType: Bank Guarantee',b'Validity in Days',b'Gyldighet i dager'
+b'apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +21',b'C-form is not applicable for Invoice: {0}',b'C-skjemaet er ikke aktuelt for faktura: {0}'
+b'DocType: Payment Reconciliation',b'Unreconciled Payment Details',b'Avstemte Betalingsopplysninger'
+b'apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py +6',b'Member Activity',b'Medlemsaktivitet'
+b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +20',b'Order Count',b'Ordre Count'
+b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +20',b'Order Count',b'Ordre Count'
+b'DocType: Global Defaults',b'Current Fiscal Year',b'V\xc3\xa6rende regnskaps\xc3\xa5r'
+b'DocType: Purchase Order',b'Group same items',b'Gruppe samme elementene'
+b'DocType: Purchase Invoice',b'Disable Rounded Total',b'Deaktiver Avrundet Total'
+b'DocType: Employee Loan Application',b'Repayment Info',b'tilbakebetaling info'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +448',"b""'Entries' cannot be empty""",b'&#39;Innlegg&#39; kan ikke v\xc3\xa6re tomt'
+b'DocType: Maintenance Team Member',b'Maintenance Role',b'Vedlikeholdsrolle'
+b'apps/erpnext/erpnext/utilities/transaction_base.py +92',b'Duplicate row {0} with same {1}',b'Duplicate rad {0} med samme {1}'
+,b'Trial Balance',b'Balanse Trial'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +443',b'Fiscal Year {0} not found',b'Regnskaps\xc3\xa5ret {0} ikke funnet'
+b'apps/erpnext/erpnext/config/hr.py +309',b'Setting up Employees',b'Sette opp ansatte'
+b'DocType: Sales Order',b'SO-',b'S\xc3\x85-'
+b'DocType: Hotel Room Reservation',b'Hotel Reservation User',b'Hotel Reservation Bruker'
+b'apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +158',b'Please select prefix first',b'Vennligst velg f\xc3\xb8rst prefiks'
+b'DocType: Student',b'O-',b'O-'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +189',b'Research',b'Forskning'
+b'DocType: Maintenance Visit Purpose',b'Work Done',b'Arbeidet Som Er Gjort'
+b'apps/erpnext/erpnext/controllers/item_variant.py +35',b'Please specify at least one attribute in the Attributes table',b'Vennligst oppgi minst ett attributt i Attributter tabellen'
+b'DocType: Announcement',b'All Students',b'alle studenter'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +45',b'Item {0} must be a non-stock item',b'Element {0} m\xc3\xa5 v\xc3\xa6re et ikke-lagervare'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +18',b'View Ledger',b'Vis Ledger'
+b'DocType: Grading Scale',b'Intervals',b'intervaller'
+b'apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41',b'Earliest',b'Tidligste'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +526',"b'An Item Group exists with same name, please change the item name or rename the item group'","b'En varegruppe eksisterer med samme navn, m\xc3\xa5 du endre elementnavnet eller endre navn varegruppen'"
+b'DocType: Crop Cycle',b'Less than a year',b'Mindre enn et \xc3\xa5r'
+b'apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py +52',b'Student Mobile No.',b'Student Mobile No.'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/defaults_setup.py +105',b'Rest Of The World',b'Resten Av Verden'
+b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +81',b'The Item {0} cannot have Batch',b'Element {0} kan ikke ha Batch'
+b'DocType: Crop',b'Yield UOM',b'Utbytte UOM'
+,b'Budget Variance Report',b'Budsjett Avvik Rapporter'
+b'DocType: Salary Slip',b'Gross Pay',b'Brutto L\xc3\xb8nn'
+b'DocType: Item',b'Is Item from Hub',b'Er element fra nav'
+b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +118',b'Row {0}: Activity Type is mandatory.',b'Rad {0}: Aktivitetstype er obligatorisk.'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +166',b'Dividends Paid',b'Utbytte betalt'
+b'apps/erpnext/erpnext/buying/doctype/supplier/supplier.js +36',b'Accounting Ledger',b'Regnskap Ledger'
+b'DocType: Stock Reconciliation',b'Difference Amount',b'Forskjellen Bel\xc3\xb8p'
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +107',b'Dr {0} on Leave on {1}',b'Dr {0} p\xc3\xa5 permisjon p\xc3\xa5 {1}'
+b'DocType: Purchase Invoice',b'Reverse Charge',b'Omvendt ladning'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +172',b'Retained Earnings',b'Opptjent egenkapital'
+b'DocType: Purchase Invoice',b'05-Change in POS',b'05-Endring i POS'
+b'DocType: Vehicle Log',b'Service Detail',b'tjenesten Detalj'
+b'DocType: BOM',b'Item Description',b'Element Beskrivelse'
+b'DocType: Student Sibling',b'Student Sibling',b'student S\xc3\xb8sken'
+b'apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py +18',b'Payment Mode',b'Betaling Mode'
+b'DocType: Purchase Invoice',b'Supplied Items',b'Leveringen'
+b'apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +85',b'Please set an active menu for Restaurant {0}',b'Vennligst sett inn en aktiv meny for Restaurant {0}'
+b'DocType: Student',b'STUD.',b'STUD.'
+b'DocType: Work Order',b'Qty To Manufacture',b'Antall \xc3\xa5 produsere'
+b'DocType: Email Digest',b'New Income',b'New Inntekt'
+b'DocType: Buying Settings',b'Maintain same rate throughout purchase cycle',b'Opprettholde samme tempo gjennom hele kj\xc3\xb8pssyklusen'
+b'DocType: Opportunity Item',b'Opportunity Item',b'Opportunity Element'
+,b'Student and Guardian Contact Details',b'Student og Guardian Kontaktdetaljer'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +53',b'Row {0}: For supplier {0} Email Address is required to send email',b'Rad {0}: For Leverand\xc3\xb8ren p\xc3\xa5legges {0} e-postadresse for \xc3\xa5 sende e-post'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +72',b'Temporary Opening',b'Midlertidig \xc3\x85pning'
+b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +10',b'View Hub',b'Se Hub'
+,b'Employee Leave Balance',b'Ansatt La Balance'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +147',b'Balance for Account {0} must always be {1}',b'Balanse for konto {0} m\xc3\xa5 alltid v\xc3\xa6re {1}'
+b'DocType: Patient Appointment',b'More Info',b'Mer Info'
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +180',b'Valuation Rate required for Item in row {0}',b'Verdsettelse Rate kreves for varen i rad {0}'
+b'DocType: Supplier Scorecard',b'Scorecard Actions',b'Scorecard Actions'
+b'apps/erpnext/erpnext/utilities/user_progress.py +169',b'Example: Masters in Computer Science',b'Eksempel: Masters i informatikk'
+b'DocType: Purchase Invoice',b'Rejected Warehouse',b'Avvist Warehouse'
+b'DocType: GL Entry',b'Against Voucher',b'Mot Voucher'
+b'DocType: Item',b'Default Buying Cost Center',b'Standard Kj\xc3\xb8pe kostnadssted'
+b'apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +6',"b'To get the best out of ERPNext, we recommend that you take some time and watch these help videos.'","b'For \xc3\xa5 f\xc3\xa5 det beste ut av ERPNext, anbefaler vi at du tar litt tid og se p\xc3\xa5 disse hjelpevideoer.'"
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +76',b' to ',b'til'
+b'DocType: Supplier Quotation Item',b'Lead Time in days',b'Lead Tid i dager'
+b'apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +70',b'Accounts Payable Summary',b'Leverand\xc3\xb8rgjeld Sammendrag'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +326',b'Payment of salary from {0} to {1}',b'Utbetaling av l\xc3\xb8nn fra {0} til {1}'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +213',b'Not authorized to edit frozen Account {0}',b'Ikke autorisert til \xc3\xa5 redigere fryst kontoen {0}'
+b'DocType: Journal Entry',b'Get Outstanding Invoices',b'F\xc3\xa5 utest\xc3\xa5ende fakturaer'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +84',b'Sales Order {0} is not valid',b'Salgsordre {0} er ikke gyldig'
+b'DocType: Supplier Scorecard',b'Warn for new Request for Quotations',b'Varsle om ny foresp\xc3\xb8rsel om tilbud'
+b'apps/erpnext/erpnext/utilities/activation.py +91',b'Purchase orders help you plan and follow up on your purchases',b'Innkj\xc3\xb8psordrer hjelpe deg \xc3\xa5 planlegge og f\xc3\xb8lge opp kj\xc3\xb8pene'
+b'apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +151',b'Lab Test Prescriptions',b'Lab Test Prescriptions'
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +166',b'The total Issue / Transfer quantity {0} in Material Request {1}  \\\n\t\t\t\t\t\t\tcannot be greater than requested quantity {2} for Item {3}',b'Den totale Issue / Transfer mengde {0} i Material Request {1} \\ kan ikke v\xc3\xa6re st\xc3\xb8rre enn \xc3\xb8nsket antall {2} for Element {3}'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +197',b'Small',b'Liten'
+b'DocType: Opening Invoice Creation Tool Item',b'Opening Invoice Creation Tool Item',b'\xc3\x85pning av fakturaopprettingsverkt\xc3\xb8yet'
+b'DocType: Education Settings',b'Employee Number',b'Ansatt Number'
+b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +67',b'Case No(s) already in use. Try from Case No {0}',b'Tilfellet Nei (e) allerede er i bruk. Pr\xc3\xb8v fra sak nr {0}'
+b'DocType: Project',b'% Completed',b'% Fullf\xc3\xb8rt'
+,b'Invoiced Amount (Exculsive Tax)',b'Fakturert bel\xc3\xb8p (exculsive Tax)'
+b'apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +14',b'Item 2',b'Sak 2'
+b'DocType: Supplier',b'SUPP-',b'leve-'
+b'DocType: Training Event',b'Training Event',b'trening Hendelses'
+b'DocType: Item',b'Auto re-order',b'Auto re-order'
+b'apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.py +59',b'Total Achieved',b'Oppn\xc3\xa5dd Total'
+b'DocType: Employee',b'Place of Issue',b'Utstedelsessted'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +101',b'Contract',b'Kontrakts'
+b'DocType: Plant Analysis',b'Laboratory Testing Datetime',b'Laboratorietesting Datetime'
+b'DocType: Email Digest',b'Add Quote',b'Legg Sitat'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +987',b'UOM coversion factor required for UOM: {0} in Item: {1}',b'M\xc3\xa5lenheter coversion faktor n\xc3\xb8dvendig for m\xc3\xa5lenheter: {0} i Sak: {1}'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +92',b'Indirect Expenses',b'Indirekte kostnader'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +98',b'Row {0}: Qty is mandatory',b'Rad {0}: Antall er obligatorisk'
+b'DocType: Agriculture Analysis Criteria',b'Agriculture',b'Landbruk'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +794',b'Sync Master Data',b'Sync Master Data'
+b'DocType: Asset Repair',b'Repair Cost',b'Reparasjonskostnad'
+b'apps/erpnext/erpnext/utilities/user_progress.py +138',b'Your Products or Services',b'Dine produkter eller tjenester'
+b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +15',b'Failed to login',b'Kunne ikke logge inn'
+b'DocType: Special Test Items',b'Special Test Items',b'Spesielle testelementer'
+b'DocType: Mode of Payment',b'Mode of Payment',b'Modus for betaling'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +202',b'Website Image should be a public file or website URL',b'Website Bilde b\xc3\xb8r v\xc3\xa6re en offentlig fil eller nettside URL'
+b'DocType: Student Applicant',b'AP',b'AP'
+b'DocType: Purchase Invoice Item',b'BOM',b'BOM'
+b'apps/erpnext/erpnext/setup/doctype/item_group/item_group.js +37',b'This is a root item group and cannot be edited.',b'Dette er en rot varegruppe og kan ikke redigeres.'
+b'DocType: Journal Entry Account',b'Purchase Order',b'Bestilling'
+b'DocType: Vehicle',b'Fuel UOM',b'drivstoff m\xc3\xa5lenheter'
+b'DocType: Warehouse',b'Warehouse Contact Info',b'Warehouse Kontaktinfo'
+b'DocType: Payment Entry',b'Write Off Difference Amount',b'Skriv Off differansebel\xc3\xb8pet'
+b'DocType: Volunteer',b'Volunteer Name',b'Frivillig navn'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +434',"b'{0}: Employee email not found, hence email not sent'","b'{0}: Ansattes e-post ikke funnet, derav e-posten ikke sendt'"
+b'apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +85',b'Shipping rule not applicable for country {0}',b'Fraktregel gjelder ikke for land {0}'
+b'DocType: Item',b'Foreign Trade Details',b'Foreign Trade Detaljer'
+,b'Assessment Plan Status',b'Evalueringsplan Status'
+b'DocType: Email Digest',b'Annual Income',b'\xc3\x85rsinntekt'
+b'DocType: Serial No',b'Serial No Details',b'Serie ingen opplysninger'
+b'DocType: Purchase Invoice Item',b'Item Tax Rate',b'Sak Skattesats'
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +89',b'Please select Physician and Date',b'Vennligst velg Leger og dato'
+b'DocType: Student Group Student',b'Group Roll Number',b'Gruppe-nummer'
+b'DocType: Student Group Student',b'Group Roll Number',b'Gruppe-nummer'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +145',"b'For {0}, only credit accounts can be linked against another debit entry'",b'For {0} kan bare kredittkontoer kobles mot en annen belastning oppf\xc3\xb8ring'
+b'apps/erpnext/erpnext/projects/doctype/project/project.py +84',b'Total of all task weights should be 1. Please adjust weights of all Project tasks accordingly',b'Summen av alle oppgave vekter b\xc3\xb8r v\xc3\xa6re 1. Juster vekter av alle prosjektoppgaver tilsvar'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +588',b'Delivery Note {0} is not submitted',b'Levering Note {0} er ikke innsendt'
+b'apps/erpnext/erpnext/stock/get_item_details.py +148',b'Item {0} must be a Sub-contracted Item',b'Elementet {0} m\xc3\xa5 v\xc3\xa6re en underleverand\xc3\xb8r Element'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +43',b'Capital Equipments',b'Capital Equipments'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +33',"b""Pricing Rule is first selected based on 'Apply On' field, which can be Item, Item Group or Brand.""","b'Prising Rule f\xc3\xb8rst valgt basert p\xc3\xa5 &quot;Apply On-feltet, som kan v\xc3\xa6re varen, varegruppe eller Brand.'"
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +246',b'Please set the Item Code first',b'Vennligst sett inn varenummeret f\xc3\xb8rst'
+b'DocType: Item',b'ITEM-',b'PUNKT-'
+b'apps/erpnext/erpnext/controllers/selling_controller.py +123',b'Total allocated percentage for sales team should be 100',b'Totalt bevilget prosent for salgsteam skal v\xc3\xa6re 100'
+b'DocType: Sales Invoice Item',b'Edit Description',b'Rediger Beskrivelse'
+b'DocType: Antibiotic',b'Antibiotic',b'Antibiotika'
+,b'Team Updates',b'laget Oppdateringer'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +912',b'For Supplier',b'For Leverand\xc3\xb8r'
+b'DocType: Account',b'Setting Account Type helps in selecting this Account in transactions.',b'Stille Kontotype hjelper i \xc3\xa5 velge denne kontoen i transaksjoner.'
+b'DocType: Purchase Invoice',b'Grand Total (Company Currency)',b'Grand Total (Selskap Valuta)'
+b'apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +9',b'Create Print Format',b'Opprett Print Format'
+b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +5',b'Fee Created',b'Avgift er opprettet'
+b'apps/erpnext/erpnext/utilities/bot.py +39',b'Did not find any item called {0}',b'Fant ikke noe element som heter {0}'
+b'DocType: Supplier Scorecard Criteria',b'Criteria Formula',b'Kriterier Formel'
+b'apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41',b'Total Outgoing',b'Total Utg\xc3\xa5ende'
+b'apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +39',"b'There can only be one Shipping Rule Condition with 0 or blank value for ""To Value""'",b'Det kan bare v\xc3\xa6re \xc3\xa9n Shipping Rule Forhold med 0 eller blank verdi for &quot;\xc3\xa5 verd&quot;'
+b'DocType: Authorization Rule',b'Transaction',b'Transaksjons'
+b'DocType: Patient Appointment',b'Duration',b'Varighet'
+b'apps/erpnext/erpnext/controllers/status_updater.py +160',"b'For an item {0}, quantity must be positive number'",b'For et element {0} m\xc3\xa5 mengden v\xc3\xa6re positivt tall'
+b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +27',b'Note: This Cost Center is a Group. Cannot make accounting entries against groups.',b'Merk: Denne Cost Center er en gruppe. Kan ikke gj\xc3\xb8re regnskapspostene mot grupper.'
+b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +53',b'Child warehouse exists for this warehouse. You can not delete this warehouse.',b'Barn lager finnes for dette lageret. Du kan ikke slette dette lageret.'
+b'DocType: Item',b'Website Item Groups',b'Website varegrupper'
+b'DocType: Purchase Invoice',b'Total (Company Currency)',b'Total (Company Valuta)'
+b'DocType: Daily Work Summary Group',b'Reminder',b'p\xc3\xa5minnelse'
+b'apps/erpnext/erpnext/stock/utils.py +207',b'Serial number {0} entered more than once',b'Serienummer {0} angitt mer enn \xc3\xa9n gang'
+b'DocType: Journal Entry',b'Journal Entry',b'Journal Entry'
+b'DocType: Expense Claim Advance',b'Unclaimed amount',b'Uoppfordret bel\xc3\xb8p'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +148',b'{0} items in progress',b'{0} elementer i fremgang'
+b'DocType: Workstation',b'Workstation Name',b'Arbeidsstasjon Name'
+b'DocType: Grading Scale Interval',b'Grade Code',b'grade Kode'
+b'DocType: POS Item Group',b'POS Item Group',b'POS Varegruppe'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +17',b'Email Digest:',b'E-post Digest:'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +613',b'BOM {0} does not belong to Item {1}',b'BOM {0} tilh\xc3\xb8rer ikke Element {1}'
+b'DocType: Sales Partner',b'Target Distribution',b'Target Distribution'
+b'DocType: Purchase Invoice',b'06-Finalization of Provisional assessment',b'06-Finalisering av forel\xc3\xb8pig vurdering'
+b'DocType: Salary Slip',b'Bank Account No.',b'Bank Account No.'
+b'DocType: Naming Series',b'This is the number of the last created transaction with this prefix',b'Dette er nummeret p\xc3\xa5 den siste laget transaksjonen med dette prefikset'
+b'DocType: Supplier Scorecard',"b'Scorecard variables can be used, as well as:\n{total_score} (the total score from that period),\n{period_number} (the number of periods to present day)\n'","b'Scorecard-variabler kan brukes, s\xc3\xa5 vel som: {total_score} (totalpoengsummen fra den perioden), {period_number} (antall perioder i dag)'"
+b'DocType: Quality Inspection Reading',b'Reading 8',b'Reading 8'
+b'DocType: Sales Partner',b'Agent',b'Agent'
+b'DocType: Purchase Invoice',b'Taxes and Charges Calculation',b'Skatter og avgifter Beregning'
+b'DocType: Accounts Settings',b'Book Asset Depreciation Entry Automatically',b'Bokf\xc3\xb8ring av aktivavskrivninger automatisk'
+b'DocType: Accounts Settings',b'Book Asset Depreciation Entry Automatically',b'Bokf\xc3\xb8ring av aktivavskrivninger automatisk'
+b'DocType: BOM Operation',b'Workstation',b'Arbeidsstasjon'
+b'DocType: Request for Quotation Supplier',b'Request for Quotation Supplier',b'Foresp\xc3\xb8rsel om prisanslag Leverand\xc3\xb8r'
+b'DocType: Healthcare Settings',b'Registration Message',b'Registreringsmelding'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +154',b'Hardware',b'Hardware'
+b'DocType: Prescription Dosage',b'Prescription Dosage',b'Reseptdosering'
+b'DocType: Attendance',b'HR Manager',b'HR Manager'
+b'apps/erpnext/erpnext/accounts/party.py +175',b'Please select a Company',b'Vennligst velg et selskap'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +92',b'Privilege Leave',b'Privilege La'
+b'DocType: Purchase Invoice',b'Supplier Invoice Date',b'Leverand\xc3\xb8r Fakturadato'
+b'DocType: Asset Settings',b'This value is used for pro-rata temporis calculation',b'Denne verdien brukes til pro rata temporis beregning'
+b'apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +90',b'You need to enable Shopping Cart',b'Du m\xc3\xa5 aktivere Handlevogn'
+b'DocType: Payment Entry',b'Writeoff',b'writeoff'
+b'DocType: Stock Settings',b'Naming Series Prefix',b'Naming Series Prefix'
+b'DocType: Appraisal Template Goal',b'Appraisal Template Goal',b'Appraisal Mal Goal'
+b'DocType: Salary Component',b'Earning',b'Tjene'
+b'DocType: Supplier Scorecard',b'Scoring Criteria',b'Scoringskriterier'
+b'DocType: Purchase Invoice',b'Party Account Currency',b'Partiet konto Valuta'
+,b'BOM Browser',b'BOM Nettleser'
+b'apps/erpnext/erpnext/templates/emails/training_event.html +13',b'Please update your status for this training event',b'Vennligst oppdatere statusen din for denne treningshendelsen'
+b'DocType: Item Barcode',b'EAN',b'EAN'
+b'DocType: Purchase Taxes and Charges',b'Add or Deduct',b'Legge til eller trekke fra'
+b'apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +148',b'Overlapping conditions found between:',b'Overlappende vilk\xc3\xa5r funnet mellom:'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +187',b'Against Journal Entry {0} is already adjusted against some other voucher',b'Mot Journal Entry {0} er allerede justert mot en annen kupong'
+b'apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +68',b'Total Order Value',b'Total ordreverdi'
+b'apps/erpnext/erpnext/demo/setup/setup_data.py +328',b'Food',b'Mat'
+b'apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +57',b'Ageing Range 3',b'Aldring Range 3'
+b'DocType: Maintenance Schedule Item',b'No of Visits',b'Ingen av bes\xc3\xb8k'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +165',b'Maintenance Schedule {0} exists against {1}',b'Vedlikeholdsplan {0} eksisterer mot {1}'
+b'apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +36',b'Enrolling student',b'p\xc3\xa5melding student'
+b'apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +33',b'Currency of the Closing Account must be {0}',b'Valuta if\xc3\xb8lge kursen konto m\xc3\xa5 v\xc3\xa6re {0}'
+b'apps/erpnext/erpnext/hr/doctype/appraisal_template/appraisal_template.py +21',b'Sum of points for all goals should be 100. It is {0}',b'Summen av poeng for alle m\xc3\xa5l b\xc3\xb8r v\xc3\xa6re 100. Det er {0}'
+b'DocType: Project',b'Start and End Dates',b'Start- og sluttdato'
+,b'Delivered Items To Be Billed',b'Leverte varer til \xc3\xa5 bli fakturert'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html +16',b'Open BOM {0}',b'\xc3\x85pen BOM {0}'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +60',b'Warehouse cannot be changed for Serial No.',b'Warehouse kan ikke endres for Serial No.'
+b'DocType: Authorization Rule',b'Average Discount',b'Gjennomsnittlig Rabatt'
+b'DocType: Project Update',b'Great/Quickly',b'Great / raskt'
+b'DocType: Purchase Invoice Item',b'UOM',b'm\xc3\xa5lenheter'
+b'DocType: Rename Tool',b'Utilities',b'Verkt\xc3\xb8y'
+b'DocType: POS Profile',b'Accounting',b'Regnskap'
+b'DocType: Employee',b'EMP/',b'EMP /'
+b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +133',b'Please select batches for batched item ',b'Vennligst velg batch for batched item'
+b'DocType: Asset',b'Depreciation Schedules',b'avskrivninger tidsplaner'
+b'apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py +192',b'Following accounts might be selected in GST Settings:',b'F\xc3\xb8lgende kontoer kan velges i GST-innstillinger:'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +70',b'Application period cannot be outside leave allocation period',b'Tegningsperioden kan ikke v\xc3\xa6re utenfor permisjon tildeling periode'
+b'DocType: Activity Cost',b'Projects',b'Prosjekter'
+b'DocType: Payment Request',b'Transaction Currency',b'transaksjonsvaluta'
+b'apps/erpnext/erpnext/controllers/buying_controller.py +30',b'From {0} | {1} {2}',b'Fra {0} | {1} {2}'
+b'DocType: Work Order Operation',b'Operation Description',b'Operasjon Beskrivelse'
+b'apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +34',b'Cannot change Fiscal Year Start Date and Fiscal Year End Date once the Fiscal Year is saved.',b'Kan ikke endre regnskaps\xc3\xa5ret Startdato og regnskaps\xc3\xa5r sluttdato n\xc3\xa5r regnskaps\xc3\xa5ret er lagret.'
+b'DocType: Quotation',b'Shopping Cart',b'Handlevogn'
+b'apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41',b'Avg Daily Outgoing',b'Gjennomsnittlig Daily Utg\xc3\xa5ende'
+b'DocType: POS Profile',b'Campaign',b'Kampanje'
+b'DocType: Supplier',b'Name and Type',b'Navn og Type'
+b'DocType: Physician',b'Contacts and Address',b'Kontakter og adresse'
+b'DocType: Purchase Invoice',b'Contact Person',b'Kontaktperson'
+b'apps/erpnext/erpnext/projects/doctype/task/task.py +38',"b""'Expected Start Date' can not be greater than 'Expected End Date'""",b'&#39;Tiltredelse&#39; ikke kan v\xc3\xa6re st\xc3\xb8rre enn &quot;Forventet sluttdato'
+b'DocType: Course Scheduling Tool',b'Course End Date',b'Kurs Sluttdato'
+b'DocType: Holiday List',b'Holidays',b'Ferier'
+b'DocType: Sales Order Item',b'Planned Quantity',b'Planlagt Antall'
+b'DocType: Purchase Invoice Item',b'Item Tax Amount',b'Sak Skattebel\xc3\xb8p'
+b'DocType: Water Analysis',b'Water Analysis Criteria',b'Vannanalysekriterier'
+b'DocType: Item',b'Maintain Stock',b'Oppretthold Stock'
+b'DocType: Employee',b'Prefered Email',b'foretrukne e-post'
+b'DocType: Student Admission',b'Eligibility and Details',b'Kvalifisering og detaljer'
+b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +38',b'Net Change in Fixed Asset',b'Netto endring i Fixed Asset'
+b'DocType: Leave Control Panel',b'Leave blank if considered for all designations',b'La st\xc3\xa5 tom hvis vurderes for alle betegnelser'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +806',"b""Charge of type 'Actual' in row {0} cannot be included in Item Rate""",b'Charge of type &#39;Actual&#39; i rad {0} kan ikke inkluderes i Element Ranger'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +382',b'Max: {0}',b'Max: {0}'
+b'apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py +24',b'From Datetime',b'Fra Datetime'
+b'DocType: Email Digest',b'For Company',b'For selskapet'
+b'apps/erpnext/erpnext/config/support.py +17',b'Communication log.',b'Kommunikasjonsloggen.'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +195',"b'Request for Quotation is disabled to access from portal, for more check portal settings.'",b'Foresp\xc3\xb8rsel om prisanslag er deaktivert tilgang fra portal for flere sjekkportalinnstillingene.'
+b'DocType: Supplier Scorecard Scoring Variable',b'Supplier Scorecard Scoring Variable',b'Leverand\xc3\xb8r Scorecard Scoring Variable'
+b'apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +72',b'Buying Amount',b'Kj\xc3\xb8pe Bel\xc3\xb8p'
+b'DocType: Sales Invoice',b'Shipping Address Name',b'Leveringsadresse Navn'
+b'DocType: Material Request',b'Terms and Conditions Content',b'Betingelser innhold'
+b'apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +18',b'There were errors creating Course Schedule',b'Det var feil \xc3\xa5 opprette kursplan'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +581',b'cannot be greater than 100',b'kan ikke v\xc3\xa6re st\xc3\xb8rre enn 100'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +752',b'Item {0} is not a stock Item',b'Element {0} er ikke en lagervare'
+b'DocType: Maintenance Visit',b'Unscheduled',b'Ikke planlagt'
+b'DocType: Employee',b'Owned',b'Eies'
+b'DocType: Salary Detail',b'Depends on Leave Without Pay',b'Avhenger La Uten Pay'
+b'DocType: Pricing Rule',"b'Higher the number, higher the priority'","b'H\xc3\xb8yere tallet er, h\xc3\xb8yere prioritet'"
+,b'Purchase Invoice Trends',b'Fakturaen Trender'
+b'DocType: Employee',b'Better Prospects',b'Bedre utsikter'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.py +217',"b'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'",b'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 \xc3\xa5 levere / utf\xc3\xb8re fra flere batcher'
+b'DocType: Vehicle',b'License Plate',b'Bilskilt'
+b'DocType: Appraisal',b'Goals',b'M\xc3\xa5l'
+b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +353',b'Select POS Profile',b'Velg POS-profil'
+b'DocType: Warranty Claim',b'Warranty / AMC Status',b'Garanti / AMC Status'
+,b'Accounts Browser',b'Kontoer Browser'
+b'DocType: Payment Entry Reference',b'Payment Entry Reference',b'Betaling Entry Reference'
+b'DocType: GL Entry',b'GL Entry',b'GL Entry'
+b'DocType: HR Settings',b'Employee Settings',b'Medarbeider Innstillinger'
+,b'Batch-Wise Balance History',b'Batch-Wise Balance Historie'
+b'apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +73',b'Print settings updated in respective print format',b'Utskriftsinnstillingene oppdatert i respektive utskriftsformat'
+b'DocType: Package Code',b'Package Code',b'pakke kode'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +105',b'Apprentice',b'L\xc3\xa6rling'
+b'DocType: Purchase Invoice',b'Company GSTIN',b'Firma GSTIN'
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +105',b'Negative Quantity is not allowed',b'Negative Antall er ikke tillatt'
+b'DocType: Purchase Invoice Item',b'Tax detail table fetched from item master as a string and stored in this field.\nUsed for Taxes and Charges',"b'Tax detalj tabell hentet fra elementet Hoved som en streng, og som er lagret p\xc3\xa5 dette feltet. Brukes for skatter og avgifter'"
+b'DocType: Supplier Scorecard Period',b'SSC-',b'SSC-'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +159',b'Employee cannot report to himself.',b'Arbeidstaker kan ikke rapportere til seg selv.'
+b'DocType: Account',"b'If the account is frozen, entries are allowed to restricted users.'","b'Hvis kontoen er fryst, er oppf\xc3\xb8ringer lov til begrensede brukere.'"
+b'DocType: Email Digest',b'Bank Balance',b'Bank Balanse'
+b'apps/erpnext/erpnext/accounts/party.py +240',b'Accounting Entry for {0}: {1} can only be made in currency: {2}',b'Regnskap Entry for {0}: {1} kan bare gj\xc3\xb8res i valuta: {2}'
+b'DocType: Job Opening',"b'Job profile, qualifications required etc.'","b'Jobb profil, kvalifikasjoner som kreves etc.'"
+b'DocType: Journal Entry Account',b'Account Balance',b'Saldo'
+b'apps/erpnext/erpnext/config/accounts.py +183',b'Tax Rule for transactions.',b'Skatteregel for transaksjoner.'
+b'DocType: Rename Tool',b'Type of document to rename.',b'Type dokument for \xc3\xa5 endre navn.'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +53',b'{0} {1}: Customer is required against Receivable account {2}',b'{0} {1}: Kunden er n\xc3\xb8dvendig mot fordringer kontoen {2}'
+b'DocType: Purchase Invoice',b'Total Taxes and Charges (Company Currency)',b'Totale skatter og avgifter (Selskapet valuta)'
+b'DocType: Weather',b'Weather Parameter',b'V\xc3\xa6rparameter'
+b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +60',"b""Show unclosed fiscal year's P&L balances""",b'Vis unclosed regnskaps\xc3\xa5rets P &amp; L balanserer'
+b'DocType: Lab Test Template',b'Collection Details',b'Samlingsdetaljer'
+b'DocType: POS Profile',b'Allow Print Before Pay',b'Tillat utskrift f\xc3\xb8r betaling'
+b'DocType: Land Unit',b'Linked Soil Texture',b'Koblet jordstruktur'
+b'DocType: Shipping Rule',b'Shipping Account',b'Shipping konto'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +92',b'{0} {1}: Account {2} is inactive',b'{0} {1}: Account {2} er inaktiv'
+b'apps/erpnext/erpnext/utilities/activation.py +82',b'Make Sales Orders to help you plan your work and deliver on-time',b'Gj\xc3\xb8r salgsordrer for \xc3\xa5 hjelpe deg med \xc3\xa5 planlegge arbeidet ditt og levere i tide'
+b'DocType: Quality Inspection',b'Readings',b'Readings'
+b'DocType: Stock Entry',b'Total Additional Costs',b'Samlede merkostnader'
+b'DocType: Course Schedule',b'SH',b'SH'
+b'DocType: BOM',b'Scrap Material Cost(Company Currency)',b'Skrap Material Cost (Selskap Valuta)'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +66',b'Sub Assemblies',b'Sub Assemblies'
+b'DocType: Asset',b'Asset Name',b'Asset Name'
+b'DocType: Project',b'Task Weight',b'Task Vekt'
+b'DocType: Shipping Rule Condition',b'To Value',b'I Value'
+b'DocType: Asset Movement',b'Stock Manager',b'Stock manager'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +171',b'Source warehouse is mandatory for row {0}',b'Kilde lageret er obligatorisk for rad {0}'
+b'apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +38',b'The Payment Term at row {0} is possibly a duplicate.',b'Betalingsperioden i rad {0} er muligens en duplikat.'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +30',b'Agriculture (beta)',b'Jordbruk (beta)'
+b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +863',b'Packing Slip',b'Pakkseddel'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +110',b'Office Rent',b'Kontor Leie'
+b'apps/erpnext/erpnext/config/setup.py +111',b'Setup SMS gateway settings',b'Oppsett SMS gateway-innstillinger'
+b'DocType: Disease',b'Common Name',b'Vanlig navn'
+b'apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +61',b'Import Failed!',b'Import mislyktes!'
+b'apps/erpnext/erpnext/public/js/templates/address_list.html +20',b'No address added yet.',b'Ingen adresse er lagt til enn\xc3\xa5.'
+b'DocType: Workstation Working Hour',b'Workstation Working Hour',b'Arbeidsstasjon Working Hour'
+b'DocType: Vital Signs',b'Blood Pressure',b'Blodtrykk'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +125',b'Analyst',b'Analytiker'
+b'DocType: Item',b'Inventory',b'Inventar'
+b'DocType: Item',b'Sales Details',b'Salgs Detaljer'
+b'DocType: Quality Inspection',b'QI-',b'QI-'
+b'DocType: Opportunity',b'With Items',b'Med Items'
+b'DocType: Asset Maintenance',b'Maintenance Team',b'Vedlikeholdsteam'
+b'apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37',b'In Qty',b'I Antall'
+b'DocType: Education Settings',b'Validate Enrolled Course for Students in Student Group',b'Bekreft innmeldt kurs for studenter i studentgruppen'
+b'DocType: Notification Control',b'Expense Claim Rejected',b'Expense krav Avvist'
+b'DocType: Item',b'Item Attribute',b'Sak Egenskap'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +147',b'Government',b'Regjeringen'
+b'apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +40',b'Expense Claim {0} already exists for the Vehicle Log',b'Expense krav {0} finnes allerede for Vehicle Log'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +64',b'Institute Name',b'Institute Name'
+b'apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +117',b'Please enter repayment Amount',b'Fyll inn gjenv\xc3\xa6rende bel\xc3\xb8pet'
+b'apps/erpnext/erpnext/config/stock.py +309',b'Item Variants',b'Element Varianter'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +29',b'Services',b'Tjenester'
+b'DocType: HR Settings',b'Email Salary Slip to Employee',b'E-post L\xc3\xb8nn Slip til Employee'
+b'DocType: Cost Center',b'Parent Cost Center',b'Parent kostnadssted'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1041',b'Select Possible Supplier',b'Velg Mulig Leverand\xc3\xb8r'
+b'DocType: Sales Invoice',b'Source',b'Source'
+b'DocType: Customer',"b'Select, to make the customer searchable with these fields'","b'Velg, for \xc3\xa5 gj\xc3\xb8re kunden s\xc3\xb8kbar med disse feltene'"
+b'apps/erpnext/erpnext/templates/pages/projects.html +31',b'Show closed',b'Vis stengt'
+b'DocType: Leave Type',b'Is Leave Without Pay',b'Er permisjon uten Pay'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +261',b'Asset Category is mandatory for Fixed Asset item',b'Asset Kategori er obligatorisk for Fixed Asset element'
+b'DocType: Fee Validity',b'Fee Validity',b'Avgift Gyldighet'
+b'apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +146',b'No records found in the Payment table',b'Ingen poster ble funnet i Payment tabellen'
+b'apps/erpnext/erpnext/education/utils.py +19',b'This {0} conflicts with {1} for {2} {3}',b'Denne {0} konflikter med {1} for {2} {3}'
+b'DocType: Student Attendance Tool',b'Students HTML',b'studenter HTML'
+b'DocType: POS Profile',b'Apply Discount',b'Bruk rabatt'
+b'DocType: GST HSN Code',b'GST HSN Code',b'GST HSN-kode'
+b'DocType: Employee External Work History',b'Total Experience',b'Total Experience'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +70',b'Open Projects',b'\xc3\xa5pne Prosjekter'
+b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +295',b'Packing Slip(s) cancelled',b'Pakking Slip (s) kansellert'
+b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +36',b'Cash Flow from Investing',b'Kontantstr\xc3\xb8m fra investerings'
+b'DocType: Program Course',b'Program Course',b'program Course'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +99',b'Freight and Forwarding Charges',b'Spedisjons- og Kostnader'
+b'DocType: Homepage',b'Company Tagline for website homepage',b'Selskapet Undertittel for nettstedet hjemmeside'
+b'DocType: Item Group',b'Item Group Name',b'Sak Gruppenavn'
+b'apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py +27',b'Taken',b'Tatt'
+b'DocType: Student',b'Date of Leaving',b'Dato Leaving'
+b'DocType: Pricing Rule',b'For Price List',b'For Prisliste'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +27',b'Executive Search',b'Executive Search'
+b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +55',b'Setting defaults',b'Angir standardinnstillinger'
+b'apps/erpnext/erpnext/utilities/activation.py +63',b'Create Leads',b'Lag Leads'
+b'DocType: Maintenance Schedule',b'Schedules',b'Rutetider'
+b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +468',b'POS Profile is required to use Point-of-Sale',b'POS-profilen kreves for \xc3\xa5 bruke Point-of-Sale'
+b'DocType: Purchase Invoice Item',b'Net Amount',b'Nettobel\xc3\xb8p'
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +141',b'{0} {1} has not been submitted so the action cannot be completed',"b'{0} {1} er ikke sendt, s\xc3\xa5 handlingen kan ikke fullf\xc3\xb8res'"
+b'DocType: Purchase Order Item Supplied',b'BOM Detail No',b'BOM Detail Nei'
+b'DocType: Landed Cost Voucher',b'Additional Charges',b'Ekstra kostnader'
+b'DocType: Purchase Invoice',b'Additional Discount Amount (Company Currency)',b'Ekstra rabatt Bel\xc3\xb8p (Selskap Valuta)'
+b'DocType: Supplier Scorecard',b'Supplier Scorecard',b'Leverand\xc3\xb8r Scorecard'
+b'DocType: Plant Analysis',b'Result Datetime',b'Resultat Datetime'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.js +21',b'Please create new account from Chart of Accounts.',b'Opprett ny konto fra kontoplanen.'
+,b'Support Hour Distribution',b'Support Time Distribution'
+b'DocType: Maintenance Visit',b'Maintenance Visit',b'Vedlikehold Visit'
+b'DocType: Student',b'Leaving Certificate Number',b'Leaving Certificate Number'
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +58',"b'Appointment cancelled, Please review and cancel the invoice {0}'","b'Avtale avbrutt, vennligst kontroller og avbryt fakturaen {0}'"
+b'DocType: Sales Invoice Item',b'Available Batch Qty at Warehouse',b'Tilgjengelig Batch Antall p\xc3\xa5 Warehouse'
+b'apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +9',b'Update Print Format',b'Oppdater Print Format'
+b'DocType: Landed Cost Voucher',b'Landed Cost Help',b'Landed Cost Hjelp'
+b'DocType: Purchase Invoice',b'Select Shipping Address',b'Velg leveringsadresse'
+b'apps/erpnext/erpnext/config/non_profit.py +28',b'Memebership Details',b'Memebership Detaljer'
+b'DocType: Leave Block List',b'Block Holidays on important days.',b'Block Ferie p\xc3\xa5 viktige dager.'
+b'apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +220',b'Please input all required Result Value(s)',b'Vennligst skriv inn alle n\xc3\xb8dvendige Resultat Verdi (r)'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js +106',b'Accounts Receivable Summary',b'Kundefordringer Sammendrag'
+b'DocType: Employee Loan',b'Monthly Repayment Amount',b'M\xc3\xa5nedlig nedbetaling bel\xc3\xb8pet'
+b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html +9',b'Opening Invoices',b'\xc3\x85pning av fakturaer'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +195',b'Please set User ID field in an Employee record to set Employee Role',b'Vennligst angi bruker-ID-feltet i en Employee rekord \xc3\xa5 sette Employee Rolle'
+b'DocType: UOM',b'UOM Name',b'M\xc3\xa5lenheter Name'
+b'DocType: GST HSN Code',b'HSN Code',b'HSN kode'
+b'apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +39',b'Contribution Amount',b'Bidrag Bel\xc3\xb8p'
+b'DocType: Purchase Invoice',b'Shipping Address',b'Sendingsadresse'
+b'DocType: Stock Reconciliation',b'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.',b'Dette verkt\xc3\xb8yet hjelper deg til \xc3\xa5 oppdatere eller fikse mengde og verdsetting av aksjer i systemet. Det er vanligvis brukes til \xc3\xa5 synkronisere systemverdier og hva som faktisk eksisterer i ditt varehus.'
+b'DocType: Delivery Note',b'In Words will be visible once you save the Delivery Note.',b'I Ord vil v\xc3\xa6re synlig n\xc3\xa5r du lagrer f\xc3\xb8lgeseddel.'
+b'DocType: Expense Claim',b'EXP',b'EXP'
+b'DocType: Water Analysis',b'Container',b'Container'
+b'apps/erpnext/erpnext/education/utils.py +50',b'Student {0} - {1} appears Multiple times in row {2} & {3}',b'Student {0} - {1} vises flere ganger p\xc3\xa5 rad {2} og {3}'
+b'DocType: Project',b'Day to Send',b'Dag \xc3\xa5 sende'
+b'DocType: Healthcare Settings',b'Manage Sample Collection',b'Administrer pr\xc3\xb8veinnsamling'
+b'DocType: Production Plan',b'Ignore Existing Ordered Quantity',b'Ignorer eksisterende bestilt antall'
+b'apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +66',b'Please set the series to be used.',b'Vennligst sett serien som skal brukes.'
+b'DocType: Patient',b'Tobacco Past Use',b'Tidligere bruk av tobakk'
+b'DocType: Sales Invoice Item',b'Brand Name',b'Merkenavn'
+b'DocType: Purchase Receipt',b'Transporter Details',b'Transporter Detaljer'
+b'apps/erpnext/erpnext/healthcare/doctype/physician/physician.py +55',b'User {0} is already assigned to Physician {1}',b'Bruker {0} er allerede tilordnet Legen {1}'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +2700',b'Default warehouse is required for selected item',b'Standardlager er n\xc3\xb8dvendig til den valgte artikkelen'
+b'apps/erpnext/erpnext/utilities/user_progress.py +146',b'Box',b'Eske'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1038',b'Possible Supplier',b'mulig Leverand\xc3\xb8r'
+b'DocType: Budget',b'Monthly Distribution',b'M\xc3\xa5nedlig Distribution'
+b'apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +68',b'Receiver List is empty. Please create Receiver List',b'Mottaker-listen er tom. Opprett Receiver Liste'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +31',b'Healthcare (beta)',b'Helsevesenet (beta)'
+b'DocType: Production Plan Sales Order',b'Production Plan Sales Order',b'Produksjonsplan Salgsordre'
+b'DocType: Sales Partner',b'Sales Partner Target',b'Sales Partner Target'
+b'DocType: Loan Type',b'Maximum Loan Amount',b'Maksimal L\xc3\xa5nebel\xc3\xb8p'
+b'DocType: Pricing Rule',b'Pricing Rule',b'Prising Rule'
+b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +58',b'Duplicate roll number for student {0}',b'Dupliseringsnummer for student {0}'
+b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +58',b'Duplicate roll number for student {0}',b'Dupliseringsnummer for student {0}'
+b'DocType: Budget',b'Action if Annual Budget Exceeded',b'Tiltak hvis \xc3\x85rlig budsjett Skredet'
+b'apps/erpnext/erpnext/config/learn.py +197',b'Material Request to Purchase Order',b'Materialet Request til innkj\xc3\xb8psordre'
+b'DocType: Shopping Cart Settings',b'Payment Success URL',b'Betaling Suksess URL'
+b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +81',b'Row # {0}: Returned Item {1} does not exists in {2} {3}',b'Row # {0}: Returned Element {1} ikke eksisterer i {2} {3}'
+b'DocType: Purchase Receipt',b'PREC-',b'PREC-'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +16',b'Bank Accounts',b'Bankkontoer'
+,b'Bank Reconciliation Statement',b'Bankavstemming Statement'
+b'DocType: Consultation',b'Medical Coding',b'Medisinsk koding'
+b'DocType: Healthcare Settings',b'Reminder Message',b'P\xc3\xa5minnelsesmelding'
+,b'Lead Name',b'Lead Name'
+,b'POS',b'POS'
+b'DocType: C-Form',b'III',b'III'
+b'apps/erpnext/erpnext/config/stock.py +314',b'Opening Stock Balance',b'\xc3\x85pning Stock Balance'
+b'apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +58',b'{0} must appear only once',b'{0} m\xc3\xa5 vises bare en gang'
+b'apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +59',b'Leaves Allocated Successfully for {0}',b'Etterlater Avsatt Vellykket for {0}'
+b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +42',b'No Items to pack',b'Ingenting \xc3\xa5 pakke'
+b'DocType: Shipping Rule Condition',b'From Value',b'Fra Verdi'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +606',b'Manufacturing Quantity is mandatory',b'Manufacturing Antall er obligatorisk'
+b'DocType: Employee Loan',b'Repayment Method',b'tilbakebetaling Method'
+b'DocType: Products Settings',"b'If checked, the Home page will be the default Item Group for the website'","b'Hvis det er merket, vil hjemmesiden v\xc3\xa6re standard Varegruppe for nettstedet'"
+b'DocType: Quality Inspection Reading',b'Reading 4',b'Reading 4'
+b'apps/erpnext/erpnext/config/hr.py +132',b'Claims for company expense.',b'Krav p\xc3\xa5 bekostning av selskapet.'
+b'apps/erpnext/erpnext/utilities/activation.py +118',"b'Students are at the heart of the system, add all your students'","b'Studentene er i hjertet av systemet, legge til alle elevene'"
+b'apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +97',b'Row #{0}: Clearance date {1} cannot be before Cheque Date {2}',b'Row # {0}: Clearance date {1} kan ikke v\xc3\xa6re f\xc3\xb8r Cheque Dato {2}'
+b'DocType: Asset Maintenance Task',b'Certificate Required',b'Sertifikat kreves'
+b'DocType: Company',b'Default Holiday List',b'Standard Holiday List'
+b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +196',b'Row {0}: From Time and To Time of {1} is overlapping with {2}',b'Rad {0}: Fra tid og klokkeslett {1} er overlappende med {2}'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +145',b'Stock Liabilities',b'Aksje Gjeld'
+b'DocType: Purchase Invoice',b'Supplier Warehouse',b'Leverand\xc3\xb8r Warehouse'
+b'DocType: Opportunity',b'Contact Mobile No',b'Kontakt Mobile No'
+b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +399',b'Select Company',b'Velg firma'
+,b'Material Requests for which Supplier Quotations are not created',b'Materielle Foresp\xc3\xb8rsler som Leverand\xc3\xb8r Sitater ikke er opprettet'
+b'DocType: Student Report Generation Tool',b'Print Section',b'Utskriftseksjon'
+b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +34',"b""User {0} doesn't have any default POS Profile. Check Default at Row {1} for this User.""",b'Bruker {0} har ingen standard POS-profil. Kontroller standard i rad {1} for denne brukeren.'
+b'DocType: Student Group',b'Set 0 for no limit',b'Sett 0 for ingen begrensning'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +122',b'The day(s) on which you are applying for leave are holidays. You need not apply for leave.',b'Dagen (e) der du s\xc3\xb8ker om permisjon er helligdager. Du trenger ikke s\xc3\xb8ke om permisjon.'
+b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +64',b'Row {idx}: {field} is required to create the Opening {invoice_type} Invoices',b'Row {idx}: {field} er p\xc3\xa5krevd for \xc3\xa5 opprette Fakturaer for \xc3\xa5pning {faktura_type}'
+b'DocType: Customer',b'Primary Address and Contact Detail',b'Prim\xc3\xa6radresse og kontaktdetaljer'
+b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +20',b'Resend Payment Email',b'Sende Betaling Email'
+b'apps/erpnext/erpnext/templates/pages/projects.html +27',b'New task',b'Ny oppgave'
+b'DocType: Consultation',b'Appointment',b'Avtale'
+b'apps/erpnext/erpnext/utilities/activation.py +74',b'Make Quotation',b'Gj\xc3\xb8r sitat'
+b'apps/erpnext/erpnext/config/education.py +230',b'Other Reports',b'andre rapporter'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +39',b'Please select at least one domain.',b'Vennligst velg minst ett domene.'
+b'DocType: Dependent Task',b'Dependent Task',b'Avhengig Task'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +444',b'Conversion factor for default Unit of Measure must be 1 in row {0}',b'Omregningsfaktor for standard Enhet m\xc3\xa5 v\xc3\xa6re en i rad {0}'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +188',b'Leave of type {0} cannot be longer than {1}',b'Permisjon av typen {0} kan ikke v\xc3\xa6re lengre enn {1}'
+b'DocType: Manufacturing Settings',b'Try planning operations for X days in advance.',b'Pr\xc3\xb8v \xc3\xa5 planlegge operasjoner for X dager i forveien.'
+b'DocType: HR Settings',b'Stop Birthday Reminders',b'Stop bursdagsp\xc3\xa5minnelser'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +235',b'Please set Default Payroll Payable Account in Company {0}',b'Vennligst sette Standard L\xc3\xb8nn betales konto i selskapet {0}'
+b'DocType: SMS Center',b'Receiver List',b'Mottaker List'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +1094',b'Search Item',b'S\xc3\xb8k Element'
+b'DocType: Payment Schedule',b'Payment Amount',b'Betalings Bel\xc3\xb8p'
+b'DocType: Patient Appointment',b'Referring Physician',b'Refererende lege'
+b'apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +46',b'Consumed Amount',b'Forbrukes Bel\xc3\xb8p'
+b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +100',b'Net Change in Cash',b'Netto endring i kontanter'
+b'DocType: Assessment Plan',b'Grading Scale',b'Grading Scale'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +438',b'Unit of Measure {0} has been entered more than once in Conversion Factor Table',b'Enhet {0} har blitt lagt inn mer enn \xc3\xa9n gang i omregningsfaktor tabell'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +639',b'Already completed',b'allerede fullf\xc3\xb8rt'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +33',b'Stock In Hand',b'Lager i h\xc3\xa5nd'
+b'apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +64',b'Import Successful!',b'Import Vellykket!'
+b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +29',b'Payment Request already exists {0}',b'Betaling Request allerede eksisterer {0}'
+b'apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +27',b'Cost of Issued Items',b'Cost of Utstedte Items'
+b'DocType: Physician',b'Hospital',b'Sykehus'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +385',b'Quantity must not be more than {0}',b'Antall m\xc3\xa5 ikke v\xc3\xa6re mer enn {0}'
+b'apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +117',b'Previous Financial Year is not closed',b'Foreg\xc3\xa5ende regnskaps\xc3\xa5r er ikke stengt'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +46',b'Age (Days)',b'Alder (dager)'
+b'DocType: Quotation Item',b'Quotation Item',b'Sitat Element'
+b'DocType: Customer',b'Customer POS Id',b'Kundens POS-ID'
+b'DocType: Account',b'Account Name',b'Brukernavn'
+b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +40',b'From Date cannot be greater than To Date',b'Fra dato ikke kan v\xc3\xa6re st\xc3\xb8rre enn To Date'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +198',b'Serial No {0} quantity {1} cannot be a fraction',b'Serial No {0} mengde {1} kan ikke v\xc3\xa6re en br\xc3\xb8kdel'
+b'apps/erpnext/erpnext/config/buying.py +43',b'Supplier Type master.',b'Leverand\xc3\xb8r Type mester.'
+b'DocType: Purchase Order Item',b'Supplier Part Number',b'Leverand\xc3\xb8r delenummer'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +108',b'Conversion rate cannot be 0 or 1',b'Konverteringsfrekvens kan ikke v\xc3\xa6re 0 eller 1'
+b'DocType: Share Balance',b'To No',b'Til nr'
+b'DocType: Subscription',b'Reference Document',b'Reference Document'
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +229',b'{0} {1} is cancelled or stopped',b'{0} {1} avbrytes eller stoppes'
+b'DocType: Accounts Settings',b'Credit Controller',b'Credit Controller'
+b'DocType: Grant Application',b'Applicant Type',b'S\xc3\xb8ker Type'
+b'DocType: Purchase Invoice',b'03-Deficiency in services',b'03-mangel p\xc3\xa5 tjenester'
+b'DocType: Delivery Note',b'Vehicle Dispatch Date',b'Vehicle Publiseringsdato'
+b'DocType: Healthcare Settings',b'Default Medical Code Standard',b'Standard medisinsk kode Standard'
+b'DocType: Purchase Invoice Item',b'HSN/SAC',b'HSN / SAC'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +237',b'Purchase Receipt {0} is not submitted',b'Kvitteringen {0} er ikke innsendt'
+b'DocType: Company',b'Default Payable Account',b'Standard Betales konto'
+b'apps/erpnext/erpnext/config/website.py +17',"b'Settings for online shopping cart such as shipping rules, price list etc.'","b'Innstillinger for online shopping cart som skipsregler, prisliste etc.'"
+b'apps/erpnext/erpnext/controllers/website_list_for_contact.py +113',b'{0}% Billed',b'{0}% Fakturert'
+b'apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +18',b'Reserved Qty',b'Reservert Antall'
+b'DocType: Party Account',b'Party Account',b'Partiet konto'
+b'apps/erpnext/erpnext/config/setup.py +122',b'Human Resources',b'Menneskelige Ressurser'
+b'DocType: Lead',b'Upper Income',b'\xc3\x98vre Inntekt'
+b'apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +17',b'Reject',b'Avvis'
+b'DocType: Journal Entry Account',b'Debit in Company Currency',b'Debet i selskapet Valuta'
+b'DocType: BOM Item',b'BOM Item',b'BOM Element'
+b'DocType: Appraisal',b'For Employee',b'For Employee'
+b'apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.js +49',b'Make Disbursement Entry',b'Gj\xc3\xb8r Utbetaling Entry'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +138',b'Row {0}: Advance against Supplier must be debit',b'Rad {0}: Advance mot Leverand\xc3\xb8ren skal belaste'
+b'DocType: Company',b'Default Values',b'Standardverdier'
+b'DocType: Membership',b'INR',b'INR'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +60',b'{frequency} Digest',b'{Frequency} Digest'
+b'DocType: Expense Claim',b'Total Amount Reimbursed',b'Totalbel\xc3\xb8p Refusjon'
+b'apps/erpnext/erpnext/hr/doctype/vehicle/vehicle_dashboard.py +5',b'This is based on logs against this Vehicle. See timeline below for details',b'Dette er basert p\xc3\xa5 loggene mot denne bilen. Se tidslinjen nedenfor for detaljer'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +90',b'Against Supplier Invoice {0} dated {1}',b'Mot Leverand\xc3\xb8r Faktura {0} datert {1}'
+b'DocType: Customer',b'Default Price List',b'Standard Prisliste'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +322',b'Asset Movement record {0} created',b'Asset Movement rekord {0} er opprettet'
+b'apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +51',b'You cannot delete Fiscal Year {0}. Fiscal Year {0} is set as default in Global Settings',b'Du kan ikke slette regnskaps\xc3\xa5r {0}. Regnskaps\xc3\xa5ret {0} er satt som standard i Globale innstillinger'
+b'apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.py +20',b'A customer with the same name already exists',b'En kunde med samme navn eksisterer allerede'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +185',b'This will submit Salary Slips and create accrual Journal Entry. Do you want to proceed?',b'Dette vil sende L\xc3\xb8nnsslipp og opprette periodiseringstabell. Vil du fortsette?'
+b'DocType: Purchase Invoice',b'Total Net Weight',b'Total nettovikt'
+b'DocType: Purchase Invoice',b'Eligibility For ITC',b'Kvalifisering for ITC'
+b'DocType: Journal Entry',b'Entry Type',b'Entry Type'
+,b'Customer Credit Balance',b'Customer Credit Balance'
+b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +28',b'Net Change in Accounts Payable',b'Netto endring i leverand\xc3\xb8rgjeld'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +48',b'EcritureLet',b'EcritureLet'
+b'apps/erpnext/erpnext/selling/doctype/customer/customer.py +209',b'Credit limit has been crossed for customer {0} ({1}/{2})',b'Kredittgrensen er krysset for kunden {0} ({1} / {2})'
+b'apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +42',"b""Customer required for 'Customerwise Discount'""",b'Kunden n\xc3\xb8dvendig for &#39;Customerwise Discount&#39;'
+b'apps/erpnext/erpnext/config/accounts.py +140',b'Update bank payment dates with journals.',b'Oppdatere bankbetalings datoer med tidsskrifter.'
+b'apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +21',b'Pricing',b'Priser'
+b'DocType: Quotation',b'Term Details',b'Term Detaljer'
+b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +30',b'Cannot enroll more than {0} students for this student group.',b'Kan ikke registrere mer enn {0} studentene p\xc3\xa5 denne studentgruppen.'
+b'apps/erpnext/erpnext/templates/print_formats/includes/total.html +4',b'Total (Without Tax)',b'Totalt (uten skatt)'
+b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +17',b'Lead Count',b'Lead Count'
+b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +17',b'Lead Count',b'Lead Count'
+b'apps/erpnext/erpnext/assets/doctype/asset_category/asset_category.py +15',b'{0} must be greater than 0',b'{0} m\xc3\xa5 v\xc3\xa6re st\xc3\xb8rre enn 0'
+b'apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +30',b'Stock Available',b'P\xc3\xa5 lager'
+b'DocType: Manufacturing Settings',b'Capacity Planning For (Days)',b'Kapasitetsplanlegging For (dager)'
+b'apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py +10',b'Procurement',b'innkj\xc3\xb8p'
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +66',b'None of the items have any change in quantity or value.',b'Ingen av elementene har noen endring i mengde eller verdi.'
+b'apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +17',b'Mandatory field - Program',b'Obligatorisk felt - Program'
+b'DocType: Special Test Template',b'Result Component',b'Resultat Komponent'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.js +46',b'Warranty Claim',b'Garantikrav'
+,b'Lead Details',b'Lead Detaljer'
+b'DocType: Volunteer',b'Availability and Skills',b'Tilgjengelighet og ferdigheter'
+b'DocType: Salary Slip',b'Loan repayment',b'l\xc3\xa5n tilbakebetaling'
+b'DocType: Purchase Invoice',"b""End date of current invoice's period""",b'Sluttdato for gjeldende faktura periode'
+b'DocType: Pricing Rule',b'Applicable For',b'Aktuelt For'
+b'DocType: Lab Test',b'Technician Name',b'Tekniker Navn'
+b'DocType: Accounts Settings',b'Unlink Payment on Cancellation of Invoice',b'Oppheve koblingen Betaling ved kansellering av faktura'
+b'apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +16',b'Current Odometer reading entered should be greater than initial Vehicle Odometer {0}',b'N\xc3\xa5v\xc3\xa6rende Kilometerstand inng\xc3\xa5tt b\xc3\xb8r v\xc3\xa6re st\xc3\xb8rre enn f\xc3\xb8rste Vehicle Teller {0}'
+b'DocType: Restaurant Reservation',b'No Show',b'Uteblivelse'
+b'DocType: Shipping Rule Country',b'Shipping Rule Country',b'Shipping Rule Land'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +10',b'Leave and Attendance',b'La og oppm\xc3\xb8te'
+b'DocType: Maintenance Visit',b'Partially Completed',b'Delvis Fullf\xc3\xb8rt'
+b'apps/erpnext/erpnext/healthcare/setup.py +257',b'Moderate Sensitivity',b'Moderat f\xc3\xb8lsomhet'
+b'DocType: Leave Type',b'Include holidays within leaves as leaves',b'Inkluder hellig innen blader som l\xc3\xb8v'
+b'DocType: Sales Invoice',b'Packed Items',b'Lunsj Items'
+b'apps/erpnext/erpnext/config/support.py +27',b'Warranty Claim against Serial No.',b'Garantikrav mot Serial No.'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +197',"b""'Total'""",b'&#39;Total&#39;'
+b'DocType: Shopping Cart Settings',b'Enable Shopping Cart',b'Aktiver Handlevogn'
+b'DocType: Employee',b'Permanent Address',b'Permanent Adresse'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +260',b'Advance paid against {0} {1} cannot be greater \\\n\t\t\t\t\t\tthan Grand Total {2}',b'Advance betalt mot {0} {1} kan ikke v\xc3\xa6re st\xc3\xb8rre \\ enn Totalsum {2}'
+b'DocType: Consultation',b'Medication',b'medisinering'
+b'DocType: Production Plan',b'Include Non Stock Items',b'Inkluder ikke-varelager'
+b'DocType: Project Update',b'Challenging/Slow',b'Utfordrende / Slow'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +147',b'Please select item code',b'Velg elementet kode'
+b'DocType: Student Sibling',b'Studying in Same Institute',b'\xc3\x85 studere i samme institutt'
+b'DocType: Territory',b'Territory Manager',b'Distriktssjef'
+b'DocType: Packed Item',b'To Warehouse (Optional)',b'Til Warehouse (valgfritt)'
+b'DocType: GST Settings',b'GST Accounts',b'GST-kontoer'
+b'DocType: Payment Entry',b'Paid Amount (Company Currency)',b'Innbetalt bel\xc3\xb8p (Company Valuta)'
+b'DocType: Purchase Invoice',b'Additional Discount',b'Ekstra rabatt'
+b'DocType: Selling Settings',b'Selling Settings',b'Selge Innstillinger'
+b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +83',b'Confirm Action',b'Bekreft handling'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +39',b'Online Auctions',b'Online auksjoner'
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +100',b'Please specify either Quantity or Valuation Rate or both',b'Vennligst oppgi enten Mengde eller Verdivurdering Rate eller begge deler'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order_dashboard.py +18',b'Fulfillment',b'Oppfyllelse'
+b'apps/erpnext/erpnext/templates/generators/item.html +82',b'View in Cart',b'Vis i handlekurven'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +103',b'Marketing Expenses',b'Markedsf\xc3\xb8ringskostnader'
+,b'Item Shortage Report',b'Sak Mangel Rapporter'
+b'apps/erpnext/erpnext/education/doctype/assessment_criteria/assessment_criteria.py +15',"b""Can't create standard criteria. Please rename the criteria""",b'Kan ikke opprette standard kriterier. Vennligst gi nytt navn til kriteriene'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +311',"b'Weight is mentioned,\\nPlease mention ""Weight UOM"" too'","b'Vekt er nevnt, \\ nVennligst nevne &quot;Weight m\xc3\xa5lenheter&quot; ogs\xc3\xa5'"
+b'DocType: Stock Entry Detail',b'Material Request used to make this Stock Entry',b'Materialet Request brukes til \xc3\xa5 gj\xc3\xb8re dette lager Entry'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +68',b'Next Depreciation Date is mandatory for new asset',b'Neste Avskrivninger dato er obligatorisk for ny aktiva'
+b'DocType: Student Group Creation Tool',b'Separate course based Group for every Batch',b'Separat kursbasert gruppe for hver batch'
+b'DocType: Student Group Creation Tool',b'Separate course based Group for every Batch',b'Separat kursbasert gruppe for hver batch'
+b'apps/erpnext/erpnext/config/support.py +32',b'Single unit of an Item.',b'Enkelt enhet av et element.'
+b'DocType: Fee Category',b'Fee Category',b'Fee Kategori'
+b'DocType: Agriculture Task',b'Next Business Day',b'Neste arbeidsdag'
+b'DocType: Drug Prescription',b'Dosage by time interval',b'Dosering etter tidsintervall'
+b'DocType: Cash Flow Mapper',b'Section Header',b'Seksjonsoverskrift'
+,b'Student Fee Collection',b'Student Fee Collection'
+b'apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +24',b'Appointment Duration (mins)',b'Avtale Varighet (min)'
+b'DocType: Accounts Settings',b'Make Accounting Entry For Every Stock Movement',b'Gj\xc3\xb8r regnskap Entry For Hver Stock Movement'
+b'DocType: Leave Allocation',b'Total Leaves Allocated',b'Totalt Leaves Avsatt'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +163',b'Warehouse required at Row No {0}',b'Warehouse kreves ved Row Nei {0}'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +145',b'Please enter valid Financial Year Start and End Dates',b'Fyll inn gyldig Regnskaps\xc3\xa5r start- og sluttdato'
+b'DocType: Employee',b'Date Of Retirement',b'Pensjoneringstidspunktet'
+b'DocType: Upload Attendance',b'Get Template',b'F\xc3\xa5 Mal'
+b'DocType: Material Request',b'Transferred',b'overf\xc3\xb8rt'
+b'DocType: Vehicle',b'Doors',b'd\xc3\xb8rer'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/defaults_setup.py +117',b'ERPNext Setup Complete!',b'ERPNext Setup Complete!'
+b'DocType: Healthcare Settings',b'Collect Fee for Patient Registration',b'Samle avgift for pasientregistrering'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +678',b'Cannot change Attributes after stock transaction. Make a new Item and transfer stock to the new Item',b'Kan ikke endre attributter etter aksje transaksjon. Lag en ny vare og overf\xc3\xb8r lager til den nye varen'
+b'DocType: Course Assessment Criteria',b'Weightage',b'Weightage'
+b'DocType: Purchase Invoice',b'Tax Breakup',b'Skatteavbrudd'
+b'DocType: Packing Slip',b'PS-',b'PS'
+b'DocType: Member',b'Non Profit Member',b'Ikke-profittmedlem'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +67',"b""{0} {1}: Cost Center is required for 'Profit and Loss' account {2}. Please set up a default Cost Center for the Company.""",b'{0} {1}: Det kreves kostnadssted for &#39;resultat&#39; konto {2}. Sett opp en standardkostnadssted for selskapet.'
+b'DocType: Payment Schedule',b'Payment Term',b'Betalingsperiode'
+b'apps/erpnext/erpnext/selling/doctype/customer/customer.py +160',b'A Customer Group exists with same name please change the Customer name or rename the Customer Group',b'En kundegruppe eksisterer med samme navn kan du endre Kundens navn eller endre navn p\xc3\xa5 Kundegruppe'
+b'DocType: Land Unit',b'Area',b'Omr\xc3\xa5de'
+b'apps/erpnext/erpnext/public/js/templates/contact_list.html +37',b'New Contact',b'Ny kontakt'
+b'DocType: Territory',b'Parent Territory',b'Parent Territory'
+b'DocType: Purchase Invoice',b'Place of Supply',b'Leveringssted'
+b'DocType: Quality Inspection Reading',b'Reading 2',b'Reading 2'
+b'DocType: Stock Entry',b'Material Receipt',b'Materialet Kvittering'
+b'DocType: Homepage',b'Products',b'Produkter'
+b'DocType: Announcement',b'Instructor',b'Instrukt\xc3\xb8r'
+b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js +61',b'Select Item (optional)',b'Velg element (valgfritt)'
+b'DocType: Fee Schedule Student Group',b'Fee Schedule Student Group',b'Avgift Schedule Student Group'
+b'DocType: Student',b'AB+',b'AB +'
+b'DocType: Item',"b'If this item has variants, then it cannot be selected in sales orders etc.'","b'Hvis dette elementet har varianter, s\xc3\xa5 det kan ikke velges i salgsordrer etc.'"
+b'DocType: Lead',b'Next Contact By',b'Neste Kontakt Av'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +325',b'Quantity required for Item {0} in row {1}',b'Mengden som kreves for Element {0} i rad {1}'
+b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +45',b'Warehouse {0} can not be deleted as quantity exists for Item {1}',b'Warehouse {0} kan ikke slettes som kvantitet finnes for Element {1}'
+b'DocType: Quotation',b'Order Type',b'Ordretype'
+,b'Item-wise Sales Register',b'Element-messig Sales Register'
+b'DocType: Asset',b'Gross Purchase Amount',b'Bruttobel\xc3\xb8pet'
+b'apps/erpnext/erpnext/utilities/user_progress.py +39',b'Opening Balances',b'\xc3\x85pningsbalanser'
+b'DocType: Asset',b'Depreciation Method',b'avskrivningsmetode'
+b'DocType: Purchase Taxes and Charges',b'Is this Tax included in Basic Rate?',b'Er dette inklusiv i Basic Rate?'
+b'apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +56',b'Total Target',b'Total Target'
+b'DocType: Soil Texture',b'Sand Composition (%)',b'Sandkomposisjon (%)'
+b'DocType: Job Applicant',b'Applicant for a Job',b'Kandidat til en jobb'
+b'DocType: Production Plan Material Request',b'Production Plan Material Request',b'Produksjonsplan Material Request'
+b'DocType: Stock Reconciliation',b'Reconciliation JSON',b'Avstemming JSON'
+b'apps/erpnext/erpnext/accounts/report/financial_statements.html +3',b'Too many columns. Export the report and print it using a spreadsheet application.',b'For mange kolonner. Eksportere rapporten og skrive den ut ved hjelp av et regnearkprogram.'
+b'DocType: Purchase Invoice Item',b'Batch No',b'Batch No'
+b'DocType: Selling Settings',"b""Allow multiple Sales Orders against a Customer's Purchase Order""",b'Tillat flere salgsordrer mot kundens innkj\xc3\xb8psordre'
+b'DocType: Student Group Instructor',b'Student Group Instructor',b'Studentgruppeinstrukt\xc3\xb8r'
+b'DocType: Grant Application',b'Assessment  Mark (Out of 10)',b'Vurderingsmerke (ut av 10)'
+b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +61',b'Guardian2 Mobile No',b'Guardian2 Mobile No'
+b'apps/erpnext/erpnext/setup/doctype/company/company.py +218',b'Main',b'Hoved'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +72',b'Variant',b'Variant'
+b'DocType: Naming Series',b'Set prefix for numbering series on your transactions',b'Still prefiks for nummerering serien p\xc3\xa5 dine transaksjoner'
+b'DocType: Employee Attendance Tool',b'Employees HTML',b'ansatte HTML'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +458',b'Default BOM ({0}) must be active for this item or its template',b'Standard BOM ({0}) m\xc3\xa5 v\xc3\xa6re aktiv for denne varen eller dens mal'
+b'DocType: Employee',b'Leave Encashed?',b'Permisjon encashed?'
+b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +32',b'Opportunity From field is mandatory',b'Opportunity Fra-feltet er obligatorisk'
+b'DocType: Email Digest',b'Annual Expenses',b'\xc3\xa5rlige utgifter'
+b'DocType: Item',b'Variants',b'Varianter'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1148',b'Make Purchase Order',b'Gj\xc3\xb8r innkj\xc3\xb8psordre'
+b'DocType: SMS Center',b'Send To',b'Send Til'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +133',b'There is not enough leave balance for Leave Type {0}',b'Det er ikke nok permisjon balanse for La Type {0}'
+b'DocType: Payment Reconciliation Payment',b'Allocated amount',b'Bevilget bel\xc3\xb8p'
+b'DocType: Sales Team',b'Contribution to Net Total',b'Bidrag til Net Total'
+b'DocType: Sales Invoice Item',"b""Customer's Item Code""",b'Kundens Elementkode'
+b'DocType: Stock Reconciliation',b'Stock Reconciliation',b'Stock Avstemming'
+b'DocType: Territory',b'Territory Name',b'Territorium Name'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +204',b'Work-in-Progress Warehouse is required before Submit',b'Work-in-progress Warehouse er n\xc3\xb8dvendig f\xc3\xb8r Send'
+b'apps/erpnext/erpnext/config/hr.py +40',b'Applicant for a Job.',b'Kandidat til en jobb.'
+b'DocType: Purchase Order Item',b'Warehouse and Reference',b'Warehouse og Reference'
+b'DocType: Supplier',b'Statutory info and other general information about your Supplier',b'Lovfestet info og annen generell informasjon om din Leverand\xc3\xb8r'
+b'DocType: Item',b'Serial Nos and Batches',b'Serienummer og partier'
+b'apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py +42',b'Student Group Strength',b'Studentgruppestyrke'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +261',b'Against Journal Entry {0} does not have any unmatched {1} entry',b'Mot Journal Entry {0} har ikke noen enest\xc3\xa5ende {1} oppf\xc3\xb8ring'
+b'apps/erpnext/erpnext/config/hr.py +142',b'Appraisals',b'medarbeidersamtaler'
+b'apps/erpnext/erpnext/hr/doctype/training_program/training_program_dashboard.py +8',b'Training Events',b'Treningsarrangementer'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +205',b'Duplicate Serial No entered for Item {0}',b'Duplisere serie Ingen kom inn for Element {0}'
+b'apps/erpnext/erpnext/config/selling.py +179',b'Track Leads by Lead Source.',b'Sporledninger av blykilde.'
+b'DocType: Shipping Rule Condition',b'A condition for a Shipping Rule',b'En forutsetning for en Shipping Rule'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +167',b'Please enter ',b'Vennligst skriv inn'
+b'apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js +43',b'Maintenance Log',b'Vedlikeholdslogg'
+b'apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +236',b'Please set filter based on Item or Warehouse',b'Vennligst sette filter basert p\xc3\xa5 varen eller Warehouse'
+b'DocType: Packing Slip',b'The net weight of this package. (calculated automatically as sum of net weight of items)',b'Nettovekten av denne pakken. (Automatisk beregnet som summen av nettovekt elementer)'
+b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +802',b'Discount amount cannot be greater than 100%',b'Rabattbel\xc3\xb8p kan ikke v\xc3\xa6re st\xc3\xb8rre enn 100%'
+b'DocType: Sales Order',b'To Deliver and Bill',b'\xc3\x85 levere og Bill'
+b'DocType: Student Group',b'Instructors',b'instrukt\xc3\xb8rer'
+b'DocType: GL Entry',b'Credit Amount in Account Currency',b'Credit bel\xc3\xb8p p\xc3\xa5 kontoen Valuta'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +603',b'BOM {0} must be submitted',b'BOM {0} m\xc3\xa5 sendes'
+b'apps/erpnext/erpnext/config/accounts.py +460',b'Share Management',b'Aksjeforvaltning'
+b'DocType: Authorization Control',b'Authorization Control',b'Autorisasjon kontroll'
+b'apps/erpnext/erpnext/controllers/buying_controller.py +317',b'Row #{0}: Rejected Warehouse is mandatory against rejected Item {1}',b'Row # {0}: Avvist Warehouse er obligatorisk mot avvist Element {1}'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +810',b'Payment',b'Betaling'
+b'apps/erpnext/erpnext/controllers/stock_controller.py +92',"b'Warehouse {0} is not linked to any account, please mention the account in  the warehouse record or set default inventory account in company {1}.'","b'Lager {0} er ikke knyttet til noen konto, vennligst oppgi kontoen i lagerregisteret eller sett inn standardbeholdningskonto i selskap {1}.'"
+b'apps/erpnext/erpnext/utilities/activation.py +81',b'Manage your orders',b'Administrere dine bestillinger'
+b'DocType: Work Order Operation',b'Actual Time and Cost',b'Faktisk leveringstid og pris'
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +56',b'Material Request of maximum {0} can be made for Item {1} against Sales Order {2}',b'Materialet Request av maksimal {0} kan gj\xc3\xb8res for Element {1} mot Salgsordre {2}'
+b'DocType: Crop',b'Crop Spacing',b'Beskj\xc3\xa6ringsavstand'
+b'DocType: Course',b'Course Abbreviation',b'Kurs forkortelse'
+b'DocType: Student Leave Application',b'Student Leave Application',b'Student La Application'
+b'DocType: Item',b'Will also apply for variants',b'Vil ogs\xc3\xa5 gjelde for varianter'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +217',"b'Asset cannot be cancelled, as it is already {0}'","b'Asset kan ikke avbestilles, som det allerede er {0}'"
+b'apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +29',b'Employee {0} on Half day on {1}',b'Employee {0} p\xc3\xa5 halv dag {1}'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +42',b'Total working hours should not be greater than max working hours {0}',b'Samlet arbeidstid m\xc3\xa5 ikke v\xc3\xa6re st\xc3\xb8rre enn maks arbeidstid {0}'
+b'apps/erpnext/erpnext/templates/pages/task_info.html +90',b'On',b'P\xc3\xa5'
+b'apps/erpnext/erpnext/config/selling.py +62',b'Bundle items at time of sale.',b'Bundle elementer p\xc3\xa5 salgstidspunktet.'
+b'DocType: Material Request Plan Item',b'Actual Qty',b'Selve Antall'
+b'DocType: Sales Invoice Item',b'References',b'Referanser'
+b'DocType: Quality Inspection Reading',b'Reading 10',b'Lese 10'
+b'DocType: Item',b'Barcodes',b'strek~~POS=TRUNC'
+b'DocType: Hub Category',b'Hub Node',b'Hub Node'
+b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +78',b'You have entered duplicate items. Please rectify and try again.',b'Du har skrevet inn like elementer. Vennligst utbedre og pr\xc3\xb8v igjen.'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +129',b'Associate',b'Forbinder'
+b'DocType: Asset Movement',b'Asset Movement',b'Asset Movement'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +508',b'Work Order {0} must be submitted',b'Arbeidsordre {0} m\xc3\xa5 sendes'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +2214',b'New Cart',b'New Handlekurv'
+b'apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +44',b'Item {0} is not a serialized Item',b'Element {0} er ikke en serie Element'
+b'DocType: SMS Center',b'Create Receiver List',b'Lag Receiver List'
+b'DocType: Vehicle',b'Wheels',b'hjul'
+b'DocType: Packing Slip',b'To Package No.',b'\xc3\x85 pakke No.'
+b'DocType: Patient Relation',b'Family',b'Familie'
+b'DocType: Production Plan',b'Material Requests',b'material~~POS=TRUNC Foresp\xc3\xb8rsler'
+b'DocType: Warranty Claim',b'Issue Date',b'Utgivelsesdato'
+b'DocType: Activity Cost',b'Activity Cost',b'Aktivitet Kostnad'
+b'DocType: Sales Invoice Timesheet',b'Timesheet Detail',b'Timeregistrering Detalj'
+b'DocType: Purchase Receipt Item Supplied',b'Consumed Qty',b'Forbrukes Antall'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +52',b'Telecommunications',b'Telekommunikasjon'
+b'apps/erpnext/erpnext/accounts/party.py +263',"b""Billing currency must be equal to either default company's currency or party account currency""",b'Faktureringsvaluta m\xc3\xa5 v\xc3\xa6re lik enten selskapets valuta- eller partikonto-valuta'
+b'DocType: Packing Slip',b'Indicates that the package is a part of this delivery (Only Draft)',b'Indikerer at pakken er en del av denne leveransen (Kun Draft)'
+b'DocType: Soil Texture',b'Loam',b'leirjord'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +705',b'Row {0}: Due Date cannot be before posting date',b'Row {0}: Forfallsdato kan ikke v\xc3\xa6re f\xc3\xb8r innleggsdato'
+b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +36',b'Make Payment Entry',b'Utf\xc3\xb8r betaling Entry'
+b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +129',b'Quantity for Item {0} must be less than {1}',b'Kvantum for Element {0} m\xc3\xa5 v\xc3\xa6re mindre enn {1}'
+,b'Sales Invoice Trends',b'Salgsfaktura Trender'
+b'DocType: Leave Application',b'Apply / Approve Leaves',b'P\xc3\xa5f\xc3\xb8r / Godkjenn L\xc3\xb8v'
+b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +3',b'For',b'Til'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +167',"b""Can refer row only if the charge type is 'On Previous Row Amount' or 'Previous Row Total'""",b'Kan referere rad bare hvis belastningen typen er &#39;On Forrige Row bel\xc3\xb8p &quot;eller&quot; Forrige Row Totals'
+b'DocType: Sales Order Item',b'Delivery Warehouse',b'Levering Warehouse'
+b'apps/erpnext/erpnext/config/accounts.py +241',b'Tree of financial Cost Centers.',b'Tre av finansielle kostnadssteder.'
+b'DocType: Serial No',b'Delivery Document No',b'Levering Dokument nr'
+b'apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +191',"b""Please set 'Gain/Loss Account on Asset Disposal' in Company {0}""",b'Vennligst sett &#39;Gevinst / tap-konto p\xc3\xa5 Asset Deponering &quot;i selskapet {0}'
+b'DocType: Landed Cost Voucher',b'Get Items From Purchase Receipts',b'F\xc3\xa5 elementer fra innkj\xc3\xb8ps Receipts'
+b'DocType: Serial No',b'Creation Date',b'Dato opprettet'
+b'apps/erpnext/erpnext/stock/doctype/item_price/item_price.py +33',b'Item {0} appears multiple times in Price List {1}',b'Element {0} forekommer flere ganger i Prisliste {1}'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +41',"b'Selling must be checked, if Applicable For is selected as {0}'","b'Selling m\xc3\xa5 sjekkes, hvis dette gjelder for er valgt som {0}'"
+b'DocType: Production Plan Material Request',b'Material Request Date',b'Materiale Request Dato'
+b'DocType: Purchase Order Item',b'Supplier Quotation Item',b'Leverand\xc3\xb8r sitat Element'
+b'DocType: Student',b'Student Mobile Number',b'Student Mobilnummer'
+b'DocType: Item',b'Has Variants',b'Har Varianter'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +488',"b'Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings'","b'Kan ikke overbillett for element {0} i rad {1} mer enn {2}. For \xc3\xa5 tillate overfakturering, vennligst sett inn Lagerinnstillinger'"
+b'apps/erpnext/erpnext/templates/emails/training_event.html +11',b'Update Response',b'Oppdater svar'
+b'apps/erpnext/erpnext/public/js/utils.js +232',b'You have already selected items from {0} {1}',b'Du har allerede valgt elementer fra {0} {1}'
+b'DocType: Monthly Distribution',b'Name of the Monthly Distribution',b'Navn p\xc3\xa5 Monthly Distribution'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.py +95',b'Batch ID is mandatory',b'Batch-ID er obligatorisk'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.py +95',b'Batch ID is mandatory',b'Batch-ID er obligatorisk'
+b'DocType: Sales Person',b'Parent Sales Person',b'Parent Sales Person'
+b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +100',b'The seller and the buyer cannot be the same',b'Selgeren og kj\xc3\xb8peren kan ikke v\xc3\xa6re det samme'
+b'DocType: Project',b'Collect Progress',b'Samle fremgang'
+b'apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +24',b'Select the program first',b'Velg programmet f\xc3\xb8rst'
+b'DocType: Patient Appointment',b'Patient Age',b'Pasientalder'
+b'apps/erpnext/erpnext/config/learn.py +253',b'Managing Projects',b'Managing Projects'
+b'DocType: Supplier',b'Supplier of Goods or Services.',b'Leverand\xc3\xb8r av varer eller tjenester.'
+b'DocType: Budget',b'Fiscal Year',b'Regnskaps\xc3\xa5r'
+b'DocType: Asset Maintenance Log',b'Planned',b'planlagt'
+b'DocType: Healthcare Settings',b'Default receivable accounts to be used if not set in Patient to book Consultation charges.',b'Standardfordelbare kontoer som skal brukes hvis ikke satt inn i pasienten for \xc3\xa5 bestille konsultasjonsgebyrer.'
+b'DocType: Vehicle Log',b'Fuel Price',b'Fuel Pris'
+b'DocType: Budget',b'Budget',b'Budsjett'
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +65',b'Set Open',b'Sett inn'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +258',b'Fixed Asset Item must be a non-stock item.',b'Fast Asset varen m\xc3\xa5 v\xc3\xa6re et ikke-lagervare.'
+b'apps/erpnext/erpnext/accounts/doctype/budget/budget.py +50',"b""Budget cannot be assigned against {0}, as it's not an Income or Expense account""","b'Budsjettet kan ikke overdras mot {0}, som det er ikke en inntekt eller kostnad konto'"
+b'apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.py +51',b'Achieved',b'Oppn\xc3\xa5s'
+b'DocType: Student Admission',b'Application Form Route',b'S\xc3\xb8knadsskjema Rute'
+b'apps/erpnext/erpnext/selling/page/sales_analytics/sales_analytics.js +66',b'Territory / Customer',b'Territorium / Customer'
+b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +44',b'Leave Type {0} cannot be allocated since it is leave without pay',b'La Type {0} kan ikke tildeles siden det er permisjon uten l\xc3\xb8nn'
+b'apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +167',b'Row {0}: Allocated amount {1} must be less than or equals to invoice outstanding amount {2}',b'Rad {0}: Nummerert mengden {1} m\xc3\xa5 v\xc3\xa6re mindre enn eller lik fakturere utest\xc3\xa5ende bel\xc3\xb8p {2}'
+b'DocType: Sales Invoice',b'In Words will be visible once you save the Sales Invoice.',b'I Ord vil v\xc3\xa6re synlig n\xc3\xa5r du lagrer salgsfaktura.'
+b'DocType: Lead',b'Follow Up',b'F\xc3\xb8lge opp'
+b'DocType: Item',b'Is Sales Item',b'Er Sales Element'
+b'apps/erpnext/erpnext/setup/doctype/item_group/item_group.js +21',b'Item Group Tree',b'Varegruppe treet'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +69',b'Item {0} is not setup for Serial Nos. Check Item master',b'Element {0} er ikke oppsett for Serial Nos. Sjekk Element mester'
+b'DocType: Maintenance Visit',b'Maintenance Time',b'Vedlikehold Tid'
+,b'Amount to Deliver',b'Bel\xc3\xb8p \xc3\xa5 levere'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +335',b'Same item has been entered multiple times. {0}',b'Samme gjenstand er oppgitt flere ganger. {0}'
+b'apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +30',b'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.',"b'Begrepet Startdato kan ikke v\xc3\xa6re tidligere enn \xc3\xa5ret startdato av studie\xc3\xa5ret som begrepet er knyttet (studie\xc3\xa5ret {}). Korriger datoene, og pr\xc3\xb8v igjen.'"
+b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +190',b'There were errors.',b'Det var feil.'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +166',b'Employee {0} has already applied for {1} between {2} and {3} : ',b'Ansatt {0} har allerede s\xc3\xb8kt om {1} mellom {2} og {3}:'
+b'DocType: Guardian',b'Guardian Interests',b'Guardian Interesser'
+b'DocType: Naming Series',b'Current Value',b'N\xc3\xa5v\xc3\xa6rende Verdi'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +273',b'Multiple fiscal years exist for the date {0}. Please set company in Fiscal Year',b'Flere regnskaps\xc3\xa5rene finnes for datoen {0}. Vennligst satt selskapet i regnskaps\xc3\xa5ret'
+b'DocType: Education Settings',b'Instructor Records to be created by',b'Instrukt\xc3\xb8rposter som skal opprettes av'
+b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +229',b'{0} created',b'{0} opprettet'
+b'DocType: GST Account',b'GST Account',b'GST-konto'
+b'DocType: Delivery Note Item',b'Against Sales Order',b'Mot Salgsordre'
+,b'Serial No Status',b'Serial No Status'
+b'DocType: Payment Entry Reference',b'Outstanding',b'Utest\xc3\xa5ende'
+b'DocType: Supplier',b'Warn POs',b'Advarsel POs'
+,b'Daily Timesheet Summary',b'Daglig Timeregistrering Oppsummering'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +137',"b'Row {0}: To set {1} periodicity, difference between from and to date \\\n\t\t\t\t\t\tmust be greater than or equal to {2}'","b'Rad {0}: Slik stiller {1} periodisitet, forskjellen mellom fra og til dato \\ m\xc3\xa5 v\xc3\xa6re st\xc3\xb8rre enn eller lik {2}'"
+b'apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +6',b'This is based on stock movement. See {0} for details',b'Dette er basert p\xc3\xa5 lagerbevegelse. Se {0} for detaljer'
+b'DocType: Pricing Rule',b'Selling',b'Selling'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +392',b'Amount {0} {1} deducted against {2}',b'Mengden {0} {1} trukket mot {2}'
+b'DocType: Employee',b'Salary Information',b'L\xc3\xb8nn Informasjon'
+b'DocType: Sales Person',b'Name and Employee ID',b'Navn og Employee ID'
+b'apps/erpnext/erpnext/accounts/party.py +308',b'Due Date cannot be before Posting Date',b'Due Date kan ikke v\xc3\xa6re f\xc3\xb8r konteringsdato'
+b'DocType: Website Item Group',b'Website Item Group',b'Website varegruppe'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +463',b'No salary slip found to submit for the above selected criteria OR salary slip already submitted',b'Ingen l\xc3\xb8nnsslipp funnet \xc3\xa5 sende inn for ovennevnte utvalgte kriterier ELLER l\xc3\xb8nnsslipp allerede sendt'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +150',b'Duties and Taxes',b'Skatter og avgifter'
+b'DocType: Projects Settings',b'Projects Settings',b'Prosjekter Innstillinger'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +356',b'Please enter Reference date',b'Skriv inn Reference dato'
+b'apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +44',b'{0} payment entries can not be filtered by {1}',b'{0} oppf\xc3\xb8ringer betalings kan ikke bli filtrert av {1}'
+b'DocType: Item Website Specification',b'Table for Item that will be shown in Web Site',b'Tabell for element som vil bli vist p\xc3\xa5 nettsiden'
+b'DocType: Purchase Order Item Supplied',b'Supplied Qty',b'Medf\xc3\xb8lgende Antall'
+b'DocType: Purchase Order Item',b'Material Request Item',b'Materialet Request Element'
+b'apps/erpnext/erpnext/config/selling.py +75',b'Tree of Item Groups.',b'Tree of varegrupper.'
+b'DocType: Production Plan',b'Total Produced Qty',b'Totalt produsert antall'
+b'DocType: Payroll Entry',b'Get Employee Details',b'F\xc3\xa5 medarbeiderdetaljer'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +177',b'Cannot refer row number greater than or equal to current row number for this Charge type',b'Kan ikke se rad tall st\xc3\xb8rre enn eller lik gjeldende rad nummer for denne debiteringstype'
+b'DocType: Asset',b'Sold',b'selges'
+,b'Item-wise Purchase History',b'Element-messig Purchase History'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +230',"b""Please click on 'Generate Schedule' to fetch Serial No added for Item {0}""",b'Vennligst klikk p\xc3\xa5 &quot;Generer Schedule &#39;for \xc3\xa5 hente serienummer lagt for Element {0}'
+b'DocType: Account',b'Frozen',b'Frozen'
+b'DocType: Sales Invoice Payment',b'Base Amount (Company Currency)',b'Grunnbel\xc3\xb8p (Selskap Valuta)'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +928',b'Raw Materials',b'R\xc3\xa5stoffer'
+b'DocType: Payment Reconciliation Payment',b'Reference Row',b'Referanse Row'
+b'DocType: Installation Note',b'Installation Time',b'Installasjon Tid'
+b'DocType: Sales Invoice',b'Accounting Details',b'Regnskap Detaljer'
+b'apps/erpnext/erpnext/setup/doctype/company/company.js +113',b'Delete all the Transactions for this Company',b'Slett alle transaksjoner for dette selskapet'
+b'DocType: Patient',b'O Positive',b'O Positiv'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +68',b'Investments',b'Investeringer'
+b'DocType: Issue',b'Resolution Details',b'Oppl\xc3\xb8sning Detaljer'
+b'apps/erpnext/erpnext/hr/doctype/leave_type/leave_type.js +3',b'Allocations',b'Avsetninger'
+b'DocType: Item Quality Inspection Parameter',b'Acceptance Criteria',b'Akseptkriterier'
+b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +159',b'Please enter Material Requests in the above table',b'Fyll inn Material foresp\xc3\xb8rsler i tabellen over'
+b'DocType: Item Attribute',b'Attribute Name',b'Attributt navn'
+b'DocType: BOM',b'Show In Website',b'Show I Website'
+b'DocType: Shopping Cart Settings',b'Show Quantity in Website',b'Vis Antall i Website'
+b'DocType: Employee Loan Application',b'Total Payable Amount',b'Totalt betales bel\xc3\xb8pet'
+b'DocType: Task',b'Expected Time (in hours)',b'Forventet tid (i timer)'
+b'DocType: Item Reorder',b'Check in (group)',b'Sjekk inn (gruppe)'
+b'DocType: Soil Texture',b'Silt',b'silt'
+,b'Qty to Order',b'Antall \xc3\xa5 bestille'
+b'DocType: Period Closing Voucher',"b'The account head under Liability or Equity, in which Profit/Loss will be booked'","b'Kontoen hodet etter forpliktelse eller et egenkapital, der gevinst / tap vil bli bokf\xc3\xb8rt'"
+b'apps/erpnext/erpnext/config/projects.py +36',b'Gantt chart of all tasks.',b'Gantt diagram av alle oppgaver.'
+b'DocType: Opportunity',b'Mins to First Response',b'Minutter til First Response'
+b'DocType: Pricing Rule',b'Margin Type',b'margin Type'
+b'apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +15',b'{0} hours',b'{0} timer'
+b'DocType: Course',b'Default Grading Scale',b'Standard Grading Scale'
+b'DocType: Appraisal',b'For Employee Name',b'For Employee Name'
+b'DocType: Holiday List',b'Clear Table',b'Clear Table'
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +119',b'Available slots',b'Tilgjengelige spor'
+b'DocType: C-Form Invoice Detail',b'Invoice No',b'Faktura Nei'
+b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +363',b'Make Payment',b'Utf\xc3\xb8re betaling'
+b'DocType: Room',b'Room Name',b'Room Name'
+b'DocType: Prescription Duration',b'Prescription Duration',b'Reseptbel\xc3\xb8p'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +81',"b'Leave cannot be applied/cancelled before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}'","b'La ikke kan brukes / kansellert f\xc3\xb8r {0}, som permisjon balanse har allerede v\xc3\xa6rt carry-sendt i fremtiden permisjon tildeling posten {1}'"
+b'DocType: Activity Cost',b'Costing Rate',b'Costing Rate'
+b'apps/erpnext/erpnext/config/selling.py +234',b'Customer Addresses And Contacts',b'Kunde Adresser og kontakter'
+,b'Campaign Efficiency',b'Kampanjeeffektivitet'
+,b'Campaign Efficiency',b'Kampanjeeffektivitet'
+b'DocType: Discussion',b'Discussion',b'Diskusjon'
+b'DocType: Payment Entry',b'Transaction ID',b'Transaksjons-ID'
+b'DocType: Volunteer',b'Anytime',b'N\xc3\xa5r som helst'
+b'DocType: Patient',b'Surgical History',b'Kirurgisk historie'
+b'DocType: Employee',b'Resignation Letter Date',b'Resignasjon Letter Dato'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +39',b'Pricing Rules are further filtered based on quantity.',b'Prising Reglene er videre filtreres basert p\xc3\xa5 kvantitet.'
+b'apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +127',b'Not Set',b'Ikke sett'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +335',b'Please set the Date Of Joining for employee {0}',b'Vennligst sett datoen for \xc3\xa5 bli med p\xc3\xa5 ansatt {0}'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +335',b'Please set the Date Of Joining for employee {0}',b'Vennligst sett datoen for \xc3\xa5 bli med p\xc3\xa5 ansatt {0}'
+b'DocType: Task',b'Total Billing Amount (via Time Sheet)',b'Total Billing Bel\xc3\xb8p (via Timeregistrering)'
+b'apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +61',b'Repeat Customer Revenue',b'Gjenta kunden Revenue'
+b'DocType: Soil Texture',b'Silty Clay Loam',b'Silty Clay Loam'
+b'DocType: Chapter',b'Chapter',b'Kapittel'
+b'apps/erpnext/erpnext/utilities/user_progress.py +146',b'Pair',b'Par'
+b'DocType: Mode of Payment Account',b'Default account will be automatically updated in POS Invoice when this mode is selected.',b'Standardkontoen oppdateres automatisk i POS-faktura n\xc3\xa5r denne modusen er valgt.'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +970',b'Select BOM and Qty for Production',b'Velg BOM og Stk for produksjon'
+b'DocType: Asset',b'Depreciation Schedule',b'avskrivninger Schedule'
+b'apps/erpnext/erpnext/config/selling.py +124',b'Sales Partner Addresses And Contacts',b'Salgspartneradresser og kontakter'
+b'DocType: Bank Reconciliation Detail',b'Against Account',b'Mot konto'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +52',b'Half Day Date should be between From Date and To Date',b'Half Day Date b\xc3\xb8r v\xc3\xa6re mellom Fra dato og Til dato'
+b'DocType: Maintenance Schedule Detail',b'Actual Date',b'Selve Dato'
+b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +139',b'Please set the Default Cost Center in {0} company.',b'Angi standardkostnadssenteret i {0} selskapet.'
+b'DocType: Item',b'Has Batch No',b'Har Batch No'
+b'apps/erpnext/erpnext/public/js/utils.js +106',b'Annual Billing: {0}',b'\xc3\x85rlig Billing: {0}'
+b'apps/erpnext/erpnext/config/accounts.py +200',b'Goods and Services Tax (GST India)',b'Varer og tjenester skatt (GST India)'
+b'DocType: Delivery Note',b'Excise Page Number',b'Vesenet Page Number'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +227',"b'Company, From Date and To Date is mandatory'","b'Company, Fra dato og Til dato er obligatorisk'"
+b'apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +33',b'Get from Consultation',b'F\xc3\xa5 fra konsultasjon'
+b'DocType: Asset',b'Purchase Date',b'Kj\xc3\xb8psdato'
+b'DocType: Volunteer',b'Volunteer Type',b'Frivillig Type'
+b'DocType: Student',b'Personal Details',b'Personlig Informasjon'
+b'apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +193',"b""Please set 'Asset Depreciation Cost Center' in Company {0}""",b'Vennligst sett &#39;Asset Avskrivninger kostnadssted &quot;i selskapet {0}'
+,b'Maintenance Schedules',b'Vedlikeholdsplaner'
+b'DocType: Task',b'Actual End Date (via Time Sheet)',b'Faktisk Sluttdato (via Timeregistrering)'
+b'DocType: Soil Texture',b'Soil Type',b'Jordtype'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +387',b'Amount {0} {1} against {2} {3}',b'Mengden {0} {1} mot {2} {3}'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +277',b'New Message',b'Ny melding'
+,b'Quotation Trends',b'Anf\xc3\xb8rsels Trender'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +160',b'Item Group not mentioned in item master for item {0}',b'Varegruppe ikke nevnt i punkt master for elementet {0}'
+b'DocType: GoCardless Mandate',b'GoCardless Mandate',b'GoCardless Mandat'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +368',b'Debit To account must be a Receivable account',b'Uttak fra kontoen m\xc3\xa5 v\xc3\xa6re en fordring konto'
+b'DocType: Shipping Rule',b'Shipping Amount',b'Fraktbel\xc3\xb8p'
+b'DocType: Supplier Scorecard Period',b'Period Score',b'Periodepoeng'
+b'apps/erpnext/erpnext/utilities/user_progress.py +66',b'Add Customers',b'Legg til kunder'
+b'apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +20',b'Pending Amount',b'Avventer Bel\xc3\xb8p'
+b'DocType: Lab Test Template',b'Special',b'Spesiell'
+b'DocType: Purchase Order Item Supplied',b'Conversion Factor',b'Omregningsfaktor'
+b'DocType: Purchase Order',b'Delivered',b'Levert'
+,b'Vehicle Expenses',b'Vehicle Utgifter'
+b'DocType: Serial No',b'Invoice Details',b'Fakturadetaljer'
+b'DocType: Grant Application',b'Show on Website',b'Vis p\xc3\xa5 nettstedet'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +212',b'Expected value after useful life must be greater than or equal to {0}',b'Forventet verdi etter levetid m\xc3\xa5 v\xc3\xa6re st\xc3\xb8rre enn eller lik {0}'
+b'apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +29',b'Start on',b'Start p\xc3\xa5'
+b'DocType: Hub Category',b'Hub Category',b'Hub kategori'
+b'DocType: Purchase Invoice',b'SEZ',b'SEZ'
+b'DocType: Purchase Receipt',b'Vehicle Number',b'Vehicle Number'
+b'DocType: Employee Loan',b'Loan Amount',b'L\xc3\xa5nebel\xc3\xb8p'
+b'DocType: Student Report Generation Tool',b'Add Letterhead',b'Legg til brevpapir'
+b'DocType: Program Enrollment',b'Self-Driving Vehicle',b'Selvkj\xc3\xb8rende kj\xc3\xb8ret\xc3\xb8y'
+b'DocType: Supplier Scorecard Standing',b'Supplier Scorecard Standing',b'Leverand\xc3\xb8r Scorecard Standing'
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +443',b'Row {0}: Bill of Materials not found for the Item {1}',b'P {0}: stykk ikke funnet med Element {1}'
+b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +98',b'Total allocated leaves {0} cannot be less than already approved leaves {1} for the period',b'Totalt bevilget blader {0} kan ikke v\xc3\xa6re mindre enn allerede godkjente blader {1} for perioden'
+b'DocType: Journal Entry',b'Accounts Receivable',b'Kundefordringer'
+,b'Supplier-Wise Sales Analytics',b'Leverand\xc3\xb8r-Wise Salgs Analytics'
+b'DocType: Purchase Invoice',b'Availed ITC Central Tax',b'Availed ITC Central Tax'
+b'DocType: Salary Structure',b'Select employees for current Salary Structure',b'Velg ansatte for n\xc3\xa5v\xc3\xa6rende l\xc3\xb8nn struktur'
+b'DocType: Sales Invoice',b'Company Address Name',b'Bedriftsadresse Navn'
+b'DocType: Work Order',b'Use Multi-Level BOM',b'Bruk Multi-Level BOM'
+b'DocType: Bank Reconciliation',b'Include Reconciled Entries',b'Inkluder forsonet Entries'
+b'DocType: Course',"b""Parent Course (Leave blank, if this isn't part of Parent Course)""","b'Foreldrekurs (Forel\xc3\xb8pig, hvis dette ikke er en del av foreldrenes kurs)'"
+b'DocType: Course',"b""Parent Course (Leave blank, if this isn't part of Parent Course)""","b'Foreldrekurs (Forel\xc3\xb8pig, hvis dette ikke er en del av foreldrenes kurs)'"
+b'DocType: Leave Control Panel',b'Leave blank if considered for all employee types',b'La st\xc3\xa5 tom hvis vurderes for alle typer medarbeider'
+b'DocType: Landed Cost Voucher',b'Distribute Charges Based On',b'Distribuere Kostnader Based On'
+b'DocType: Projects Settings',b'Timesheets',b'Timelister'
+b'DocType: HR Settings',b'HR Settings',b'HR-innstillinger'
+b'DocType: Salary Slip',b'net pay info',b'nettol\xc3\xb8nn info'
+b'DocType: Lab Test Template',b'This value is updated in the Default Sales Price List.',b'Denne verdien er oppdatert i standard salgsprislisten.'
+b'DocType: Email Digest',b'New Expenses',b'nye Utgifter'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +79',b'PDC/LC Amount',b'PDC / LC Bel\xc3\xb8p'
+b'DocType: Shareholder',b'Shareholder',b'Aksjon\xc3\xa6r'
+b'DocType: Purchase Invoice',b'Additional Discount Amount',b'Ekstra rabatt Bel\xc3\xb8p'
+b'DocType: Cash Flow Mapper',b'Position',b'Posisjon'
+b'DocType: Patient',b'Patient Details',b'Pasientdetaljer'
+b'DocType: Patient',b'B Positive',b'B Positiv'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +596',"b'Row #{0}: Qty must be 1, as item is a fixed asset. Please use separate row for multiple qty.'",b'Row # {0}: Antall m\xc3\xa5 v\xc3\xa6re en som elementet er et anleggsmiddel. Bruk egen rad for flere stk.'
+b'DocType: Leave Block List Allow',b'Leave Block List Allow',b'La Block List Tillat'
+b'apps/erpnext/erpnext/setup/doctype/company/company.py +317',b'Abbr can not be blank or space',b'Abbr kan ikke v\xc3\xa6re tomt eller plass'
+b'DocType: Patient Medical Record',b'Patient Medical Record',b'Patient Medical Record'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.js +68',b'Group to Non-Group',b'Gruppe til Non-gruppe'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +50',b'Sports',b'Sport'
+b'DocType: Loan Type',b'Loan Name',b'l\xc3\xa5n Name'
+b'apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +56',b'Total Actual',b'Total Actual'
+b'DocType: Lab Test UOM',b'Test UOM',b'Test UOM'
+b'DocType: Student Siblings',b'Student Siblings',b'student S\xc3\xb8sken'
+b'apps/erpnext/erpnext/utilities/user_progress.py +146',b'Unit',b'Enhet'
+b'apps/erpnext/erpnext/stock/get_item_details.py +138',b'Please specify Company',b'Vennligst oppgi selskapet'
+,b'Customer Acquisition and Loyalty',b'Kunden Oppkj\xc3\xb8p og Loyalty'
+b'DocType: Asset Maintenance Task',b'Maintenance Task',b'Vedlikeholdsoppgave'
+b'apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py +118',b'Please set B2C Limit in GST Settings.',b'Vennligst sett inn B2C Limit i GST-innstillinger.'
+b'DocType: Purchase Invoice',b'Warehouse where you are maintaining stock of rejected items',b'Warehouse hvor du opprettholder lager avviste elementer'
+b'DocType: Work Order',b'Skip Material Transfer',b'Hopp over materialoverf\xc3\xb8ring'
+b'DocType: Work Order',b'Skip Material Transfer',b'Hopp over materialoverf\xc3\xb8ring'
+b'apps/erpnext/erpnext/setup/utils.py +109',b'Unable to find exchange rate for {0} to {1} for key date {2}. Please create a Currency Exchange record manually',b'Kan ikke finne valutakurs for {0} til {1} for n\xc3\xb8kkeldato {2}. Vennligst opprett en valutautvekslingsrekord manuelt'
+b'DocType: POS Profile',b'Price List',b'Pris Liste'
+b'apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +22',b'{0} is now the default Fiscal Year. Please refresh your browser for the change to take effect.',b'{0} er n\xc3\xa5 standard regnskaps\xc3\xa5ret. Vennligst oppdater nettleser for at endringen skal tre i kraft.'
+b'apps/erpnext/erpnext/projects/doctype/task/task.js +45',b'Expense Claims',b'Regninger'
+b'DocType: Issue',b'Support',b'Support'
+,b'BOM Search',b'BOM S\xc3\xb8k'
+b'DocType: Project',b'Total Consumed Material Cost  (via Stock Entry)',b'Total forbruket materialkostnad (via lagerinngang)'
+b'DocType: Item',"b'Publish ""In Stock"" or ""Not in Stock"" on Hub based on stock available in this warehouse.'",b'Publiser &quot;P\xc3\xa5 lager&quot; eller &quot;Ikke p\xc3\xa5 lager&quot; p\xc3\xa5 Hub basert p\xc3\xa5 lager tilgjengelig i dette varehuset.'
+b'DocType: Vehicle',b'Fuel Type',b'drivstoff'
+b'apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +27',b'Please specify currency in Company',b'Vennligst oppgi valuta i selskapet'
+b'DocType: Workstation',b'Wages per hour',b'L\xc3\xb8nn per time'
+b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +47',b'Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3}',b'Stock balanse i Batch {0} vil bli negativ {1} for Element {2} p\xc3\xa5 Warehouse {3}'
+b'apps/erpnext/erpnext/templates/emails/reorder_item.html +1',"b""Following Material Requests have been raised automatically based on Item's re-order level""",b'F\xc3\xb8lgende materiale Requests har v\xc3\xa6rt reist automatisk basert p\xc3\xa5 element re-order niv\xc3\xa5'
+b'DocType: Email Digest',b'Pending Sales Orders',b'Avventer salgsordrer'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +312',b'Account {0} is invalid. Account Currency must be {1}',b'Konto {0} er ugyldig. Account Valuta m\xc3\xa5 v\xc3\xa6re {1}'
+b'DocType: Healthcare Settings',b'Remind Before',b'P\xc3\xa5minn f\xc3\xb8r'
+b'apps/erpnext/erpnext/buying/utils.py +34',b'UOM Conversion factor is required in row {0}',b'M\xc3\xa5lenheter Omregningsfaktor er n\xc3\xb8dvendig i rad {0}'
+b'DocType: Production Plan Item',b'material_request_item',b'material_request_item'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1087',"b'Row #{0}: Reference Document Type must be one of Sales Order, Sales Invoice or Journal Entry'","b'Row # {0}: Reference Document Type m\xc3\xa5 v\xc3\xa6re en av salgsordre, salgsfaktura eller bilagsregistrering'"
+b'DocType: Salary Component',b'Deduction',b'Fradrag'
+b'DocType: Item',b'Retain Sample',b'Behold pr\xc3\xb8ve'
+b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +115',b'Row {0}: From Time and To Time is mandatory.',b'Rad {0}: Fra tid og Tid er obligatorisk.'
+b'DocType: Stock Reconciliation Item',b'Amount Difference',b'bel\xc3\xb8p Difference'
+b'apps/erpnext/erpnext/stock/get_item_details.py +356',b'Item Price added for {0} in Price List {1}',b'Varen Pris lagt for {0} i Prisliste {1}'
+b'apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js +8',b'Please enter Employee Id of this sales person',b'Skriv inn Employee Id av denne salgs person'
+b'DocType: Territory',b'Classification of Customers by region',b'Klassifisering av kunder etter region'
+b'apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +71',b'In Production',b'I produksjon'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +65',b'Difference Amount must be zero',b'Forskjellen Bel\xc3\xb8pet m\xc3\xa5 v\xc3\xa6re null'
+b'DocType: Project',b'Gross Margin',b'Bruttomargin'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +61',b'Please enter Production Item first',b'Skriv inn Produksjon varen f\xc3\xb8rst'
+b'apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +45',b'Calculated Bank Statement balance',b'Beregnet kontoutskrift balanse'
+b'DocType: Normal Test Template',b'Normal Test Template',b'Normal testmal'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +64',b'disabled user',b'deaktivert bruker'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +919',b'Quotation',b'Sitat'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +984',b'Cannot set a received RFQ to No Quote',b'Kan ikke angi en mottatt RFQ til No Quote'
+b'DocType: Quotation',b'QTN-',b'QTN-'
+b'DocType: Salary Slip',b'Total Deduction',b'Total Fradrag'
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +18',b'Select an account to print in account currency',b'Velg en konto for \xc3\xa5 skrive ut i kontovaluta'
+,b'Production Analytics',b'produksjons~~POS=TRUNC Analytics'
+b'apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +6',b'This is based on transactions against this Patient. See timeline below for details',b'Dette er basert p\xc3\xa5 transaksjoner mot denne pasienten. Se tidslinjen nedenfor for detaljer'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +204',b'Cost Updated',b'Kostnad Oppdatert'
+b'DocType: Patient',b'Date of Birth',b'F\xc3\xb8dselsdato'
+b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +133',b'Item {0} has already been returned',b'Element {0} er allerede returnert'
+b'DocType: Fiscal Year',b'**Fiscal Year** represents a Financial Year. All accounting entries and other major transactions are tracked against **Fiscal Year**.',b'** Regnskaps\xc3\xa5r ** representerer et regnskaps\xc3\xa5r. Alle regnskapspostene og andre store transaksjoner spores mot ** regnskaps\xc3\xa5r **.'
+b'DocType: Opportunity',b'Customer / Lead Address',b'Kunde / Lead Adresse'
+b'DocType: Supplier Scorecard Period',b'Supplier Scorecard Setup',b'Leverand\xc3\xb8r Scorecard Setup'
+b'apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +133',b'Assessment Plan Name',b'Evalueringsplan Navn'
+b'DocType: Work Order Operation',b'Work Order Operation',b'Arbeidsordreoperasjon'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +233',b'Warning: Invalid SSL certificate on attachment {0}',b'Advarsel: Ugyldig SSL-sertifikat p\xc3\xa5 vedlegg {0}'
+b'apps/erpnext/erpnext/utilities/activation.py +64',"b'Leads help you get business, add all your contacts and more as your leads'","b'Leads hjelpe deg \xc3\xa5 f\xc3\xa5 virksomheten, legge til alle dine kontakter og mer som dine potensielle kunder'"
+b'DocType: Work Order Operation',b'Actual Operation Time',b'Selve Operasjon Tid'
+b'DocType: Authorization Rule',b'Applicable To (User)',b'Gjelder til (User)'
+b'DocType: Purchase Taxes and Charges',b'Deduct',b'Trekke'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +238',b'Job Description',b'Stillingsbeskrivelse'
+b'DocType: Student Applicant',b'Applied',b'Tatt i bruk'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +874',b'Re-open',b'Re-open'
+b'DocType: Sales Invoice Item',b'Qty as per Stock UOM',b'Antall pr Stock m\xc3\xa5lenheter'
+b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +59',b'Guardian2 Name',b'Guardian2 Name'
+b'DocType: Purchase Invoice',b'02-Post Sale Discount',b'02-post salg rabatt'
+b'apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +132',"b'Special Characters except ""-"", ""#"", ""."" and ""/"" not allowed in naming series'","b'Spesialtegn unntatt &quot;-&quot; &quot;.&quot;, &quot;#&quot;, og &quot;/&quot; ikke tillatt i navngi serie'"
+b'DocType: Campaign',"b'Keep Track of Sales Campaigns. Keep track of Leads, Quotations, Sales Order etc from Campaigns to gauge Return on Investment.'","b'Hold orden p\xc3\xa5 salgskampanjer. Hold styr p\xc3\xa5 Leads, Sitater, Salgsordre etc fra kampanjer for \xc3\xa5 m\xc3\xa5le avkastning p\xc3\xa5 investeringen.'"
+,b'SO Qty',b'SO Antall'
+b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +91',b'The field To Shareholder cannot be blank',b'Feltet Til Aksjon\xc3\xa6r kan ikke v\xc3\xa6re tomt'
+b'DocType: Guardian',b'Work Address',b'arbeid Adresse'
+b'DocType: Appraisal',b'Calculate Total Score',b'Beregn Total Score'
+b'DocType: Health Insurance',b'Health Insurance',b'Helseforsikring'
+b'DocType: Asset Repair',b'Manufacturing Manager',b'Produksjonssjef'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +191',b'Serial No {0} is under warranty upto {1}',b'Serial No {0} er under garanti opptil {1}'
+b'DocType: Plant Analysis Criteria',b'Minimum Permissible Value',b'Minste tillatte verdi'
+b'apps/erpnext/erpnext/education/doctype/guardian/guardian.py +41',b'User {0} already exists',b'Bruker {0} eksisterer allerede'
+b'apps/erpnext/erpnext/hooks.py +109',b'Shipments',b'Forsendelser'
+b'DocType: Payment Entry',b'Total Allocated Amount (Company Currency)',b'Totalt tildelte bel\xc3\xb8p (Selskap Valuta)'
+b'DocType: Purchase Order Item',b'To be delivered to customer',b'Som skal leveres til kunde'
+b'DocType: BOM',b'Scrap Material Cost',b'Skrap Material Cost'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +227',b'Serial No {0} does not belong to any Warehouse',b'Serial No {0} tilh\xc3\xb8rer ikke noen Warehouse'
+b'DocType: Grant Application',b'Email Notification Sent',b'E-postvarsling sendt'
+b'DocType: Purchase Invoice',b'In Words (Company Currency)',b'I Words (Company Valuta)'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1018',"b'Item Code, warehouse, quantity are required on row'","b'Varenummer, lager, antall er p\xc3\xa5krevd p\xc3\xa5 rad'"
+b'DocType: Pricing Rule',b'Supplier',b'Leverand\xc3\xb8r'
+b'apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js +41',b'Show Payment Details',b'Vis betalingsdetaljer'
+b'DocType: Consultation',b'Consultation Time',b'Konsultasjonstid'
+b'DocType: C-Form',b'Quarter',b'Quarter'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +106',b'Miscellaneous Expenses',b'Diverse utgifter'
+b'DocType: Global Defaults',b'Default Company',b'Standard selskapet'
+b'apps/erpnext/erpnext/controllers/stock_controller.py +227',b'Expense or Difference account is mandatory for Item {0} as it impacts overall stock value',b'Kostnad eller Difference konto er obligatorisk for Element {0} som det p\xc3\xa5virker samlede b\xc3\xb8rsverdi'
+b'DocType: Payment Request',b'PR',b'PR'
+b'DocType: Cheque Print Template',b'Bank Name',b'Bank Name'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.py +30',b'-Above',b'-Above'
+b'DocType: Employee Loan',b'Employee Loan Account',b'Medarbeider Loan konto'
+b'DocType: Leave Application',b'Total Leave Days',b'Totalt La Days'
+b'DocType: Email Digest',b'Note: Email will not be sent to disabled users',b'Merk: E-post vil ikke bli sendt til funksjonshemmede brukere'
+b'apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +14',b'Number of Interaction',b'Antall interaksjoner'
+b'apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +14',b'Number of Interaction',b'Antall interaksjoner'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +105',b'Item Variant Settings',b'Variantinnstillinger'
+b'apps/erpnext/erpnext/manufacturing/page/production_analytics/production_analytics.js +37',b'Select Company...',b'Velg Company ...'
+b'DocType: Leave Control Panel',b'Leave blank if considered for all departments',b'La st\xc3\xa5 tom hvis vurderes for alle avdelinger'
+b'apps/erpnext/erpnext/config/hr.py +228',"b'Types of employment (permanent, contract, intern etc.).'","b'Typer arbeid (fast, kontrakt, l\xc3\xa6rling etc.).'"
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +434',b'{0} is mandatory for Item {1}',b'{0} er obligatorisk for Element {1}'
+b'apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js +136',"b'Item {0}: {1} qty produced, '","b'Vare {0}: {1} Antall produsert,'"
+b'DocType: Payroll Entry',b'Fortnightly',b'hver fjortende dag'
+b'DocType: Currency Exchange',b'From Currency',b'Fra Valuta'
+b'DocType: Vital Signs',b'Weight (In Kilogram)',b'Vekt (i kilogram)'
+b'DocType: Chapter',b'chapters/chapter_name\nleave blank automatically set after saving chapter.',b'kapitler / kapittelnavn la blankt sett automatisk etter lagring av kapittel.'
+b'apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py +202',b'Please set GST Accounts in GST Settings',b'Vennligst sett GST-kontoer i GST-innstillinger'
+b'apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js +31',b'Type of Business',b'Type virksomhet'
+b'apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +171',"b'Please select Allocated Amount, Invoice Type and Invoice Number in atleast one row'","b'Vennligst velg avsatt bel\xc3\xb8p, fakturatype og fakturanummer i minst \xc3\xa9n rad'"
+b'apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +128',b'Cost of New Purchase',b'Kostnad for nye kj\xc3\xb8p'
+b'apps/erpnext/erpnext/agriculture/doctype/crop_cycle/crop_cycle.py +35',b'All tasks for the detected diseases were imported',b'Alle oppgaver for de oppdagede sykdommene ble importert'
+b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +97',b'Sales Order required for Item {0}',b'Salgsordre kreves for Element {0}'
+b'DocType: Grant Application',b'Grant Description',b'Grant Beskrivelse'
+b'DocType: Purchase Invoice Item',b'Rate (Company Currency)',b'Rate (Selskap Valuta)'
+b'DocType: Student Guardian',b'Others',b'Annet'
+b'DocType: Payment Entry',b'Unallocated Amount',b'uallokert Bel\xc3\xb8p'
+b'apps/erpnext/erpnext/templates/includes/product_page.js +91',b'Cannot find a matching Item. Please select some other value for {0}.',b'Kan ikke finne en matchende element. Vennligst velg en annen verdi for {0}.'
+b'DocType: POS Profile',b'Taxes and Charges',b'Skatter og avgifter'
+b'DocType: Item',"b'A Product or a Service that is bought, sold or kept in stock.'","b'Et produkt eller en tjeneste som er kj\xc3\xb8pt, solgt eller holdes p\xc3\xa5 lager.'"
+b'apps/erpnext/erpnext/hr/page/team_updates/team_updates.js +44',b'No more updates',b'Ingen flere oppdateringer'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +171',"b""Cannot select charge type as 'On Previous Row Amount' or 'On Previous Row Total' for first row""",b'Kan ikke velge charge type som &#39;On Forrige Row bel\xc3\xb8p &quot;eller&quot; On Forrige Row Totals for f\xc3\xb8rste rad'
+b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py +6',b'This covers all scorecards tied to this Setup',b'Dette dekker alle scorecards knyttet til denne oppsettet'
+b'apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.py +29',b'Child Item should not be a Product Bundle. Please remove item `{0}` and save',b'Barn Varen b\xc3\xb8r ikke v\xc3\xa6re et produkt Bundle. Vennligst fjern element `{0}` og lagre'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +12',b'Banking',b'Banking'
+b'apps/erpnext/erpnext/utilities/activation.py +108',b'Add Timesheets',b'Legg Timelister'
+b'DocType: Vehicle Service',b'Service Item',b'tjenesten Element'
+b'DocType: Bank Guarantee',b'Bank Guarantee',b'Bankgaranti'
+b'DocType: Bank Guarantee',b'Bank Guarantee',b'Bankgaranti'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +39',"b""Please click on 'Generate Schedule' to get schedule""",b'Vennligst klikk p\xc3\xa5 &quot;Generer Schedule &#39;for \xc3\xa5 f\xc3\xa5 timeplanen'
+b'DocType: Bin',b'Ordered Quantity',b'Bestilte Antall'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +118',"b'e.g. ""Build tools for builders""'",b'f.eks &quot;Bygg verkt\xc3\xb8y for utbyggere&quot;'
+b'DocType: Grading Scale',b'Grading Scale Intervals',b'Karakterskalaen Intervaller'
+b'apps/erpnext/erpnext/accounts/report/profit_and_loss_statement/profit_and_loss_statement.py +39',b'Profit for the year',b'\xc3\x85rets resultat'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +125',b'{0} {1}: Accounting Entry for {2} can only be made in currency: {3}',b'{0} {1}: Regnskap Entry for {2} kan bare gj\xc3\xb8res i valuta: {3}'
+b'DocType: Fee Schedule',b'In Process',b'Igang'
+b'DocType: Authorization Rule',b'Itemwise Discount',b'Itemwise Rabatt'
+b'apps/erpnext/erpnext/config/accounts.py +75',b'Tree of financial accounts.',b'Tre av finansregnskap.'
+b'DocType: Cash Flow Mapping',b'Cash Flow Mapping',b'Cash Flow Mapping'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +364',b'{0} against Sales Order {1}',b'{0} mot Salgsordre {1}'
+b'DocType: Account',b'Fixed Asset',b'Fast Asset'
+b'apps/erpnext/erpnext/config/stock.py +324',b'Serialized Inventory',b'Serialisert Lager'
+b'apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +74',b'Email not found in default contact',b'E-post ikke funnet i standardkontakt'
+b'DocType: Employee Loan',b'Account Info',b'Kontoinformasjon'
+b'DocType: Activity Type',b'Default Billing Rate',b'Standard Billing pris'
+b'DocType: Fees',b'Include Payment',b'Inkluder betaling'
+b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +77',b'{0} Student Groups created.',b'{0} Studentgrupper opprettet.'
+b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +77',b'{0} Student Groups created.',b'{0} Studentgrupper opprettet.'
+b'DocType: Sales Invoice',b'Total Billing Amount',b'Total Billing Bel\xc3\xb8p'
+b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.py +50',b'Program in the Fee Structure and Student Group {0} are different.',b'Programmet i avgiftsstrukturen og studentgruppen {0} er forskjellig.'
+b'DocType: Fee Schedule',b'Receivable Account',b'Fordring konto'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +618',b'Row #{0}: Asset {1} is already {2}',b'Row # {0}: Asset {1} er allerede {2}'
+b'DocType: Quotation Item',b'Stock Balance',b'Stock Balance'
+b'apps/erpnext/erpnext/config/selling.py +321',b'Sales Order to Payment',b'Salgsordre til betaling'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +123',b'CEO',b'administrerende direkt\xc3\xb8r'
+b'DocType: Purchase Invoice',b'With Payment of Tax',b'Med betaling av skatt'
+b'DocType: Expense Claim Detail',b'Expense Claim Detail',b'Expense krav Detalj'
+b'DocType: Purchase Invoice',b'TRIPLICATE FOR SUPPLIER',b'TRIPLIKAT FOR LEVERAND\xc3\x98R'
+b'DocType: Land Unit',b'Is Container',b'Er Container'
+b'DocType: Crop Cycle',b'This will be day 1 of the crop cycle',b'Dette blir dag 1 i avlingen syklus'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +871',b'Please select correct account',b'Velg riktig konto'
+b'DocType: Purchase Invoice Item',b'Weight UOM',b'Vekt m\xc3\xa5lenheter'
+b'apps/erpnext/erpnext/config/accounts.py +466',b'List of available Shareholders with folio numbers',b'Liste over tilgjengelige Aksjon\xc3\xa6rer med folio nummer'
+b'DocType: Salary Structure Employee',b'Salary Structure Employee',b'L\xc3\xb8nn Struktur Employee'
+b'apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.js +45',b'Show Variant Attributes',b'Vis variantattributter'
+b'DocType: Student',b'Blood Group',b'Blodgruppe'
+b'DocType: Course',b'Course Name',b'Course Name'
+b'DocType: Employee Leave Approver',"b""Users who can approve a specific employee's leave applications""",b'Brukere som kan godkjenne en bestemt ansattes permisjon applikasjoner'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +52',b'Office Equipments',b'Kontor utstyr'
+b'DocType: Purchase Invoice Item',b'Qty',b'Antall'
+b'DocType: Fiscal Year',b'Companies',b'Selskaper'
+b'DocType: Supplier Scorecard',b'Scoring Setup',b'Scoring Setup'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +24',b'Electronics',b'Elektronikk'
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +326',b'Debit ({0})',b'Debet ({0})'
+b'DocType: Stock Settings',b'Raise Material Request when stock reaches re-order level',b'Hev Material Request n\xc3\xa5r aksjen n\xc3\xa5r re-order niv\xc3\xa5'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +98',b'Full-time',b'Fulltid'
+b'DocType: Payroll Entry',b'Employees',b'medarbeidere'
+b'DocType: Employee',b'Contact Details',b'Kontaktinformasjon'
+b'DocType: C-Form',b'Received Date',b'Mottatt dato'
+b'DocType: Delivery Note',"b'If you have created a standard template in Sales Taxes and Charges Template, select one and click on the button below.'","b'Hvis du har opprettet en standard mal i salgs skatter og avgifter mal, velger du ett og klikk p\xc3\xa5 knappen under.'"
+b'DocType: BOM Scrap Item',b'Basic Amount (Company Currency)',b'Grunnbel\xc3\xb8pet (Selskap Valuta)'
+b'DocType: Student',b'Guardians',b'Voktere'
+b'apps/erpnext/erpnext/templates/pages/integrations/gocardless_confirmation.html +13',b'Payment Confirmation',b'Betalingsbekreftelse'
+b'DocType: Shopping Cart Settings',b'Prices will not be shown if Price List is not set',b'Prisene vil ikke bli vist hvis prislisten er ikke satt'
+b'DocType: Stock Entry',b'Total Incoming Value',b'Total Innkommende Verdi'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +362',b'Debit To is required',b'Debet \xc3\x85 kreves'
+b'apps/erpnext/erpnext/utilities/activation.py +109',"b'Timesheets help keep track of time, cost and billing for activites done by your team'","b'Timelister bidra til \xc3\xa5 holde styr p\xc3\xa5 tid, kostnader og fakturering for aktiviteter gjort av teamet ditt'"
+b'apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +39',b'Purchase Price List',b'Kj\xc3\xb8p Prisliste'
+b'apps/erpnext/erpnext/config/buying.py +155',b'Templates of supplier scorecard variables.',b'Maler av leverand\xc3\xb8rens scorecard-variabler.'
+b'DocType: Job Offer Term',b'Offer Term',b'Tilbudet Term'
+b'DocType: Asset',b'Quality Manager',b'Quality Manager'
+b'DocType: Job Applicant',b'Job Opening',b'Job Opening'
+b'DocType: Payment Reconciliation',b'Payment Reconciliation',b'Betaling Avstemming'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +153',"b""Please select Incharge Person's name""",b'Vennligst velg Incharge persons navn'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +51',b'Technology',b'Teknologi'
+b'DocType: Hub Settings',b'Unregister from Hub',b'Avregistrer fra Hub'
+b'apps/erpnext/erpnext/public/js/utils.js +108',b'Total Unpaid: {0}',b'Total Ubetalte: {0}'
+b'DocType: BOM Website Operation',b'BOM Website Operation',b'BOM Nettstedet Operasjon'
+b'DocType: Supplier Scorecard',b'Supplier Score',b'Leverand\xc3\xb8rpoeng'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +213',b'Total Invoiced Amt',b'Total Fakturert Amt'
+b'DocType: Supplier',b'Warn RFQs',b'Advarsel RFQs'
+b'DocType: BOM',b'Conversion Rate',b'konverterings~~POS=TRUNC'
+b'apps/erpnext/erpnext/templates/pages/product_search.html +3',b'Product Search',b'Produkts\xc3\xb8k'
+b'DocType: Assessment Plan',b'To Time',b'Til Time'
+b'DocType: Authorization Rule',b'Approving Role (above authorized value)',b'Godkjenne Role (ovenfor autorisert verdi)'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +118',b'Credit To account must be a Payable account',b'Kreditt til kontoen m\xc3\xa5 v\xc3\xa6re en Betales konto'
+b'apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +43',b'Please select Student Admission which is mandatory for the paid student applicant',"b'Vennligst velg Student Admission, som er obligatorisk for den betalte student s\xc3\xb8keren'"
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +355',b'BOM recursion: {0} cannot be parent or child of {2}',b'BOM rekursjon: {0} kan ikke v\xc3\xa6re forelder eller barn av {2}'
+b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +21',b'Please select a Price List to publish pricing',b'Vennligst velg en prisliste for \xc3\xa5 publisere priser'
+b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +38',b'Budget List',b'Budsjettliste'
+b'DocType: Work Order Operation',b'Completed Qty',b'Fullf\xc3\xb8rt Antall'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +148',"b'For {0}, only debit accounts can be linked against another credit entry'",b'For {0} kan bare belastning kontoer knyttes opp mot en annen kreditt oppf\xc3\xb8ring'
+b'apps/erpnext/erpnext/stock/doctype/item_price/item_price.py +27',b'Price List {0} is disabled',b'Prisliste {0} er deaktivert'
+b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +127',b'Row {0}: Completed Qty cannot be more than {1} for operation {2}',b'Rad {0}: Fullf\xc3\xb8rt Antall kan ikke v\xc3\xa6re mer enn {1} for drift {2}'
+b'DocType: Manufacturing Settings',b'Allow Overtime',b'Tillat Overtid'
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +148',"b'Serialized Item {0} cannot be updated using Stock Reconciliation, please use Stock Entry'","b'Serialisert element {0} kan ikke oppdateres ved hjelp av Stock Forsoning, vennligst bruk Stock Entry'"
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +148',"b'Serialized Item {0} cannot be updated using Stock Reconciliation, please use Stock Entry'","b'Serialisert element {0} kan ikke oppdateres ved hjelp av Stock Forsoning, vennligst bruk Stock Entry'"
+b'DocType: Training Event Employee',b'Training Event Employee',b'Trening Hendelses Employee'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1031',b'Maximum Samples - {0} can be retained for Batch {1} and Item {2}.',b'Maksimale pr\xc3\xb8ver - {0} kan beholdes for Batch {1} og Item {2}.'
+b'apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +7',b'Add Time Slots',b'Legg til tidsluker'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +201',b'{0} Serial Numbers required for Item {1}. You have provided {2}.',b'{0} serienumre som kreves for Element {1}. Du har gitt {2}.'
+b'DocType: Stock Reconciliation Item',b'Current Valuation Rate',b'N\xc3\xa5v\xc3\xa6rende Verdivurdering Rate'
+b'DocType: Training Event',b'Advance',b'Avansere'
+b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +6',b'for making recurring again.',b'for \xc3\xa5 gjenta igjen.'
+b'apps/erpnext/erpnext/config/erpnext_integrations.py +13',b'GoCardless payment gateway settings',b'GoCardless betalings gateway innstillinger'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +122',b'Exchange Gain/Loss',b'Valutagevinst / tap'
+b'DocType: Opportunity',b'Lost Reason',b'Mistet Reason'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +265',b'Row #{0}: Account {1} does not belong to company {2}',b'Rute # {0}: Konto {1} tilh\xc3\xb8rer ikke firma {2}'
+b'apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +30',b'Unable to find DocType {0}',b'Kan ikke finne DocType {0}'
+b'apps/erpnext/erpnext/public/js/templates/address_list.html +22',b'New Address',b'Ny adresse'
+b'DocType: Quality Inspection',b'Sample Size',b'Sample Size'
+b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +47',b'Please enter Receipt Document',b'Fyll inn Kvittering Document'
+b'apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +369',b'All items have already been invoiced',b'Alle elementene er allerede blitt fakturert'
+b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +49',"b""Please specify a valid 'From Case No.'""",b'Vennligst oppgi en gyldig &quot;Fra sak nr &#39;'
+b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +24',b'Further cost centers can be made under Groups but entries can be made against non-Groups',b'Ytterligere kostnadsb\xc3\xa6rere kan gj\xc3\xb8res under Grupper men oppf\xc3\xb8ringene kan gj\xc3\xb8res mot ikke-grupper'
+b'apps/erpnext/erpnext/config/setup.py +66',b'Users and Permissions',b'Brukere og tillatelser'
+b'DocType: Vehicle Log',b'VLOG.',b'Vlog.'
+b'DocType: Branch',b'Branch',b'Branch'
+b'DocType: Soil Analysis',b'Ca/(K+Ca+Mg)',b'Ca / (K + Ca + Mg)'
+b'DocType: Delivery Trip',b'Fulfillment User',b'Fulfillment User'
+b'apps/erpnext/erpnext/config/setup.py +61',b'Printing and Branding',b'Trykking og merkevarebygging'
+b'DocType: Company',b'Total Monthly Sales',b'Totalt m\xc3\xa5nedlig salg'
+b'DocType: Agriculture Analysis Criteria',b'Weather',b'V\xc3\xa6r'
+b'DocType: Bin',b'Actual Quantity',b'Selve Antall'
+b'DocType: Shipping Rule',b'example: Next Day Shipping',b'Eksempel: Neste Day Shipping'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +187',b'Serial No {0} not found',b'Serial No {0} ikke funnet'
+b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +291',b'Subscription has been {0}',b'Abonnementet har v\xc3\xa6rt {0}'
+b'DocType: Fee Schedule Program',b'Fee Schedule Program',b'Avgift Schedule Program'
+b'DocType: Fee Schedule Program',b'Student Batch',b'student Batch'
+b'apps/erpnext/erpnext/utilities/activation.py +119',b'Make Student',b'Gj\xc3\xb8r Student'
+b'DocType: Supplier Scorecard Scoring Standing',b'Min Grade',b'Min karakter'
+b'apps/erpnext/erpnext/projects/doctype/project/project.py +218',b'You have been invited to collaborate on the project: {0}',b'Du har blitt invitert til \xc3\xa5 samarbeide om prosjektet: {0}'
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +157',b'Physician not available on {0}',b'Legen ikke tilgjengelig p\xc3\xa5 {0}'
+b'DocType: Leave Block List Date',b'Block Date',b'Block Dato'
+b'DocType: Crop',b'Crop',b'Avling'
+b'DocType: Purchase Receipt',b'Supplier Delivery Note',b'Leverand\xc3\xb8rleverans Note'
+b'apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +70',b'Apply Now',b'S\xc3\xb8k n\xc3\xa5'
+b'apps/erpnext/erpnext/stock/dashboard/item_dashboard_list.html +25',b'Actual Qty {0} / Waiting Qty {1}',b'Faktisk antall {0} / Venter antall {1}'
+b'apps/erpnext/erpnext/stock/dashboard/item_dashboard_list.html +25',b'Actual Qty {0} / Waiting Qty {1}',b'Faktisk antall {0} / Venter antall {1}'
+b'DocType: Purchase Invoice',b'E-commerce GSTIN',b'E-handel GSTIN'
+b'DocType: Sales Order',b'Not Delivered',b'Ikke levert'
+,b'Bank Clearance Summary',b'Bank Lagersalg Summary'
+b'apps/erpnext/erpnext/config/setup.py +106',"b'Create and manage daily, weekly and monthly email digests.'","b'Opprette og administrere daglige, ukentlige og m\xc3\xa5nedlige e-postford\xc3\xb8yer.'"
+b'DocType: Appraisal Goal',b'Appraisal Goal',b'Appraisal Goal'
+b'DocType: Stock Reconciliation Item',b'Current Amount',b'Gjeldende Bel\xc3\xb8p'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +58',b'Buildings',b'bygninger'
+b'DocType: Fee Schedule',b'Fee Structure',b'Avgiftsstruktur struktur~~POS=HEADCOMP'
+b'DocType: Timesheet Detail',b'Costing Amount',b'Costing Bel\xc3\xb8p'
+b'DocType: Student Admission Program',b'Application Fee',b'P\xc3\xa5meldingsavgift'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +52',b'Submit Salary Slip',b'Send L\xc3\xb8nn Slip'
+b'apps/erpnext/erpnext/controllers/selling_controller.py +137',b'Maxiumm discount for Item {0} is {1}%',b'Maxiumm rabatt for Element {0} er {1}%'
+b'apps/erpnext/erpnext/stock/doctype/item_price/item_price.js +16',b'Import in Bulk',b'Import i Bulk'
+b'DocType: Sales Partner',b'Address & Contacts',b'Adresse og Kontakt'
+b'DocType: SMS Log',b'Sender Name',b'Avsender Navn'
+b'DocType: Agriculture Analysis Criteria',b'Agriculture Analysis Criteria',b'Landbruk Analyse Kriterier'
+b'DocType: POS Profile',b'[Select]',b'[Velg]'
+b'DocType: Vital Signs',b'Blood Pressure (diastolic)',b'Blodtrykk (diastolisk)'
+b'DocType: SMS Log',b'Sent To',b'Sendt til'
+b'DocType: Agriculture Task',b'Holiday Management',b'Holiday Management'
+b'DocType: Payment Request',b'Make Sales Invoice',b'Gj\xc3\xb8r Sales Faktura'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +61',b'Softwares',b'programvare'
+b'apps/erpnext/erpnext/crm/doctype/lead/lead.py +53',b'Next Contact Date cannot be in the past',b'Neste Kontakt Datoen kan ikke v\xc3\xa6re i fortiden'
+b'DocType: Company',b'For Reference Only.',b'For referanse.'
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +112',b'Physician {0} not available on {1}',b'Lege {0} ikke tilgjengelig p\xc3\xa5 {1}'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +2581',b'Select Batch No',b'Velg batchnummer'
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +61',b'Invalid {0}: {1}',b'Ugyldig {0}: {1}'
+,b'GSTR-1',b'GSTR-en'
+b'DocType: Purchase Invoice',b'PINV-RET-',b'PINV-RET-'
+b'DocType: Fee Validity',b'Reference Inv',b'Referanse Inv'
+b'DocType: Sales Invoice Advance',b'Advance Amount',b'Forskuddsbel\xc3\xb8p'
+b'DocType: Manufacturing Settings',b'Capacity Planning',b'Kapasitetsplanlegging'
+b'DocType: Supplier Quotation',b'Rounding Adjustment (Company Currency',b'Avrundingsjustering (Bedriftsvaluta'
+b'apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +43',"b""'From Date' is required""",b'&quot;Fra dato&quot; er n\xc3\xb8dvendig'
+b'DocType: Journal Entry',b'Reference Number',b'Referanse Nummer'
+b'DocType: Employee',b'Employment Details',b'Sysselsetting Detaljer'
+b'DocType: Employee',b'New Workplace',b'Nye arbeidsplassen'
+b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +17',b'Set as Closed',b'Sett som Stengt'
+b'apps/erpnext/erpnext/stock/get_item_details.py +127',b'No Item with Barcode {0}',b'Ingen Element med Barcode {0}'
+b'DocType: Normal Test Items',b'Require Result Value',b'Krever resultatverdi'
+b'DocType: Item',b'Show a slideshow at the top of the page',b'Vis en lysbildeserie p\xc3\xa5 toppen av siden'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +532',b'Boms',b'Boms'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +162',b'Stores',b'Butikker'
+b'DocType: Project Type',b'Projects Manager',b'Prosjekter manager'
+b'DocType: Serial No',b'Delivery Time',b'Leveringstid'
+b'apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +33',b'Ageing Based On',b'Aldring Based On'
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +61',b'Appointment cancelled',b'Avtale kansellert'
+b'DocType: Item',b'End of Life',b'Slutten av livet'
+b'apps/erpnext/erpnext/demo/setup/setup_data.py +331',b'Travel',b'Reise'
+b'DocType: Student Report Generation Tool',b'Include All Assessment Group',b'Inkluder alle vurderingsgrupper'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +183',b'No active or default Salary Structure found for employee {0} for the given dates',b'Ingen aktive eller standard L\xc3\xb8nn Struktur funnet for arbeidstaker {0} for den gitte datoer'
+b'DocType: Leave Block List',b'Allow Users',b'Gi brukere'
+b'DocType: Purchase Order',b'Customer Mobile No',b'Kunden Mobile No'
+b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +1',b'Recurring',b'Gjentakende'
+b'DocType: Cash Flow Mapping Template Details',b'Cash Flow Mapping Template Details',b'Kontantstr\xc3\xb8m kartlegging detaljer'
+b'DocType: Cost Center',b'Track separate Income and Expense for product verticals or divisions.',b'Spor separat inntekter og kostnader for produkt vertikaler eller divisjoner.'
+b'DocType: Rename Tool',b'Rename Tool',b'Rename Tool'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +72',b'Update Cost',b'Oppdater Cost'
+b'DocType: Item Reorder',b'Item Reorder',b'Sak Omgj\xc3\xb8re'
+b'apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +463',b'Show Salary Slip',b'Vis L\xc3\xb8nn Slip'
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +849',b'Transfer Material',b'Transfer Material'
+b'DocType: Fees',b'Send Payment Request',b'Send betalingsforesp\xc3\xb8rsel'
+b'DocType: BOM',"b'Specify the operations, operating cost and give a unique Operation no to your operations.'","b'Spesifiser drift, driftskostnadene og gi en unik Operation nei til driften.'"
+b'DocType: Water Analysis',b'Origin',b'Opprinnelse'
+b'apps/erpnext/erpnext/controllers/status_updater.py +204',b'This document is over limit by {0} {1} for item {4}. Are you making another {3} against the same {2}?',b'Dette dokumentet er over grensen av {0} {1} for elementet {4}. Er du gj\xc3\xb8r en annen {3} mot samme {2}?'
+b'apps/erpnext/erpnext/public/js/controllers/transaction.js +1154',b'Please set recurring after saving',b'Vennligst sett gjentakende etter lagring'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +769',b'Select change amount account',b'Velg endring mengde konto'
+b'DocType: Purchase Invoice',b'Price List Currency',b'Prisliste Valuta'
+b'DocType: Naming Series',b'User must always select',b'Brukeren m\xc3\xa5 alltid velge'
+b'DocType: Stock Settings',b'Allow Negative Stock',b'Tillat Negative Stock'
+b'DocType: Installation Note',b'Installation Note',b'Installasjon Merk'
+b'DocType: Soil Texture',b'Clay',b'Leire'
+b'DocType: Topic',b'Topic',b'Emne'
+b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +45',b'Cash Flow from Financing',b'Kontantstr\xc3\xb8m fra finansierings'
+b'DocType: Budget Account',b'Budget Account',b'budsjett konto'
+b'DocType: Quality Inspection',b'Verified By',b'Verified by'
+b'apps/erpnext/erpnext/setup/doctype/company/company.py +78',"b""Cannot change company's default currency, because there are existing transactions. Transactions must be cancelled to change the default currency.""","b'Kan ikke endre selskapets standardvaluta, fordi det er eksisterende transaksjoner. Transaksjoner m\xc3\xa5 avbestilles \xc3\xa5 endre valgt valuta.'"
+b'DocType: Cash Flow Mapping',b'Is Income Tax Liability',b'Er skatt p\xc3\xa5 inntektsskatt'
+b'DocType: Grading Scale Interval',b'Grade Description',b'grade Beskrivelse'
+b'DocType: Stock Entry',b'Purchase Receipt No',b'Kvitteringen Nei'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +30',b'Earnest Money',b'Earnest Penger'
+b'DocType: Sales Invoice',b' Shipping Bill Number',b'Fraktregningsnummer'
+b'apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +34',b'Traceability',b'Sporbarhet'
+b'DocType: Asset Maintenance Log',b'Actions performed',b'Handlinger utf\xc3\xb8rt'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +51',b'Customer &gt; Customer Group &gt; Territory',b'Kunde&gt; Kundegruppe&gt; Territorium'
+b'DocType: Cash Flow Mapper',b'Section Leader',b'Seksjonsleder'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +137',b'Source of Funds (Liabilities)',b'Source of Funds (Gjeld)'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +431',b'Quantity in row {0} ({1}) must be same as manufactured quantity {2}',b'Antall p\xc3\xa5 rad {0} ({1}) m\xc3\xa5 v\xc3\xa6re det samme som produsert mengde {2}'
+b'DocType: Supplier Scorecard Scoring Standing',b'Employee',b'Ansatt'
+b'DocType: Asset Repair',b'Failure Date',b'Feil dato'
+b'DocType: Sample Collection',b'Collected Time',b'Samlet tid'
+b'DocType: Company',b'Sales Monthly History',b'Salg M\xc3\xa5nedlig historie'
+b'DocType: Asset Maintenance Task',b'Next Due Date',b'neste frist'
+b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +214',b'Select Batch',b'Velg Batch'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +244',b'{0} {1} is fully billed',b'{0} {1} er fullt fakturert'
+b'apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.js +31',b'Vital Signs',b'Livstegn'
+b'DocType: Training Event',b'End Time',b'Sluttid'
+b'apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +63',b'Active Salary Structure {0} found for employee {1} for the given dates',b'Aktiv L\xc3\xb8nn Struktur {0} funnet for ansatt {1} for de gitte datoer'
+b'DocType: Payment Entry',b'Payment Deductions or Loss',b'Betalings fradrag eller tap'
+b'DocType: Soil Analysis',b'Soil Analysis Criterias',b'Jordanalysekriterier'
+b'apps/erpnext/erpnext/config/setup.py +42',b'Standard contract terms for Sales or Purchase.',b'Standard kontraktsvilk\xc3\xa5r for salg eller kj\xc3\xb8p.'
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +112',b'Group by Voucher',b'Grupper etter Voucher'
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +233',b'Are you sure you want to cancel this appointment?',b'Er du sikker p\xc3\xa5 at du vil avbryte denne avtalen?'
+b'DocType: Hotel Room Pricing Package',b'Hotel Room Pricing Package',b'Hotellrom Prispakke'
+b'apps/erpnext/erpnext/config/crm.py +6',b'Sales Pipeline',b'salgs~~POS=TRUNC'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +201',b'Please set default account in Salary Component {0}',b'Vennligst angi standardkonto i L\xc3\xb8nn Component {0}'
+b'apps/erpnext/erpnext/templates/form_grid/material_request_grid.html +7',b'Required On',b'N\xc3\xb8dvendig P\xc3\xa5'
+b'DocType: Rename Tool',b'File to Rename',b'Filen til Rename'
+b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +200',b'Please select BOM for Item in Row {0}',b'Vennligst velg BOM for Element i Rad {0}'
+b'apps/erpnext/erpnext/accounts/doctype/mode_of_payment/mode_of_payment.py +28',b'Account {0} does not match with Company {1} in Mode of Account: {2}',b'Konto {0} stemmer ikke overens med Selskapet {1} i Konto modus: {2}'
+b'apps/erpnext/erpnext/controllers/buying_controller.py +464',b'Specified BOM {0} does not exist for Item {1}',b'Spesifisert BOM {0} finnes ikke for Element {1}'
+b'apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +301',b'Course: ',b'Kurs:'
+b'DocType: Soil Texture',b'Sandy Loam',b'Sandy Loam'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +232',b'Maintenance Schedule {0} must be cancelled before cancelling this Sales Order',b'Vedlikeholdsplan {0} m\xc3\xa5 avbestilles f\xc3\xb8r den avbryter denne salgsordre'
+b'DocType: POS Profile',b'Applicable for Users',b'Gjelder for brukere'
+b'DocType: Notification Control',b'Expense Claim Approved',b'Expense krav Godkjent'
+b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +231',b'No Work Orders created',b'Ingen arbeidsordre opprettet'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +321',b'Salary Slip of employee {0} already created for this period',b'L\xc3\xb8nn Slip av ansattes {0} som allerede er opprettet for denne perioden'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +155',b'Pharmaceutical',b'Pharmaceutical'
+b'apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26',b'Cost of Purchased Items',b'Kostnad for kj\xc3\xb8pte varer'
+b'DocType: Selling Settings',b'Sales Order Required',b'Salgsordre P\xc3\xa5krevd'
+b'DocType: Purchase Invoice',b'Credit To',b'Kreditt til'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +46',b'PieceDate',b'PieceDate'
+b'apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +31',b'Active Leads / Customers',b'Aktive Ledninger / Kunder'
+b'DocType: Employee Education',b'Post Graduate',b'Post Graduate'
+b'DocType: Maintenance Schedule Detail',b'Maintenance Schedule Detail',b'Vedlikeholdsplan Detalj'
+b'DocType: Supplier Scorecard',b'Warn for new Purchase Orders',b'Varsle om nye innkj\xc3\xb8psordrer'
+b'DocType: Quality Inspection Reading',b'Reading 9',b'Lese 9'
+b'DocType: Supplier',b'Is Frozen',b'Er Frozen'
+b'apps/erpnext/erpnext/stock/utils.py +224',b'Group node warehouse is not allowed to select for transactions',b'Gruppe node lageret er ikke lov til \xc3\xa5 velge for transaksjoner'
+b'DocType: Buying Settings',b'Buying Settings',b'Kj\xc3\xb8pe Innstillinger'
+b'DocType: Stock Entry Detail',b'BOM No. for a Finished Good Item',b'BOM No. for et ferdig God Sak'
+b'DocType: Upload Attendance',b'Attendance To Date',b'Oppm\xc3\xb8te To Date'
+b'DocType: Request for Quotation Supplier',b'No Quote',b'Ingen sitat'
+b'DocType: Warranty Claim',b'Raised By',b'Raised By'
+b'DocType: Payment Gateway Account',b'Payment Account',b'Betaling konto'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +909',b'Please specify Company to proceed',b'Vennligst oppgi selskapet \xc3\xa5 fortsette'
+b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +27',b'Net Change in Accounts Receivable',b'Netto endring i kundefordringer'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +88',b'Compensatory Off',b'Kompenserende Off'
+b'DocType: Job Offer',b'Accepted',b'Akseptert'
+b'DocType: Grant Application',b'Organization',b'Organisasjon'
+b'DocType: BOM Update Tool',b'BOM Update Tool',b'BOM Update Tool'
+b'DocType: SG Creation Tool Course',b'Student Group Name',b'Student Gruppenavn'
+b'apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.js +17',b'Show exploded view',b'Vis eksplodert visning'
+b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +7',b'Creating Fees',b'Opprette avgifter'
+b'apps/erpnext/erpnext/setup/doctype/company/company.js +91',b'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.',b'S\xc3\xb8rg for at du virkelig \xc3\xb8nsker \xc3\xa5 slette alle transaksjoner for dette selskapet. Dine stamdata vil forbli som det er. Denne handlingen kan ikke angres.'
+b'apps/erpnext/erpnext/templates/pages/product_search.html +21',b'Search Results',b'S\xc3\xb8keresultater'
+b'DocType: Room',b'Room Number',b'Romnummer'
+b'apps/erpnext/erpnext/utilities/transaction_base.py +107',b'Invalid reference {0} {1}',b'Ugyldig referanse {0} {1}'
+b'DocType: Shipping Rule',b'Shipping Rule Label',b'Shipping Rule Etikett'
+b'DocType: Journal Entry Account',b'Payroll Entry',b'L\xc3\xb8nninngang'
+b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +75',b'View Fees Records',b'Se avgifter'
+b'apps/erpnext/erpnext/setup/doctype/company/company.js +35',b'Make Tax Template',b'Lag skatteremne'
+b'apps/erpnext/erpnext/public/js/conf.js +28',b'User Forum',b'bruker~~POS=TRUNC'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +319',b'Raw Materials cannot be blank.',b'R\xc3\xa5vare kan ikke v\xc3\xa6re blank.'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +498',"b'Could not update stock, invoice contains drop shipping item.'","b'Kunne ikke oppdatere lager, inneholder faktura slippe frakt element.'"
+b'DocType: Lab Test Sample',b'Lab Test Sample',b'Lab Test pr\xc3\xb8ve'
+b'DocType: Item Variant Settings',b'Allow Rename Attribute Value',b'Tillat omd\xc3\xb8pe attributtverdi'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +491',b'Quick Journal Entry',b'Hurtig Journal Entry'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +200',b'You can not change rate if BOM mentioned agianst any item',b'Du kan ikke endre prisen dersom BOM nevnt agianst ethvert element'
+b'DocType: Restaurant',b'Invoice Series Prefix',b'Faktura Serie Prefiks'
+b'DocType: Employee',b'Previous Work Experience',b'Tidligere arbeidserfaring'
+b'DocType: Stock Entry',b'For Quantity',b'For Antall'
+b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +205',b'Please enter Planned Qty for Item {0} at row {1}',b'Skriv inn Planned Antall for Element {0} p\xc3\xa5 rad {1}'
+b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +93',b'Google Maps integration is not enabled',b'Integrasjon med Google Maps er ikke aktivert'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +241',b'{0} {1} is not submitted',b'{0} {1} ikke er sendt'
+b'DocType: Member',b'Membership Expiry Date',b'Medlemskapets utl\xc3\xb8psdato'
+b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +131',b'{0} must be negative in return document',b'{0} m\xc3\xa5 v\xc3\xa6re negativ i retur dokument'
+,b'Minutes to First Response for Issues',b'Minutter til First Response for Issues'
+b'DocType: Purchase Invoice',b'Terms and Conditions1',b'Vilk\xc3\xa5r og forhold 1'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +109',b'The name of the institute for which you are setting up this system.',b'Navnet p\xc3\xa5 institutt for som du setter opp dette systemet.'
+b'DocType: Accounts Settings',"b'Accounting entry frozen up to this date, nobody can do / modify entry except role specified below.'","b'Regnskap oppf\xc3\xb8ring frosset opp til denne datoen, kan ingen gj\xc3\xb8re / endre oppf\xc3\xb8ring unntatt rolle angitt nedenfor.'"
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +116',b'Please save the document before generating maintenance schedule',b'Vennligst lagre dokumentet f\xc3\xb8r du genererer vedlikeholdsplan'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.js +30',b'Latest price updated in all BOMs',b'Siste pris oppdatert i alle BOMs'
+b'apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +28',b'Project Status',b'Prosjekt Status'
+b'DocType: UOM',b'Check this to disallow fractions. (for Nos)',b'Sjekk dette for \xc3\xa5 forby fraksjoner. (For Nos)'
+b'DocType: Student Admission Program',b'Naming Series (for Student Applicant)',b'Naming Series (Student s\xc3\xb8keren)'
+b'DocType: Delivery Note',b'Transporter Name',b'Transporter Name'
+b'DocType: Authorization Rule',b'Authorized Value',b'Autorisert Verdi'
+b'DocType: BOM',b'Show Operations',b'Vis Operations'
+,b'Minutes to First Response for Opportunity',b'Minutter til First Response for Opportunity'
+b'apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68',b'Total Absent',b'Total Frav\xc3\xa6rende'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +862',b'Item or Warehouse for row {0} does not match Material Request',b'Element eller Warehouse for rad {0} samsvarer ikke Material Request'
+b'apps/erpnext/erpnext/config/stock.py +191',b'Unit of Measure',b'M\xc3\xa5leenhet'
+b'DocType: Fiscal Year',b'Year End Date',b'\xc3\x85r Sluttdato'
+b'DocType: Task Depends On',b'Task Depends On',b'Task Avhenger'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1026',b'Opportunity',b'Opportunity'
+b'DocType: Operation',b'Default Workstation',b'Standard arbeidsstasjon'
+b'DocType: Notification Control',b'Expense Claim Approved Message',b'Expense krav Godkjent melding'
+b'DocType: Payment Entry',b'Deductions or Loss',b'Fradrag eller tap'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +247',b'{0} {1} is closed',b'{0} {1} er stengt'
+b'DocType: Email Digest',b'How frequently?',b'Hvor ofte?'
+b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +55',b'Total Collected: {0}',b'Samlet samlet: {0}'
+b'DocType: Purchase Receipt',b'Get Current Stock',b'F\xc3\xa5 Current Stock'
+b'DocType: Purchase Invoice',b'ineligible',b'ikke kvalifisert'
+b'apps/erpnext/erpnext/config/manufacturing.py +46',b'Tree of Bill of Materials',b'Tree of Bill of Materials'
+b'DocType: Student',b'Joining Date',b'Bli med dato'
+,b'Employees working on a holiday',b'Arbeidstakere som arbeider p\xc3\xa5 ferie'
+b'DocType: Share Balance',b'Current State',b'N\xc3\xa5v\xc3\xa6rende situasjon'
+b'apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +152',b'Mark Present',b'Mark Present'
+b'DocType: Share Transfer',b'From Shareholder',b'Fra Aksjon\xc3\xa6r'
+b'DocType: Project',b'% Complete Method',b'% Komplett Method'
+b'apps/erpnext/erpnext/healthcare/setup.py +181',b'Drug',b'Legemiddel'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +200',b'Maintenance start date can not be before delivery date for Serial No {0}',b'Vedlikehold startdato kan ikke v\xc3\xa6re f\xc3\xb8r leveringsdato for Serial No {0}'
+b'DocType: Work Order',b'Actual End Date',b'Selve sluttdato'
+b'DocType: Cash Flow Mapping',b'Is Finance Cost Adjustment',b'Er finansieringskostnadsjustering'
+b'DocType: BOM',b'Operating Cost (Company Currency)',b'Driftskostnader (Selskap Valuta)'
+b'DocType: Purchase Invoice',b'PINV-',b'PINV-'
+b'DocType: Authorization Rule',b'Applicable To (Role)',b'Gjelder til (Role)'
+b'DocType: BOM Update Tool',b'Replace BOM',b'Erstatt BOM'
+b'apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.py +110',b'Code {0} already exist',b'Kode {0} finnes allerede'
+b'DocType: Employee Advance',b'Purpose',b'Form\xc3\xa5let'
+b'DocType: Company',b'Fixed Asset Depreciation Settings',b'Fast Asset Avskrivninger Innstillinger'
+b'DocType: Item',b'Will also apply for variants unless overrridden',b'Vil ogs\xc3\xa5 gjelde for varianter med mindre overrridden'
+b'DocType: Purchase Invoice',b'Advances',b'Fremskritt'
+b'DocType: Work Order',b'Manufacture against Material Request',b'Produksjon mot Material Request'
+b'apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +14',b'Assessment Group: ',b'Bed\xc3\xb8mmelsesgruppe:'
+b'DocType: Item Reorder',b'Request for',b'Foresp\xc3\xb8rsel etter'
+b'apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +32',b'Approving User cannot be same as user the rule is Applicable To',b'Godkjenne Brukeren kan ikke v\xc3\xa6re det samme som bruker regelen gjelder for'
+b'DocType: Stock Entry Detail',b'Basic Rate (as per Stock UOM)',b'Basic Rate (som per Stock m\xc3\xa5lenheter)'
+b'DocType: SMS Log',b'No of Requested SMS',b'Ingen av Spurt SMS'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +246',b'Leave Without Pay does not match with approved Leave Application records',b'La Uten Pay ikke samsvarer med godkjente La S\xc3\xb8knad poster'
+b'DocType: Campaign',b'Campaign-.####',b'Kampanje -. ####'
+b'apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +21',b'Next Steps',b'Neste skritt'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +796',b'Please supply the specified items at the best possible rates',b'Vennligst oppgi de angitte elementene p\xc3\xa5 de best mulige priser'
+b'DocType: Membership',b'USD',b'USD'
+b'apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +28',b'Make Invoice',b'Gj\xc3\xb8r Faktura'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +80',b'Remaining Balance',b'Gjenv\xc3\xa6rende balanse'
+b'DocType: Selling Settings',b'Auto close Opportunity after 15 days',b'Auto n\xc3\xa6r mulighet etter 15 dager'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +86',b'Purchase Orders are not allowed for {0} due to a scorecard standing of {1}.',b'Innkj\xc3\xb8psordrer er ikke tillatt for {0} p\xc3\xa5 grunn av et scorecard som st\xc3\xa5r p\xc3\xa5 {1}.'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +498',b'Barcode {0} is not a valid {1} code',b'Strekkode {0} er ikke en gyldig {1} kode'
+b'apps/erpnext/erpnext/public/js/financial_statements.js +83',b'End Year',b'slutt \xc3\x85r'
+b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +23',b'Quot/Lead %',b'Quot / Lead%'
+b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +23',b'Quot/Lead %',b'Quot / Lead%'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +124',b'Contract End Date must be greater than Date of Joining',b'Kontraktssluttdato m\xc3\xa5 v\xc3\xa6re st\xc3\xb8rre enn tidspunktet for inntreden'
+b'DocType: Driver',b'Driver',b'Sj\xc3\xa5f\xc3\xb8r'
+b'DocType: Vital Signs',b'Nutrition Values',b'Ern\xc3\xa6ringsverdier'
+b'DocType: Lab Test Template',b'Is billable',b'Er fakturerbart'
+b'DocType: Delivery Note',b'DN-',b'DN-'
+b'DocType: Sales Partner',b'A third party distributor / dealer / commission agent / affiliate / reseller who sells the companies products for a commission.',b'En tredjepart distribut\xc3\xb8r / forhandler / kommisjon\xc3\xa6r / agent / forhandler som selger selskaper produkter for en kommisjon.'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +376',b'{0} against Purchase Order {1}',b'{0} mot innkj\xc3\xb8psordre {1}'
+b'DocType: Patient',b'Patient Demographics',b'Pasientdemografi'
+b'DocType: Task',b'Actual Start Date (via Time Sheet)',b'Faktisk startdato (via Timeregistrering)'
+b'apps/erpnext/erpnext/portal/doctype/homepage/homepage.py +15',b'This is an example website auto-generated from ERPNext',b'Dette er et eksempel nettsiden automatisk generert fra ERPNext'
+b'apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +43',b'Ageing Range 1',b'Aldring Range 1'
+b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +212',b'Total advance amount cannot be greater than total claimed amount',b'Samlet forskuddsbel\xc3\xb8p kan ikke v\xc3\xa6re st\xc3\xb8rre enn totalt bel\xc3\xb8p'
+b'DocType: Purchase Taxes and Charges Template',"b'Standard tax template that can be applied to all Purchase Transactions. This template can contain list of tax heads and also other expense heads like ""Shipping"", ""Insurance"", ""Handling"" etc.\n\n#### Note\n\nThe tax rate you define here will be the standard tax rate for all **Items**. If there are **Items** that have different rates, they must be added in the **Item Tax** table in the **Item** master.\n\n#### Description of Columns\n\n1. Calculation Type: \n    - This can be on **Net Total** (that is the sum of basic amount).\n    - **On Previous Row Total / Amount** (for cumulative taxes or charges). If you select this option, the tax will be applied as a percentage of the previous row (in the tax table) amount or total.\n    - **Actual** (as mentioned).\n2. Account Head: The Account ledger under which this tax will be booked\n3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.\n4. Description: Description of the tax (that will be printed in invoices / quotes).\n5. Rate: Tax rate.\n6. Amount: Tax amount.\n7. Total: Cumulative total to this point.\n8. Enter Row: If based on ""Previous Row Total"" you can select the row number which will be taken as a base for this calculation (default is the previous row).\n9. Consider Tax or Charge for: In this section you can specify if the tax / charge is only for valuation (not a part of total) or only for total (does not add value to the item) or for both.\n10. Add or Deduct: Whether you want to add or deduct the tax.'","b'Standard skatt mal som kan brukes p\xc3\xa5 alle kj\xc3\xb8pstransaksjoner. Denne malen kan inneholde liste over skatte hoder og ogs\xc3\xa5 andre utgifter hoder som &quot;Shipping&quot;, &quot;Forsikring&quot;, &quot;H\xc3\xa5ndtering&quot; osv #### Note Skattesatsen du definerer her vil v\xc3\xa6re standard skattesats for alle ** Items * *. Hvis det er ** Elementer ** som har forskjellige priser, m\xc3\xa5 de legges i ** Sak Skatt ** bord i ** Sak ** mester. #### Beskrivelse av kolonner 1. Beregning Type: - Dette kan v\xc3\xa6re p\xc3\xa5 ** Net Total ** (som er summen av grunnbel\xc3\xb8pet). - ** P\xc3\xa5 Forrige Row Total / Bel\xc3\xb8p ** (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\xc3\xb8rt 3. Cost Center: Hvis skatt / avgift er en inntekt (som frakt) eller utgifter det m\xc3\xa5 bestilles mot et kostnadssted. 4. Beskrivelse: Beskrivelse av skatt (som vil bli skrevet ut i fakturaer / sitater). 5. Ranger: skattesats. 6. Bel\xc3\xb8p: Skatt bel\xc3\xb8p. 7. Totalt: Akkumulert total til dette punktet. 8. Angi Row: Dersom basert p\xc3\xa5 &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\xc3\xb8re verdi til elementet) eller for begge. 10. legge til eller trekke: Enten du \xc3\xb8nsker \xc3\xa5 legge til eller trekke skatt.'"
+b'DocType: Homepage',b'Homepage',b'hjemmeside'
+b'apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +68',b'Select Physician...',b'Velg lege ...'
+b'DocType: Grant Application',b'Grant Application Details ',b'Gi s\xc3\xb8knadsdetaljer'
+b'DocType: Purchase Receipt Item',b'Recd Quantity',b'Recd Antall'
+b'apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py +65',b'Fee Records Created - {0}',b'Fee Records Laget - {0}'
+b'DocType: Asset Category Account',b'Asset Category Account',b'Asset Kategori konto'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +913',b'Row #{0} (Payment Table): Amount must be positive',b'Row # {0} (Betalingstabell): Bel\xc3\xb8pet m\xc3\xa5 v\xc3\xa6re positivt'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +44',b'CompteNum',b'CompteNum'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +137',b'Cannot produce more Item {0} than Sales Order quantity {1}',b'Kan ikke produsere mer Element {0} enn Salgsordre kvantitet {1}'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +391',b'Select Attribute Values',b'Velg Attributtverdier'
+b'DocType: Purchase Invoice',b'Reason For Issuing document',b'\xc3\x85rsak til utstedelse av dokument'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +539',b'Stock Entry {0} is not submitted',b'Stock Entry {0} er ikke innsendt'
+b'DocType: Payment Reconciliation',b'Bank / Cash Account',b'Bank / minibank konto'
+b'apps/erpnext/erpnext/crm/doctype/lead/lead.py +47',b'Next Contact By cannot be same as the Lead Email Address',b'Neste Kontakt By kan ikke v\xc3\xa6re samme som Lead e-postadresse'
+b'DocType: Tax Rule',b'Billing City',b'Fakturering By'
+b'DocType: Asset',b'Manual',b'H\xc3\xa5ndbok'
+b'DocType: Salary Component Account',b'Salary Component Account',b'L\xc3\xb8nn Component konto'
+b'DocType: Global Defaults',b'Hide Currency Symbol',b'Skjule Valutasymbol'
+b'apps/erpnext/erpnext/config/non_profit.py +58',b'Donor information.',b'Donorinformasjon.'
+b'apps/erpnext/erpnext/config/accounts.py +330',"b'e.g. Bank, Cash, Credit Card'","b'f.eks Bank, Cash, Kredittkort'"
+b'DocType: Lead Source',b'Source Name',b'Source Name'
+b'DocType: Vital Signs',"b'Normal resting blood pressure in an adult is approximately 120 mmHg systolic, and 80 mmHg diastolic, abbreviated ""120/80 mmHg""'","b'Normal hvilende blodtrykk hos en voksen er ca. 120 mmHg systolisk og 80 mmHg diastolisk, forkortet &quot;120/80 mmHg&quot;'"
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.py +119',"b'Set items shelf life in days, to set expiry based on manufacturing_date plus self life'","b'Angi gjenstander holdbarhet om dager, for \xc3\xa5 angi utl\xc3\xb8p basert p\xc3\xa5 manufacturing_date pluss selvtid'"
+b'DocType: Journal Entry',b'Credit Note',b'Kreditnota'
+b'DocType: Projects Settings',b'Ignore Employee Time Overlap',b'Ignorer arbeidstakertidoverlapping'
+b'DocType: Warranty Claim',b'Service Address',b'Tjenesten Adresse'
+b'DocType: Asset Maintenance Task',b'Calibration',b'kalibrering'
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +97',b'{0} is a company holiday',b'{0} er en firmas ferie'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +49',b'Furnitures and Fixtures',b'M\xc3\xb8bler og inventar'
+b'DocType: Item',b'Manufacture',b'Produksjon'
+b'apps/erpnext/erpnext/utilities/user_progress.py +27',b'Setup Company',b'Oppsett Company'
+,b'Lab Test Report',b'Lab Test Report'
+b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +13',b'Please Delivery Note first',b'Vennligst f\xc3\xb8lgeseddel f\xc3\xb8rst'
+b'DocType: Student Applicant',b'Application Date',b'S\xc3\xb8knadsdato'
+b'DocType: Salary Detail',b'Amount based on formula',b'Bel\xc3\xb8p basert p\xc3\xa5 formelen'
+b'DocType: Purchase Invoice',b'Currency and Price List',b'Valuta og prisliste'
+b'DocType: Opportunity',b'Customer / Lead Name',b'Kunde / Lead navn'
+b'apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +115',b'Clearance Date not mentioned',b'Klaring Dato ikke nevnt'
+b'apps/erpnext/erpnext/config/manufacturing.py +7',b'Production',b'Produksjon'
+b'DocType: Guardian',b'Occupation',b'Okkupasjon'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +74',b'Row {0}:Start Date must be before End Date',b'Rad {0}: Startdato m\xc3\xa5 v\xc3\xa6re f\xc3\xb8r sluttdato'
+b'DocType: Crop',b'Planting Area',b'Planteomr\xc3\xa5de'
+b'apps/erpnext/erpnext/controllers/trends.py +19',b'Total(Qty)',b'Total (Stk)'
+b'DocType: Installation Note Item',b'Installed Qty',b'Installert antall'
+b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +4',b'This could be because of some invalid Email Addresses in the',b'Dette kan skyldes noen ugyldige e-postadresser i'
+b'apps/erpnext/erpnext/utilities/user_progress.py +31',b'You added ',b'Du har lagt til'
+b'DocType: Purchase Taxes and Charges',b'Parenttype',b'Parenttype'
+b'apps/erpnext/erpnext/hr/doctype/training_event/training_event.js +10',b'Training Result',b'trening Resultat'
+b'DocType: Purchase Invoice',b'Is Paid',b'er betalt'
+b'DocType: Salary Structure',b'Total Earning',b'Total Tjene'
+b'DocType: Purchase Receipt',b'Time at which materials were received',b'Tidspunktet for n\xc3\xa5r materialene ble mottatt'
+b'DocType: Products Settings',b'Products per Page',b'Produkter per side'
+b'DocType: Stock Ledger Entry',b'Outgoing Rate',b'Utg\xc3\xa5ende Rate'
+b'apps/erpnext/erpnext/config/hr.py +233',b'Organization branch master.',b'Organisering gren mester.'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +313',b' or ',b'eller'
+b'DocType: Sales Order',b'Billing Status',b'Billing Status'
+b'apps/erpnext/erpnext/public/js/conf.js +32',b'Report an Issue',b'Melde om et problem'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +120',b'Utility Expenses',b'Utility Utgifter'
+b'apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +64',b'90-Above',b'90-Above'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +252',b'Row #{0}: Journal Entry {1} does not have account {2} or already matched against another voucher',b'Row # {0}: Bilagsregistrering {1} har ikke konto {2} eller allerede matchet mot en annen kupong'
+b'DocType: Supplier Scorecard Criteria',b'Criteria Weight',b'Kriterier Vekt'
+b'DocType: Buying Settings',b'Default Buying Price List',b'Standard Kj\xc3\xb8pe Prisliste'
+b'DocType: Payroll Entry',b'Salary Slip Based on Timesheet',b'L\xc3\xb8nn Slip Basert p\xc3\xa5 Timeregistrering'
+b'apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +43',b'Buying Rate',b'Kj\xc3\xb8pspris'
+b'DocType: Notification Control',b'Sales Order Message',b'Salgsordre Message'
+b'apps/erpnext/erpnext/config/setup.py +15',"b'Set Default Values like Company, Currency, Current Fiscal Year, etc.'","b'Sett standardverdier som Company, Valuta, v\xc3\xa6rende regnskaps\xc3\xa5r, etc.'"
+b'DocType: Payment Entry',b'Payment Type',b'Betalings Type'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.py +240',b'Please select a Batch for Item {0}. Unable to find a single batch that fulfills this requirement',b'Vennligst velg en batch for element {0}. Kunne ikke finne en enkelt batch som oppfyller dette kravet'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.py +240',b'Please select a Batch for Item {0}. Unable to find a single batch that fulfills this requirement',b'Vennligst velg en batch for element {0}. Kunne ikke finne en enkelt batch som oppfyller dette kravet'
+b'DocType: Hub Category',b'Parent Category',b'Foreldrekategori'
+b'DocType: Payroll Entry',b'Select Employees',b'Velg Medarbeidere'
+b'DocType: Opportunity',b'Potential Sales Deal',b'Potensielle Sales Deal'
+b'DocType: Complaint',b'Complaints',b'klager'
+b'DocType: Payment Entry',b'Cheque/Reference Date',b'Sjekk / Reference Date'
+b'DocType: Purchase Invoice',b'Total Taxes and Charges',b'Totale skatter og avgifter'
+b'DocType: Employee',b'Emergency Contact',b'N\xc3\xb8dtelefon'
+b'DocType: Bank Reconciliation Detail',b'Payment Entry',b'betaling Entry'
+,b'sales-browser',b'salg-browser'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.js +79',b'Ledger',b'Ledger'
+b'DocType: Patient Medical Record',b'PMR-',b'PMR-'
+b'DocType: Drug Prescription',b'Drug Code',b'Legemiddelkode'
+b'DocType: Target Detail',b'Target  Amount',b'Target Bel\xc3\xb8p'
+b'DocType: POS Profile',b'Print Format for Online',b'Utskriftsformat for Internett'
+b'DocType: Shopping Cart Settings',b'Shopping Cart Settings',b'Handlevogn Innstillinger'
+b'DocType: Journal Entry',b'Accounting Entries',b'Regnskaps Entries'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +17',"b""If selected Pricing Rule is made for 'Rate', it will overwrite Price List. Pricing Rule rate is the final rate, so no further discount should be applied. Hence, in transactions like Sales Order, Purchase Order etc, it will be fetched in 'Rate' field, rather than 'Price List Rate' field.""","b'Hvis valgt prismodell er laget for \xc2\xabRate\xc2\xbb, vil den overskrive Prisliste. Prissetting Regelsats er sluttprisen, s\xc3\xa5 ingen ytterligere rabatt skal brukes. Derfor, i transaksjoner som salgsordre, innkj\xc3\xb8psordre osv., Blir det hentet i feltet &#39;Rate&#39;, i stedet for &#39;Prislistefrekvens&#39;.'"
+b'apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +24',b'Duplicate Entry. Please check Authorization Rule {0}',b'Duplisere Entry. Vennligst sjekk Authorization Rule {0}'
+b'DocType: Journal Entry Account',b'Reference Due Date',b'Referansedato'
+b'DocType: Purchase Order',b'Ref SQ',b'Ref SQ'
+b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +55',b'Receipt document must be submitted',b'Kvittering dokumentet m\xc3\xa5 sendes'
+b'DocType: Purchase Invoice Item',b'Received Qty',b'Mottatt Antall'
+b'DocType: Stock Entry Detail',b'Serial No / Batch',b'Serial No / Batch'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +340',b'Not Paid and Not Delivered',b'Ikke betalt og ikke levert'
+b'DocType: Product Bundle',b'Parent Item',b'Parent Element'
+b'DocType: Account',b'Account Type',b'Kontotype'
+b'DocType: Delivery Note',b'DN-RET-',b'DN-RET-'
+b'apps/erpnext/erpnext/templates/pages/projects.html +58',b'No time sheets',b'Ingen timelister'
+b'DocType: GoCardless Mandate',b'GoCardless Customer',b'GoCardless kunde'
+b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +123',b'Leave Type {0} cannot be carry-forwarded',b'La Type {0} kan ikke b\xc3\xa6re-videre'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +215',"b""Maintenance Schedule is not generated for all the items. Please click on 'Generate Schedule'""",b'Vedlikeholdsplan genereres ikke for alle elementene. Vennligst klikk p\xc3\xa5 &quot;Generer Schedule &#39;'
+,b'To Produce',b'\xc3\x85 Produsere'
+b'apps/erpnext/erpnext/config/hr.py +93',b'Payroll',b'l\xc3\xb8nn'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +196',"b'For row {0} in {1}. To include {2} in Item rate, rows {3} must also be included'","b'For rad {0} i {1}. For \xc3\xa5 inkludere {2} i Element rate, rader {3} m\xc3\xa5 ogs\xc3\xa5 inkluderes'"
+b'DocType: Patient Service Unit',b'Parent Service Unit',b'Foreldre Service Unit'
+b'apps/erpnext/erpnext/utilities/activation.py +101',b'Make User',b'Gj\xc3\xb8r Bruker'
+b'DocType: Packing Slip',b'Identification of the package for the delivery (for print)',b'Identifikasjon av pakken for levering (for print)'
+b'DocType: Bin',b'Reserved Quantity',b'Reservert Antall'
+b'apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +34',b'Please enter valid email address',b'Vennligst skriv inn gyldig e-postadresse'
+b'apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +34',b'Please enter valid email address',b'Vennligst skriv inn gyldig e-postadresse'
+b'DocType: Volunteer Skill',b'Volunteer Skill',b'Frivillig ferdighet'
+b'DocType: Bank Reconciliation',b'Include POS Transactions',b'Inkluder POS-transaksjoner'
+b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +784',b'Please select an item in the cart',b'Vennligst velg et element i handlekurven'
+b'DocType: Landed Cost Voucher',b'Purchase Receipt Items',b'Kvitteringen Items'
+b'apps/erpnext/erpnext/config/learn.py +21',b'Customizing Forms',b'Tilpasse Forms'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +74',b'Arrear',b'etterskudd'
+b'apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +158',b'Depreciation Amount during the period',b'Avskrivningsbel\xc3\xb8pet i perioden'
+b'apps/erpnext/erpnext/accounts/doctype/sales_taxes_and_charges_template/sales_taxes_and_charges_template.py +43',b'Disabled template must not be default template',b'Funksjonshemmede malen m\xc3\xa5 ikke v\xc3\xa6re standardmal'
+b'apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py +314',b'For row {0}: Enter planned qty',b'For rad {0}: Skriv inn planlagt antall'
+b'DocType: Shareholder',b'SH-',b'SH'
+b'DocType: Account',b'Income Account',b'Inntekt konto'
+b'DocType: Payment Request',"b""Amount in customer's currency""",b'Bel\xc3\xb8p i kundens valuta'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +825',b'Delivery',b'Levering'
+b'DocType: Volunteer',b'Weekdays',b'hver~~POS=TRUNC'
+b'DocType: Stock Reconciliation Item',b'Current Qty',b'N\xc3\xa5v\xc3\xa6rende Antall'
+b'DocType: Restaurant Menu',b'Restaurant Menu',b'Restaurantmeny'
+b'apps/erpnext/erpnext/templates/generators/item_group.html +36',b'Prev',b'prev'
+b'DocType: Appraisal Goal',b'Key Responsibility Area',b'Key Ansvar Omr\xc3\xa5de'
+b'apps/erpnext/erpnext/utilities/activation.py +127',"b'Student Batches help you track attendance, assessments and fees for students'","b'Student batcher hjelpe deg med \xc3\xa5 spore oppm\xc3\xb8te, vurderinger og avgifter for studenter'"
+b'DocType: Payment Entry',b'Total Allocated Amount',b'Totalt tildelte bel\xc3\xb8p'
+b'apps/erpnext/erpnext/setup/doctype/company/company.py +151',b'Set default inventory account for perpetual inventory',b'Angi standard beholdningskonto for evigvarende beholdning'
+b'DocType: Item Reorder',b'Material Request Type',b'Materialet Request Type'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +252',b'Accural Journal Entry for salaries from {0} to {1}',b'Accural dagboken til l\xc3\xb8nninger fra {0} i {1}'
+b'apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.js +17',b'Send Grant Review Email',b'Send Grant Review Email'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +848',"b'LocalStorage is full, did not save'","b'Localstorage er full, ikke redde'"
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +100',b'Row {0}: UOM Conversion Factor is mandatory',b'Rad {0}: m\xc3\xa5lenheter omregningsfaktor er obligatorisk'
+b'apps/erpnext/erpnext/utilities/user_progress.py +235',b'Room Capacity',b'Romkapasitet'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +95',b'Ref',b'Ref'
+b'DocType: Lab Test',b'LP-',b'LP-'
+b'DocType: Healthcare Settings',b'Registration Fee',b'Registreringsavgift'
+b'DocType: Budget',b'Cost Center',b'Kostnadssted'
+b'apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +45',b'Voucher #',b'Kupong #'
+b'DocType: Notification Control',b'Purchase Order Message',b'Innkj\xc3\xb8psordre Message'
+b'DocType: Tax Rule',b'Shipping Country',b'Shipping Land'
+b'DocType: Selling Settings',"b""Hide Customer's Tax Id from Sales Transactions""",b'Skjule Kundens Tax ID fra salgstransaksjoner'
+b'DocType: Upload Attendance',b'Upload HTML',b'Last opp HTML'
+b'DocType: Employee',b'Relieving Date',b'Lindrende Dato'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +14',"b'Pricing Rule is made to overwrite Price List / define discount percentage, based on some criteria.'","b'Prising Rule er laget for \xc3\xa5 overskrive Prisliste / definere rabattprosenten, basert p\xc3\xa5 noen kriterier.'"
+b'DocType: Serial No',b'Warehouse can only be changed via Stock Entry / Delivery Note / Purchase Receipt',b'Lageret kan bare endres via Stock Entry / f\xc3\xb8lgeseddel / Kj\xc3\xb8pskvittering'
+b'DocType: Employee Education',b'Class / Percentage',b'Klasse / Prosent'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +134',b'Head of Marketing and Sales',b'Head of Marketing and Sales'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +72',b'Income Tax',b'Inntektsskatt'
+b'apps/erpnext/erpnext/config/selling.py +174',b'Track Leads by Industry Type.',b'Spor Leads etter bransje Type.'
+b'apps/erpnext/erpnext/utilities/user_progress.py +101',b'Go to Letterheads',b'G\xc3\xa5 til Letterheads'
+b'DocType: Item Supplier',b'Item Supplier',b'Sak Leverand\xc3\xb8r'
+b'apps/erpnext/erpnext/public/js/controllers/transaction.js +1255',b'Please enter Item Code to get batch no',b'Skriv inn Element kode for \xc3\xa5 f\xc3\xa5 batch no'
+b'apps/erpnext/erpnext/selling/doctype/quotation/quotation.js +880',b'Please select a value for {0} quotation_to {1}',b'Velg en verdi for {0} quotation_to {1}'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +419',b'No Items selected for transfer',b'Ingen elementer valgt for overf\xc3\xb8ring'
+b'apps/erpnext/erpnext/config/selling.py +46',b'All Addresses.',b'Alle adresser.'
+b'DocType: Company',b'Stock Settings',b'Aksje Innstillinger'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +183',"b'Merging is only possible if following properties are same in both records. Is Group, Root Type, Company'","b'Sammensl\xc3\xa5ing er bare mulig hvis f\xc3\xb8lgende egenskaper er samme i begge postene. Er Group, Root Type, Company'"
+b'DocType: Vehicle',b'Electric',b'Elektrisk'
+b'DocType: Task',b'% Progress',b'% Progress'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +123',b'Gain/Loss on Asset Disposal',b'Gevinst / Tap p\xc3\xa5 Asset Avhending'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +117',b'Account number for account {0} is not available.<br> Please setup your Chart of Accounts correctly.',b'Kontonummer for konto {0} er ikke tilgjengelig. <br> Vennligst konfigurer kontoregnskapet ditt riktig.'
+b'DocType: Task',b'Depends on Tasks',b'Avhenger Oppgaver'
+b'apps/erpnext/erpnext/config/selling.py +36',b'Manage Customer Group Tree.',b'Administrere kunde Gruppe treet.'
+b'DocType: Shopping Cart Settings',b'Attachments can be shown without enabling the shopping cart',b'Vedlegg kan vises uten \xc3\xa5 tillate handlekurven'
+b'DocType: Normal Test Items',b'Result Value',b'Resultat Verdi'
+b'DocType: Hotel Room',b'Hotels',b'hoteller'
+b'DocType: Supplier Quotation',b'SQTN-',b'SQTN-'
+b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +22',b'New Cost Center Name',b'New kostnadssted Navn'
+b'DocType: Leave Control Panel',b'Leave Control Panel',b'La Kontrollpanel'
+b'DocType: Project',b'Task Completion',b'Task Fullf\xc3\xb8ring'
+b'apps/erpnext/erpnext/templates/includes/product_page.js +22',b'Not in Stock',b'Ikke p\xc3\xa5 lager'
+b'DocType: Volunteer',b'Volunteer Skills',b'Frivillig Ferdigheter'
+b'DocType: Appraisal',b'HR User',b'HR User'
+b'DocType: Purchase Invoice',b'Taxes and Charges Deducted',b'Skatter og avgifter fratrukket'
+b'apps/erpnext/erpnext/hooks.py +142',b'Issues',b'Problemer'
+b'apps/erpnext/erpnext/controllers/status_updater.py +12',b'Status must be one of {0}',b'Status m\xc3\xa5 v\xc3\xa6re en av {0}'
+b'apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +64',b'Reminder to update GSTIN Sent',b'P\xc3\xa5minnelse om \xc3\xa5 oppdatere GSTIN Sendt'
+b'DocType: Sales Invoice',b'Debit To',b'Debet \xc3\x85'
+b'DocType: Restaurant Menu Item',b'Restaurant Menu Item',b'Restaurant menyelement'
+b'DocType: Delivery Note',b'Required only for sample item.',b'Kreves bare for pr\xc3\xb8ve element.'
+b'DocType: Stock Ledger Entry',b'Actual Qty After Transaction',b'Selve Antall Etter Transaksjons'
+,b'Pending SO Items For Purchase Request',b'Avventer SO varer for kj\xc3\xb8p Request'
+b'apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +35',b'Student Admissions',b'student Opptak'
+b'apps/erpnext/erpnext/accounts/party.py +388',b'{0} {1} is disabled',b'{0} {1} er deaktivert'
+b'DocType: Supplier',b'Billing Currency',b'Faktureringsvaluta'
+b'DocType: Sales Invoice',b'SINV-RET-',b'SINV-RET-'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +200',b'Extra Large',b'Extra large'
+b'DocType: Crop',b'Scientific Name',b'Vitenskapelig navn'
+b'apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68',b'Total Leaves',b'Totalt Leaves'
+b'DocType: Customer',"b'Reselect, if the chosen contact is edited after save'",b'Velg hvis den valgte kontakten redigeres etter lagre'
+b'DocType: Consultation',b'In print',b'I papirutgave'
+,b'Profit and Loss Statement',b'Resultatregnskap'
+b'DocType: Bank Reconciliation Detail',b'Cheque Number',b'Sjekk Antall'
+,b'Sales Browser',b'Salg Browser'
+b'DocType: Journal Entry',b'Total Credit',b'Total Credit'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +542',b'Warning: Another {0} # {1} exists against stock entry {2}',b'Advarsel: Another {0} # {1} finnes mot aksje oppf\xc3\xb8ring {2}'
+b'apps/erpnext/erpnext/utilities/user_progress_utils.py +66',b'Local',b'Lokal'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +26',b'Loans and Advances (Assets)',b'Utl\xc3\xa5n (Eiendeler)'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +12',b'Debtors',b'Skyldnere'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +199',b'Large',b'Stor'
+b'DocType: Homepage Featured Product',b'Homepage Featured Product',b'Hjemmeside Aktuelle produkter'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +248',b'All Assessment Groups',b'Alle Assessment grupper'
+b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js +15',b'New Warehouse Name',b'New Warehouse navn'
+b'apps/erpnext/erpnext/accounts/report/financial_statements.py +259',b'Total {0} ({1})',b'Totalt {0} ({1})'
+b'DocType: C-Form Invoice Detail',b'Territory',b'Territorium'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +151',b'Please mention no of visits required',b'Vennligst oppgi ingen av bes\xc3\xb8k som kreves'
+b'DocType: Stock Settings',b'Default Valuation Method',b'Standard verdsettelsesmetode'
+b'apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +26',b'Fee',b'Avgift'
+b'apps/erpnext/erpnext/setup/doctype/company/company.js +154',b'Update in progress. It might take a while.',b'Oppdatering p\xc3\xa5g\xc3\xa5r. Det kan ta en stund.'
+b'DocType: Production Plan Item',b'Produced Qty',b'Produsert antall'
+b'DocType: Vehicle Log',b'Fuel Qty',b'drivstoff Antall'
+b'DocType: Stock Entry',b'Target Warehouse Name',b'M\xc3\xa5llagernavn'
+b'DocType: Work Order Operation',b'Planned Start Time',b'Planlagt Starttid'
+b'DocType: Course',b'Assessment',b'Assessment'
+b'DocType: Payment Entry Reference',b'Allocated',b'Avsatt'
+b'apps/erpnext/erpnext/config/accounts.py +267',b'Close Balance Sheet and book Profit or Loss.',b'Lukk Balanse og bok resultatet.'
+b'DocType: Student Applicant',b'Application Status',b's\xc3\xb8knad Status'
+b'DocType: Sensitivity Test Items',b'Sensitivity Test Items',b'Sensitivitetstestelementer'
+b'DocType: Project Update',b'Project Update',b'Prosjektoppdatering'
+b'DocType: Fees',b'Fees',b'avgifter'
+b'DocType: Currency Exchange',b'Specify Exchange Rate to convert one currency into another',b'Spesifiser Exchange Rate \xc3\xa5 konvertere en valuta til en annen'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +159',b'Quotation {0} is cancelled',b'Sitat {0} er kansellert'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +119',b'Total Outstanding Amount',b'Totalt utest\xc3\xa5ende bel\xc3\xb8p'
+b'DocType: Sales Partner',b'Targets',b'Targets'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].js +54',b'Please register the SIREN number in the company information file',b'Vennligst registrer SIREN-nummeret i bedriftsinformasjonsfilen'
+b'DocType: Price List',b'Price List Master',b'Prisliste Master'
+b'DocType: GST Account',b'CESS Account',b'CESS-konto'
+b'DocType: Sales Person',b'All Sales Transactions can be tagged against multiple **Sales Persons** so that you can set and monitor targets.',b'Alle salgstransaksjoner kan v\xc3\xa6re merket mot flere ** Salgs Personer ** slik at du kan stille inn og overv\xc3\xa5ke m\xc3\xa5l.'
+,b'S.O. No.',b'SO No.'
+b'apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +241',b'Please create Customer from Lead {0}',b'Opprett Customer fra Lead {0}'
+b'apps/erpnext/erpnext/healthcare/page/medical_record/patient_select.html +3',b'Select Patient',b'Velg Pasient'
+b'DocType: Price List',b'Applicable for Countries',b'Gjelder for Land'
+b'DocType: Supplier Scorecard Scoring Variable',b'Parameter Name',b'Parameternavn'
+b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +52',b'Student Group Name is mandatory in row {0}',b'Student Gruppenavn er obligatorisk i rad {0}'
+b'DocType: Homepage',b'Products to be shown on website homepage',b'Produkter som skal vises p\xc3\xa5 nettstedet hjemmeside'
+b'apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.js +13',b'This is a root customer group and cannot be edited.',"b'Dette er en rot kundegruppe, og kan ikke redigeres.'"
+b'DocType: Student',b'AB-',b'AB-'
+b'DocType: POS Profile',b'Ignore Pricing Rule',b'Ignorer Pricing Rule'
+b'DocType: Employee Education',b'Graduate',b'Utdannet'
+b'DocType: Leave Block List',b'Block Days',b'Block Days'
+b'apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +83',"b'Shipping Address does not have country, which is required for this Shipping Rule'","b'Fraktadresse har ikke land, som kreves for denne leveringsregelen'"
+b'DocType: Journal Entry',b'Excise Entry',b'Vesenet Entry'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +65',"b""Warning: Sales Order {0} already exists against Customer's Purchase Order {1}""",b'Advarsel: Salgsordre {0} finnes allerede mot kundens innkj\xc3\xb8psordre {1}'
+b'DocType: Terms and Conditions',"b'Standard Terms and Conditions that can be added to Sales and Purchases.\n\nExamples:\n\n1. Validity of the offer.\n1. Payment Terms (In Advance, On Credit, part advance etc).\n1. What is extra (or payable by the Customer).\n1. Safety / usage warning.\n1. Warranty if any.\n1. Returns Policy.\n1. Terms of shipping, if applicable.\n1. Ways of addressing disputes, indemnity, liability, etc.\n1. Address and Contact of your Company.'","b'Standardvilk\xc3\xa5rene som kan legges til salg og kj\xc3\xb8p. Eksempler: 1. Gyldighet av tilbudet. 1. Betalingsvilk\xc3\xa5r (p\xc3\xa5 forh\xc3\xa5nd, p\xc3\xa5 kreditt, del forh\xc3\xa5nd etc). 1. Hva er ekstra (eller skal betales av kunden). 1. Sikkerhet / bruk advarsel. 1. Garanti om noen. 1. Returrett. 1. Vilk\xc3\xa5r for frakt, hvis aktuelt. 1. M\xc3\xa5ter adressering tvister, erstatning, ansvar, etc. 1. Adresse og kontakt med din bedrift.'"
+b'DocType: Issue',b'Issue Type',b'Utgave type'
+b'DocType: Attendance',b'Leave Type',b'La Type'
+b'DocType: Purchase Invoice',b'Supplier Invoice Details',b'Leverand\xc3\xb8r Fakturadetaljer'
+b'DocType: Agriculture Task',b'Ignore holidays',b'Ignorer ferier'
+b'apps/erpnext/erpnext/controllers/stock_controller.py +233',"b""Expense / Difference account ({0}) must be a 'Profit or Loss' account""",b'Expense / Difference konto ({0}) m\xc3\xa5 v\xc3\xa6re en &quot;resultatet&quot; konto'
+b'DocType: Project',b'Copied From',b'Kopiert fra'
+b'DocType: Project',b'Copied From',b'Kopiert fra'
+b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +340',b'Invoice already created for all billing hours',b'Faktura som allerede er opprettet for alle faktureringstimer'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +96',b'Name error: {0}',b'Navn feil: {0}'
+b'DocType: Cash Flow Mapping',b'Is Finance Cost',b'Er finansieringskostnad'
+b'apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +18',b'Attendance for employee {0} is already marked',b'Oppm\xc3\xb8te for arbeidstaker {0} er allerede merket'
+b'DocType: Packing Slip',b'If more than one package of the same type (for print)',b'Hvis mer enn en pakke av samme type (for print)'
+b'apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +27',b'Please set default customer in Restaurant Settings',b'Vennligst sett standardkunden i Restaurantinnstillinger'
+,b'Salary Register',b'l\xc3\xb8nn Register'
+b'DocType: Warehouse',b'Parent Warehouse',b'Parent Warehouse'
+b'DocType: C-Form Invoice Detail',b'Net Total',b'Net Total'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +546',b'Default BOM not found for Item {0} and Project {1}',b'Standard BOM ikke funnet for element {0} og prosjekt {1}'
+b'apps/erpnext/erpnext/config/hr.py +168',b'Define various loan types',b'Definere ulike typer l\xc3\xa5n'
+b'DocType: Bin',b'FCFS Rate',b'FCFS Rate'
+b'DocType: Opening Invoice Creation Tool Item',b'Outstanding Amount',b'Utest\xc3\xa5ende Bel\xc3\xb8p'
+b'apps/erpnext/erpnext/templates/generators/bom.html +71',b'Time(in mins)',b'Tid (i minutter)'
+b'DocType: Project Task',b'Working',b'Arbeids'
+b'DocType: Stock Ledger Entry',b'Stock Queue (FIFO)',b'Stock Queue (FIFO)'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +127',b'Financial Year',b'Regnskaps\xc3\xa5r'
+b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +46',b'{0} does not belong to Company {1}',b'{0} ikke tilh\xc3\xb8rer selskapet {1}'
+b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard_period/supplier_scorecard_period.py +66',b'Could not solve criteria score function for {0}. Make sure the formula is valid.',b'Kunne ikke l\xc3\xb8se kriterier score funksjon for {0}. Pass p\xc3\xa5 at formelen er gyldig.'
+b'apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +122',b'Cost as on',b'Koste s\xc3\xa5 p\xc3\xa5'
+b'DocType: Healthcare Settings',b'Out Patient Settings',b'Ut pasientinnstillinger'
+b'DocType: Account',b'Round Off',b'Avrunde'
+b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +259',b'Quantity must be positive',b'Mengden m\xc3\xa5 v\xc3\xa6re positiv'
+b'DocType: Material Request Plan Item',b'Requested Qty',b'Spurt Antall'
+b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +96',b'The fields From Shareholder and To Shareholder cannot be blank',b'Feltene fra Aksjon\xc3\xa6r og Til Aksjon\xc3\xa6r kan ikke v\xc3\xa6re tomme'
+b'DocType: Tax Rule',b'Use for Shopping Cart',b'Brukes til handlekurv'
+b'apps/erpnext/erpnext/controllers/item_variant.py +101',b'Value {0} for Attribute {1} does not exist in the list of valid Item Attribute Values for Item {2}',b'Verdi {0} for Egenskap {1} finnes ikke i listen over gyldige elementattributtet Verdier for Element {2}'
+b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +79',b'Select Serial Numbers',b'Velg serienummer'
+b'DocType: BOM Item',b'Scrap %',b'Skrap%'
+b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +46',"b'Charges will be distributed proportionately based on item qty or amount, as per your selection'","b'Kostnader vil bli fordelt forholdsmessig basert p\xc3\xa5 element stk eller bel\xc3\xb8p, som per ditt valg'"
+b'DocType: Maintenance Visit',b'Purposes',b'Form\xc3\xa5l'
+b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +112',b'Atleast one item should be entered with negative quantity in return document',b'Atleast ett element b\xc3\xb8r legges inn med negativt antall i retur dokument'
+b'apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +71',"b'Operation {0} longer than any available working hours in workstation {1}, break down the operation into multiple operations'","b'Operation {0} lenger enn noen tilgjengelige arbeidstimer i arbeidsstasjonen {1}, bryte ned driften i flere operasjoner'"
+b'DocType: Membership',b'Membership Status',b'Medlemskapsstatus'
+,b'Requested',b'Spurt'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +93',b'No Remarks',b'Nei Anmerkninger'
+b'DocType: Asset',b'In Maintenance',b'Ved vedlikehold'
+b'DocType: Purchase Invoice',b'Overdue',b'Forfalt'
+b'DocType: Account',b'Stock Received But Not Billed',"b'Stock mottatt, men ikke fakturert'"
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +84',b'Root Account must be a group',b'Root-kontoen m\xc3\xa5 v\xc3\xa6re en gruppe'
+b'DocType: Drug Prescription',b'Drug Prescription',b'Drug Prescription'
+b'DocType: Fees',b'FEE.',b'AVGIFT.'
+b'DocType: Employee Loan',b'Repaid/Closed',b'Tilbakebetalt / Stengt'
+b'DocType: Item',b'Total Projected Qty',b'Samlet forventet Antall'
+b'DocType: Monthly Distribution',b'Distribution Name',b'Distribusjon Name'
+b'apps/erpnext/erpnext/stock/stock_ledger.py +477',"b'Valuation rate not found for the Item {0}, which is required to do accounting entries for {1} {2}. If the item is transacting as a zero valuation rate item in the {1}, please mention that in the {1} Item table. Otherwise, please create an incoming stock transaction for the item or mention valuation rate in the Item record, and then try submiting/cancelling this entry'","b'Verdsettelsesraten ikke funnet for elementet {0}, som er n\xc3\xb8dvendig for \xc3\xa5 gj\xc3\xb8re regnskapsposter for {1} {2}. Hvis varen er transaksjon som nullverdieringsgrad i {1}, m\xc3\xa5 du nevne det i {1} elementtabellen. Ellers kan du opprette en inntektsaksjonstransaksjon for varen eller nevne verdsettelsesraten i vareoppf\xc3\xb8ringen, og pr\xc3\xb8v deretter \xc3\xa5 sende inn / avbryte denne oppf\xc3\xb8ringen'"
+b'DocType: Course',b'Course Code',b'Kurskode'
+b'apps/erpnext/erpnext/controllers/stock_controller.py +337',b'Quality Inspection required for Item {0}',b'Quality Inspection n\xc3\xb8dvendig for Element {0}'
+b'DocType: POS Settings',b'Use POS in Offline Mode',b'Bruk POS i frakoblet modus'
+b'DocType: Supplier Scorecard',b'Supplier Variables',b'Leverand\xc3\xb8rvariabler'
+b'DocType: Quotation',"b""Rate at which customer's currency is converted to company's base currency""",b'Hastigheten som kundens valuta er konvertert til selskapets hovedvaluta'
+b'DocType: Purchase Invoice Item',b'Net Rate (Company Currency)',b'Netto Rate (Selskap Valuta)'
+b'DocType: Salary Detail',b'Condition and Formula Help',b'Tilstand og Formula Hjelp'
+b'apps/erpnext/erpnext/config/selling.py +105',b'Manage Territory Tree.',b'Administrer Territory treet.'
+b'DocType: Patient Service Unit',b'Patient Service Unit',b'Pasient Service Unit'
+b'DocType: Journal Entry Account',b'Sales Invoice',b'Salg Faktura'
+b'DocType: Journal Entry Account',b'Party Balance',b'Fest Balance'
+b'DocType: Cash Flow Mapper',b'Section Subtotal',b'Seksjon Subtotal'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +498',b'Please select Apply Discount On',b'Vennligst velg Bruk rabatt p\xc3\xa5'
+b'DocType: Stock Settings',b'Sample Retention Warehouse',b'Pr\xc3\xb8vebehandlingslager'
+b'DocType: Company',b'Default Receivable Account',b'Standard fordringer konto'
+b'DocType: Physician Schedule',b'Physician Schedule',b'Legerplan'
+b'DocType: Purchase Invoice',b'Deemed Export',b'Gjeldende eksport'
+b'DocType: Stock Entry',b'Material Transfer for Manufacture',b'Material Transfer for Produksjon'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +20',b'Discount Percentage can be applied either against a Price List or for all Price List.',b'Rabattprosenten kan brukes enten mot en prisliste eller for alle Prisliste.'
+b'DocType: Subscription',b'Half-yearly',b'Halv\xc3\xa5rs'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +407',b'Accounting Entry for Stock',b'Regnskap Entry for Stock'
+b'DocType: Lab Test',b'LabTest Approver',b'LabTest Approver'
+b'apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py +61',b'You have already assessed for the assessment criteria {}.',b'Du har allerede vurdert for vurderingskriteriene {}.'
+b'DocType: Vehicle Service',b'Engine Oil',b'Motorolje'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1005',b'Work Orders Created: {0}',b'Arbeidsordre opprettet: {0}'
+b'DocType: Sales Invoice',b'Sales Team1',b'Salg TEAM1'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +547',b'Item {0} does not exist',b'Element {0} finnes ikke'
+b'DocType: Sales Invoice',b'Customer Address',b'Kunde Adresse'
+b'DocType: Employee Loan',b'Loan Details',b'l\xc3\xa5n Detaljer'
+b'DocType: Company',b'Default Inventory Account',b'Standard lagerkonto'
+b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +192',b'The folio numbers are not matching',b'Folio tallene stemmer ikke overens'
+b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +124',b'Row {0}: Completed Qty must be greater than zero.',b'Rad {0}: Fullf\xc3\xb8rt Antall m\xc3\xa5 v\xc3\xa6re st\xc3\xb8rre enn null.'
+b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +262',b'Payment Request for {0}',b'Betalingsforesp\xc3\xb8rsel om {0}'
+b'DocType: Item Barcode',b'Barcode Type',b'Strekkode Type'
+b'DocType: Antibiotic',b'Antibiotic Name',b'Antibiotisk navn'
+b'DocType: Purchase Invoice',b'Apply Additional Discount On',b'P\xc3\xa5f\xc3\xb8r Ytterligere rabatt p\xc3\xa5'
+b'apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +66',b'Select Type...',b'Velg type ...'
+b'DocType: Crop Cycle',b'A link to all the Land Units in which the Crop is growing',b'En kobling til alle arealene der gr\xc3\xb8ften vokser'
+b'DocType: Account',b'Root Type',b'Root Type'
+b'DocType: Item',b'FIFO',b'FIFO'
+b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +136',b'Row # {0}: Cannot return more than {1} for Item {2}',b'Row # {0}: Kan ikke returnere mer enn {1} for Element {2}'
+b'DocType: Item Group',b'Show this slideshow at the top of the page',b'Vis lysbildefremvisning p\xc3\xa5 toppen av siden'
+b'DocType: BOM',b'Item UOM',b'Sak m\xc3\xa5lenheter'
+b'DocType: Sales Taxes and Charges',b'Tax Amount After Discount Amount (Company Currency)',b'Skattebel\xc3\xb8p Etter Rabattbel\xc3\xb8p (Company Valuta)'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +177',b'Target warehouse is mandatory for row {0}',b'Target lageret er obligatorisk for rad {0}'
+b'DocType: Cheque Print Template',b'Primary Settings',b'prim\xc3\xa6re Innstillinger'
+b'DocType: Purchase Invoice',b'Select Supplier Address',b'Velg Leverand\xc3\xb8r Adresse'
+b'apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +397',b'Add Employees',b'Legg Medarbeidere'
+b'DocType: Purchase Invoice Item',b'Quality Inspection',b'Quality Inspection'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +196',b'Extra Small',b'Extra Small'
+b'DocType: Company',b'Standard Template',b'standard Template'
+b'DocType: Training Event',b'Theory',b'Teori'
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +806',b'Warning: Material Requested Qty is less than Minimum Order Qty',b'Advarsel: Material Requested Antall er mindre enn Minimum Antall'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +211',b'Account {0} is frozen',b'Konto {0} er frosset'
+b'DocType: Company',b'Legal Entity / Subsidiary with a separate Chart of Accounts belonging to the Organization.',b'Legal Entity / Datterselskap med en egen konto tilh\xc3\xb8righet til organisasjonen.'
+b'DocType: Payment Request',b'Mute Email',b'Demp Email'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +29',"b'Food, Beverage & Tobacco'","b'Mat, drikke og tobakk'"
+b'DocType: Account',b'Account Number',b'Kontonummer'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +752',b'Can only make payment against unbilled {0}',b'Kan bare gj\xc3\xb8re betaling mot fakturert {0}'
+b'apps/erpnext/erpnext/controllers/selling_controller.py +102',b'Commission rate cannot be greater than 100',b'Kommisjon kan ikke v\xc3\xa6re st\xc3\xb8rre enn 100'
+b'DocType: Volunteer',b'Volunteer',b'Frivillig'
+b'DocType: Stock Entry',b'Subcontract',b'Underentrepriser'
+b'apps/erpnext/erpnext/public/js/utils/party.js +166',b'Please enter {0} first',b'Fyll inn {0} f\xc3\xb8rst'
+b'apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py +104',b'No replies from',b'Ingen svar fra'
+b'DocType: Work Order Operation',b'Actual End Time',b'Faktisk Sluttid'
+b'DocType: Item',b'Manufacturer Part Number',b'Produsentens varenummer'
+b'DocType: Work Order Operation',b'Estimated Time and Cost',b'Estimert leveringstid og pris'
+b'DocType: Bin',b'Bin',b'Bin'
+b'DocType: Crop',b'Crop Name',b'Beskj\xc3\xa6re navn'
+b'DocType: SMS Log',b'No of Sent SMS',b'Ingen av Sendte SMS'
+b'DocType: Antibiotic',b'Healthcare Administrator',b'Helseadministrator'
+b'apps/erpnext/erpnext/utilities/user_progress.py +47',b'Set a Target',b'Angi et m\xc3\xa5l'
+b'DocType: Dosage Strength',b'Dosage Strength',b'Doseringsstyrke'
+b'DocType: Account',b'Expense Account',b'Expense konto'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +49',b'Software',b'Programvare'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +203',b'Colour',b'Farge'
+b'DocType: Assessment Plan Criteria',b'Assessment Plan Criteria',b'Assessment Plan Kriterier'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.py +118',b'Expiry date is mandatory for selected item',b'Utl\xc3\xb8psdato er obligatorisk for valgt element'
+b'DocType: Supplier Scorecard Scoring Standing',b'Prevent Purchase Orders',b'Forhindre innkj\xc3\xb8psordrer'
+b'apps/erpnext/erpnext/healthcare/setup.py +258',b'Susceptible',b'utsatt'
+b'DocType: Patient Appointment',b'Scheduled',b'Planlagt'
+b'apps/erpnext/erpnext/config/buying.py +18',b'Request for quotation.',b'Foresp\xc3\xb8rsel om kostnadsoverslag.'
+b'apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.js +13',"b'Please select Item where ""Is Stock Item"" is ""No"" and ""Is Sales Item"" is ""Yes"" and there is no other Product Bundle'","b'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'"
+b'apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.js +148',b'Select Customer',b'Velg kunde'
+b'DocType: Student Log',b'Academic',b'akademisk'
+b'DocType: Patient',b'Personal and Social History',b'Personlig og sosial historie'
+b'apps/erpnext/erpnext/education/doctype/guardian/guardian.py +51',b'User {0} created',b'Bruker {0} opprettet'
+b'DocType: Fee Schedule',b'Fee Breakup for each student',b'Fee Breakup for hver student'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +541',b'Total advance ({0}) against Order {1} cannot be greater than the Grand Total ({2})',b'Total forh\xc3\xa5nd ({0}) mot Bestill {1} kan ikke v\xc3\xa6re st\xc3\xb8rre enn totalsummen ({2})'
+b'DocType: Sales Partner',b'Select Monthly Distribution to unevenly distribute targets across months.',b'Velg M\xc3\xa5nedlig Distribusjon til ujevnt fordele m\xc3\xa5lene gjennom m\xc3\xa5neder.'
+b'apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +78',b'Change Code',b'Endre kode'
+b'DocType: Purchase Invoice Item',b'Valuation Rate',b'Verdivurdering Rate'
+b'DocType: Stock Reconciliation',b'SR/',b'SR /'
+b'DocType: Vehicle',b'Diesel',b'diesel'
+b'apps/erpnext/erpnext/stock/get_item_details.py +388',b'Price List Currency not selected',b'Prisliste Valuta ikke valgt'
+b'DocType: Purchase Invoice',b'Availed ITC Cess',b'Benyttet ITC Cess'
+,b'Student Monthly Attendance Sheet',b'Student M\xc3\xa5nedlig Oppm\xc3\xb8te Sheet'
+b'apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +96',b'Shipping rule only applicable for Selling',b'Fraktregel gjelder kun for salg'
+b'apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +30',b'Project Start Date',b'Prosjekt startdato'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +23',b'Until',b'Inntil'
+b'DocType: Rename Tool',b'Rename Log',b'Rename Logg'
+b'apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py +27',b'Student Group or Course Schedule is mandatory',b'Studentgruppe eller kursplan er obligatorisk'
+b'apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py +27',b'Student Group or Course Schedule is mandatory',b'Studentgruppe eller kursplan er obligatorisk'
+b'DocType: HR Settings',b'Maintain Billing Hours and Working Hours Same on Timesheet',b'Opprettholde Fakturerings timer og arbeidstid samme p\xc3\xa5 Timeregistrering'
+b'DocType: Maintenance Visit Purpose',b'Against Document No',b'Mot Dokument nr'
+b'DocType: BOM',b'Scrap',b'skrap'
+b'apps/erpnext/erpnext/utilities/user_progress.py +217',b'Go to Instructors',b'G\xc3\xa5 til Instrukt\xc3\xb8rer'
+b'apps/erpnext/erpnext/config/selling.py +110',b'Manage Sales Partners.',b'Administrer Salgs Partners.'
+b'DocType: Quality Inspection',b'Inspection Type',b'Inspeksjon Type'
+b'DocType: Fee Validity',b'Visited yet',b'Bes\xc3\xb8kt enn\xc3\xa5'
+b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +134',b'Warehouses with existing transaction can not be converted to group.',b'N\xc3\xa6ringslokaler med eksisterende transaksjon kan ikke konverteres til gruppen.'
+b'DocType: Assessment Result Tool',b'Result HTML',b'resultat HTML'
+b'apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +35',b'Expires On',b'G\xc3\xa5r ut p\xc3\xa5 dato den'
+b'apps/erpnext/erpnext/utilities/activation.py +117',b'Add Students',b'Legg Studenter'
+b'apps/erpnext/erpnext/public/js/utils.js +270',b'Please select {0}',b'Vennligst velg {0}'
+b'DocType: C-Form',b'C-Form No',b'C-Form Nei'
+b'DocType: BOM',b'Exploded_items',b'Exploded_items'
+b'apps/erpnext/erpnext/utilities/user_progress.py +139',b'List your products or services that you buy or sell.',b'Oppgi produktene eller tjenestene du kj\xc3\xb8per eller selger.'
+b'DocType: Water Analysis',b'Storage Temperature',b'Lager temperatur'
+b'DocType: Employee Attendance Tool',b'Unmarked Attendance',b'Umerket Oppm\xc3\xb8te'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +137',b'Researcher',b'Forsker'
+b'DocType: Program Enrollment Tool Student',b'Program Enrollment Tool Student',b'Program P\xc3\xa5melding Tool Student'
+b'apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.py +16',b'Start date should be less than end date for task {0}',b'Startdato b\xc3\xb8r v\xc3\xa6re mindre enn sluttdato for oppgaven {0}'
+b'apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py +25',b'Name or Email is mandatory',b'Navn eller E-post er obligatorisk'
+b'DocType: Member',b'MEM-',b'med-'
+b'DocType: Instructor',b'Instructor Log',b'Instrukt\xc3\xb8rlogg'
+b'DocType: Purchase Order Item',b'Returned Qty',b'Returnerte Stk'
+b'DocType: Student',b'Exit',b'Utgang'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +156',b'Root Type is mandatory',b'Root Type er obligatorisk'
+b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +29',b'Failed to install presets',b'Kunne ikke installere forh\xc3\xa5ndsinnstillinger'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +44',"b'{0} currently has a {1} Supplier Scorecard standing, and RFQs to this supplier should be issued with caution.'","b'{0} har for \xc3\xb8yeblikket en {1} leverand\xc3\xb8r scorecard, og RFQs til denne leverand\xc3\xb8ren skal utstedes med forsiktighet.'"
+b'DocType: Chapter',b'Non Profit Manager',b'Non Profit Manager'
+b'DocType: BOM',b'Total Cost(Company Currency)',b'Totalkostnad (Selskap Valuta)'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +315',b'Serial No {0} created',b'Serial No {0} opprettet'
+b'DocType: Homepage',b'Company Description for website homepage',b'Selskapet beskrivelse for nettstedet hjemmeside'
+b'DocType: Item Customer Detail',"b'For the convenience of customers, these codes can be used in print formats like Invoices and Delivery Notes'","b'For det lettere for kunder, kan disse kodene brukes i trykte formater som regningene og leveringssedlene'"
+b'apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py +18',b'Suplier Name',b'suplier Name'
+b'apps/erpnext/erpnext/accounts/report/financial_statements.py +174',b'Could not retrieve information for {0}.',b'Kunne ikke hente informasjon for {0}.'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +134',b'Opening Entry Journal',b'\xc3\x85pningsoppf\xc3\xb8ring Journal'
+b'DocType: Sales Invoice',b'Time Sheet List',b'Timeregistrering List'
+b'DocType: Employee',b'You can enter any date manually',b'Du kan legge inn noen dato manuelt'
+b'DocType: Healthcare Settings',b'Result Printed',b'Resultat Trykt'
+b'DocType: Asset Category Account',b'Depreciation Expense Account',b'Avskrivninger konto'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +233',b'Probationary Period',b'Pr\xc3\xb8vetid'
+b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js +32',b'View {0}',b'Se {0}'
+b'DocType: Customer Group',b'Only leaf nodes are allowed in transaction',b'Bare bladnoder er tillatt i transaksjonen'
+b'DocType: Project',b'Total Costing Amount (via Timesheets)',b'Totalt kostende bel\xc3\xb8p (via tidsskrifter)'
+b'DocType: Employee Advance',b'Expense Approver',b'Expense Godkjenner'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +136',b'Row {0}: Advance against Customer must be credit',b'Rad {0}: Advance mot Kunden m\xc3\xa5 v\xc3\xa6re kreditt'
+b'DocType: Project',b'Hourly',b'Hver time'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.js +89',b'Non-Group to Group',b'Non-gruppe til gruppe'
+b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +58',b'Batch is mandatory in row {0}',b'Batch er obligatorisk i rad {0}'
+b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +58',b'Batch is mandatory in row {0}',b'Batch er obligatorisk i rad {0}'
+b'DocType: Purchase Receipt Item Supplied',b'Purchase Receipt Item Supplied',b'Kvitteringen Sak Leveres'
+b'apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py +24',b'To Datetime',b'Til Datetime'
+b'apps/erpnext/erpnext/config/selling.py +302',b'Logs for maintaining sms delivery status',b'Logger for \xc3\xa5 opprettholde sms leveringsstatus'
+b'DocType: Accounts Settings',b'Make Payment via Journal Entry',b'Utf\xc3\xb8r betaling via bilagsregistrering'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +223',b'Printed On',b'Trykt p\xc3\xa5'
+b'DocType: Item',b'Inspection Required before Delivery',b'Inspeksjon P\xc3\xa5krevd f\xc3\xb8r Levering'
+b'DocType: Item',b'Inspection Required before Purchase',b'Inspeksjon P\xc3\xa5krevd f\xc3\xb8r kj\xc3\xb8p'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +93',b'Pending Activities',b'Ventende Aktiviteter'
+b'DocType: Patient Appointment',b'Reminded',b'minnet'
+b'DocType: Patient',b'PID-',b'PID-'
+b'DocType: Chapter Member',b'Chapter Member',b'Kapittelmedlem'
+b'DocType: Material Request Plan Item',b'Minimum Order Quantity',b'Minimum antall'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +106',b'Your Organization',b'Din organisasjon'
+b'DocType: Fee Component',b'Fees Category',b'avgifter Kategori'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +134',b'Please enter relieving date.',b'Skriv inn lindrende dato.'
+b'apps/erpnext/erpnext/controllers/trends.py +149',b'Amt',b'Amt'
+b'DocType: Supplier Scorecard',b'Notify Employee',b'Informer medarbeider'
+b'DocType: Opportunity',b'Enter name of campaign if source of enquiry is campaign',b'Skriv inn navnet p\xc3\xa5 kampanjen hvis kilden til henvendelsen er kampanje'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +38',b'Newspaper Publishers',b'Avis Publishers'
+b'apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +30',b'Select Fiscal Year',b'Velg regnskaps\xc3\xa5r'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +115',b'Expected Delivery Date should be after Sales Order Date',b'Forventet leveringsdato b\xc3\xb8r v\xc3\xa6re etter salgsordre'
+b'apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +42',b'Reorder Level',b'Omgj\xc3\xb8re niv\xc3\xa5'
+b'DocType: Company',b'Chart Of Accounts Template',b'Konto Mal'
+b'DocType: Attendance',b'Attendance Date',b'Oppm\xc3\xb8te Dato'
+b'apps/erpnext/erpnext/stock/get_item_details.py +352',b'Item Price updated for {0} in Price List {1}',b'Sak Pris oppdateres for {0} i prislisten {1}'
+b'DocType: Salary Structure',b'Salary breakup based on Earning and Deduction.',b'L\xc3\xb8nn breakup basert p\xc3\xa5 opptjening og fradrag.'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +128',b'Account with child nodes cannot be converted to ledger',b'Konto med barnet noder kan ikke konverteres til Ledger'
+b'DocType: Purchase Invoice Item',b'Accepted Warehouse',b'Akseptert Warehouse'
+b'DocType: Bank Reconciliation Detail',b'Posting Date',b'Publiseringsdato'
+b'DocType: Item',b'Valuation Method',b'Verdsettelsesmetode'
+b'apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +203',b'Mark Half Day',b'Mark Half Day'
+b'DocType: Sales Invoice',b'Sales Team',b'Sales Team'
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +87',b'Duplicate entry',b'Duplicate entry'
+b'DocType: Program Enrollment Tool',b'Get Students',b'F\xc3\xa5 Studenter'
+b'DocType: Serial No',b'Under Warranty',b'Under Garanti'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +516',b'[Error]',b'[Error]'
+b'DocType: Sales Order',b'In Words will be visible once you save the Sales Order.',b'I Ord vil v\xc3\xa6re synlig n\xc3\xa5r du lagrer kundeordre.'
+,b'Employee Birthday',b'Ansatt Bursdag'
+b'apps/erpnext/erpnext/assets/doctype/asset_repair/asset_repair.py +14',b'Please select Completion Date for Completed Repair',b'Vennligst velg Fullf\xc3\xb8ringsdato for fullf\xc3\xb8rt reparasjon'
+b'DocType: Student Batch Attendance Tool',b'Student Batch Attendance Tool',b'Student Batch Oppm\xc3\xb8te Tool'
+b'apps/erpnext/erpnext/controllers/status_updater.py +213',b'Limit Crossed',b'Limit Krysset'
+b'apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.js +22',b'Scheduled Upto',b'Planlagt Upto'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +55',b'Venture Capital',b'Venture Capital'
+b'apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +40',"b""An academic term with this 'Academic Year' {0} and 'Term Name' {1} already exists. Please modify these entries and try again.""",b'Et semester med denne &#39;Academic Year&#39; {0} og &quot;Term Name {1} finnes allerede. Vennligst endre disse oppf\xc3\xb8ringene og pr\xc3\xb8v igjen.'
+b'DocType: UOM',b'Must be Whole Number',b'M\xc3\xa5 v\xc3\xa6re hele tall'
+b'DocType: Leave Control Panel',b'New Leaves Allocated (In Days)',b'Nye L\xc3\xb8v Tildelte (i dager)'
+b'DocType: Purchase Invoice',b'Invoice Copy',b'Faktura kopi'
+b'apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +49',b'Serial No {0} does not exist',b'Serial No {0} finnes ikke'
+b'DocType: Sales Invoice Item',b'Customer Warehouse (Optional)',b'Customer Warehouse (valgfritt)'
+b'DocType: Pricing Rule',b'Discount Percentage',b'Rabatt Prosent'
+b'apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +51',b'Reserved for sub contracting',b'Reservert for underentreprise'
+b'DocType: Payment Reconciliation Invoice',b'Invoice Number',b'Fakturanummer'
+b'DocType: Shopping Cart Settings',b'Orders',b'Bestillinger'
+b'DocType: Employee Leave Approver',b'Leave Approver',b'La Godkjenner'
+b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +285',b'Please select a batch',b'Vennligst velg en batch'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +42',b'JournalLib',b'JournalLib'
+b'DocType: Assessment Group',b'Assessment Group Name',b'Assessment Gruppenavn'
+b'DocType: Manufacturing Settings',b'Material Transferred for Manufacture',b'Materialet Overf\xc3\xb8rt for Produksjon'
+b'DocType: Landed Cost Item',b'Receipt Document Type',b'Kvittering dokumenttype'
+b'DocType: Daily Work Summary Settings',b'Select Companies',b'Velg selskaper'
+b'DocType: Antibiotic',b'Healthcare',b'Helsetjenester'
+b'DocType: Target Detail',b'Target Detail',b'Target Detalj'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +65',b'Single Variant',b'Enkelt variant'
+b'apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +24',b'All Jobs',b'alle jobber'
+b'DocType: Sales Order',b'% of materials billed against this Sales Order',b'% Av materialer fakturert mot denne kundeordre'
+b'DocType: Program Enrollment',b'Mode of Transportation',b'Transportform'
+b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +49',b'Period Closing Entry',b'Periode Closing Entry'
+b'apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +72',b'Select Department...',b'Velg avdeling ...'
+b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +38',b'Cost Center with existing transactions can not be converted to group',b'Kostnadssted med eksisterende transaksjoner kan ikke konverteres til gruppen'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +374',b'Amount {0} {1} {2} {3}',b'Mengden {0} {1} {2} {3}'
+b'DocType: Account',b'Depreciation',b'Avskrivninger'
+b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +102',b'The number of shares and the share numbers are inconsistent',b'Antall aksjer og aksjenumrene er inkonsekvente'
+b'apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +49',b'Supplier(s)',b'Leverand\xc3\xb8r (er)'
+b'DocType: Employee Attendance Tool',b'Employee Attendance Tool',b'Employee Oppm\xc3\xb8te Tool'
+b'DocType: Guardian Student',b'Guardian Student',b'Guardian Student'
+b'DocType: Supplier',b'Credit Limit',b'Kredittgrense'
+b'apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +70',b'Avg. Selling Price List Rate',b'Nr. Selge prisliste rate'
+b'DocType: Salary Component',b'Salary Component',b'l\xc3\xb8nn Component'
+b'apps/erpnext/erpnext/accounts/utils.py +495',b'Payment Entries {0} are un-linked',b'Betalings Innlegg {0} er un-linked'
+b'DocType: GL Entry',b'Voucher No',b'Kupong Ingen'
+,b'Lead Owner Efficiency',b'Leder Eier Effektivitet'
+,b'Lead Owner Efficiency',b'Leder Eier Effektivitet'
+b'DocType: Leave Allocation',b'Leave Allocation',b'La Allocation'
+b'DocType: Payment Request',b'Recipient Message And Payment Details',b'Mottakers Message og betalingsinformasjon'
+b'DocType: Training Event',b'Trainer Email',b'trener E-post'
+b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +550',b'Material Requests {0} created',b'Materielle Foresp\xc3\xb8rsler {0} er opprettet'
+b'DocType: Restaurant Reservation',b'No of People',b'Ingen av mennesker'
+b'apps/erpnext/erpnext/config/selling.py +164',b'Template of terms or contract.',b'Mal av begreper eller kontrakt.'
+b'DocType: Purchase Invoice',b'Address and Contact',b'Adresse og Kontakt'
+b'DocType: Cheque Print Template',b'Is Account Payable',b'Er konto Betales'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +276',b'Stock cannot be updated against Purchase Receipt {0}',b'Stock kan ikke oppdateres mot Kj\xc3\xb8pskvittering {0}'
+b'DocType: Support Settings',b'Auto close Issue after 7 days',b'Auto n\xc3\xa6r Issue etter 7 dager'
+b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +71',"b'Leave cannot be allocated before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}'","b'Permisjon kan ikke tildeles f\xc3\xb8r {0}, som permisjon balanse har allerede v\xc3\xa6rt carry-sendt i fremtiden permisjon tildeling posten {1}'"
+b'apps/erpnext/erpnext/accounts/party.py +317',b'Note: Due / Reference Date exceeds allowed customer credit days by {0} day(s)',b'Merk: P\xc3\xa5 grunn / Reference Date stiger tillatt kunde kreditt dager med {0} dag (er)'
+b'apps/erpnext/erpnext/education/doctype/program/program.js +8',b'Student Applicant',b'student S\xc3\xb8ker'
+b'DocType: Purchase Invoice',b'ORIGINAL FOR RECIPIENT',b'ORIGINAL FOR RECIPIENT'
+b'DocType: Asset Category Account',b'Accumulated Depreciation Account',b'Akkumulerte avskrivninger konto'
+b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +11',b'This email is autogenerated',b'Denne e-posten er autogenerert'
+b'DocType: Stock Settings',b'Freeze Stock Entries',b'Freeze Stock Entries'
+b'DocType: Program Enrollment',b'Boarding Student',b'Studerende Student'
+b'DocType: Asset',b'Expected Value After Useful Life',b'Forventet verdi Etter Levetid'
+b'DocType: Item',b'Reorder level based on Warehouse',b'Omgj\xc3\xb8re niv\xc3\xa5 basert p\xc3\xa5 Warehouse'
+b'DocType: Activity Cost',b'Billing Rate',b'Billing Rate'
+,b'Qty to Deliver',b'Antall \xc3\xa5 levere'
+,b'Stock Analytics',b'Aksje Analytics'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +523',b'Operations cannot be left blank',b'Operasjoner kan ikke v\xc3\xa6re tomt'
+b'DocType: Maintenance Visit Purpose',b'Against Document Detail No',b'Mot Document Detail Nei'
+b'apps/erpnext/erpnext/regional/__init__.py +11',b'Deletion is not permitted for country {0}',b'Sletting er ikke tillatt for land {0}'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +110',b'Party Type is mandatory',b'Partiet Type er obligatorisk'
+b'DocType: Quality Inspection',b'Outgoing',b'Utg\xc3\xa5ende'
+b'DocType: Material Request',b'Requested For',b'Spurt For'
+b'DocType: Quotation Item',b'Against Doctype',b'Mot Doctype'
+b'apps/erpnext/erpnext/controllers/buying_controller.py +404',b'{0} {1} is cancelled or closed',b'{0} {1} er kansellert eller lukket'
+b'DocType: Asset',b'Calculate Depreciation',b'Beregn Avskrivninger'
+b'DocType: Delivery Note',b'Track this Delivery Note against any Project',b'Spor dette f\xc3\xb8lgeseddel mot ethvert prosjekt'
+b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +35',b'Net Cash from Investing',b'Netto kontantstr\xc3\xb8m fra investerings'
+b'DocType: Work Order',b'Work-in-Progress Warehouse',b'Work-in-progress Warehouse'
+b'apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +111',b'Asset {0} must be submitted',b'Asset {0} m\xc3\xa5 fremlegges'
+b'DocType: Fee Schedule Program',b'Total Students',b'Totalt studenter'
+b'apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py +56',b'Attendance Record {0} exists against Student {1}',b'Oppm\xc3\xb8te Record {0} finnes mot Student {1}'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +354',b'Reference #{0} dated {1}',b'Reference # {0} datert {1}'
+b'apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +164',b'Depreciation Eliminated due to disposal of assets',b'Avskrivninger Sl\xc3\xa5tt p\xc3\xa5 grunn av salg av eiendeler'
+b'DocType: Member',b'Member',b'Medlem'
+b'apps/erpnext/erpnext/templates/includes/cart/cart_address.html +15',b'Manage Addresses',b'Administrer Adresser'
+b'DocType: Work Order Item',b'Work Order Item',b'Arbeid Bestillingselement'
+b'DocType: Pricing Rule',b'Item Code',b'Sak Kode'
+b'DocType: Serial No',b'Warranty / AMC Details',b'Garanti / AMC Detaljer'
+b'apps/erpnext/erpnext/education/doctype/student_group/student_group.js +116',b'Select students manually for the Activity based Group',b'Velg studenter manuelt for aktivitetsbasert gruppe'
+b'DocType: Journal Entry',b'User Remark',b'Bruker Remark'
+b'DocType: Lead',b'Market Segment',b'Markedssegment'
+b'DocType: Agriculture Analysis Criteria',b'Agriculture Manager',b'Landbruksansvarlig'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +966',b'Paid Amount cannot be greater than total negative outstanding amount {0}',b'Betalt Bel\xc3\xb8pet kan ikke v\xc3\xa6re st\xc3\xb8rre enn total negativ utest\xc3\xa5ende bel\xc3\xb8p {0}'
+b'DocType: Supplier Scorecard Period',b'Variables',b'variabler'
+b'DocType: Employee Internal Work History',b'Employee Internal Work History',b'Ansatt Intern Work History'
+b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +249',b'Closing (Dr)',b'Lukking (Dr)'
+b'DocType: Cheque Print Template',b'Cheque Size',b'sjekk Size'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +232',b'Serial No {0} not in stock',b'Serial No {0} ikke p\xc3\xa5 lager'
+b'apps/erpnext/erpnext/config/selling.py +169',b'Tax template for selling transactions.',b'Skatt mal for \xc3\xa5 selge transaksjoner.'
+b'DocType: Sales Invoice',b'Write Off Outstanding Amount',b'Skriv Av utest\xc3\xa5ende bel\xc3\xb8p'
+b'apps/erpnext/erpnext/hr/doctype/expense_claim_type/expense_claim_type.py +27',b'Account {0} does not match with Company {1}',b'Konto {0} stemmer ikke overens med selskapets {1}'
+b'DocType: Education Settings',b'Current Academic Year',b'N\xc3\xa5v\xc3\xa6rende akademisk \xc3\xa5r'
+b'DocType: Education Settings',b'Current Academic Year',b'N\xc3\xa5v\xc3\xa6rende akademisk \xc3\xa5r'
+b'DocType: Stock Settings',b'Default Stock UOM',b'Standard Stock m\xc3\xa5lenheter'
+b'DocType: Asset',b'Number of Depreciations Booked',b'Antall Avskrivninger bestilt'
+b'apps/erpnext/erpnext/public/js/pos/pos.html +71',b'Qty Total',b'Antall totalt'
+b'apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +32',b'Against Employee Loan: {0}',b'Mot Ansattes l\xc3\xa5n: {0}'
+b'DocType: Landed Cost Item',b'Receipt Document',b'kvittering Document'
+b'DocType: Employee Education',b'School/University',b'Skole / universitet'
+b'DocType: Payment Request',b'Reference Details',b'Referanse Detaljer'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +56',b'Expected Value After Useful Life must be less than Gross Purchase Amount',b'Forventet verdi Etter Nyttig Livet m\xc3\xa5 v\xc3\xa6re mindre enn Bruttobel\xc3\xb8pet'
+b'DocType: Sales Invoice Item',b'Available Qty at Warehouse',b'Tilgjengelig Antall p\xc3\xa5 Warehouse'
+b'apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +20',b'Billed Amount',b'Fakturert bel\xc3\xb8p'
+b'DocType: Share Transfer',b'(including)',b'(gjelder ogs\xc3\xa5)'
+b'DocType: Asset',b'Double Declining Balance',b'Dobbel degressiv'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +180',b'Closed order cannot be cancelled. Unclose to cancel.',b'Stengt for kan ikke avbestilles. Unclose \xc3\xa5 avbryte.'
+b'DocType: Student Guardian',b'Father',b'Far'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +627',"b""'Update Stock' cannot be checked for fixed asset sale""",b'&#39;Oppdater Stock &quot;kan ikke kontrolleres for driftsmiddel salg'
+b'DocType: Bank Reconciliation',b'Bank Reconciliation',b'Bankavstemming'
+b'DocType: Attendance',b'On Leave',b'P\xc3\xa5 ferie'
+b'apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +7',b'Get Updates',b'F\xc3\xa5 oppdateringer'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +96',b'{0} {1}: Account {2} does not belong to Company {3}',b'{0} {1}: Account {2} ikke tilh\xc3\xb8rer selskapet {3}'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +397',b'Select at least one value from each of the attributes.',b'Velg minst \xc3\xa9n verdi fra hver av attributter.'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +166',b'Material Request {0} is cancelled or stopped',b'Materialet Request {0} blir kansellert eller stoppet'
+b'apps/erpnext/erpnext/config/hr.py +314',b'Leave Management',b'La Ledelse'
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +118',b'Group by Account',b'Grupper etter Account'
+b'apps/erpnext/erpnext/education/doctype/instructor/instructor.py +21',b'Please select Employee',b'Vennligst velg Medarbeider'
+b'DocType: Sales Order',b'Fully Delivered',b'Fullt Leveres'
+b'DocType: Lead',b'Lower Income',b'Lavere inntekt'
+b'DocType: Restaurant Order Entry',b'Current Order',b'N\xc3\xa5v\xc3\xa6rende ordre'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +196',b'Source and target warehouse cannot be same for row {0}',b'Kilden og m\xc3\xa5let lageret kan ikke v\xc3\xa6re det samme for rad {0}'
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +243',"b'Difference Account must be a Asset/Liability type account, since this Stock Reconciliation is an Opening Entry'","b'Forskjellen konto m\xc3\xa5 v\xc3\xa6re en eiendel / forpliktelse type konto, siden dette Stock Forsoning er en \xc3\xa5pning Entry'"
+b'apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +107',b'Disbursed Amount cannot be greater than Loan Amount {0}',b'Utbetalt Mengde kan ikke v\xc3\xa6re st\xc3\xb8rre enn l\xc3\xa5ne bel\xc3\xb8pet {0}'
+b'apps/erpnext/erpnext/utilities/user_progress.py +176',b'Go to Programs',b'G\xc3\xa5 til Programmer'
+b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +205',b'Row {0}# Allocated amount {1} cannot be greater than unclaimed amount {2}',b'Row {0} # Tilordnet mengde {1} kan ikke v\xc3\xa6re st\xc3\xb8rre enn uanmeldt bel\xc3\xb8p {2}'
+b'apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +89',b'Purchase Order number required for Item {0}',b'Innkj\xc3\xb8psordrenummeret som kreves for Element {0}'
+b'apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +18',"b""'From Date' must be after 'To Date'""",b'&quot;Fra dato&quot; m\xc3\xa5 v\xc3\xa6re etter &#39;To Date&#39;'
+b'apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +39',b'Cannot change status as student {0} is linked with student application {1}',b'Kan ikke endre status som student {0} er knyttet til studentens s\xc3\xb8knad {1}'
+b'DocType: Asset',b'Fully Depreciated',b'fullt avskrevet'
+b'DocType: Item Barcode',b'UPC-A',b'UPC-A'
+,b'Stock Projected Qty',b'Lager Antall projiserte'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +444',b'Customer {0} does not belong to project {1}',b'Kunden {0} ikke h\xc3\xb8rer til prosjektet {1}'
+b'DocType: Employee Attendance Tool',b'Marked Attendance HTML',b'Merket Oppm\xc3\xb8te HTML'
+b'apps/erpnext/erpnext/utilities/activation.py +73',"b'Quotations are proposals, bids you have sent to your customers'","b'Sitater er forslag, bud du har sendt til dine kunder'"
+b'DocType: Sales Invoice',"b""Customer's Purchase Order""",b'Kundens innkj\xc3\xb8psordre'
+b'DocType: Consultation',b'Patient',b'Pasient'
+b'apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +47',b'Bypass credit check at Sales Order ',b'Bypass kreditt sjekk p\xc3\xa5 salgsordre'
+b'DocType: Land Unit',b'Check if it is a hydroponic unit',b'Sjekk om det er en hydroponisk enhet'
+b'apps/erpnext/erpnext/config/stock.py +109',b'Serial No and Batch',b'Serial No og Batch'
+b'DocType: Warranty Claim',b'From Company',b'Fra Company'
+b'apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py +52',b'Sum of Scores of Assessment Criteria needs to be {0}.',b'Summen av Resultater av vurderingskriterier m\xc3\xa5 v\xc3\xa6re {0}.'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +77',b'Please set Number of Depreciations Booked',b'Vennligst sett Antall Avskrivninger bestilt'
+b'DocType: Supplier Scorecard Period',b'Calculations',b'beregninger'
+b'apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +86',b'Value or Qty',b'Verdi eller Stk'
+b'DocType: Payment Terms Template',b'Payment Terms',b'Betalingsbetingelser'
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +449',b'Productions Orders cannot be raised for:',b'Productions Bestillinger kan ikke heves for:'
+b'apps/erpnext/erpnext/utilities/user_progress.py +147',b'Minute',b'Minutt'
+b'DocType: Purchase Invoice',b'Purchase Taxes and Charges',b'Kj\xc3\xb8pe skatter og avgifter'
+b'DocType: Chapter',b'Meetup Embed HTML',b'Meetup Embed HTML'
+b'apps/erpnext/erpnext/utilities/user_progress.py +121',b'Go to Suppliers',b'G\xc3\xa5 til Leverand\xc3\xb8rer'
+,b'Qty to Receive',b'Antall \xc3\xa5 motta'
+b'DocType: Leave Block List',b'Leave Block List Allowed',b'La Block List tillatt'
+b'DocType: Grading Scale Interval',b'Grading Scale Interval',b'Grading Scale Intervall'
+b'apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +49',b'Expense Claim for Vehicle Log {0}',b'Expense krav for Vehicle Logg {0}'
+b'DocType: Sales Invoice Item',b'Discount (%) on Price List Rate with Margin',b'Rabatt (%) p\xc3\xa5 prisliste med margin'
+b'apps/erpnext/erpnext/patches/v7_0/create_warehouse_nestedset.py +59',b'All Warehouses',b'alle N\xc3\xa6ringslokaler'
+b'DocType: Sales Partner',b'Retailer',b'Forhandler'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +115',b'Credit To account must be a Balance Sheet account',b'Kreditt til kontoen m\xc3\xa5 v\xc3\xa6re en balansekonto'
+b'apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +118',b'All Supplier Types',b'Alle Leverand\xc3\xb8r Typer'
+b'DocType: Donor',b'Donor',b'donor'
+b'DocType: Global Defaults',b'Disable In Words',b'Deaktiver I Ord'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +60',b'Item Code is mandatory because Item is not automatically numbered',b'Elementkode er obligatorisk fordi varen ikke blir automatisk nummerert'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +98',b'Quotation {0} not of type {1}',b'Sitat {0} ikke av typen {1}'
+b'DocType: Maintenance Schedule Item',b'Maintenance Schedule Item',b'Vedlikeholdsplan Sak'
+b'DocType: Sales Order',b'%  Delivered',b'% Leveres'
+b'apps/erpnext/erpnext/education/doctype/fees/fees.js +105',b'Please set the Email ID for the Student to send the Payment Request',b'Vennligst still inn e-post-IDen for studenten for \xc3\xa5 sende betalingsanmodningen'
+b'DocType: Patient',b'Medical History',b'Medisinsk historie'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +157',b'Bank Overdraft Account',b'Kassekreditt konto'
+b'DocType: Patient',b'Patient ID',b'Pasient ID'
+b'DocType: Physician Schedule',b'Schedule Name',b'Planleggingsnavn'
+b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js +48',b'Make Salary Slip',b'Gj\xc3\xb8r L\xc3\xb8nn Slip'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +840',b'Add All Suppliers',b'Legg til alle leverand\xc3\xb8rer'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +94',b'Row #{0}: Allocated Amount cannot be greater than outstanding amount.',b'Rad # {0}: Tilordnet bel\xc3\xb8p kan ikke v\xc3\xa6re st\xc3\xb8rre enn utest\xc3\xa5ende bel\xc3\xb8p.'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +75',b'Browse BOM',b'Bla BOM'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +155',b'Secured Loans',b'Sikret l\xc3\xa5n'
+b'DocType: Purchase Invoice',b'Edit Posting Date and Time',b'Rediger konteringsdato og klokkeslett'
+b'apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +101',b'Please set Depreciation related Accounts in Asset Category {0} or Company {1}',b'Vennligst sett Avskrivninger relatert kontoer i Asset Kategori {0} eller selskapet {1}'
+b'DocType: Lab Test Groups',b'Normal Range',b'Normal rekkevidde'
+b'DocType: Academic Term',b'Academic Year',b'Studie\xc3\xa5r'
+b'apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +72',b'Available Selling',b'Tilgjengelig salg'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +169',b'Opening Balance Equity',b'\xc3\x85pningsbalanse Equity'
+b'DocType: Lead',b'CRM',b'CRM'
+b'DocType: Purchase Invoice',b'N',b'N'
+b'apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +175',b'Remaining',b'Gjenv\xc3\xa6rende v\xc3\xa6rende~~POS=HEADCOMP'
+b'DocType: Appraisal',b'Appraisal',b'Appraisal'
+b'DocType: Purchase Invoice',b'GST Details',b'GST-detaljer'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +156',b'Email sent to supplier {0}',b'E-post sendt til leverand\xc3\xb8ren {0}'
+b'DocType: Item',b'Default Sales Unit of Measure',b'Standard salgsmengde av m\xc3\xa5l'
+b'apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +9',b'Academic Year: ',b'Studie\xc3\xa5r:'
+b'DocType: Opportunity',b'OPTY-',b'OPTY-'
+b'apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py +19',b'Date is repeated',b'Dato gjentas'
+b'apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +27',b'Authorized Signatory',b'Autorisert signatur'
+b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +64',b'Create Fees',b'Opprett gebyrer'
+b'DocType: Project',b'Total Purchase Cost (via Purchase Invoice)',b'Total anskaffelseskost (via fakturaen)'
+b'DocType: Training Event',b'Start Time',b'Starttid'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +400',b'Select Quantity',b'Velg Antall'
+b'DocType: Customs Tariff Number',b'Customs Tariff Number',b'Tolltariffen nummer'
+b'DocType: Patient Appointment',b'Patient Appointment',b'Pasientavtale'
+b'apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +34',b'Approving Role cannot be same as role the rule is Applicable To',b'Godkjenne Role kan ikke v\xc3\xa6re det samme som rollen regelen gjelder for'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +64',b'Unsubscribe from this Email Digest',b'Melde deg ut av denne e-post Digest'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +830',b'Get Suppliers By',b'F\xc3\xa5 leverand\xc3\xb8rer av'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +173',b'{0} not found for Item {1}',b'{0} ikke funnet for element {1}'
+b'apps/erpnext/erpnext/utilities/user_progress.py +197',b'Go to Courses',b'G\xc3\xa5 til kurs'
+b'DocType: Accounts Settings',b'Show Inclusive Tax In Print',b'Vis inklusiv skatt i utskrift'
+b'apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +17',"b'Bank Account, From Date and To Date are Mandatory'","b'Bankkonto, fra dato og til dato er obligatorisk'"
+b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +28',b'Message Sent',b'Melding Sendt'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +98',b'Account with child nodes cannot be set as ledger',b'Konto med barnet noder kan ikke settes som hovedbok'
+b'DocType: C-Form',b'II',b'II'
+b'DocType: Sales Invoice',"b""Rate at which Price list currency is converted to customer's base currency""",b'Hastigheten som Prisliste valuta er konvertert til kundens basisvaluta'
+b'DocType: Purchase Invoice Item',b'Net Amount (Company Currency)',b'Nettobel\xc3\xb8p (Company Valuta)'
+b'DocType: Physician',b'Physician Schedules',b'Legeplaner'
+b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +215',b'Total advance amount cannot be greater than total sanctioned amount',b'Samlet forskuddbel\xc3\xb8p kan ikke v\xc3\xa6re st\xc3\xb8rre enn total sanksjonert bel\xc3\xb8p'
+b'DocType: Salary Slip',b'Hour Rate',b'Time Rate'
+b'DocType: Stock Settings',b'Item Naming By',b'Sak Naming Av'
+b'apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +46',b'Another Period Closing Entry {0} has been made after {1}',b'En annen periode Closing Entry {0} har blitt gjort etter {1}'
+b'DocType: Work Order',b'Material Transferred for Manufacturing',b'Materialet Overf\xc3\xb8rt for Manufacturing'
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +41',b'Account {0} does not exists',b'Konto {0} ikke eksisterer'
+b'DocType: Project',b'Project Type',b'Prosjekttype'
+b'apps/erpnext/erpnext/projects/doctype/task/task.py +153',b'Child Task exists for this Task. You can not delete this Task.',b'Barneoppgave eksisterer for denne oppgaven. Du kan ikke slette denne oppgaven.'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +48',b'DateLet',b'DateLet'
+b'apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +16',b'Either target qty or target amount is mandatory.',b'Enten m\xc3\xa5let stk eller m\xc3\xa5l bel\xc3\xb8pet er obligatorisk.'
+b'apps/erpnext/erpnext/config/projects.py +56',b'Cost of various activities',b'Kostnad for ulike aktiviteter'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +60',"b'Setting Events to {0}, since the Employee attached to the below Sales Persons does not have a User ID{1}'","b'Innstilling Hendelser til {0}, siden den ansatte knyttet til under selgerne ikke har en bruker-ID {1}'"
+b'DocType: Timesheet',b'Billing Details',b'Fakturadetaljer'
+b'apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +163',b'Source and target warehouse must be different',b'Kilde og m\xc3\xa5l lageret m\xc3\xa5 v\xc3\xa6re annerledes'
+b'apps/erpnext/erpnext/erpnext_integrations/doctype/gocardless_settings/gocardless_settings.py +140',b'Payment Failed. Please check your GoCardless Account for more details',b'Betalingen feilet. Vennligst sjekk din GoCardless-konto for mer informasjon'
+b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +101',b'Not allowed to update stock transactions older than {0}',b'Ikke lov til \xc3\xa5 oppdatere lagertransaksjoner eldre enn {0}'
+b'DocType: BOM',b'Inspection Required',b'Inspeksjon p\xc3\xa5krevd'
+b'DocType: Purchase Invoice Item',b'PR Detail',b'PR Detalj'
+b'DocType: Driving License Category',b'Class',b'Klasse'
+b'DocType: Sales Order',b'Fully Billed',b'Fullt Fakturert'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +426',b'Work Order cannot be raised against a Item Template',b'Arbeidsordre kan ikke heves opp mot en varemaling'
+b'apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +101',b'Shipping rule only applicable for Buying',b'Fraktregel gjelder kun for kj\xc3\xb8p'
+b'DocType: Vital Signs',b'BMI',b'BMI'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +20',b'Cash In Hand',b'Kontanter'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +137',b'Delivery warehouse required for stock item {0}',b'Levering lager n\xc3\xb8dvendig for lagervare {0}'
+b'DocType: Packing Slip',b'The gross weight of the package. Usually net weight + packaging material weight. (for print)',b'Totalvekten av pakken. Vanligvis nettovekt + emballasjematerialet vekt. (For utskrift)'
+b'DocType: Assessment Plan',b'Program',b'Program'
+b'DocType: Accounts Settings',b'Users with this role are allowed to set frozen accounts and create / modify accounting entries against frozen accounts',b'Brukere med denne rollen har lov til \xc3\xa5 sette frosne kontoer og lage / endre regnskapspostene mot frosne kontoer'
+b'DocType: Serial No',b'Is Cancelled',b'Er Avlyst'
+b'DocType: Student Group',b'Group Based On',b'Gruppe basert p\xc3\xa5'
+b'DocType: Student Group',b'Group Based On',b'Gruppe basert p\xc3\xa5'
+b'DocType: Journal Entry',b'Bill Date',b'Bill Dato'
+b'DocType: Healthcare Settings',b'Laboratory SMS Alerts',b'Laboratory SMS Alerts'
+b'apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +20',"b'Service Item,Type,frequency and expense amount are required'","b'Tjenesten varen, type, frekvens og utgiftene bel\xc3\xb8p kreves'"
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +45',"b'Even if there are multiple Pricing Rules with highest priority, then following internal priorities are applied:'","b'Selv om det er flere Prising regler med h\xc3\xb8yest prioritet, deretter f\xc3\xb8lgende interne prioriteringer til grunn:'"
+b'DocType: Plant Analysis Criteria',b'Plant Analysis Criteria',b'Plantanalyse Kriterier'
+b'DocType: Cheque Print Template',b'Cheque Height',b'sjekk H\xc3\xb8yde'
+b'DocType: Supplier',b'Supplier Details',b'Leverand\xc3\xb8r Detaljer'
+b'DocType: Setup Progress',b'Setup Progress',b'Oppsett Progress'
+b'DocType: Hub Settings',b'Publish Items to Hub',b'Publiser varer i Hub'
+b'apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +35',b'From value must be less than to value in row {0}',b'Fra verdien m\xc3\xa5 v\xc3\xa6re mindre enn til verdien i rad {0}'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +182',b'Wire Transfer',b'Wire Transfer'
+b'apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +92',b'Check all',b'Sjekk alt'
+,b'Issued Items Against Work Order',b'Utstedte varer mot arbeidsordre'
+b'DocType: Vehicle Log',b'Invoice Ref',b'faktura~~POS=TRUNC Ref'
+b'DocType: Company',b'Default Income Account',b'Standard Inntekt konto'
+b'apps/erpnext/erpnext/selling/page/sales_analytics/sales_analytics.js +32',b'Customer Group / Customer',b'Kunden Group / Kunde'
+b'apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +37',b'Unclosed Fiscal Years Profit / Loss (Credit)',b'Unclosed regnskaps\xc3\xa5rene Profit / Loss (Credit)'
+b'DocType: Sales Invoice',b'Time Sheets',b'timelister'
+b'DocType: Lab Test Template',b'Change In Item',b'Endre i element'
+b'DocType: Payment Gateway Account',b'Default Payment Request Message',b'Standard betalingsforesp\xc3\xb8rsel Message'
+b'DocType: Item Group',b'Check this if you want to show in website',b'Sjekk dette hvis du vil vise p\xc3\xa5 nettstedet'
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +338',b'Balance ({0})',b'Balanse ({0})'
+b'apps/erpnext/erpnext/config/accounts.py +134',b'Banking and Payments',b'Bank og Betalinger'
+,b'Welcome to ERPNext',b'Velkommen til ERPNext'
+b'apps/erpnext/erpnext/config/learn.py +102',b'Lead to Quotation',b'F\xc3\xb8re til prisanslag'
+b'apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +34',b'Email Reminders will be sent to all parties with email contacts',b'E-mail p\xc3\xa5minnelser vil bli sendt til alle parter med e-postkontakter'
+b'DocType: Project',b'Twice Daily',b'To ganger daglig'
+b'DocType: Patient',b'A Negative',b'En negativ'
+b'apps/erpnext/erpnext/templates/includes/product_list.js +45',b'Nothing more to show.',b'Ingenting mer \xc3\xa5 vise.'
+b'DocType: Lead',b'From Customer',b'Fra Customer'
+b'apps/erpnext/erpnext/demo/setup/setup_data.py +327',b'Calls',b'Samtaler'
+b'apps/erpnext/erpnext/utilities/user_progress.py +143',b'A Product',b'Et produkt'
+b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +207',b'Batches',b'batcher'
+b'apps/erpnext/erpnext/education/doctype/fee_structure/fee_structure.js +34',b'Make Fee Schedule',b'Lag avgiftsplan'
+b'DocType: Purchase Order Item Supplied',b'Stock UOM',b'Stock m\xc3\xa5lenheter'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +233',b'Purchase Order {0} is not submitted',b'Purchase Order {0} ikke er sendt'
+b'DocType: Vital Signs',b'Normal reference range for an adult is 16\xe2\x80\x9320 breaths/minute (RCP 2012)',b'Normalt referanseomr\xc3\xa5de for en voksen er 16-20 puste / minutt (RCP 2012)'
+b'DocType: Customs Tariff Number',b'Tariff Number',b'tariff Antall'
+b'DocType: Work Order Item',b'Available Qty at WIP Warehouse',b'Tilgjengelig antall p\xc3\xa5 WIP Warehouse'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +39',b'Projected',b'Prosjekterte'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +222',b'Serial No {0} does not belong to Warehouse {1}',b'Serial No {0} tilh\xc3\xb8rer ikke Warehouse {1}'
+b'apps/erpnext/erpnext/controllers/status_updater.py +177',b'Note: System will not check over-delivery and over-booking for Item {0} as quantity or amount is 0',b'Merk: Systemet vil ikke sjekke over-levering og over-booking for Element {0} som mengde eller bel\xc3\xb8pet er 0'
+b'DocType: Notification Control',b'Quotation Message',b'Sitat Message'
+b'DocType: Employee Loan',b'Employee Loan Application',b'Medarbeider l\xc3\xa5nes\xc3\xb8knad'
+b'DocType: Issue',b'Opening Date',b'\xc3\x85pningsdato'
+b'apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +86',b'Please save the patient first',b'Vennligst lagre pasienten f\xc3\xb8rst'
+b'apps/erpnext/erpnext/education/api.py +80',b'Attendance has been marked successfully.',b'Oppm\xc3\xb8te er merket med hell.'
+b'DocType: Program Enrollment',b'Public Transport',b'Offentlig transport'
+b'DocType: Soil Texture',b'Silt Composition (%)',b'Siltkomposisjon (%)'
+b'DocType: Journal Entry',b'Remark',b'Bemerkning'
+b'DocType: Healthcare Settings',b'Avoid Confirmation',b'Unng\xc3\xa5 bekreftelse'
+b'DocType: Purchase Receipt Item',b'Rate and Amount',b'Rate og Bel\xc3\xb8p'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +176',b'Account Type for {0} must be {1}',b'Kontotype for {0} m\xc3\xa5 v\xc3\xa6re {1}'
+b'DocType: Healthcare Settings',b'Default income accounts to be used if not set in Physician to book Consultation charges.',b'Standard inntektsregnskap som skal brukes dersom ikke settes i Lege for \xc3\xa5 bestille Konsultasjonsgebyrer.'
+b'apps/erpnext/erpnext/config/hr.py +55',b'Leaves and Holiday',b'Blader og Holiday'
+b'DocType: Education Settings',b'Current Academic Term',b'N\xc3\xa5v\xc3\xa6rende faglig term'
+b'DocType: Education Settings',b'Current Academic Term',b'N\xc3\xa5v\xc3\xa6rende faglig term'
+b'DocType: Sales Order',b'Not Billed',b'Ikke Fakturert'
+b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +76',b'Both Warehouse must belong to same Company',b'B\xc3\xa5de Warehouse m\xc3\xa5 tilh\xc3\xb8re samme selskapet'
+b'apps/erpnext/erpnext/public/js/templates/contact_list.html +34',b'No contacts added yet.',b'Ingen kontakter er lagt til enn\xc3\xa5.'
+b'DocType: Purchase Invoice Item',b'Landed Cost Voucher Amount',b'Landed Cost Voucher Bel\xc3\xb8p'
+,b'Item Balance (Simple)',b'Varebalanse (Enkel)'
+b'apps/erpnext/erpnext/config/accounts.py +17',b'Bills raised by Suppliers.',b'Regninger oppdratt av leverand\xc3\xb8rer.'
+b'DocType: POS Profile',b'Write Off Account',b'Skriv Off konto'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +215',b'Debit Note Amt',b'Debet notat Amt'
+b'apps/erpnext/erpnext/templates/print_formats/includes/taxes.html +5',b'Discount Amount',b'Rabattbel\xc3\xb8p'
+b'DocType: Purchase Invoice',b'Return Against Purchase Invoice',b'Tilbake mot fakturaen'
+b'DocType: Item',b'Warranty Period (in days)',b'Garantiperioden (i dager)'
+b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +61',b'Failed to set defaults',b'Kunne ikke angi standardinnstillinger'
+b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +56',b'Relation with Guardian1',b'Relasjon med Guardian1'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +786',b'Please select BOM against item {0}',b'Vennligst velg BOM mot element {0}'
+b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +18',b'Make Invoices',b'Lag fakturaer'
+b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +23',b'Net Cash from Operations',b'Netto kontantstr\xc3\xb8m fra driften'
+b'apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +26',b'Item 4',b'Sak 4'
+b'DocType: Student Admission',b'Admission End Date',b'Opptak Sluttdato'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py +30',b'Sub-contracting',b'Underleverand\xc3\xb8rer'
+b'DocType: Journal Entry Account',b'Journal Entry Account',b'Journal Entry konto'
+b'apps/erpnext/erpnext/education/doctype/academic_year/academic_year.js +3',b'Student Group',b'student Gruppe'
+b'DocType: Shopping Cart Settings',b'Quotation Series',b'Sitat Series'
+b'apps/erpnext/erpnext/setup/doctype/item_group/item_group.py +57',"b'An item exists with same name ({0}), please change the item group name or rename the item'","b'Et element eksisterer med samme navn ({0}), m\xc3\xa5 du endre navn varegruppen eller endre navn p\xc3\xa5 elementet'"
+b'DocType: Soil Analysis Criteria',b'Soil Analysis Criteria',b'Jordanalyse Kriterier'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +2041',b'Please select customer',b'Velg kunde'
+b'DocType: C-Form',b'I',b'Jeg'
+b'DocType: Company',b'Asset Depreciation Cost Center',b'Asset Avskrivninger kostnadssted'
+b'DocType: Production Plan Sales Order',b'Sales Order Date',b'Salgsordre Dato'
+b'DocType: Sales Invoice Item',b'Delivered Qty',b'Leveres Antall'
+b'DocType: Assessment Plan',b'Assessment Plan',b'Assessment Plan'
+b'apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +90',b'Customer {0} is created.',b'Kunden {0} er opprettet.'
+b'DocType: Stock Settings',b'Limit Percent',b'grense Prosent'
+b'apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +82',b' Currently no stock available in any warehouse',b'Forel\xc3\xb8pig ingen lager tilgjengelig i varehus'
+,b'Payment Period Based On Invoice Date',b'Betaling perioden basert p\xc3\xa5 Fakturadato'
+b'DocType: Sample Collection',b'No. of print',b'Antall utskrifter'
+b'DocType: Hotel Room Reservation Item',b'Hotel Room Reservation Item',b'Hotel Room Reservation Item'
+b'apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +58',b'Missing Currency Exchange Rates for {0}',b'Mangler valutakurser for {0}'
+b'DocType: Health Insurance',b'Health Insurance Name',b'Helseforsikringsnavn'
+b'DocType: Assessment Plan',b'Examiner',b'Examiner'
+b'DocType: Student',b'Siblings',b's\xc3\xb8sken'
+b'DocType: Journal Entry',b'Stock Entry',b'Stock Entry'
+b'DocType: Payment Entry',b'Payment References',b'Betalings Referanser'
+b'DocType: C-Form',b'C-FORM-',b'C-form-'
+b'DocType: Vehicle',b'Insurance Details',b'forsikring Detaljer'
+b'DocType: Account',b'Payable',b'Betales'
+b'DocType: Share Balance',b'Share Type',b'Del Type'
+b'apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +113',b'Please enter Repayment Periods',b'Fyll inn nedbetalingstid'
+b'apps/erpnext/erpnext/shopping_cart/cart.py +378',b'Debtors ({0})',b'Skyldnere ({0})'
+b'DocType: Pricing Rule',b'Margin',b'Margin'
+b'apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +57',b'New Customers',b'Nye kunder'
+b'apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +74',b'Gross Profit %',b'Bruttofortjeneste%'
+b'DocType: Appraisal Goal',b'Weightage (%)',b'Weightage (%)'
+b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +503',b'Change POS Profile',b'Endre POS-profil'
+b'DocType: Bank Reconciliation Detail',b'Clearance Date',b'Klaring Dato'
+b'apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +7',b'Assessment Report',b'Vurderingsrapport'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +59',b'Gross Purchase Amount is mandatory',b'Bruttobel\xc3\xb8pet er obligatorisk'
+b'apps/erpnext/erpnext/setup/doctype/company/company.js +95',b'Company name not same',b'Firmanavn ikke det samme'
+b'DocType: Lead',b'Address Desc',b'Adresse Desc'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +113',b'Party is mandatory',b'Party er obligatorisk'
+b'DocType: Journal Entry',b'JV-',b'JV-'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +712',b'Rows with duplicate due dates in other rows were found: {list}',b'Rader med dupliserte forfallsdatoer i andre rader ble funnet: {list}'
+b'DocType: Topic',b'Topic Name',b'emne Name'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +37',b'Atleast one of the Selling or Buying must be selected',b'Minst \xc3\xa9n av de selge eller kj\xc3\xb8pe m\xc3\xa5 velges'
+b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +290',b'Select an employee to get the employee advance.',b'Velg en ansatt for \xc3\xa5 f\xc3\xa5 ansatt p\xc3\xa5 forh\xc3\xa5nd.'
+b'apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +56',b'Please select a valid Date',b'Vennligst velg en gyldig dato'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +36',b'Select the nature of your business.',b'Velg form\xc3\xa5let med virksomheten.'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +24',b'Please setup Employee Naming System in Human Resource &gt; HR Settings',b'Vennligst oppsett Medarbeiders navngivningssystem i menneskelig ressurs&gt; HR-innstillinger'
+b'DocType: Lab Test Template',"b'Single for results which require only a single input, result UOM and normal value \n<br>\nCompound for results which require multiple input fields with corresponding event names, result UOMs and normal values\n<br>\nDescriptive for tests which have multiple result components and corresponding result entry fields. \n<br>\nGrouped for test templates which are a group of other test templates.\n<br>\nNo Result for tests with no results. Also, no Lab Test is created. e.g.. Sub Tests for Grouped results.'","b'Enkelt for resultater som krever bare ett enkelt inngang, resultat UOM og normal verdi <br> Sammensatt for resultater som krever flere inntastingsfelter med tilsvarende hendelsesnavn, resulterer UOM og normale verdier <br> Beskrivende for tester som har flere resultatkomponenter og tilh\xc3\xb8rende resultatoppf\xc3\xb8ringsfelter. <br> Gruppert for testmaler som er en gruppe andre testmaler. <br> Ingen resultat for tester uten resultater. Ogs\xc3\xa5, ingen Lab Test er opprettet. f.eks. Delpr\xc3\xb8ver for grupperte resultater.'"
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +86',b'Row #{0}: Duplicate entry in References {1} {2}',b'Row # {0}: Dupliseringsoppf\xc3\xb8ring i Referanser {1} {2}'
+b'apps/erpnext/erpnext/config/manufacturing.py +57',b'Where manufacturing operations are carried.',b'Hvor fabrikasjonsvirksomhet gjennomf\xc3\xb8res.'
+b'apps/erpnext/erpnext/education/doctype/instructor/instructor.js +18',b'As Examiner',b'Som eksaminator'
+b'DocType: Appointment Type',b'Default Duration',b'Standard varighet'
+b'DocType: Asset Movement',b'Source Warehouse',b'Kilde Warehouse'
+b'DocType: Installation Note',b'Installation Date',b'Installasjonsdato'
+b'apps/erpnext/erpnext/accounts/doctype/shareholder/shareholder.js +30',b'Share Ledger',b'Del Ledger'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +606',b'Row #{0}: Asset {1} does not belong to company {2}',b'Row # {0}: Asset {1} ikke tilh\xc3\xb8rer selskapet {2}'
+b'apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +206',b'Sales Invoice {0} created',b'Salgsfaktura {0} opprettet'
+b'DocType: Employee',b'Confirmation Date',b'Bekreftelse Dato'
+b'DocType: C-Form',b'Total Invoiced Amount',b'Total Fakturert bel\xc3\xb8p'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +50',b'Min Qty can not be greater than Max Qty',b'Min Antall kan ikke v\xc3\xa6re st\xc3\xb8rre enn Max Antall'
+b'DocType: Soil Texture',b'Silty Clay',b'Silty Clay'
+b'DocType: Account',b'Accumulated Depreciation',b'akkumulerte avskrivninger'
+b'DocType: Supplier Scorecard Scoring Standing',b'Standing Name',b'St\xc3\xa5ende navn'
+b'DocType: Stock Entry',b'Customer or Supplier Details',b'Kunde eller leverand\xc3\xb8r Detaljer'
+b'DocType: Employee Loan Application',b'Required by Date',b'Kreves av Dato'
+b'DocType: Lead',b'Lead Owner',b'Lead Eier'
+b'DocType: Production Plan',b'Sales Orders Detail',b'Salgsordre detalj'
+b'DocType: Bin',b'Requested Quantity',b'Requested Antall'
+b'DocType: Patient',b'Marital Status',b'Sivilstatus'
+b'DocType: Stock Settings',b'Auto Material Request',b'Auto Materiell Request'
+b'DocType: Delivery Note Item',b'Available Batch Qty at From Warehouse',b'Tilgjengelig Batch Antall p\xc3\xa5 From Warehouse'
+b'DocType: Customer',b'CUST-',b'CUST-'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +50',b'Idevise',b'Idevise'
+b'DocType: Salary Slip',b'Gross Pay - Total Deduction - Loan Repayment',b'Brutto l\xc3\xb8nn - Totalt Fradrag - Loan Nedbetaling'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +29',b'Current BOM and New BOM can not be same',b'N\xc3\xa5v\xc3\xa6rende BOM og New BOM kan ikke v\xc3\xa6re det samme'
+b'apps/erpnext/erpnext/hr/report/salary_register/salary_register.py +47',b'Salary Slip ID',b'L\xc3\xb8nn Slip ID'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +118',b'Date Of Retirement must be greater than Date of Joining',b'Pensjoneringstidspunktet m\xc3\xa5 v\xc3\xa6re st\xc3\xb8rre enn tidspunktet for inntreden'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +68',b'Multiple Variants',b'Flere variasjoner'
+b'DocType: Sales Invoice',b'Against Income Account',b'Mot Inntekt konto'
+b'apps/erpnext/erpnext/controllers/website_list_for_contact.py +117',b'{0}% Delivered',b'{0}% Leveres'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +107',b'Item {0}: Ordered qty {1} cannot be less than minimum order qty {2} (defined in Item).',b'Element {0}: Bestilte qty {1} kan ikke v\xc3\xa6re mindre enn minimum ordreantall {2} (definert i punkt).'
+b'DocType: Monthly Distribution Percentage',b'Monthly Distribution Percentage',b'M\xc3\xa5nedlig Distribution Prosent'
+b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +49',b'Please login as another user.',b'Vennligst logg inn som en annen bruker.'
+b'DocType: Daily Work Summary Group User',b'Daily Work Summary Group User',b'Daglig arbeidsoppsummeringsgruppebruker'
+b'DocType: Territory',b'Territory Targets',b'Terri Targets'
+b'DocType: Soil Analysis',b'Ca/Mg',b'Ca / Mg'
+b'DocType: Delivery Note',b'Transporter Info',b'Transporter Info'
+b'apps/erpnext/erpnext/accounts/utils.py +502',b'Please set default {0} in Company {1}',b'Vennligst sett standard {0} i selskapet {1}'
+b'DocType: Cheque Print Template',b'Starting position from top edge',b'Startposisjon fra \xc3\xb8verste kant'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +33',b'Same supplier has been entered multiple times',b'Samme leverand\xc3\xb8r er angitt flere ganger'
+b'apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.py +152',b'Gross Profit / Loss',b'Brutto gevinst / tap'
+,b'Warehouse wise Item Balance Age and Value',b'Lagerbetraktet Varebalanse Alder og verdi'
+b'DocType: Purchase Order Item Supplied',b'Purchase Order Item Supplied',b'Innkj\xc3\xb8psordre Sak Leveres'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +94',b'Company Name cannot be Company',b'Firmanavn kan ikke v\xc3\xa6re selskap'
+b'apps/erpnext/erpnext/config/setup.py +27',b'Letter Heads for print templates.',b'Brevark for utskriftsmaler.'
+b'apps/erpnext/erpnext/config/setup.py +32',b'Titles for print templates e.g. Proforma Invoice.',b'Titler for utskriftsmaler f.eks Proforma Faktura.'
+b'DocType: Program Enrollment',b'Walking',b'walking'
+b'DocType: Student Guardian',b'Student Guardian',b'student Guardian'
+b'DocType: Member',b'Member Name',b'Medlemsnavn'
+b'DocType: Stock Settings',b'Use Naming Series',b'Bruk Naming Series'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +218',b'Valuation type charges can not marked as Inclusive',b'Verdsettelse typen kostnader kan ikke merket som Inclusive'
+b'DocType: POS Profile',b'Update Stock',b'Oppdater Stock'
+b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +10',b'in the subscription',b'i abonnementet'
+b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +100',b'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.',b'Ulik m\xc3\xa5lenheter for elementer vil f\xc3\xb8re til feil (Total) Netto vekt verdi. S\xc3\xb8rg for at nettovekt av hvert element er i samme m\xc3\xa5lenheter.'
+b'DocType: Membership',b'Payment Details',b'Betalingsinformasjon'
+b'apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +39',b'BOM Rate',b'BOM Rate'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +225',"b'Stopped Work Order cannot be cancelled, Unstop it first to cancel'","b'Stoppet arbeidsordre kan ikke kanselleres, Unstop det f\xc3\xb8rst for \xc3\xa5 avbryte'"
+b'DocType: Asset',b'Journal Entry for Scrap',b'Bilagsregistrering for Scrap'
+b'apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +83',b'Please pull items from Delivery Note',b'Kan trekke elementer fra f\xc3\xb8lgeseddel'
+b'apps/erpnext/erpnext/accounts/utils.py +472',b'Journal Entries {0} are un-linked',b'Journal Entries {0} er un-linked'
+b'apps/erpnext/erpnext/config/crm.py +92',"b'Record of all communications of type email, phone, chat, visit, etc.'","b'Registrering av all kommunikasjon av typen e-post, telefon, chat, bes\xc3\xb8k, etc.'"
+b'DocType: Supplier Scorecard Scoring Standing',b'Supplier Scorecard Scoring Standing',b'Leverand\xc3\xb8r Scorecard Scoring Standing'
+b'DocType: Manufacturer',b'Manufacturers used in Items',b'Produsenter som brukes i Items'
+b'apps/erpnext/erpnext/accounts/general_ledger.py +170',b'Please mention Round Off Cost Center in Company',b'Vennligst oppgi Round Off Cost Center i selskapet'
+b'DocType: Purchase Invoice',b'Terms',b'Vilk\xc3\xa5r'
+b'apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +10',b'Select Days',b'Velg dager'
+b'DocType: Academic Term',b'Term Name',b'Term Navn'
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +332',b'Credit ({0})',b'Kreditt ({0})'
+b'DocType: Buying Settings',b'Purchase Order Required',b'Innkj\xc3\xb8psordre P\xc3\xa5krevd'
+,b'Item-wise Sales History',b'Element-messig Sales History'
+b'DocType: Expense Claim',b'Total Sanctioned Amount',b'Total vedtatte bel\xc3\xb8p'
+b'DocType: Land Unit',b'Land Unit',b'Land Unit'
+,b'Purchase Analytics',b'Kj\xc3\xb8ps Analytics'
+b'DocType: Sales Invoice Item',b'Delivery Note Item',b'Levering Note Element'
+b'DocType: Asset Maintenance Log',b'Task',b'Task'
+b'DocType: Purchase Taxes and Charges',b'Reference Row #',b'Referanse Row #'
+b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +76',b'Batch number is mandatory for Item {0}',b'Batchnummer er obligatorisk for Element {0}'
+b'apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.js +13',b'This is a root sales person and cannot be edited.',b'Dette er en grunnlegg salg person og kan ikke redigeres.'
+b'DocType: Salary Detail',"b""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. ""","b'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.'"
+b'DocType: Salary Detail',"b""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. ""","b'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.'"
+b'DocType: Asset Settings',b'Number of Days in Fiscal Year',b'Antall dager i regnskaps\xc3\xa5ret'
+,b'Stock Ledger',b'Stock Ledger'
+b'apps/erpnext/erpnext/templates/includes/cart/cart_items.html +29',b'Rate: {0}',b'Valuta: {0}'
+b'DocType: Company',b'Exchange Gain / Loss Account',b'Valutagevinst / tap-konto'
+b'apps/erpnext/erpnext/config/hr.py +7',b'Employee and Attendance',b'Medarbeider og oppm\xc3\xb8te'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +93',b'Purpose must be one of {0}',b'Hensikten m\xc3\xa5 v\xc3\xa6re en av {0}'
+b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +100',b'Fill the form and save it',b'Fyll ut skjemaet og lagre det'
+b'apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +26',b'Community Forum',b'Community Forum'
+b'apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +52',b'Actual qty in stock',b'Faktisk antall p\xc3\xa5 lager'
+b'apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +52',b'Actual qty in stock',b'Faktisk antall p\xc3\xa5 lager'
+b'DocType: Homepage',"b'URL for ""All Products""'",b'URL for &quot;Alle produkter&quot;'
+b'DocType: Leave Application',b'Leave Balance Before Application',b'La Balance F\xc3\xb8r Application'
+b'apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +46',b'Send SMS',b'Send SMS'
+b'DocType: Supplier Scorecard Criteria',b'Max Score',b'Max score'
+b'DocType: Cheque Print Template',b'Width of amount in word',b'Bredde p\xc3\xa5 bel\xc3\xb8pet i ord'
+b'DocType: Company',b'Default Letter Head',b'Standard Brevhode'
+b'DocType: Purchase Order',b'Get Items from Open Material Requests',b'F\xc3\xa5 Elementer fra \xc3\x85pen Material Foresp\xc3\xb8rsler'
+b'DocType: Hotel Room Amenity',b'Billable',b'Fakturerbare'
+b'DocType: Lab Test Template',b'Standard Selling Rate',b'Standard salgskurs'
+b'DocType: Account',b'Rate at which this tax is applied',b'Hastigheten som denne skatten er brukt'
+b'DocType: Cash Flow Mapper',b'Section Name',b'Seksjonsnavn'
+b'apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +77',b'Reorder Qty',b'Omgj\xc3\xb8re Antall'
+b'apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +28',b'Current Job Openings',b'N\xc3\xa5v\xc3\xa6rende jobb \xc3\x85pninger'
+b'DocType: Company',b'Stock Adjustment Account',b'Stock Adjustment konto'
+b'apps/erpnext/erpnext/public/js/payment/pos_payment.html +17',b'Write Off',b'Skriv Off'
+b'DocType: Patient Service Unit',b'Allow Overlap',b'Tillat overlapping'
+b'DocType: Timesheet Detail',b'Operation ID',b'Operation ID'
+b'DocType: Employee',"b'System User (login) ID. If set, it will become default for all HR forms.'","b'Systemet bruker (innlogging) ID. Hvis satt, vil det bli standard for alle HR-skjemaer.'"
+b'apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +16',b'{0}: From {1}',b'{0}: Fra {1}'
+b'DocType: Task',b'depends_on',b'kommer an p\xc3\xa5'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +60',b'Queued for updating latest price in all Bill of Materials. It may take a few minutes.',b'I k\xc3\xb8 for \xc3\xa5 oppdatere siste pris i alle Materialebevis. Det kan ta noen minutter.'
+b'apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +26',"b""Name of new Account. Note: Please don't create accounts for Customers and Suppliers""",b'Navn p\xc3\xa5 ny konto. Merk: Vennligst ikke opprette kontoer for kunder og leverand\xc3\xb8rer'
+b'apps/erpnext/erpnext/config/setup.py +37',b'Country wise default Address Templates',b'Country klok standardadresse Maler'
+b'DocType: Water Analysis',b'Appearance',b'Utseende'
+b'apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +70',b'Avg. Buying Price List Rate',b'Nr. Kj\xc3\xb8pe prisliste rate'
+b'DocType: Sales Order Item',b'Supplier delivers to Customer',b'Leverand\xc3\xb8r leverer til kunden'
+b'apps/erpnext/erpnext/config/non_profit.py +23',b'Member information.',b'Medlemsinformasjon.'
+b'apps/erpnext/erpnext/utilities/bot.py +34',b'[{0}](#Form/Item/{0}) is out of stock',b'[{0}] (# Form / post / {0}) er utsolgt'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.js +58',b'Asset Maintenance',b'Asset Maintenance'
+,b'Sales Payment Summary',b'Salgsbetalingssammendrag'
+b'DocType: Restaurant',b'Restaurant',b'Restaurant'
+b'apps/erpnext/erpnext/accounts/party.py +320',b'Due / Reference Date cannot be after {0}',b'Due / Reference Datoen kan ikke v\xc3\xa6re etter {0}'
+b'apps/erpnext/erpnext/config/setup.py +51',b'Data Import and Export',b'Data import og eksport'
+b'DocType: Patient',b'Account Details',b'kontodetaljer'
+b'DocType: Crop',b'Materials Required',b'Materialer som kreves'
+b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +76',b'No students Found',b'Ingen studenter Funnet'
+b'DocType: Medical Department',b'Medical Department',b'Medisinsk avdeling'
+b'DocType: Supplier Scorecard Scoring Criteria',b'Supplier Scorecard Scoring Criteria',b'Leverand\xc3\xb8r Scorecard Scoring Criteria'
+b'apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +55',b'Invoice Posting Date',b'Faktura Publiseringsdato'
+b'apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +25',b'Sell',b'Selge'
+b'DocType: Purchase Invoice',b'Rounded Total',b'Avrundet Total'
+b'DocType: Product Bundle',b'List items that form the package.',b'Listeelementer som danner pakken.'
+b'apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.py +39',b'Not permitted. Please disable the Test Template',b'Ikke tillatt. Vennligst deaktiver testmalen'
+b'apps/erpnext/erpnext/accounts/doctype/monthly_distribution/monthly_distribution.py +26',b'Percentage Allocation should be equal to 100%',b'Prosentvis Tildeling skal v\xc3\xa6re lik 100%'
+b'DocType: Crop Cycle',b'Linked Land Unit',b'Tilknyttet landsenhet'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +584',b'Please select Posting Date before selecting Party',b'Vennligst velg Publiseringsdato f\xc3\xb8r du velger Partiet'
+b'DocType: Program Enrollment',b'School House',b'school House'
+b'DocType: Serial No',b'Out of AMC',b'Ut av AMC'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +82',b'Number of Depreciations Booked cannot be greater than Total Number of Depreciations',b'Antall Avskrivninger reservert kan ikke v\xc3\xa6re st\xc3\xb8rre enn Totalt antall Avskrivninger'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +47',b'Make Maintenance Visit',b'Gj\xc3\xb8r Vedlikehold Visit'
+b'apps/erpnext/erpnext/selling/doctype/customer/customer.py +215',b'Please contact to the user who have Sales Master Manager {0} role',b'Ta kontakt for brukeren som har salgs Master manager {0} rolle'
+b'DocType: Company',b'Default Cash Account',b'Standard Cash konto'
+b'apps/erpnext/erpnext/config/accounts.py +62',b'Company (not Customer or Supplier) master.',b'Company (ikke kunde eller leverand\xc3\xb8r) mester.'
+b'apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +6',b'This is based on the attendance of this Student',b'Dette er basert p\xc3\xa5 tilstedev\xc3\xa6relse av denne Student'
+b'apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +178',b'No Students in',b'Ingen studenter i'
+b'apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +179',b'Add more items or open full form',b'Legg til flere elementer eller \xc3\xa5pne full form'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +212',b'Delivery Notes {0} must be cancelled before cancelling this Sales Order',b'Levering Merknader {0} m\xc3\xa5 avbestilles f\xc3\xb8r den avbryter denne salgsordre'
+b'apps/erpnext/erpnext/utilities/user_progress.py +259',b'Go to Users',b'G\xc3\xa5 til Brukere'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +85',b'Paid amount + Write Off Amount can not be greater than Grand Total',b'Innbetalt bel\xc3\xb8p + avskrive Bel\xc3\xb8pet kan ikke v\xc3\xa6re st\xc3\xb8rre enn Totalsum'
+b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +78',b'{0} is not a valid Batch Number for Item {1}',b'{0} er ikke en gyldig batchnummer for varen {1}'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +130',b'Note: There is not enough leave balance for Leave Type {0}',b'Merk: Det er ikke nok permisjon balanse for La Type {0}'
+b'apps/erpnext/erpnext/regional/india/utils.py +16',b'Invalid GSTIN or Enter NA for Unregistered',b'Ugyldig GSTIN eller Skriv inn NA for Uregistrert'
+b'DocType: Training Event',b'Seminar',b'Seminar'
+b'DocType: Program Enrollment Fee',b'Program Enrollment Fee',b'Program innmeldingsavgift'
+b'DocType: Item',b'Supplier Items',b'Leverand\xc3\xb8r Items'
+b'DocType: Opportunity',b'Opportunity Type',b'Opportunity Type'
+b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +16',b'New Company',b'Nytt firma'
+b'apps/erpnext/erpnext/setup/doctype/company/delete_company_transactions.py +17',b'Transactions can only be deleted by the creator of the Company',b'Transaksjoner kan bare slettes av skaperen av selskapet'
+b'apps/erpnext/erpnext/accounts/general_ledger.py +21',b'Incorrect number of General Ledger Entries found. You might have selected a wrong Account in the transaction.',b'Feil antall hovedbok Entries funnet. Du kan ha valgt feil konto i transaksjonen.'
+b'DocType: Employee',b'Prefered Contact Email',b'Foretrukket Kontakt E-post'
+b'DocType: Cheque Print Template',b'Cheque Width',b'sjekk Bredde'
+b'DocType: Selling Settings',b'Validate Selling Price for Item against Purchase Rate or Valuation Rate',b'Validere salgspris for varen mot Purchase Rate Verdivurdering Ranger'
+b'DocType: Fee Schedule',b'Fee Schedule',b'Prisliste'
+b'DocType: Hub Settings',b'Publish Availability',b'Publiser Tilgjengelighet'
+b'DocType: Company',b'Create Chart Of Accounts Based On',b'Opprett kontoplan basert p\xc3\xa5'
+b'apps/erpnext/erpnext/projects/doctype/task/task.js +91',b'Cannot convert it to non-group. Child Tasks exist.',b'Kan ikke konvertere det til ikke-gruppe. Barnoppgaver eksisterer.'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +112',b'Date of Birth cannot be greater than today.',b'F\xc3\xb8dselsdato kan ikke v\xc3\xa6re st\xc3\xb8rre enn i dag.'
+,b'Stock Ageing',b'Stock Ageing'
+b'apps/erpnext/erpnext/education/doctype/student/student.py +40',b'Student {0} exist against student applicant {1}',b'Student {0} eksistere mot student S\xc3\xb8keren {1}'
+b'DocType: Purchase Invoice',b'Rounding Adjustment (Company Currency)',b'Avrundingsjustering (Bedriftsvaluta)'
+b'apps/erpnext/erpnext/projects/doctype/task/task.js +39',b'Timesheet',b'Tids skjema'
+b'apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +243',b'Batch: ',b'Parti:'
+b'DocType: Volunteer',b'Afternoon',b'Ettermiddag'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +258',"b""{0} '{1}' is disabled""",b'{0} {1} er deaktivert'
+b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +13',b'Set as Open',b'Sett som \xc3\x85pen'
+b'DocType: Cheque Print Template',b'Scanned Cheque',b'skannede Cheque'
+b'DocType: Notification Control',b'Send automatic emails to Contacts on Submitting transactions.',b'Send automatisk e-poster til Kontakter p\xc3\xa5 Sende transaksjoner.'
+b'DocType: Timesheet',b'Total Billable Amount',b'Total Fakturerbart Bel\xc3\xb8p'
+b'DocType: Customer',b'Credit Limit and Payment Terms',b'Kredittgrense og betalingsbetingelser'
+b'apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +20',b'Item 3',b'Sak 3'
+b'apps/erpnext/erpnext/restaurant/doctype/restaurant/restaurant.js +6',b'Order Entry',b'Bestillingsinngang'
+b'DocType: Purchase Order',b'Customer Contact Email',b'Kundekontakt E-post'
+b'DocType: Warranty Claim',b'Item and Warranty Details',b'Element og Garanti Detaljer'
+b'DocType: Chapter',b'Chapter Members',b'Kapittelmedlemmer'
+b'DocType: Sales Team',b'Contribution (%)',b'Bidrag (%)'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +102',"b""Note: Payment Entry will not be created since 'Cash or Bank Account' was not specified""",b'Merk: Betaling Entry vil ikke bli laget siden &quot;Cash eller bankkontoen ble ikke spesifisert'
+b'apps/erpnext/erpnext/projects/doctype/project/project.py +70',b'Project {0} already exists',b'Prosjektet {0} eksisterer allerede'
+b'DocType: Medical Department',b'Nursing User',b'Sykepleier Bruker'
+b'DocType: Plant Analysis',b'Plant Analysis Criterias',b'Plant Analyse Kriterier'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +239',b'Responsibilities',b'Ansvarsomr\xc3\xa5der'
+b'apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +125',b'Validity period of this quotation has ended.',b'Gyldighetsperioden for dette sitatet er avsluttet.'
+b'DocType: Expense Claim Account',b'Expense Claim Account',b'Expense krav konto'
+b'DocType: Accounts Settings',b'Allow Stale Exchange Rates',b'Tillat uaktuelle valutakurser'
+b'DocType: Sales Person',b'Sales Person Name',b'Sales Person Name'
+b'apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +54',b'Please enter atleast 1 invoice in the table',b'Skriv inn atleast en faktura i tabellen'
+b'apps/erpnext/erpnext/utilities/user_progress.py +247',b'Add Users',b'Legg til brukere'
+b'DocType: POS Item Group',b'Item Group',b'Varegruppe'
+b'apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +16',b'Student Group: ',b'Studentgruppe:'
+b'DocType: Item',b'Safety Stock',b'Safety Stock'
+b'DocType: Healthcare Settings',b'Healthcare Settings',b'Helseinstitusjoner'
+b'apps/erpnext/erpnext/projects/doctype/task/task.py +54',b'Progress % for a task cannot be more than 100.',b'Progress% for en oppgave kan ikke v\xc3\xa6re mer enn 100.'
+b'DocType: Stock Reconciliation Item',b'Before reconciliation',b'F\xc3\xb8r avstemming'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py +12',b'To {0}',b'Til {0}'
+b'DocType: Purchase Invoice',b'Taxes and Charges Added (Company Currency)',b'Skatter og avgifter legges (Company Valuta)'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +476',b'Item Tax Row {0} must have account of type Tax or Income or Expense or Chargeable',b'Sak Skatte Rad {0} m\xc3\xa5 ha konto for type skatt eller inntekt eller kostnad eller Charge'
+b'DocType: Sales Order',b'Partly Billed',b'Delvis Fakturert'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +43',b'Item {0} must be a Fixed Asset Item',b'Element {0} m\xc3\xa5 v\xc3\xa6re et driftsmiddel element'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +372',b'Make Variants',b'Lag variasjoner'
+b'DocType: Item',b'Default BOM',b'Standard BOM'
+b'DocType: Project',b'Total Billed Amount (via Sales Invoices)',b'Sum fakturert bel\xc3\xb8p (via salgsfakturaer)'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +118',b'Debit Note Amount',b'Debet Note Bel\xc3\xb8p'
+b'DocType: Project Update',b'Not Updated',b'Ikke oppdatert'
+b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +106',"b'There are inconsistencies between the rate, no of shares and the amount calculated'","b'Det er uoverensstemmelser mellom rente, antall aksjer og beregnet bel\xc3\xb8p'"
+b'apps/erpnext/erpnext/setup/doctype/company/company.js +89',b'Please re-type company name to confirm',b'Vennligst re-type firmanavn for \xc3\xa5 bekrefte'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +216',b'Total Outstanding Amt',b'Total Outstanding Amt'
+b'DocType: Journal Entry',b'Printing Settings',b'Utskriftsinnstillinger'
+b'DocType: Employee Advance',b'Advance Account',b'Forh\xc3\xa5ndskonto'
+b'DocType: Job Offer',b'Job Offer Terms',b'Jobbtilbudsbetingelser'
+b'DocType: Sales Invoice',b'Include Payment (POS)',b'Inkluder Payment (POS)'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +292',b'Total Debit must be equal to Total Credit. The difference is {0}',b'Total debet m\xc3\xa5 v\xc3\xa6re lik samlet kreditt. Forskjellen er {0}'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +11',b'Automotive',b'Automotive'
+b'DocType: Vehicle',b'Insurance Company',b'Forsikringsselskap'
+b'DocType: Asset Category Account',b'Fixed Asset Account',b'Fast Asset konto'
+b'apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +414',b'Variable',b'variabel'
+b'apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.js +47',b'From Delivery Note',b'Fra f\xc3\xb8lgeseddel'
+b'DocType: Chapter',b'Members',b'medlemmer'
+b'DocType: Student',b'Student Email Address',b'Student e-postadresse'
+b'DocType: Item',b'Hub Warehouse',b'Hub lager'
+b'DocType: Assessment Plan',b'From Time',b'Fra Time'
+b'DocType: Hotel Settings',b'Hotel Settings',b'Hotellinnstillinger'
+b'apps/erpnext/erpnext/public/js/pos/pos_bill_item.html +12',b'In Stock: ',b'P\xc3\xa5 lager:'
+b'DocType: Notification Control',b'Custom Message',b'Standard melding'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +33',b'Investment Banking',b'Investment Banking'
+b'DocType: Purchase Invoice',b'input',b'inngang'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +79',b'Cash or Bank Account is mandatory for making payment entry',b'Kontanter eller bankkontoen er obligatorisk for \xc3\xa5 gj\xc3\xb8re betaling oppf\xc3\xb8ring'
+b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +54',b'Student Address',b'Studentadresse'
+b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +54',b'Student Address',b'Studentadresse'
+b'DocType: Purchase Invoice',b'Price List Exchange Rate',b'Prisliste Exchange Rate'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +251',b'Account Number {0} already used in account {1}',b'Kontonummer {0} som allerede er brukt i konto {1}'
+b'DocType: GoCardless Mandate',b'Mandate',b'mandat'
+b'DocType: POS Profile',b'POS Profile Name',b'POS profilnavn'
+b'DocType: Hotel Room Reservation',b'Booked',b'bestilt'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +45',b'CompAuxLib',b'CompAuxLib'
+b'DocType: Purchase Invoice Item',b'Rate',b'Rate'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +104',b'Intern',b'Intern'
+b'DocType: Delivery Stop',b'Address Name',b'Adressenavn'
+b'DocType: Stock Entry',b'From BOM',b'Fra BOM'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +639',b'Splitting {0} units of {1}',b'Splitting {0} enheter av {1}'
+b'DocType: Assessment Code',b'Assessment Code',b'Assessment Kode'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +73',b'Basic',b'Grunnleggende'
+b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +94',b'Stock transactions before {0} are frozen',b'Lagertransaksjoner f\xc3\xb8r {0} er frosset'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +219',"b""Please click on 'Generate Schedule'""",b'Vennligst klikk p\xc3\xa5 &quot;Generer Schedule &#39;'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +122',b'Reference No is mandatory if you entered Reference Date',b'Referansenummer er obligatorisk hvis du skrev Reference Date'
+b'DocType: Bank Reconciliation Detail',b'Payment Document',b'betaling Document'
+b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py +37',b'Error evaluating the criteria formula',b'Feil ved vurdering av kriterieformelen'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +115',b'Date of Joining must be greater than Date of Birth',b'Dato Bli m\xc3\xa5 v\xc3\xa6re st\xc3\xb8rre enn f\xc3\xb8dselsdato'
+b'DocType: Salary Slip',b'Salary Structure',b'L\xc3\xb8nn Struktur'
+b'DocType: Account',b'Bank',b'Bank'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +9',b'Airline',b'Flyselskap'
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +853',b'Issue Material',b'Issue Material'
+b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +3',b'An error occured while creating recurring',b'Det oppstod en feil under oppretting'
+b'DocType: Material Request Item',b'For Warehouse',b'For Warehouse'
+b'DocType: Employee',b'Offer Date',b'Tilbudet Dato'
+b'apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +33',b'Quotations',b'Sitater'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +735',b'You are in offline mode. You will not be able to reload until you have network.',b'Du er i frakoblet modus. Du vil ikke v\xc3\xa6re i stand til \xc3\xa5 laste f\xc3\xb8r du har nettverk.'
+b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +47',b'No Student Groups created.',b'Ingen studentgrupper opprettet.'
+b'DocType: Purchase Invoice Item',b'Serial No',b'Serial No'
+b'apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +119',b'Monthly Repayment Amount cannot be greater than Loan Amount',b'M\xc3\xa5nedlig nedbetaling bel\xc3\xb8pet kan ikke v\xc3\xa6re st\xc3\xb8rre enn L\xc3\xa5nebel\xc3\xb8p'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +143',b'Please enter Maintaince Details first',b'Skriv inn maintaince detaljer F\xc3\xb8rste'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +56',b'Row #{0}: Expected Delivery Date cannot be before Purchase Order Date',b'Rute # {0}: Forventet leveringsdato kan ikke v\xc3\xa6re f\xc3\xb8r innkj\xc3\xb8psordrenes dato'
+b'DocType: Purchase Invoice',b'Print Language',b'Print Spr\xc3\xa5k'
+b'DocType: Salary Slip',b'Total Working Hours',b'Samlet arbeidstid'
+b'DocType: Sales Invoice',b'Customer PO Details',b'Kunde PO Detaljer'
+b'DocType: Subscription',b'Next Schedule Date',b'Neste planleggingsdato'
+b'DocType: Stock Entry',b'Including items for sub assemblies',b'Inkludert elementer for sub samlinger'
+b'DocType: Opening Invoice Creation Tool Item',b'Temporary Opening Account',b'Midlertidig \xc3\xa5pningskonto'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +1964',b'Enter value must be positive',b'Oppgi verdien skal v\xc3\xa6re positiv'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/pos.py +446',b'All Territories',b'Alle Territories'
+b'apps/erpnext/erpnext/projects/doctype/task/task_tree.js +49',b'Add Multiple Tasks',b'Legg til flere oppgaver'
+b'DocType: Purchase Invoice',b'Items',b'Elementer'
+b'apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py +34',b'Student is already enrolled.',b'Student er allerede registrert.'
+b'DocType: Fiscal Year',b'Year Name',b'\xc3\x85r Navn'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +241',b'There are more holidays than working days this month.',b'Det er mer ferie enn virkedager denne m\xc3\xa5neden.'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +78',b'PDC/LC Ref',b'PDC / LC Ref'
+b'DocType: Product Bundle Item',b'Product Bundle Item',b'Produktet Bundle Element'
+b'DocType: Sales Partner',b'Sales Partner Name',b'Sales Partner Name'
+b'apps/erpnext/erpnext/hooks.py +136',b'Request for Quotations',b'Foresp\xc3\xb8rsel om Sitater'
+b'DocType: Payment Reconciliation',b'Maximum Invoice Amount',b'Maksimal Fakturert bel\xc3\xb8p'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +50',b'Montantdevise',b'Montantdevise'
+b'apps/erpnext/erpnext/healthcare/setup.py +210',b'Haematology',b'hematologi'
+b'DocType: Normal Test Items',b'Normal Test Items',b'Normale testelementer'
+b'DocType: Student Language',b'Student Language',b'student Spr\xc3\xa5k'
+b'apps/erpnext/erpnext/config/selling.py +23',b'Customers',b'kunder'
+b'DocType: Cash Flow Mapping',b'Is Working Capital',b'Er arbeidskapital'
+b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +24',b'Order/Quot %',b'Ordre / Quot%'
+b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +24',b'Order/Quot %',b'Ordre / Quot%'
+b'apps/erpnext/erpnext/config/healthcare.py +25',b'Record Patient Vitals',b'Opptak Pasient Vitals'
+b'DocType: Fee Schedule',b'Institution',b'institusjon'
+b'DocType: Asset',b'Partially Depreciated',b'delvis Avskrives'
+b'DocType: Issue',b'Opening Time',b'\xc3\x85pning Tid'
+b'apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +89',b'From and To dates required',b'Fra og Til dato kreves'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +46',b'Securities & Commodity Exchanges',b'Verdipapirer og r\xc3\xa5vareb\xc3\xb8rser'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +689',"b""Default Unit of Measure for Variant '{0}' must be same as in Template '{1}'""",b'Standard Enhet for Variant {0} m\xc3\xa5 v\xc3\xa6re samme som i malen {1}'
+b'DocType: Shipping Rule',b'Calculate Based On',b'Beregn basert p\xc3\xa5'
+b'DocType: Delivery Note Item',b'From Warehouse',b'Fra Warehouse'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +59',b'No employees for the mentioned criteria',b'Ingen ansatte for de nevnte kriteriene'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +955',b'No Items with Bill of Materials to Manufacture',b'Ingen elementer med Bill of Materials til Manufacture'
+b'DocType: Hotel Settings',b'Default Customer',b'Standardkund'
+b'DocType: Assessment Plan',b'Supervisor Name',b'Supervisor Name'
+b'DocType: Healthcare Settings',b'Do not confirm if appointment is created for the same day',b'Bekreft ikke om avtalen er opprettet for samme dag'
+b'DocType: Program Enrollment Course',b'Program Enrollment Course',b'Programopptakskurs'
+b'DocType: Program Enrollment Course',b'Program Enrollment Course',b'Programopptakskurs'
+b'DocType: Purchase Taxes and Charges',b'Valuation and Total',b'Verdivurdering og Total'
+b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py +11',b'Scorecards',b'm\xc3\xa5lstyring'
+b'DocType: Tax Rule',b'Shipping City',b'Shipping by'
+b'DocType: Notification Control',b'Customize the Notification',b'Tilpass varslings'
+b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +24',b'Cash Flow from Operations',b'Kontantstr\xc3\xb8m fra driften'
+b'DocType: Purchase Invoice',b'Shipping Rule',b'Shipping Rule'
+b'DocType: Patient Relation',b'Spouse',b'Ektefelle'
+b'DocType: Lab Test Groups',b'Add Test',b'Legg til test'
+b'DocType: Manufacturer',b'Limited to 12 characters',b'Begrenset til 12 tegn'
+b'DocType: Journal Entry',b'Print Heading',b'Print Overskrift'
+b'apps/erpnext/erpnext/config/stock.py +146',b'Delivery Trip service tours to customers.',b'Leveringsturtjenesten til kunder.'
+b'apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +57',b'Total cannot be zero',b'Totalt kan ikke v\xc3\xa6re null'
+b'apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +16',"b""'Days Since Last Order' must be greater than or equal to zero""",b'&#39;Dager siden siste Bestill &quot;m\xc3\xa5 v\xc3\xa6re st\xc3\xb8rre enn eller lik null'
+b'DocType: Plant Analysis Criteria',b'Maximum Permissible Value',b'Maksimal tillatelig verdi'
+b'DocType: Journal Entry Account',b'Employee Advance',b'Ansattes fremskritt'
+b'DocType: Payroll Entry',b'Payroll Frequency',b'l\xc3\xb8nn Frequency'
+b'DocType: Lab Test Template',b'Sensitivity',b'F\xc3\xb8lsomhet'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +941',b'Raw Material',b'R\xc3\xa5materiale'
+b'DocType: Leave Application',b'Follow via Email',b'F\xc3\xb8lg via e-post'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +55',b'Plants and Machineries',b'Planter og Machineries'
+b'DocType: Purchase Taxes and Charges',b'Tax Amount After Discount Amount',b'Skattebel\xc3\xb8p Etter Rabattbel\xc3\xb8p'
+b'DocType: Daily Work Summary Settings',b'Daily Work Summary Settings',b'Daglige arbeid Oppsummering Innstillinger'
+b'apps/erpnext/erpnext/controllers/buying_controller.py +447',b'Please enter Reqd by Date',b'Vennligst skriv inn reqd etter dato'
+b'DocType: Payment Entry',b'Internal Transfer',b'Internal Transfer'
+b'DocType: Asset Maintenance',b'Maintenance Tasks',b'Vedlikeholdsoppgaver'
+b'apps/erpnext/erpnext/setup/doctype/territory/territory.py +19',b'Either target qty or target amount is mandatory',b'Enten m\xc3\xa5let stk eller m\xc3\xa5l bel\xc3\xb8pet er obligatorisk'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +366',b'Please select Posting Date first',b'Vennligst velg Publiseringsdato f\xc3\xb8rst'
+b'apps/erpnext/erpnext/public/js/account_tree_grid.js +209',b'Opening Date should be before Closing Date',b'\xc3\x85pningsdato b\xc3\xb8r v\xc3\xa6re f\xc3\xb8r p\xc3\xa5meldingsfristens utl\xc3\xb8p'
+b'DocType: Leave Control Panel',b'Carry Forward',b'Fremf\xc3\xb8ring'
+b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +30',b'Cost Center with existing transactions can not be converted to ledger',b'Kostnadssted med eksisterende transaksjoner kan ikke konverteres til Ledger'
+b'DocType: Department',b'Days for which Holidays are blocked for this department.',b'Dager som Holidays er blokkert for denne avdelingen.'
+b'DocType: GoCardless Mandate',b'ERPNext Integrations',b'ERPNext Integrasjoner'
+b'DocType: Crop Cycle',b'Detected Disease',b'Oppdaget sykdom'
+,b'Produced',b'Produsert'
+b'DocType: Item',b'Item Code for Suppliers',b'Sak Kode for leverand\xc3\xb8rer'
+b'DocType: Issue',b'Raised By (Email)',b'Raised By (e-post)'
+b'DocType: Training Event',b'Trainer Name',b'trener Name'
+b'DocType: Mode of Payment',b'General',b'Generelt'
+b'apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +28',b'Last Communication',b'Siste kommunikasjon'
+b'apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +28',b'Last Communication',b'Siste kommunikasjon'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +372',"b""Cannot deduct when category is for 'Valuation' or 'Valuation and Total'""",b'Kan ikke trekke n\xc3\xa5r kategorien er for verdsetting &quot;eller&quot; Verdsettelse og Totals'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +234',b'Serial Nos Required for Serialized Item {0}',b'Serial Nos N\xc3\xb8dvendig for Serialisert Element {0}'
+b'apps/erpnext/erpnext/config/accounts.py +144',b'Match Payments with Invoices',b'Match Betalinger med Fakturaer'
+b'DocType: Journal Entry',b'Bank Entry',b'Bank Entry'
+b'DocType: Authorization Rule',b'Applicable To (Designation)',b'Gjelder til (Betegnelse)'
+,b'Profitability Analysis',b'l\xc3\xb8nnsomhets~~POS=TRUNC'
+b'DocType: Fees',b'Student Email',b'Student e-post'
+b'DocType: Supplier',b'Prevent POs',b'Forhindre PO&#39;er'
+b'DocType: Patient',"b'Allergies, Medical and Surgical History'","b'Allergier, medisinsk og kirurgisk historie'"
+b'apps/erpnext/erpnext/templates/generators/item.html +77',b'Add to Cart',b'Legg til i handlevogn'
+b'apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.js +28',b'Group By',b'Grupper etter'
+b'DocType: Guardian',b'Interests',b'Interesser'
+b'apps/erpnext/erpnext/config/accounts.py +298',b'Enable / disable currencies.',b'Aktivere / deaktivere valutaer.'
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +105',b'Dr {0} on Half day Leave on {1}',b'Dr {0} p\xc3\xa5 halv dag permisjon p\xc3\xa5 {1}'
+b'DocType: Production Plan',b'Get Material Request',b'F\xc3\xa5 Material Request'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +111',b'Postal Expenses',b'Post Utgifter'
+b'apps/erpnext/erpnext/controllers/trends.py +19',b'Total(Amt)',b'Total (Amt)'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +26',b'Entertainment & Leisure',b'Entertainment &amp; Leisure'
+,b'Item Variant Details',b'Varevarianter Detaljer'
+b'DocType: Quality Inspection',b'Item Serial No',b'Sak Serial No'
+b'apps/erpnext/erpnext/utilities/activation.py +135',b'Create Employee Records',b'Lag Medarbeider Records'
+b'apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68',b'Total Present',b'Total Present'
+b'apps/erpnext/erpnext/config/accounts.py +105',b'Accounting Statements',b'regnskaps~~POS=TRUNC Uttalelser'
+b'DocType: Drug Prescription',b'Hour',b'Time'
+b'DocType: Restaurant Order Entry',b'Last Sales Invoice',b'Siste salgsfaktura'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +788',b'Please select Qty against item {0}',b'Vennligst velg antall til elementet {0}'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +29',b'New Serial No cannot have Warehouse. Warehouse must be set by Stock Entry or Purchase Receipt',b'New Serial No kan ikke ha Warehouse. Warehouse m\xc3\xa5 settes av Stock Entry eller Kj\xc3\xb8pskvittering'
+b'DocType: Lead',b'Lead Type',b'Lead Type'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +114',b'You are not authorized to approve leaves on Block Dates',b'Du er ikke autorisert til \xc3\xa5 godkjenne blader p\xc3\xa5 Block Datoer'
+b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +394',b'All these items have already been invoiced',b'Alle disse elementene er allerede blitt fakturert'
+b'DocType: Company',b'Monthly Sales Target',b'M\xc3\xa5nedlig salgsm\xc3\xa5l'
+b'apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py +37',b'Can be approved by {0}',b'Kan godkjennes av {0}'
+b'DocType: Hotel Room',b'Hotel Room Type',b'Hotellromtype'
+b'DocType: Item',b'Default Material Request Type',b'Standard Material Request Type'
+b'DocType: Supplier Scorecard',b'Evaluation Period',b'Evalueringsperiode'
+b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_list.js +13',b'Unknown',b'Ukjent'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +954',b'Work Order not created',b'Arbeidsordre er ikke opprettet'
+b'DocType: Shipping Rule',b'Shipping Rule Conditions',b'Frakt Regel betingelser'
+b'DocType: Purchase Invoice',b'Export Type',b'Eksporttype'
+b'DocType: Salary Slip Loan',b'Salary Slip Loan',b'L\xc3\xb8nnsslippl\xc3\xa5n'
+b'DocType: BOM Update Tool',b'The new BOM after replacement',b'Den nye BOM etter utskiftning'
+,b'Point of Sale',b'Utsalgssted'
+b'DocType: Payment Entry',b'Received Amount',b'mottatt bel\xc3\xb8p'
+b'DocType: Patient',b'Widow',b'Enke'
+b'DocType: GST Settings',b'GSTIN Email Sent On',b'GSTIN Email Sent On'
+b'DocType: Program Enrollment',b'Pick/Drop by Guardian',b'Pick / Drop av Guardian'
+b'DocType: Crop',b'Planting UOM',b'Planting UOM'
+b'DocType: Account',b'Tax',b'Skatte'
+b'apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py +45',b'Not Marked',b'ikke Merket'
+b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html +1',b'Opening Invoices Summary',b'\xc3\x85pning av fakturaoversikt'
+b'DocType: Education Settings',b'Education Manager',b'Utdannelsesleder'
+b'DocType: Crop Cycle',b'The minimum length between each plant in the field for optimum growth',b'Minimale lengde mellom hver plante i feltet for optimal vekst'
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +152',"b'Batched Item {0} cannot be updated using Stock Reconciliation, instead use Stock Entry'","b'Batched Item {0} kan ikke oppdateres ved hjelp av Stock Forsoning, bruk i stedet Lagerinngang'"
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +152',"b'Batched Item {0} cannot be updated using Stock Reconciliation, instead use Stock Entry'","b'Batched Item {0} kan ikke oppdateres ved hjelp av Stock Forsoning, bruk i stedet Lagerinngang'"
+b'DocType: Quality Inspection',b'Report Date',b'Rapporter Date'
+b'DocType: Student',b'Middle Name',b'Mellomnavn'
+b'DocType: C-Form',b'Invoices',b'Fakturaer'
+b'DocType: Water Analysis',b'Type of Sample',b'Type pr\xc3\xb8ve'
+b'DocType: Batch',b'Source Document Name',b'Kilde dokumentnavn'
+b'DocType: Batch',b'Source Document Name',b'Kilde dokumentnavn'
+b'DocType: Production Plan',b'Get Raw Materials For Production',b'F\xc3\xa5 r\xc3\xa5materialer til produksjon'
+b'DocType: Job Opening',b'Job Title',b'Jobbtittel'
+b'apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py +84',"b'{0} indicates that {1} will not provide a quotation, but all items \\\n\t\t\t\t\thave been quoted. Updating the RFQ quote status.'","b'{0} indikerer at {1} ikke vil gi et tilbud, men alle elementer \\ er blitt sitert. Oppdaterer RFQ sitatstatus.'"
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1026',b'Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.',b'Maksimale pr\xc3\xb8ver - {0} har allerede blitt beholdt for Batch {1} og Item {2} i Batch {3}.'
+b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +125',b'Please Set Supplier Type in Buying Settings.',b'Vennligst sett Leverand\xc3\xb8r Type i Kj\xc3\xb8psinnstillinger.'
+b'DocType: Manufacturing Settings',b'Update BOM Cost Automatically',b'Oppdater BOM Kostnad automatisk'
+b'DocType: Lab Test',b'Test Name',b'Testnavn'
+b'apps/erpnext/erpnext/utilities/activation.py +99',b'Create Users',b'Lag brukere'
+b'apps/erpnext/erpnext/utilities/user_progress.py +147',b'Gram',b'Gram'
+b'DocType: Supplier Scorecard',b'Per Month',b'Per m\xc3\xa5ned'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +433',b'Quantity to Manufacture must be greater than 0.',b'Antall \xc3\xa5 Manufacture m\xc3\xa5 v\xc3\xa6re st\xc3\xb8rre enn 0.'
+b'DocType: Asset Settings',b'Calculate Prorated Depreciation Schedule Based on Fiscal Year',b'Beregn Prorated Depreciation Schedule Basert p\xc3\xa5 Skatte\xc3\xa5r'
+b'apps/erpnext/erpnext/config/maintenance.py +17',b'Visit report for maintenance call.',b'Bes\xc3\xb8k rapport for vedlikehold samtale.'
+b'DocType: Stock Entry',b'Update Rate and Availability',b'Oppdateringsfrekvens og tilgjengelighet'
+b'DocType: Stock Settings',b'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.',b'Prosentvis du har lov til \xc3\xa5 motta eller levere mer mot antall bestilte produkter. For eksempel: Hvis du har bestilt 100 enheter. og din Fradrag er 10% s\xc3\xa5 du har lov til \xc3\xa5 motta 110 enheter.'
+b'DocType: POS Customer Group',b'Customer Group',b'Kundegruppe'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +217',b'Row #{0}: Operation {1} is not completed for {2} qty of finished goods in Work Order # {3}. Please update operation status via Time Logs',b'Rute # {0}: Drift {1} er ikke fullf\xc3\xb8rt for {2} Antall ferdige varer i Arbeidsordre # {3}. Oppdater operasjonsstatus via Time Logs'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +128',b'New Batch ID (Optional)',b'Ny batch-ID (valgfritt)'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +128',b'New Batch ID (Optional)',b'Ny batch-ID (valgfritt)'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +201',b'Expense account is mandatory for item {0}',b'Utgiftskonto er obligatorisk for elementet {0}'
+b'DocType: BOM',b'Website Description',b'Website Beskrivelse'
+b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +47',b'Net Change in Equity',b'Netto endring i egenkapital'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +220',b'Please cancel Purchase Invoice {0} first',b'Vennligst avbryte fakturaen {0} f\xc3\xb8rst'
+b'apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py +43',"b'Email Address must be unique, already exists for {0}'","b'E-post adresse m\xc3\xa5 v\xc3\xa6re unikt, allerede eksisterer for {0}'"
+b'DocType: Serial No',b'AMC Expiry Date',b'AMC Utl\xc3\xb8psdato'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +880',b'Receipt',b'Kvittering'
+,b'Sales Register',b'Salg Register'
+b'DocType: Daily Work Summary Group',b'Send Emails At',b'Send e-post til'
+b'DocType: Quotation',b'Quotation Lost Reason',b'Sitat av Lost Reason'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +381',b'Transaction reference no {0} dated {1}',b'Transaksjonsreferanse ikke {0} datert {1}'
+b'apps/erpnext/erpnext/setup/doctype/supplier_type/supplier_type.js +5',b'There is nothing to edit.',b'Det er ingenting \xc3\xa5 redigere.'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +116',b'Summary for this month and pending activities',b'Oppsummering for denne m\xc3\xa5neden og ventende aktiviteter'
+b'apps/erpnext/erpnext/utilities/user_progress.py +248',"b'Add users to your organization, other than yourself.'","b'Legg til brukere i organisasjonen din, bortsett fra deg selv.'"
+b'DocType: Customer Group',b'Customer Group Name',b'Kundegruppenavn'
+b'apps/erpnext/erpnext/public/js/pos/pos.html +109',b'No Customers yet!',b'Ingen kunder enn\xc3\xa5!'
+b'apps/erpnext/erpnext/public/js/financial_statements.js +56',b'Cash Flow Statement',b'Kontantstr\xc3\xb8moppstilling'
+b'apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py +473',b'No material request created',b'Ingen materiell foresp\xc3\xb8rsel opprettet'
+b'apps/erpnext/erpnext/hr/doctype/employee_loan_application/employee_loan_application.py +23',b'Loan Amount cannot exceed Maximum Loan Amount of {0}',b'L\xc3\xa5nebel\xc3\xb8p kan ikke overstige maksimalt l\xc3\xa5nebel\xc3\xb8p p\xc3\xa5 {0}'
+b'apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py +22',b'License',b'Tillatelse'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +491',b'Please remove this Invoice {0} from C-Form {1}',b'Vennligst fjern denne Faktura {0} fra C-Form {1}'
+b'DocType: Leave Control Panel',"b""Please select Carry Forward if you also want to include previous fiscal year's balance leaves to this fiscal year""",b'Vennligst velg b\xc3\xa6re frem hvis du ogs\xc3\xa5 vil ha med forrige regnskaps\xc3\xa5r balanse later til dette regnskaps\xc3\xa5ret'
+b'DocType: GL Entry',b'Against Voucher Type',b'Mot Voucher Type'
+b'DocType: Physician',b'Phone (R)',b'Telefon (R)'
+b'apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +56',b'Time slots added',b'Tidsluker lagt til'
+b'DocType: Item',b'Attributes',b'Egenskaper'
+b'apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +31',b'Enable Template',b'Aktiver mal'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +226',b'Please enter Write Off Account',b'Skriv inn avskrive konto'
+b'apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +71',b'Last Order Date',b'Siste Order Date'
+b'DocType: Patient',b'B Negative',b'B Negativ'
+b'apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +25',b'Maintenance Status has to be Cancelled or Completed to Submit',b'Vedlikeholdsstatus m\xc3\xa5 avbrytes eller fullf\xc3\xb8res for \xc3\xa5 sende inn'
+b'DocType: Hotel Room',b'Hotel Room',b'Hotellrom'
+b'apps/erpnext/erpnext/accounts/doctype/budget/budget.py +47',b'Account {0} does not belongs to company {1}',b'Konto {0} ikke tilh\xc3\xb8rer selskapet {1}'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +884',b'Serial Numbers in row {0} does not match with Delivery Note',b'Serienumre i rad {0} stemmer ikke overens med leveringsnotat'
+b'DocType: Student',b'Guardian Details',b'Guardian Detaljer'
+b'DocType: C-Form',b'C-Form',b'C-Form'
+b'apps/erpnext/erpnext/config/hr.py +18',b'Mark Attendance for multiple employees',b'Mark Oppm\xc3\xb8te for flere ansatte'
+b'DocType: Agriculture Task',b'Start Day',b'Start dag'
+b'DocType: Vehicle',b'Chassis No',b'chassis Nei'
+b'DocType: Payment Request',b'Initiated',b'Initiert'
+b'DocType: Production Plan Item',b'Planned Start Date',b'Planlagt startdato'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +618',b'Please select a BOM',b'Vennligst velg en BOM'
+b'DocType: Purchase Invoice',b'Availed ITC Integrated Tax',b'Benyttet ITC Integrated Tax'
+b'DocType: Serial No',b'Creation Document Type',b'Creation dokumenttype'
+b'DocType: Project Task',b'View Timesheet',b'Se tidsskema'
+b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +54',b'End date must be greater than start date',b'Sluttdato m\xc3\xa5 v\xc3\xa6re st\xc3\xb8rre enn startdato'
+b'DocType: Leave Type',b'Is Encash',b'Er encash'
+b'DocType: Leave Allocation',b'New Leaves Allocated',b'Nye Leaves Avsatt'
+b'apps/erpnext/erpnext/controllers/trends.py +269',b'Project-wise data is not available for Quotation',b'Prosjekt-messig data er ikke tilgjengelig for prisanslag'
+b'apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +30',b'End on',b'Slutt p\xc3\xa5'
+b'DocType: Project',b'Expected End Date',b'Forventet sluttdato'
+b'DocType: Budget Account',b'Budget Amount',b'budsjett~~POS=TRUNC'
+b'DocType: Donor',b'Donor Name',b'Donornavn'
+b'DocType: Appraisal Template',b'Appraisal Template Title',b'Appraisal Mal Tittel'
+b'apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +39',"b""From Date {0} for Employee {1} cannot be before employee's joining Date {2}""",b'Fra Dato {0} for Employee {1} kan ikke v\xc3\xa6re f\xc3\xb8r arbeidstakers begynte Dato {2}'
+b'apps/erpnext/erpnext/utilities/user_progress_utils.py +29',b'Commercial',b'Commercial'
+b'DocType: Patient',b'Alcohol Current Use',b'Alkoholstr\xc3\xb8mbruk'
+b'DocType: Student Admission Program',b'Student Admission Program',b'Studentopptaksprogram'
+b'DocType: Payment Entry',b'Account Paid To',b'Konto Betalt for \xc3\xa5'
+b'apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.py +24',b'Parent Item {0} must not be a Stock Item',b'Parent Element {0} m\xc3\xa5 ikke v\xc3\xa6re en lagervare'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +466',b'Could not submit any Salary Slip <br>\\\n\t\t\tPossible reasons: <br>\\\n\t\t\t1. Net pay is less than 0. <br>\\\n\t\t\t2. Company Email Address specified in employee master is not valid. <br>',"b'Kunne ikke sende inn L\xc3\xb8nnsslipp <br> \\ Mulige \xc3\xa5rsaker: <br> \\ 1. Netto l\xc3\xb8nn er mindre enn 0. <br> \\ 2. Firmaets e-postadresse som er oppgitt i ansattmesteren, er ikke gyldig. <br>'"
+b'apps/erpnext/erpnext/config/selling.py +57',b'All Products or Services.',b'Alle produkter eller tjenester.'
+b'DocType: Expense Claim',b'More Details',b'Mer informasjon'
+b'DocType: Supplier Quotation',b'Supplier Address',b'Leverand\xc3\xb8r Adresse'
+b'apps/erpnext/erpnext/accounts/doctype/budget/budget.py +128',b'{0} Budget for Account {1} against {2} {3} is {4}. It will exceed by {5}',b'{0} budsjettet for kontoen {1} mot {2} {3} er {4}. Det vil overstige ved {5}'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +695',"b""Row {0}# Account must be of type 'Fixed Asset'""",b'Rad {0} # konto m\xc3\xa5 v\xc3\xa6re av typen &quot;Fixed Asset &#39;'
+b'apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37',b'Out Qty',b'Ut Antall'
+b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +6',b'and unchcked Disabled in the',b'og unchcked Disabled in the'
+b'apps/erpnext/erpnext/buying/doctype/supplier/supplier.py +41',b'Series is mandatory',b'Serien er obligatorisk'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +28',b'Financial Services',b'Finansielle Tjenester'
+b'DocType: Student Sibling',b'Student ID',b'Student ID'
+b'apps/erpnext/erpnext/config/projects.py +51',b'Types of activities for Time Logs',b'Typer aktiviteter for Tid Logger'
+b'DocType: Opening Invoice Creation Tool',b'Sales',b'Salgs'
+b'DocType: Stock Entry Detail',b'Basic Amount',b'Grunnbel\xc3\xb8p'
+b'DocType: Training Event',b'Exam',b'Eksamen'
+b'DocType: Complaint',b'Complaint',b'Klage'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +462',b'Warehouse required for stock Item {0}',b'Warehouse n\xc3\xb8dvendig for lager Element {0}'
+b'DocType: Leave Allocation',b'Unused leaves',b'Ubrukte blader'
+b'DocType: Patient',b'Alcohol Past Use',b'Alkohol Tidligere Bruk'
+b'DocType: Fertilizer Content',b'Fertilizer Content',b'Gj\xc3\xb8dselinnhold'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +187',b'Cr',b'Cr'
+b'DocType: Project Update',b'Problematic/Stuck',b'Problematisk / Stuck'
+b'DocType: Tax Rule',b'Billing State',b'Billing State'
+b'DocType: Share Transfer',b'Transfer',b'Transfer'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +252',b'Work Order {0} must be cancelled before cancelling this Sales Order',b'Arbeidsordre {0} m\xc3\xa5 avbestilles f\xc3\xb8r du kansellerer denne salgsordren'
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +917',b'Fetch exploded BOM (including sub-assemblies)',b'Hente eksploderte BOM (inkludert underenheter)'
+b'DocType: Authorization Rule',b'Applicable To (Employee)',b'Gjelder til (Employee)'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +137',b'Due Date is mandatory',b'Due Date er obligatorisk'
+b'apps/erpnext/erpnext/controllers/item_variant.py +82',b'Increment for Attribute {0} cannot be 0',b'\xc3\x98kning for Egenskap {0} kan ikke v\xc3\xa6re 0'
+b'apps/erpnext/erpnext/hotels/report/hotel_room_occupancy/hotel_room_occupancy.py +19',b'Rooms Booked',b'Rom bestilles'
+b'apps/erpnext/erpnext/crm/doctype/lead/lead.py +57',b'Ends On date cannot be before Next Contact Date.',b'Slutter p\xc3\xa5 dato kan ikke v\xc3\xa6re f\xc3\xb8r neste kontakt dato.'
+b'DocType: Journal Entry',b'Pay To / Recd From',b'Betal Til / recd From'
+b'DocType: Naming Series',b'Setup Series',b'Oppsett Series'
+b'DocType: Payment Reconciliation',b'To Invoice Date',b'\xc3\x85 Fakturadato'
+b'DocType: Shareholder',b'Contact HTML',b'Kontakt HTML'
+b'apps/erpnext/erpnext/healthcare/doctype/healthcare_settings/healthcare_settings.py +19',b'Registration fee can not be Zero',b'Registreringsavgift kan ikke v\xc3\xa6re null'
+b'DocType: Disease',b'Treatment Period',b'Behandlingsperiode'
+b'apps/erpnext/erpnext/education/api.py +338',b'Result already Submitted',b'Resultat allerede sendt'
+b'apps/erpnext/erpnext/controllers/buying_controller.py +169',b'Reserved Warehouse is mandatory for Item {0} in Raw Materials supplied',b'Reservert lager er obligatorisk for vare {0} i r\xc3\xa5varer som leveres'
+,b'Inactive Customers',b'inaktive kunder'
+b'DocType: Student Admission Program',b'Maximum Age',b'Maksimal alder'
+b'apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +28',b'Please wait 3 days before resending the reminder.',b'Vennligst vent 3 dager f\xc3\xb8r du sender p\xc3\xa5minnelsen p\xc3\xa5 nytt.'
+b'DocType: Landed Cost Voucher',b'LCV',b'LCV'
+b'DocType: Landed Cost Voucher',b'Purchase Receipts',b'Kj\xc3\xb8ps Kvitteringer'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +29',b'How Pricing Rule is applied?',b'Hvordan Pricing Rule er brukt?'
+b'DocType: Stock Entry',b'Delivery Note No',b'Levering Note Nei'
+b'DocType: Cheque Print Template',b'Message to show',b'Melding for visning'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +28',b'Retail',b'Retail'
+b'DocType: Student Attendance',b'Absent',b'Frav\xc3\xa6rende'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +591',b'Product Bundle',b'Produktet Bundle'
+b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +38',b'Unable to find score starting at {0}. You need to have standing scores covering 0 to 100',b'Kan ikke finne poeng som starter ved {0}. Du m\xc3\xa5 ha st\xc3\xa5ende poeng som dekker 0 til 100'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +212',b'Row {0}: Invalid reference {1}',b'Rad {0}: Ugyldig referanse {1}'
+b'DocType: Purchase Taxes and Charges Template',b'Purchase Taxes and Charges Template',b'Kj\xc3\xb8pe skatter og avgifter Mal'
+b'DocType: Timesheet',b'TS-',b'TS-'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +61',b'{0} {1}: Either debit or credit amount is required for {2}',b'{0} {1}: Enten debet- eller kredittbel\xc3\xb8pet er n\xc3\xb8dvendig for {2}'
+b'DocType: GL Entry',b'Remarks',b'Bemerkninger'
+b'DocType: Hotel Room Amenity',b'Hotel Room Amenity',b'Hotel Romfasiliteter'
+b'DocType: Payment Entry',b'Account Paid From',b'Konto betalt fra'
+b'DocType: Purchase Order Item Supplied',b'Raw Material Item Code',b'Raw Material Elementkode'
+b'DocType: Task',b'Parent Task',b'Foreldreoppgave'
+b'DocType: Journal Entry',b'Write Off Based On',b'Skriv Off basert p\xc3\xa5'
+b'apps/erpnext/erpnext/utilities/activation.py +65',b'Make Lead',b'Gj\xc3\xb8r Lead'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +112',b'Print and Stationery',b'Skriv ut og Saker'
+b'DocType: Stock Settings',b'Show Barcode Field',b'Vis strekkodefelt'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +809',b'Send Supplier Emails',b'Send Leverand\xc3\xb8r e-post'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +96',"b'Salary already processed for period between {0} and {1}, Leave application period cannot be between this date range.'","b'L\xc3\xb8nn allerede behandlet for perioden mellom {0} og {1}, La s\xc3\xb8knadsperioden kan ikke v\xc3\xa6re mellom denne datoperioden.'"
+b'DocType: Chapter Member',b'Leave Reason',b'Legg igjen grunn'
+b'DocType: Guardian Interest',b'Guardian Interest',b'Guardian Rente'
+b'DocType: Volunteer',b'Availability',b'Tilgjengelighet'
+b'apps/erpnext/erpnext/config/accounts.py +319',b'Setup default values for POS Invoices',b'Oppsett standardverdier for POS-fakturaer'
+b'apps/erpnext/erpnext/config/hr.py +182',b'Training',b'Oppl\xc3\xa6ring'
+b'DocType: Project',b'Time to send',b'Tid til \xc3\xa5 sende'
+b'DocType: Timesheet',b'Employee Detail',b'Medarbeider Detalj'
+b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +58',b'Guardian1 Email ID',b'Guardian1 Email ID'
+b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +58',b'Guardian1 Email ID',b'Guardian1 Email ID'
+b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +68',"b""Next Date's day and Repeat on Day of Month must be equal""",b'Neste Date dag og gjenta p\xc3\xa5 dag i m\xc3\xa5neden m\xc3\xa5 v\xc3\xa6re lik'
+b'DocType: Lab Prescription',b'Test Code',b'Testkode'
+b'apps/erpnext/erpnext/config/website.py +11',b'Settings for website homepage',b'Innstillinger for nettstedet hjemmeside'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +40',b'RFQs are not allowed for {0} due to a scorecard standing of {1}',b'RFQ er ikke tillatt for {0} p\xc3\xa5 grunn av et resultatkort som st\xc3\xa5r for {1}'
+b'DocType: Job Offer',b'Awaiting Response',b'Venter p\xc3\xa5 svar'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +60',b'Above',b'Fremfor'
+b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1466',b'Total Amount {0}',b'Totalt bel\xc3\xb8p {0}'
+b'apps/erpnext/erpnext/controllers/item_variant.py +306',b'Invalid attribute {0} {1}',b'Ugyldig egenskap {0} {1}'
+b'DocType: Supplier',b'Mention if non-standard payable account',b'Nevn hvis ikke-standard betalingskonto'
+b'apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.py +25',"b""Please select the assessment group other than 'All Assessment Groups'""",b'Vennligst velg vurderingsgruppen annet enn &#39;Alle vurderingsgrupper&#39;'
+b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +67',b'Row {0}: Cost center is required for an item {1}',b'Row {0}: Kostnadsstedet kreves for et element {1}'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +43',b'EcritureDate',b'EcritureDate'
+b'DocType: Training Event Employee',b'Optional',b'Valgfri'
+b'DocType: Salary Slip',b'Earning & Deduction',b'Tjene &amp; Fradrag'
+b'DocType: Agriculture Analysis Criteria',b'Water Analysis',b'Vannanalyse'
+b'DocType: Chapter',b'Region',b'Region'
+b'apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +38',b'Optional. This setting will be used to filter in various transactions.',b'Valgfritt. Denne innstillingen vil bli brukt for \xc3\xa5 filtrere i forskjellige transaksjoner.'
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +110',b'Negative Valuation Rate is not allowed',b'Negative Verdivurdering Rate er ikke tillatt'
+b'DocType: Holiday List',b'Weekly Off',b'Ukentlig Off'
+b'apps/erpnext/erpnext/agriculture/doctype/crop_cycle/crop_cycle.js +7',b'Reload Linked Analysis',b'Last inn sammenkoblet analyse'
+b'DocType: Fiscal Year',"b'For e.g. 2012, 2012-13'","b'For eksempel 2012, 2012-13'"
+b'apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +96',b'Provisional Profit / Loss (Credit)',b'Forel\xc3\xb8pig Profit / Loss (Credit)'
+b'DocType: Sales Invoice',b'Return Against Sales Invoice',b'Tilbake Mot Salg Faktura'
+b'apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +32',b'Item 5',b'Sak 5'
+b'DocType: Serial No',b'Creation Time',b'Creation Tid'
+b'apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +62',b'Total Revenue',b'Totale Inntekter'
+b'DocType: Patient',b'Other Risk Factors',b'Andre risikofaktorer'
+b'DocType: Sales Invoice',b'Product Bundle Help',b'Produktet Bundle Hjelp'
+,b'Monthly Attendance Sheet',b'M\xc3\xa5nedlig Oppm\xc3\xb8te Sheet'
+b'apps/erpnext/erpnext/hr/report/employee_advance_summary/employee_advance_summary.py +15',b'No record found',b'Ingen rekord funnet'
+b'apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +140',b'Cost of Scrapped Asset',b'Kostnad for kasserte Asset'
+b'apps/erpnext/erpnext/controllers/stock_controller.py +236',b'{0} {1}: Cost Center is mandatory for Item {2}',b'{0} {1}: Kostnadssted er obligatorisk for Element {2}'
+b'DocType: Vehicle',b'Policy No',b'Regler Nei'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +686',b'Get Items from Product Bundle',b'F\xc3\xa5 Elementer fra Produkt Bundle'
+b'DocType: Asset',b'Straight Line',b'Rett linje'
+b'DocType: Project User',b'Project User',b'prosjekt Bruker'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +72',b'Split',b'Dele'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +72',b'Split',b'Dele'
+b'DocType: GL Entry',b'Is Advance',b'Er Advance'
+b'apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +21',b'Attendance From Date and Attendance To Date is mandatory',b'Oppm\xc3\xb8te Fra Dato og oppm\xc3\xb8te To Date er obligatorisk'
+b'apps/erpnext/erpnext/controllers/buying_controller.py +156',"b""Please enter 'Is Subcontracted' as Yes or No""",b'Skriv inn &#39;Er underleverand\xc3\xb8r&#39; som Ja eller Nei'
+b'DocType: Item',b'Default Purchase Unit of Measure',b'Standard innkj\xc3\xb8psenhet for m\xc3\xa5l'
+b'apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +29',b'Last Communication Date',b'Siste kommunikasjonsdato'
+b'apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +29',b'Last Communication Date',b'Siste kommunikasjonsdato'
+b'DocType: Sales Team',b'Contact No.',b'Kontaktnummer.'
+b'DocType: Bank Reconciliation',b'Payment Entries',b'Betalings Entries'
+b'DocType: Land Unit',b'Land Unit Details',b'Land Enhet Detaljer'
+b'DocType: Land Unit',b'Latitude',b'Breddegrad'
+b'DocType: Work Order',b'Scrap Warehouse',b'skrap Warehouse'
+b'DocType: Work Order',b'Check if material transfer entry is not required',b'Sjekk om materialoverf\xc3\xb8ring ikke er n\xc3\xb8dvendig'
+b'DocType: Work Order',b'Check if material transfer entry is not required',b'Sjekk om materialoverf\xc3\xb8ring ikke er n\xc3\xb8dvendig'
+b'DocType: Program Enrollment Tool',b'Get Students From',b'F\xc3\xa5 studenter fra'
+b'apps/erpnext/erpnext/config/learn.py +263',b'Publish Items on Website',b'Publiser Elementer p\xc3\xa5 nettstedet'
+b'apps/erpnext/erpnext/utilities/activation.py +126',b'Group your students in batches',b'Gruppe elevene i grupper'
+b'DocType: Authorization Rule',b'Authorization Rule',b'Autorisasjon Rule'
+b'DocType: POS Profile',b'Offline POS Section',b'Frakoblet POS-seksjon'
+b'DocType: Sales Invoice',b'Terms and Conditions Details',b'Vilk\xc3\xa5r og betingelser Detaljer'
+b'apps/erpnext/erpnext/templates/generators/item.html +100',b'Specifications',b'Spesifikasjoner'
+b'DocType: Sales Taxes and Charges Template',b'Sales Taxes and Charges Template',b'Salgs skatter og avgifter Mal'
+b'apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +68',b'Total (Credit)',b'Total (Credit)'
+b'DocType: Repayment Schedule',b'Payment Date',b'Betalingsdato'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +122',b'New Batch Qty',b'Ny batch Antall'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +122',b'New Batch Qty',b'Ny batch Antall'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +10',b'Apparel & Accessories',b'Kl\xc3\xa6r og tilbeh\xc3\xb8r'
+b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard_period/supplier_scorecard_period.py +91',b'Could not solve weighted score function. Make sure the formula is valid.',b'Kunne ikke l\xc3\xb8se vektet poengsumfunksjon. Pass p\xc3\xa5 at formelen er gyldig.'
+b'apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +67',b'Number of Order',b'Antall Bestill'
+b'DocType: Item Group',b'HTML / Banner that will show on the top of product list.',b'HTML / Banner som vil vises p\xc3\xa5 toppen av listen over produkter.'
+b'DocType: Shipping Rule',b'Specify conditions to calculate shipping amount',b'Spesifiser forhold til \xc3\xa5 beregne frakt bel\xc3\xb8p'
+b'DocType: Program Enrollment',"b""Institute's Bus""",b'Instituttets buss'
+b'DocType: Accounts Settings',b'Role Allowed to Set Frozen Accounts & Edit Frozen Entries',b'Rolle lov til \xc3\xa5 sette Frosne Kontoer og Rediger Frosne Entries'
+b'DocType: Supplier Scorecard Scoring Variable',b'Path',b'Sti'
+b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +28',b'Cannot convert Cost Center to ledger as it has child nodes',b'Kan ikke konvertere kostnadssted til hovedbok som den har barnet noder'
+b'DocType: Production Plan',b'Total Planned Qty',b'Totalt planlagt antall'
+b'apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +68',b'Opening Value',b'\xc3\xa5pning Verdi'
+b'DocType: Salary Detail',b'Formula',b'Formel'
+b'apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +47',b'Serial #',b'Serial #'
+b'DocType: Lab Test Template',b'Lab Test Template',b'Lab Test Template'
+b'apps/erpnext/erpnext/setup/doctype/company/company.py +181',b'Sales Account',b'Salgskonto'
+b'DocType: Purchase Invoice Item',b'Total Weight',b'Total vekt'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +94',b'Commission on Sales',b'Provisjon p\xc3\xa5 salg'
+b'DocType: Job Offer Term',b'Value / Description',b'Verdi / beskrivelse'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +630',"b'Row #{0}: Asset {1} cannot be submitted, it is already {2}'","b'Row # {0}: Asset {1} kan ikke sendes inn, er det allerede {2}'"
+b'DocType: Tax Rule',b'Billing Country',b'Fakturering Land'
+b'DocType: Purchase Order Item',b'Expected Delivery Date',b'Forventet Leveringsdato'
+b'DocType: Restaurant Order Entry',b'Restaurant Order Entry',b'Restaurant Bestillingsinngang'
+b'apps/erpnext/erpnext/accounts/general_ledger.py +134',b'Debit and Credit not equal for {0} #{1}. Difference is {2}.',b'Debet- og kredittkort ikke lik for {0} # {1}. Forskjellen er {2}.'
+b'DocType: Asset Maintenance Task',b'Assign To Name',b'Tilordne til navn'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +98',b'Entertainment Expenses',b'Underholdning Utgifter'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +98',b'Make Material Request',b'Gj\xc3\xb8r Material Request'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html +20',b'Open Item {0}',b'\xc3\x85pen Element {0}'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +222',b'Sales Invoice {0} must be cancelled before cancelling this Sales Order',b'Salg Faktura {0} m\xc3\xa5 slettes f\xc3\xb8r den sletter denne salgsordre'
+b'DocType: Consultation',b'Age',b'Alder'
+b'DocType: Sales Invoice Timesheet',b'Billing Amount',b'Faktureringsbel\xc3\xb8p'
+b'DocType: Cash Flow Mapping',b'Select Maximum Of 1',b'Velg Maksimum 1'
+b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +84',b'Invalid quantity specified for item {0}. Quantity should be greater than 0.',b'Ugyldig kvantum spesifisert for elementet {0}. Antall m\xc3\xa5 v\xc3\xa6re st\xc3\xb8rre enn 0.'
+b'DocType: Company',b'Default Employee Advance Account',b'Standard ansattskonto'
+b'apps/erpnext/erpnext/config/hr.py +60',b'Applications for leave.',b'S\xc3\xb8knader om permisjon.'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +164',b'Account with existing transaction can not be deleted',b'Konto med eksisterende transaksjon kan ikke slettes'
+b'DocType: Vehicle',b'Last Carbon Check',b'Siste Carbon Sjekk'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +102',b'Legal Expenses',b'Rettshjelp'
+b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +140',b'Please select quantity on row ',b'Vennligst velg antall p\xc3\xa5 rad'
+b'apps/erpnext/erpnext/config/accounts.py +277',b'Make Opening Sales and Purchase Invoices',b'Lag \xc3\xa5pne salgs- og kj\xc3\xb8psfakturaer'
+b'DocType: Purchase Invoice',b'Posting Time',b'Postering Tid'
+b'DocType: Timesheet',b'% Amount Billed',b'% Mengde Fakturert'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +118',b'Telephone Expenses',b'Telefon Utgifter'
+b'DocType: Sales Partner',b'Logo',b'Logo'
+b'DocType: Naming Series',b'Check this if you want to force the user to select a series before saving. There will be no default if you check this.',b'Sjekk dette hvis du vil tvinge brukeren til \xc3\xa5 velge en serie f\xc3\xb8r du lagrer. Det blir ingen standard hvis du sjekke dette.'
+b'apps/erpnext/erpnext/stock/get_item_details.py +131',b'No Item with Serial No {0}',b'Ingen Element med Serial No {0}'
+b'DocType: Email Digest',b'Open Notifications',b'\xc3\x85pne P\xc3\xa5minnelser'
+b'DocType: Payment Entry',b'Difference Amount (Company Currency)',b'Forskjell Bel\xc3\xb8p (Selskap Valuta)'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +79',b'Direct Expenses',b'Direkte kostnader'
+b'apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +60',b'New Customer Revenue',b'Ny kunde Revenue'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +119',b'Travel Expenses',b'Reiseutgifter'
+b'DocType: Maintenance Visit',b'Breakdown',b'Sammenbrudd'
+b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +50',b'Add custom field Subscription in the doctype {0}',b'Legg til egendefinert felt Abonnement i doktypen {0}'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +820',b'Account: {0} with currency: {1} can not be selected',b'Konto: {0} med valuta: {1} kan ikke velges'
+b'DocType: Purchase Receipt Item',b'Sample Quantity',b'Pr\xc3\xb8vekvantitet'
+b'DocType: Manufacturing Settings',"b'Update BOM cost automatically via Scheduler, based on latest valuation rate / price list rate / last purchase rate of raw materials.'","b'Oppdater BOM kostnad automatisk via Scheduler, basert p\xc3\xa5 siste verdivurdering / prisliste rate / siste kj\xc3\xb8pshastighet av r\xc3\xa5varer.'"
+b'DocType: Bank Reconciliation Detail',b'Cheque Date',b'Sjekk Dato'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +50',b'Account {0}: Parent account {1} does not belong to company: {2}',b'Konto {0}: Parent konto {1} ikke tilh\xc3\xb8rer selskapet: {2}'
+b'apps/erpnext/erpnext/setup/doctype/company/company.js +106',b'Successfully deleted all transactions related to this company!',b'Slettet alle transaksjoner knyttet til dette selskapet!'
+b'apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +27',b'As on Date',b'Som p\xc3\xa5 dato'
+b'DocType: Appraisal',b'HR',b'HR'
+b'DocType: Program Enrollment',b'Enrollment Date',b'p\xc3\xa5melding Dato'
+b'DocType: Healthcare Settings',b'Out Patient SMS Alerts',b'Ut Patient SMS Alerts'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +100',b'Probation',b'Pr\xc3\xb8vetid'
+b'apps/erpnext/erpnext/config/hr.py +115',b'Salary Components',b'l\xc3\xb8nn Components'
+b'DocType: Program Enrollment Tool',b'New Academic Year',b'Nytt studie\xc3\xa5r'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +811',b'Return / Credit Note',b'Retur / kreditnota'
+b'DocType: Stock Settings',b'Auto insert Price List rate if missing',b'Auto innsats Prisliste rente hvis mangler'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +117',b'Total Paid Amount',b'Totalt innbetalt bel\xc3\xb8p'
+b'DocType: GST Settings',b'B2C Limit',b'B2C Limit'
+b'DocType: Work Order Item',b'Transferred Qty',b'Overf\xc3\xb8rt Antall'
+b'apps/erpnext/erpnext/config/learn.py +11',b'Navigating',b'Navigere'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +188',b'Planning',b'Planlegging'
+b'DocType: Share Balance',b'Issued',b'Utstedt'
+b'apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +14',b'Student Activity',b'Studentaktivitet'
+b'apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +80',b'Supplier Id',b'Leverand\xc3\xb8r Id'
+b'DocType: Payment Request',b'Payment Gateway Details',b'Betaling Gateway Detaljer'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +276',b'Quantity should be greater than 0',b'Mengden skal v\xc3\xa6re st\xc3\xb8rre enn 0'
+b'DocType: Journal Entry',b'Cash Entry',b'Cash Entry'
+b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js +17',"b""Child nodes can be only created under 'Group' type nodes""",b'Ordnede noder kan bare opprettes under &#39;Gruppe&#39; type noder'
+b'DocType: Leave Application',b'Half Day Date',b'Half Day Date'
+b'DocType: Academic Year',b'Academic Year Name',b'Akademisk \xc3\x85r Navn'
+b'DocType: Sales Partner',b'Contact Desc',b'Kontakt Desc'
+b'apps/erpnext/erpnext/config/hr.py +65',"b'Type of leaves like casual, sick etc.'","b'Type blader som casual, syke etc.'"
+b'DocType: Email Digest',b'Send regular summary reports via Email.',b'Send vanlige oppsummeringsrapporter via e-post.'
+b'DocType: Payment Entry',b'PE-',b'PE'
+b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +282',b'Please set default account in Expense Claim Type {0}',b'Vennligst angi standardkonto i Expense krav Type {0}'
+b'DocType: Assessment Result',b'Student Name',b'Student navn'
+b'DocType: Brand',b'Item Manager',b'Sak manager'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +143',b'Payroll Payable',b'l\xc3\xb8nn Betales'
+b'DocType: Buying Settings',b'Default Supplier Type',b'Standard Leverand\xc3\xb8r Type'
+b'DocType: Plant Analysis',b'Collection Datetime',b'Samling Datetime'
+b'DocType: Work Order',b'Total Operating Cost',b'Total driftskostnader'
+b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +171',b'Note: Item {0} entered multiple times',b'Merk: Element {0} inng\xc3\xa5tt flere ganger'
+b'apps/erpnext/erpnext/config/selling.py +41',b'All Contacts.',b'Alle kontakter.'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +71',b'Company Abbreviation',b'Firma Forkortelse'
+b'apps/erpnext/erpnext/healthcare/doctype/physician/physician.py +47',b'User {0} does not exist',b'Bruker {0} finnes ikke'
+b'DocType: Payment Term',b'Day(s) after invoice date',b'Dag (er) etter faktura dato'
+b'DocType: Payment Schedule',b'Payment Schedule',b'Nedbetalingsplan'
+b'DocType: Subscription',b'SUB-',b'UNDER-'
+b'DocType: Item Attribute Value',b'Abbreviation',b'Forkortelse'
+b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +195',b'Payment Entry already exists',b'Betaling Entry finnes allerede'
+b'apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py +36',b'Not authroized since {0} exceeds limits',b'Ikke authroized siden {0} overskrider grensene'
+b'apps/erpnext/erpnext/config/hr.py +110',b'Salary template master.',b'L\xc3\xb8nn mal mester.'
+b'apps/erpnext/erpnext/healthcare/setup.py +241',b'Pathology',b'Patologi'
+b'DocType: Restaurant Order Entry',b'Restaurant Table',b'Restaurantbord'
+b'DocType: Hotel Room',b'Hotel Manager',b'Hotell sjef'
+b'DocType: Leave Type',b'Max Days Leave Allowed',b'Max Dager La tillatt'
+b'apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +63',b'Set Tax Rule for shopping cart',b'Still skatteregel for shopping cart'
+b'DocType: Purchase Invoice',b'Taxes and Charges Added',b'Skatter og avgifter legges'
+,b'Sales Funnel',b'Sales trakt'
+b'apps/erpnext/erpnext/setup/doctype/company/company.py +49',b'Abbreviation is mandatory',b'Forkortelsen er obligatorisk'
+b'DocType: Project',b'Task Progress',b'Task Progress'
+b'apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html +7',b'Cart',b'Kurven'
+,b'Qty to Transfer',b'Antall overf\xc3\xb8re'
+b'apps/erpnext/erpnext/config/selling.py +13',b'Quotes to Leads or Customers.',b'Sitater for \xc3\xa5 Leads eller kunder.'
+b'DocType: Stock Settings',b'Role Allowed to edit frozen stock',b'Rolle tillatt \xc3\xa5 redigere frossen lager'
+,b'Territory Target Variance Item Group-Wise',b'Territorium Target Avviks varegruppe-Wise'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +143',b'All Customer Groups',b'Alle kundegrupper'
+b'apps/erpnext/erpnext/accounts/doctype/budget/budget.py +114',b'Accumulated Monthly',b'akkumulert pr m\xc3\xa5ned'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +781',b'{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2}.',b'{0} er obligatorisk. Kanskje Valutaveksling posten ikke er skapt for {1} til {2}.'
+b'apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +44',b'Tax Template is mandatory.',b'Skatt Mal er obligatorisk.'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +44',b'Account {0}: Parent account {1} does not exist',b'Konto {0}: Parent konto {1} finnes ikke'
+b'DocType: Purchase Invoice Item',b'Price List Rate (Company Currency)',b'Prisliste Rate (Selskap Valuta)'
+b'DocType: Products Settings',b'Products Settings',b'Produkter Innstillinger'
+,b'Item Price Stock',b'Varen Pris Lager'
+b'DocType: Lab Prescription',b'Test Created',b'Test laget'
+b'DocType: Healthcare Settings',b'Custom Signature in Print',b'Tilpasset signatur i utskrift'
+b'DocType: Account',b'Temporary',b'Midlertidig'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +107',b'Customer LPO No.',b'Kunde LPO nr.'
+b'DocType: Program',b'Courses',b'kurs'
+b'DocType: Monthly Distribution Percentage',b'Percentage Allocation',b'Prosentvis Allocation'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +128',b'Secretary',b'Sekret\xc3\xa6r'
+b'DocType: Global Defaults',"b""If disable, 'In Words' field will not be visible in any transaction""","b'Hvis deaktivere, &#39;I Ord-feltet ikke vil v\xc3\xa6re synlig i enhver transaksjon'"
+b'DocType: Serial No',b'Distinct unit of an Item',b'Distinkt enhet av et element'
+b'DocType: Supplier Scorecard Criteria',b'Criteria Name',b'Kriterium Navn'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1295',b'Please set Company',b'Vennligst sett selskap'
+b'DocType: Pricing Rule',b'Buying',b'Kj\xc3\xb8pe'
+b'apps/erpnext/erpnext/config/agriculture.py +24',b'Diseases & Fertilizers',b'Sykdommer og gj\xc3\xb8dsel'
+b'DocType: HR Settings',b'Employee Records to be created by',b'Medarbeider Records \xc3\xa5 v\xc3\xa6re skapt av'
+b'DocType: Patient',b'AB Negative',b'AB Negativ'
+b'DocType: Sample Collection',b'SMPL-',b'SMPL-'
+b'DocType: POS Profile',b'Apply Discount On',b'P\xc3\xa5f\xc3\xb8r rabatt p\xc3\xa5'
+b'DocType: Member',b'Membership Type',b'Medlemskapstype'
+,b'Reqd By Date',b'Reqd etter dato'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +140',b'Creditors',b'Kreditorer'
+b'DocType: Assessment Plan',b'Assessment Name',b'Assessment Name'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js +94',b'Show PDC in Print',b'Vis PDC i Print'
+b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +97',b'Row # {0}: Serial No is mandatory',b'Row # {0}: Serial No er obligatorisk'
+b'DocType: Purchase Taxes and Charges',b'Item Wise Tax Detail',b'Sak Wise Skatt Detalj'
+b'apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.js +13',b'Job Offer',b'Jobbtilbud'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +71',b'Institute Abbreviation',b'Institute forkortelse'
+,b'Item-wise Price List Rate',b'Element-messig Prisliste Ranger'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1082',b'Supplier Quotation',b'Leverand\xc3\xb8r sitat'
+b'DocType: Quotation',b'In Words will be visible once you save the Quotation.',b'I Ord vil v\xc3\xa6re synlig n\xc3\xa5r du lagrer Tilbud.'
+b'apps/erpnext/erpnext/utilities/transaction_base.py +164',b'Quantity ({0}) cannot be a fraction in row {1}',b'Antall ({0}) kan ikke v\xc3\xa6re en br\xc3\xb8kdel i rad {1}'
+b'apps/erpnext/erpnext/utilities/transaction_base.py +164',b'Quantity ({0}) cannot be a fraction in row {1}',b'Antall ({0}) kan ikke v\xc3\xa6re en br\xc3\xb8kdel i rad {1}'
+b'DocType: Consultation',b'C-',b'C-'
+b'DocType: Attendance',b'ATT-',b'ATT-'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +492',b'Barcode {0} already used in Item {1}',b'Barcode {0} allerede brukt i Element {1}'
+b'apps/erpnext/erpnext/config/selling.py +86',b'Rules for adding shipping costs.',b'Regler for \xc3\xa5 legge til fraktkostnader.'
+b'DocType: Hotel Room',b'Extra Bed Capacity',b'Ekstra seng kapasitet'
+b'DocType: Item',b'Opening Stock',b'\xc3\xa5pning Stock'
+b'apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +20',b'Customer is required',b'Kunden m\xc3\xa5'
+b'DocType: Lab Test',b'Result Date',b'Resultatdato'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +77',b'PDC/LC Date',b'PDC / LC-dato'
+b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +20',b'{0} is mandatory for Return',b'{0} er obligatorisk for Return'
+b'DocType: Purchase Order',b'To Receive',b'\xc3\x85 Motta'
+b'apps/erpnext/erpnext/utilities/user_progress.py +252',b'user@example.com',b'user@example.com'
+b'DocType: Asset',b'Asset Owner',b'Asset Eier'
+b'DocType: Employee',b'Personal Email',b'Personlig e-post'
+b'apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +57',b'Total Variance',b'Total Variance'
+b'DocType: Accounts Settings',"b'If enabled, the system will post accounting entries for inventory automatically.'","b'Hvis aktivert, vil systemet starte regnskapspostene for inventar automatisk.'"
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +15',b'Brokerage',b'Brokerage'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +195',b'Attendance for employee {0} is already marked for this day',b'Oppm\xc3\xb8te for arbeidstaker {0} er allerede markert for denne dagen'
+b'DocType: Work Order Operation',"b""in Minutes\nUpdated via 'Time Log'""",b'Minutter Oppdatert via &#39;Time Logg&#39;'
+b'DocType: Customer',b'From Lead',b'Fra Lead'
+b'apps/erpnext/erpnext/config/manufacturing.py +13',b'Orders released for production.',b'Bestillinger frigitt for produksjon.'
+b'apps/erpnext/erpnext/public/js/account_tree_grid.js +65',b'Select Fiscal Year...',b'Velg regnskaps\xc3\xa5r ...'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +567',b'POS Profile required to make POS Entry',b'POS Profile n\xc3\xb8dvendig \xc3\xa5 foreta POS Entry'
+b'DocType: Program Enrollment Tool',b'Enroll Students',b'Meld Studenter'
+b'DocType: Lab Test',b'Approved Date',b'Godkjent dato'
+b'apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py +21',b'Standard Selling',b'Standard Selling'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +165',b'Atleast one warehouse is mandatory',b'Minst \xc3\xa9n lageret er obligatorisk'
+b'DocType: Serial No',b'Out of Warranty',b'Ut av Garanti'
+b'DocType: BOM Update Tool',b'Replace',b'Erstatt'
+b'apps/erpnext/erpnext/templates/includes/product_list.js +42',b'No products found.',b'Ingen produkter funnet.'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +360',b'{0} against Sales Invoice {1}',b'{0} mot Sales Faktura {1}'
+b'DocType: Antibiotic',b'Laboratory User',b'Laboratoriebruker'
+b'DocType: Sales Invoice',b'SINV-',b'SINV-'
+b'DocType: Request for Quotation Item',b'Project Name',b'Prosjektnavn'
+b'DocType: Customer',b'Mention if non-standard receivable account',b'Nevn hvis ikke-standard fordring konto'
+b'DocType: Journal Entry Account',b'If Income or Expense',b'Dersom inntekt eller kostnad'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +288',b'Select interest income account in employee loan {0}',b'Velg renteinntekter konto i ansatt l\xc3\xa5n {0}'
+b'DocType: Work Order',b'Required Items',b'n\xc3\xb8dvendige elementer'
+b'DocType: Stock Ledger Entry',b'Stock Value Difference',b'Stock Verdi Difference'
+b'apps/erpnext/erpnext/config/learn.py +229',b'Human Resource',b'Menneskelig Resurs'
+b'DocType: Payment Reconciliation Payment',b'Payment Reconciliation Payment',b'Betaling Avstemming Betaling'
+b'DocType: Disease',b'Treatment Task',b'Behandlingsoppgave'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +38',b'Tax Assets',b'Skattefordel'
+b'DocType: BOM Item',b'BOM No',b'BOM Nei'
+b'DocType: Instructor',b'INS/',b'INS /'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +160',b'Journal Entry {0} does not have account {1} or already matched against other voucher',b'Journal Entry {0} ikke har konto {1} eller allerede matchet mot andre verdikupong'
+b'DocType: Item',b'Moving Average',b'Glidende gjennomsnitt'
+b'DocType: BOM Update Tool',b'The BOM which will be replaced',b'BOM som vil bli erstattet'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +46',b'Electronic Equipments',b'elektronisk utstyr'
+b'DocType: Asset',b'Maintenance Required',b'Vedlikehold kreves'
+b'DocType: Account',b'Debit',b'Debet'
+b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +49',b'Leaves must be allocated in multiples of 0.5',"b'Bladene skal avsettes i multipler av 0,5'"
+b'DocType: Work Order',b'Operation Cost',b'Operation Cost'
+b'apps/erpnext/erpnext/config/hr.py +29',b'Upload attendance from a .csv file',b'Last opp oppm\xc3\xb8te fra en CSV-fil'
+b'apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +45',b'Outstanding Amt',b'Enest\xc3\xa5ende Amt'
+b'DocType: Sales Person',b'Set targets Item Group-wise for this Sales Person.',b'Sette m\xc3\xa5l varegruppe-messig for Sales Person.'
+b'DocType: Stock Settings',b'Freeze Stocks Older Than [Days]',b'Freeze Aksjer Eldre enn [dager]'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +600',b'Row #{0}: Asset is mandatory for fixed asset purchase/sale',b'Row # {0}: Asset er obligatorisk for anleggsmiddel kj\xc3\xb8p / salg'
+b'DocType: Asset Maintenance Team',b'Maintenance Team Name',b'Vedlikehold Lagnavn'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +42',"b'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.'","b'Hvis to eller flere Prising Reglene er funnet basert p\xc3\xa5 de ovennevnte forhold, er Priority brukt. Prioritet er et tall mellom 0 og 20, mens standardverdi er null (blank). H\xc3\xb8yere tall betyr at det vil ha forrang dersom det er flere Prising regler med samme betingelser.'"
+b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +197',"b""Customer is mandatory if 'Opportunity From' is selected as Customer""",b'Kunden er obligatorisk dersom &#39;Mulighet Fra&#39; er valgt som kunde'
+b'apps/erpnext/erpnext/controllers/trends.py +36',b'Fiscal Year: {0} does not exists',b'Fiscal Year: {0} ikke eksisterer'
+b'DocType: Currency Exchange',b'To Currency',b'\xc3\x85 Valuta'
+b'DocType: Leave Block List',b'Allow the following users to approve Leave Applications for block days.',b'Tillat f\xc3\xb8lgende brukere \xc3\xa5 godkjenne La Applications for blokk dager.'
+b'apps/erpnext/erpnext/config/hr.py +137',b'Types of Expense Claim.',b'Typer av Expense krav.'
+b'apps/erpnext/erpnext/controllers/selling_controller.py +148',b'Selling rate for item {0} is lower than its {1}. Selling rate should be atleast {2}',b'Selgingsfrekvensen for elementet {0} er lavere enn dens {1}. Salgsprisen b\xc3\xb8r v\xc3\xa6re minst {2}'
+b'DocType: Item',b'Taxes',b'Skatter'
+b'DocType: Purchase Invoice',b'capital goods',b'kapitalvarer'
+b'DocType: Purchase Invoice Item',b'Weight Per Unit',b'Vekt pr. Enhet'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +344',b'Paid and Not Delivered',b'Betalt og ikke levert'
+b'DocType: Project',b'Default Cost Center',b'Standard kostnadssted'
+b'DocType: Bank Guarantee',b'End Date',b'Sluttdato'
+b'apps/erpnext/erpnext/config/stock.py +7',b'Stock Transactions',b'aksje~~POS=TRUNC'
+b'DocType: Budget',b'Budget Accounts',b'Budsjett Regnskap'
+b'DocType: Employee',b'Internal Work History',b'Intern Work History'
+b'DocType: Depreciation Schedule',b'Accumulated Depreciation Amount',b'Akkumulerte avskrivninger bel\xc3\xb8p'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +42',b'Private Equity',b'Private Equity'
+b'DocType: Supplier Scorecard Variable',b'Supplier Scorecard Variable',b'Leverand\xc3\xb8r Scorecard Variable'
+b'DocType: Employee Loan',b'Fully Disbursed',b'fullt utbetalt'
+b'DocType: Employee Advance',b'Due Advance Amount',b'Forfallsbel\xc3\xb8p'
+b'DocType: Maintenance Visit',b'Customer Feedback',b'Customer Feedback'
+b'DocType: Account',b'Expense',b'Expense'
+b'apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.js +54',b'Score cannot be greater than Maximum Score',b'Score kan ikke v\xc3\xa6re st\xc3\xb8rre enn Maksimal poengsum'
+b'apps/erpnext/erpnext/utilities/user_progress.py +129',b'Customers and Suppliers',b'Kunder og leverand\xc3\xb8rer'
+b'DocType: Item Attribute',b'From Range',b'Fra Range'
+b'DocType: BOM',b'Set rate of sub-assembly item based on BOM',b'Angi hastighet p\xc3\xa5 underenhetens element basert p\xc3\xa5 BOM'
+b'DocType: Hotel Room Reservation',b'Invoiced',b'fakturert'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +98',b'Syntax error in formula or condition: {0}',b'Syntaksfeil i formelen eller tilstand: {0}'
+b'DocType: Daily Work Summary Settings Company',b'Daily Work Summary Settings Company',b'Daglig arbeid Oppsummering Innstillinger selskapet'
+b'apps/erpnext/erpnext/stock/utils.py +125',b'Item {0} ignored since it is not a stock item',b'Element {0} ignorert siden det ikke er en lagervare'
+b'DocType: Appraisal',b'APRSL',b'APRSL'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +23',"b'To not apply Pricing Rule in a particular transaction, all applicable Pricing Rules should be disabled.'","b'Hvis du ikke vil bruke Prissetting regel i en bestemt transaksjon, b\xc3\xb8r alle gjeldende reglene for prissetting deaktiveres.'"
+b'DocType: Payment Term',b'Day(s) after the end of the invoice month',b'Dag (er) etter slutten av faktura m\xc3\xa5neden'
+b'DocType: Assessment Group',b'Parent Assessment Group',b'Parent Assessment Group'
+b'apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +27',b'Jobs',b'Jobs'
+,b'Sales Order Trends',b'Salgsordre Trender'
+b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +51',"b""The 'From Package No.' field must neither be empty nor it's value less than 1.""",b'Fra pakke nr. feltet m\xc3\xa5 verken v\xc3\xa6re tomt eller det er mindre enn 1.'
+b'DocType: Employee',b'Held On',b'Avholdt'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order_calendar.js +36',b'Production Item',b'Produksjon Element'
+,b'Employee Information',b'Informasjon ansatt'
+b'DocType: Stock Entry Detail',b'Additional Cost',b'Tilleggs Cost'
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +48',"b'Can not filter based on Voucher No, if grouped by Voucher'","b'Kan ikke filtrere basert p\xc3\xa5 Voucher Nei, hvis gruppert etter Voucher'"
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +918',b'Make Supplier Quotation',b'Gj\xc3\xb8r Leverand\xc3\xb8r sitat'
+b'DocType: Quality Inspection',b'Incoming',b'Innkommende'
+b'apps/erpnext/erpnext/setup/doctype/company/company.js +70',b'Default tax templates for sales and purchase are created.',b'Standard skattemaler for salg og kj\xc3\xb8p opprettes.'
+b'apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.py +57',b'Assessment Result record {0} already exists.',b'Vurderingsresultatrekord {0} eksisterer allerede.'
+b'DocType: BOM',b'Materials Required (Exploded)',b'Materialer som er n\xc3\xb8dvendige (Exploded)'
+b'apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py +60',"b""Please set Company filter blank if Group By is 'Company'""",b'Vennligst sett Company filter blank hvis Group By er &#39;Company&#39;'
+b'apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +66',b'Posting Date cannot be future date',b'Publiseringsdato kan ikke v\xc3\xa6re fremtidig dato'
+b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +102',b'Row # {0}: Serial No {1} does not match with {2} {3}',b'Row # {0}: Serial No {1} samsvarer ikke med {2} {3}'
+b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +10',b'for generating the recurring',b'for \xc3\xa5 generere de tilbakevendende'
+b'DocType: Stock Entry',b'Target Warehouse Address',b'M\xc3\xa5llageradresse'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +86',b'Casual Leave',b'Casual La'
+b'DocType: Agriculture Task',b'End Day',b'Endedag'
+b'DocType: Batch',b'Batch ID',b'Batch ID'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +380',b'Note: {0}',b'Merk: {0}'
+,b'Delivery Note Trends',b'Levering Note Trender'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +112',"b""This Week's Summary""",b'Denne ukens oppsummering'
+b'apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py +22',b'In Stock Qty',b'P\xc3\xa5 lager Antall'
+b'DocType: Delivery Trip',b'Calculate Estimated Arrival Times',b'Beregn ansl\xc3\xa5tte ankomsttider'
+b'apps/erpnext/erpnext/accounts/general_ledger.py +113',b'Account: {0} can only be updated via Stock Transactions',b'Konto: {0} kan bare oppdateres via lagertransaksjoner'
+b'DocType: Student Group Creation Tool',b'Get Courses',b'F\xc3\xa5 Kurs'
+b'DocType: GL Entry',b'Party',b'Selskap'
+b'DocType: Healthcare Settings',b'Patient Name',b'Pasientnavn'
+b'DocType: Variant Field',b'Variant Field',b'Variantfelt'
+b'DocType: Sales Order',b'Delivery Date',b'Leveringsdato'
+b'DocType: Opportunity',b'Opportunity Date',b'Opportunity Dato'
+b'DocType: Employee',b'Health Insurance Provider',b'Helseforsikringsselskap'
+b'DocType: Purchase Receipt',b'Return Against Purchase Receipt',b'Tilbake Against Kj\xc3\xb8pskvittering'
+b'DocType: Water Analysis',b'Person Responsible',b'Ansvarlig person'
+b'DocType: Request for Quotation Item',b'Request for Quotation Item',b'Foresp\xc3\xb8rsel om prisanslag Element'
+b'DocType: Purchase Order',b'To Bill',b'Til Bill'
+b'DocType: Material Request',b'% Ordered',b'% Bestilt'
+b'DocType: Education Settings',"b'For Course based Student Group, the Course will be validated for every Student from the enrolled Courses in Program Enrollment.'",b'For kursbasert studentgruppe vil kurset bli validert for hver student fra de innmeldte kursene i programopptaket.'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +103',b'Piecework',b'Akkord'
+b'apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +70',b'Avg. Buying Rate',b'Avg. Kj\xc3\xb8pe Rate'
+b'DocType: Share Balance',b'From No',b'Fra nr'
+b'DocType: Task',b'Actual Time (in Hours)',b'Virkelig tid (i timer)'
+b'DocType: Employee',b'History In Company',b'Historie I selskapet'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +270',b'New Message from {sender}',b'Ny melding fra {avsender}'
+b'DocType: Customer',b'Customer Primary Address',b'Kunde hovedadresse'
+b'apps/erpnext/erpnext/config/learn.py +107',b'Newsletters',b'Nyhetsbrev'
+b'DocType: Drug Prescription',b'Description/Strength',b'Beskrivelse / styrke'
+b'DocType: Share Balance',b'Is Company',b'Er selskapet'
+b'DocType: Stock Ledger Entry',b'Stock Ledger Entry',b'Stock Ledger Entry'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +83',b'Same item has been entered multiple times',b'Samme element er angitt flere ganger'
+b'DocType: Department',b'Leave Block List',b'La Block List'
+b'DocType: Purchase Invoice',b'Tax ID',b'Skatt ID'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +192',b'Item {0} is not setup for Serial Nos. Column must be blank',b'Element {0} er ikke oppsett for Serial Nos. Kolonne m\xc3\xa5 v\xc3\xa6re tomt'
+b'DocType: Accounts Settings',b'Accounts Settings',b'Regnskap Innstillinger'
+b'apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +11',b'Approve',b'Vedta'
+b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +69',"b'Malformatted address for {0}, please fix to continue.'","b'Malformatted adresse for {0}, v\xc3\xa6r s\xc3\xa5 snill \xc3\xa5 fikse for \xc3\xa5 fortsette.'"
+b'apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +28',"b'Number of new Account, it will be included in the account name as a prefix'","b'Antall ny konto, den vil bli inkludert i kontonavnet som prefiks'"
+b'DocType: Maintenance Team Member',b'Team Member',b'Teammedlem'
+b'apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js +151',b'No Result to submit',b'Ingen resultat \xc3\xa5 sende inn'
+b'DocType: Customer',b'Sales Partner and Commission',b'Sales Partner og Kommisjonen'
+b'DocType: Employee Loan',b'Rate of Interest (%) / Year',b'Rente (%) / \xc3\x85r'
+,b'Project Quantity',b'prosjekt Antall'
+b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +79',"b""Total {0} for all items is zero, may be you should change 'Distribute Charges Based On'""","b'Totalt {0} for alle elementer er null, kan v\xc3\xa6re du b\xc3\xb8r endre &#39;Fordel Avgifter basert p\xc3\xa5&#39;'"
+b'DocType: Opportunity',b'To Discuss',b'\xc3\x85 Diskutere'
+b'apps/erpnext/erpnext/stock/stock_ledger.py +377',b'{0} units of {1} needed in {2} to complete this transaction.',b'{0} enheter av {1} trengs i {2} for \xc3\xa5 fullf\xc3\xb8re denne transaksjonen.'
+b'DocType: Loan Type',b'Rate of Interest (%) Yearly',b'Rente (%) \xc3\x85rlig'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +71',b'Temporary Accounts',b'Midlertidige kontoer'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +207',b'Black',b'Svart'
+b'DocType: BOM Explosion Item',b'BOM Explosion Item',b'BOM Explosion Element'
+b'DocType: Shareholder',b'Contact List',b'Kontaktliste'
+b'DocType: Account',b'Auditor',b'Revisor'
+b'DocType: Project',b'Frequency To Collect Progress',b'Frekvens for \xc3\xa5 samle fremgang'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +132',b'{0} items produced',b'{0} elementer produsert'
+b'apps/erpnext/erpnext/utilities/user_progress.py +58',b'Learn More',b'L\xc3\xa6re mer'
+b'DocType: Cheque Print Template',b'Distance from top edge',b'Avstand fra \xc3\xb8vre kant'
+b'apps/erpnext/erpnext/stock/get_item_details.py +367',b'Price List {0} is disabled or does not exist',b'Prisliste {0} er deaktivert eller eksisterer ikke'
+b'DocType: Purchase Invoice',b'Return',b'Return'
+b'DocType: Pricing Rule',b'Disable',b'Deaktiver'
+b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +180',b'Mode of payment is required to make a payment',b'Modus for betaling er n\xc3\xb8dvendig \xc3\xa5 foreta en betaling'
+b'DocType: Project Task',b'Pending Review',b'Avventer omtale'
+b'apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +14',"b'Edit in full page for more options like assets, serial nos, batches etc.'","b'Rediger p\xc3\xa5 full side for flere alternativer som eiendeler, serienummer, batcher etc.'"
+b'apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +10',b'Appointments and Consultations',b'Utnevnelser og konsultasjoner'
+b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +41',b'{0} - {1} is not enrolled in the Batch {2}',b'{0} - {1} er ikke p\xc3\xa5meldt i batch {2}'
+b'apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +113',"b'Asset {0} cannot be scrapped, as it is already {1}'","b'Asset {0} kan ikke bli vraket, som det er allerede {1}'"
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +77',b'Cheques Required',b'Sjekker p\xc3\xa5krevd'
+b'DocType: Task',b'Total Expense Claim (via Expense Claim)',b'Total Expense krav (via Expense krav)'
+b'apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +177',b'Mark Absent',b'Mark Frav\xc3\xa6rende'
+b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +40',b'Failed to setup company',b'Kunne ikke opprette selskapet'
+b'DocType: Asset Repair',b'Asset Repair',b'Asset Repair'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +143',b'Row {0}: Currency of the BOM #{1} should be equal to the selected currency {2}',b'Rad {0}: valuta BOM # {1} b\xc3\xb8r v\xc3\xa6re lik den valgte valutaen {2}'
+b'DocType: Journal Entry Account',b'Exchange Rate',b'Vekslingskurs'
+b'DocType: Patient',b'Additional information regarding the patient',b'Ytterligere informasjon om pasienten'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +585',b'Sales Order {0} is not submitted',b'Salgsordre {0} er ikke innsendt'
+b'DocType: Homepage',b'Tag Line',b'tag Linje'
+b'DocType: Fee Component',b'Fee Component',b'Fee Component'
+b'apps/erpnext/erpnext/config/hr.py +204',b'Fleet Management',b'Fl\xc3\xa5testyring'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1080',b'Add items from',b'Legg elementer fra'
+b'apps/erpnext/erpnext/config/agriculture.py +7',b'Crops & Lands',b'Crops &amp; Lands'
+b'DocType: Cheque Print Template',b'Regular',b'Regelmessig'
+b'DocType: Fertilizer',b'Density (if liquid)',b'Tetthet (hvis flytende)'
+b'apps/erpnext/erpnext/education/doctype/course/course.py +20',b'Total Weightage of all Assessment Criteria must be 100%',b'Totalt weightage av alle vurderingskriteriene m\xc3\xa5 v\xc3\xa6re 100%'
+b'DocType: Purchase Order Item',b'Last Purchase Rate',b'Siste Purchase Rate'
+b'DocType: Account',b'Asset',b'Asset'
+b'DocType: Project Task',b'Task ID',b'Task ID'
+b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +84',b'Stock cannot exist for Item {0} since has variants',b'Stock kan ikke eksistere for Element {0} siden har varianter'
+b'DocType: Lab Test',b'Mobile',b'Mobil'
+,b'Sales Person-wise Transaction Summary',b'Transaksjons Oppsummering Sales Person-messig'
+b'DocType: Training Event',b'Contact Number',b'Kontakt nummer'
+b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +73',b'Warehouse {0} does not exist',b'Warehouse {0} finnes ikke'
+b'DocType: Monthly Distribution',b'Monthly Distribution Percentages',b'M\xc3\xa5nedlig Distribusjonsprosent'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.py +110',b'The selected item cannot have Batch',b'Den valgte elementet kan ikke ha Batch'
+b'DocType: Delivery Note',b'% of materials delivered against this Delivery Note',b'% Av materialer leveres mot denne f\xc3\xb8lgeseddel'
+b'DocType: Asset Maintenance Log',b'Has Certificate',b'Har sertifikat'
+b'DocType: Project',b'Customer Details',b'Kunde Detaljer'
+b'DocType: Asset',b'Check if Asset requires Preventive Maintenance or Calibration',b'Sjekk om Asset krever forebyggende vedlikehold eller kalibrering'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +87',b'Company Abbreviation cannot have more than 5 characters',b'Selskapets forkortelse kan ikke inneholde mer enn 5 tegn'
+b'DocType: Employee',b'Reports to',b'Rapporter til'
+,b'Unpaid Expense Claim',b'Ubetalte Expense krav'
+b'DocType: Payment Entry',b'Paid Amount',b'Innbetalt bel\xc3\xb8p'
+b'apps/erpnext/erpnext/utilities/user_progress.py +158',b'Explore Sales Cycle',b'Utforsk salgssyklusen'
+b'DocType: Assessment Plan',b'Supervisor',b'Supervisor'
+b'apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +869',b'Retention Stock Entry',b'Beholdningsinngang'
+,b'Available Stock for Packing Items',b'Tilgjengelig p\xc3\xa5 lager for pakk gjenstander'
+b'DocType: Item Variant',b'Item Variant',b'Sak Variant'
+,b'Work Order Stock Report',b'Arbeide ordre lagerrapport'
+b'DocType: Assessment Result Tool',b'Assessment Result Tool',b'Assessment Resultat Tool'
+b'apps/erpnext/erpnext/education/doctype/instructor/instructor.js +24',b'As Supervisor',b'Som veileder'
+b'DocType: BOM Scrap Item',b'BOM Scrap Item',b'BOM Scrap Element'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +895',b'Submitted orders can not be deleted',b'Innsendte bestillinger kan ikke slettes'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +114',"b""Account balance already in Debit, you are not allowed to set 'Balance Must Be' as 'Credit'""","b'Saldo allerede i debet, har du ikke lov til \xc3\xa5 sette &quot;Balance m\xc3\xa5 v\xc3\xa6re &#39;som&#39; Credit &#39;'"
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +118',b'Quality Management',b'Kvalitetsstyring'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +41',b'Item {0} has been disabled',b'Element {0} har blitt deaktivert'
+b'DocType: Project',b'Total Billable Amount (via Timesheets)',b'Totalt fakturerbart bel\xc3\xb8p (via tidsskrifter)'
+b'DocType: Agriculture Task',b'Previous Business Day',b'Tidligere arbeidsdag'
+b'DocType: Employee Loan',b'Repay Fixed Amount per Period',b'Smelle fast bel\xc3\xb8p per periode'
+b'DocType: Employee',b'Health Insurance No',b'Helseforsikring nr'
+b'apps/erpnext/erpnext/buying/utils.py +47',b'Please enter quantity for Item {0}',b'Skriv inn antall for Element {0}'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +215',b'Credit Note Amt',b'Kreditt notat Amt'
+b'DocType: Employee External Work History',b'Employee External Work History',b'Ansatt Ekstern Work History'
+b'DocType: Opening Invoice Creation Tool',b'Purchase',b'Kj\xc3\xb8p'
+b'apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37',b'Balance Qty',b'Balanse Antall'
+b'apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +20',b'Goals cannot be empty',b'M\xc3\xa5l kan ikke v\xc3\xa6re tomt'
+b'apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.js +15',b'Enrolling students',b'Registrering av studenter'
+b'DocType: Item Group',b'Parent Item Group',b'Parent varegruppe'
+b'DocType: Appointment Type',b'Appointment Type',b'Avtale Type'
+b'apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +21',b'{0} for {1}',b'{0} for {1}'
+b'DocType: Healthcare Settings',b'Valid number of days',b'Gyldig antall dager'
+b'apps/erpnext/erpnext/setup/doctype/company/company.js +39',b'Cost Centers',b'Kostnadssteder'
+b'DocType: Land Unit',b'Linked Plant Analysis',b'Linked Plant Analysis'
+b'DocType: Purchase Receipt',"b""Rate at which supplier's currency is converted to company's base currency""",b'Hastigheten som leverand\xc3\xb8rens valuta er konvertert til selskapets hovedvaluta'
+b'apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +36',b'Row #{0}: Timings conflicts with row {1}',b'Row # {0}: timings konflikter med rad {1}'
+b'DocType: Purchase Invoice Item',b'Allow Zero Valuation Rate',b'Tillat null verdivurdering'
+b'DocType: Training Event Employee',b'Invited',b'invitert'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +178',b'Multiple active Salary Structures found for employee {0} for the given dates',b'Flere aktive L\xc3\xb8nn Structures funnet for arbeidstaker {0} for den gitte datoer'
+b'apps/erpnext/erpnext/config/accounts.py +308',b'Setup Gateway accounts.',b'Oppsett Gateway kontoer.'
+b'DocType: Employee',b'Employment Type',b'Type stilling'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +42',b'Fixed Assets',b'Anleggsmidler'
+b'DocType: Payment Entry',b'Set Exchange Gain / Loss',b'Sett valutagevinst / tap'
+,b'GST Purchase Register',b'GST Innkj\xc3\xb8psregister'
+,b'Cash Flow',b'Cash Flow'
+b'apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +25',b'Combined invoice portion must equal 100%',b'Kombinert fakturaport m\xc3\xa5 v\xc3\xa6re 100%'
+b'DocType: Item Group',b'Default Expense Account',b'Standard kostnadskonto'
+b'DocType: GST Account',b'CGST Account',b'CGST-konto'
+b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +53',b'Student Email ID',b'Student Email ID'
+b'DocType: Employee',b'Notice (days)',b'Varsel (dager)'
+b'DocType: Tax Rule',b'Sales Tax Template',b'Merverdiavgift Mal'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +2510',b'Select items to save the invoice',b'Velg elementer for \xc3\xa5 lagre fakturaen'
+b'DocType: Employee',b'Encashment Date',b'Encashment Dato'
+b'DocType: Training Event',b'Internet',b'Internett'
+b'DocType: Special Test Template',b'Special Test Template',b'Spesiell testmal'
+b'DocType: Account',b'Stock Adjustment',b'Stock Adjustment'
+b'apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +34',b'Default Activity Cost exists for Activity Type - {0}',b'Standard Aktivitet Kostnad finnes for Aktivitetstype - {0}'
+b'DocType: Work Order',b'Planned Operating Cost',b'Planlagt driftskostnader'
+b'DocType: Academic Term',b'Term Start Date',b'Term Startdato'
+b'apps/erpnext/erpnext/config/accounts.py +471',b'List of all share transactions',b'Liste over alle aksje transaksjoner'
+b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +18',b'Opp Count',b'Opptelling'
+b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +244',b'Please find attached {0} #{1}',b'Vedlagt {0} # {1}'
+b'apps/erpnext/erpnext/accounts/report/share_balance/share_balance.py +52',b'Average Rate',b'Gjennomsnittlig rente'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +728',b'Total Payment Amount in Payment Schedule must be equal to Grand / Rounded Total',b'Totalt betalingsbel\xc3\xb8p i betalingsplan m\xc3\xa5 v\xc3\xa6re lik Grand / Rounded Total'
+b'apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +34',b'Bank Statement balance as per General Ledger',b'Kontoutskrift balanse pr hovedbok'
+b'DocType: Job Applicant',b'Applicant Name',b'S\xc3\xb8kerens navn'
+b'DocType: Authorization Rule',b'Customer / Item Name',b'Kunde / Navn'
+b'DocType: Buying Settings',"b'If enabled, last purchase details of items will not be fetched from previous purchase order or purchase receipt'","b'Hvis aktivert, vil siste kj\xc3\xb8psdetaljer for elementer ikke bli hentet fra tidligere innkj\xc3\xb8psordre eller kj\xc3\xb8pskvittering'"
+b'DocType: Product Bundle',"b'Aggregate group of **Items** into another **Item**. This is useful if you are bundling a certain **Items** into a package and you maintain stock of the packed **Items** and not the aggregate **Item**. \n\nThe package **Item** will have ""Is Stock Item"" as ""No"" and ""Is Sales Item"" as ""Yes"".\n\nFor Example: If you are selling Laptops and Backpacks separately and have a special price if the customer buys both, then the Laptop + Backpack will be a new Product Bundle Item.\n\nNote: BOM = Bill of Materials'","b'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\xc3\xa6rbare datamaskiner og ryggsekker separat og har en spesiell pris hvis kunden kj\xc3\xb8per begge, s\xc3\xa5 Laptop + Backpack vil v\xc3\xa6re et nytt produkt Bundle varen. Merk: BOM = Bill of Materials'"
+b'apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +42',b'Serial No is mandatory for Item {0}',b'Serial No er obligatorisk for Element {0}'
+b'DocType: Item Variant Attribute',b'Attribute',b'Attributt'
+b'apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +43',b'Please specify from/to range',b'Vennligst oppgi fra / til spenner'
+b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +28',b'Opening {0} Invoice created',b'\xc3\x85pning {0} Faktura opprettet'
+b'DocType: Serial No',b'Under AMC',b'Under AMC'
+b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +55',b'Item valuation rate is recalculated considering landed cost voucher amount',b'Sak verdivurdering rente beregnes p\xc3\xa5 nytt vurderer inntakskost kupong bel\xc3\xb8p'
+b'apps/erpnext/erpnext/config/selling.py +153',b'Default settings for selling transactions.',b'Standardinnstillingene for salg transaksjoner.'
+b'DocType: Guardian',b'Guardian Of ',b'Guardian Av'
+b'DocType: Grading Scale Interval',b'Threshold',b'Terskel'
+b'DocType: BOM Update Tool',b'Current BOM',b'N\xc3\xa5v\xc3\xa6rende BOM'
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html +32',b'Balance (Dr - Cr)',b'Balanse (Dr - Cr)'
+b'apps/erpnext/erpnext/public/js/utils.js +55',b'Add Serial No',b'Legg Serial No'
+b'DocType: Work Order Item',b'Available Qty at Source Warehouse',b'Tilgjengelig antall p\xc3\xa5 Source Warehouse'
+b'apps/erpnext/erpnext/config/support.py +22',b'Warranty',b'Garanti'
+b'DocType: Purchase Invoice',b'Debit Note Issued',b'Debitnota Utstedt'
+b'DocType: Work Order',b'Warehouses',b'N\xc3\xa6ringslokaler'
+b'apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +18',b'{0} asset cannot be transferred',b'{0} eiendelen kan ikke overf\xc3\xb8res'
+b'DocType: Hotel Room Pricing',b'Hotel Room Pricing',b'Hotellrompriser'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +80',b'This Item is a Variant of {0} (Template).',b'Denne varen er en variant av {0} (mal).'
+b'DocType: Workstation',b'per hour',b'per time'
+b'apps/erpnext/erpnext/config/buying.py +7',b'Purchasing',b'innkj\xc3\xb8p'
+b'DocType: Announcement',b'Announcement',b'Kunngj\xc3\xb8ring'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +84',b'Customer LPO',b'Kunde LPO'
+b'DocType: Education Settings',"b'For Batch based Student Group, the Student Batch will be validated for every Student from the Program Enrollment.'","b'For Batch-baserte Studentgruppen, vil studentenes batch bli validert for hver student fra programopptaket.'"
+b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +50',b'Warehouse can not be deleted as stock ledger entry exists for this warehouse.',b'Warehouse kan ikke slettes som finnes lager hovedbok oppf\xc3\xb8ring for dette lageret.'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +25',b'Distribution',b'Distribusjon'
+b'DocType: Expense Claim Advance',b'Expense Claim Advance',b'Kostnadskrav Advance'
+b'DocType: Lab Test',b'Report Preference',b'Rapportpreferanse'
+b'apps/erpnext/erpnext/config/non_profit.py +43',b'Volunteer information.',b'Frivillig informasjon.'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +133',b'Project Manager',b'Prosjektleder'
+,b'Quoted Item Comparison',b'Sitert Element Sammenligning'
+b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +34',b'Overlap in scoring between {0} and {1}',b'Overlappe i scoring mellom {0} og {1}'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +114',b'Dispatch',b'Dispatch'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +74',b'Max discount allowed for item: {0} is {1}%',b'Maks rabatt tillatt for element: {0} er {1}%'
+b'apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +176',b'Net Asset value as on',b'Net Asset verdi som p\xc3\xa5'
+b'DocType: Crop',b'Produce',b'Produsere'
+b'DocType: Hotel Settings',b'Default Taxes and Charges',b'Standard Skatter og avgifter'
+b'DocType: Account',b'Receivable',b'Fordring'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +308',b'Row #{0}: Not allowed to change Supplier as Purchase Order already exists',b'Row # {0}: Ikke lov til \xc3\xa5 endre Leverand\xc3\xb8r som innkj\xc3\xb8psordre allerede eksisterer'
+b'DocType: Accounts Settings',b'Role that is allowed to submit transactions that exceed credit limits set.',b'Rollen som f\xc3\xa5r lov til \xc3\xa5 sende transaksjoner som overstiger kredittgrenser fastsatt.'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +989',b'Select Items to Manufacture',b'Velg delbetaling Produksjon'
+b'DocType: Delivery Stop',b'Delivery Stop',b'Leveringsstopp'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +963',"b'Master data syncing, it might take some time'","b'Master data synkronisering, kan det ta litt tid'"
+b'DocType: Item',b'Material Issue',b'Material Issue'
+b'DocType: Employee Education',b'Qualification',b'Kvalifisering'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +42',b'View Salary Slips',b'Se L\xc3\xb8nnsslipp'
+b'DocType: Item Price',b'Item Price',b'Sak Pris'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +48',b'Soap & Detergent',b'S\xc3\xa5pe og vaskemiddel'
+b'DocType: BOM',b'Show Items',b'Vis Items'
+b'apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.py +30',b'From Time cannot be greater than To Time.',b'Fra tid kan ikke v\xc3\xa6re st\xc3\xb8rre enn til annen.'
+b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +92',b'Do you want to notify all the customers by email?',b'Vil du varsle alle kundene via e-post?'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +36',b'Motion Picture & Video',b'Motion Picture &amp; Video'
+b'apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js +5',b'Ordered',b'Bestilt'
+b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js +51',b'Resume',b'Gjenoppta'
+b'DocType: Salary Detail',b'Component',b'Komponent'
+b'DocType: Assessment Criteria',b'Assessment Criteria Group',b'Vurderingskriterier Gruppe'
+b'DocType: Healthcare Settings',b'Patient Name By',b'Pasientnavn Av'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +72',b'Opening Accumulated Depreciation must be less than equal to {0}',b'\xc3\x85pning akkumulerte avskrivninger m\xc3\xa5 v\xc3\xa6re mindre enn eller lik {0}'
+b'DocType: Warehouse',b'Warehouse Name',b'Warehouse Name'
+b'DocType: Naming Series',b'Select Transaction',b'Velg Transaksjons'
+b'apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +30',b'Please enter Approving Role or Approving User',b'Skriv inn Godkjenne Rolle eller Godkjenne User'
+b'DocType: Journal Entry',b'Write Off Entry',b'Skriv Off Entry'
+b'DocType: BOM',b'Rate Of Materials Based On',b'Valuta materialer basert p\xc3\xa5'
+b'apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +21',b'Support Analtyics',b'St\xc3\xb8tte Analtyics'
+b'apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +102',b'Uncheck all',b'Fjern haken ved alle'
+b'DocType: POS Profile',b'Terms and Conditions',b'Vilk\xc3\xa5r og betingelser'
+b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +49',b'To Date should be within the Fiscal Year. Assuming To Date = {0}',b'To Date b\xc3\xb8r v\xc3\xa6re innenfor regnskaps\xc3\xa5ret. Antar To Date = {0}'
+b'DocType: Employee',"b'Here you can maintain height, weight, allergies, medical concerns etc'","b'Her kan du opprettholde h\xc3\xb8yde, vekt, allergier, medisinske bekymringer etc'"
+b'DocType: Leave Block List',b'Applies to Company',b'Gjelder Selskapet'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +231',b'Cannot cancel because submitted Stock Entry {0} exists',b'Kan ikke avbryte fordi innsendt Stock Entry {0} finnes'
+b'DocType: Employee Loan',b'Disbursement Date',b'Innbetalingsdato'
+b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +80',"b""'Recipients' not specified""",b'&#39;Mottakere&#39; ikke spesifisert'
+b'DocType: BOM Update Tool',b'Update latest price in all BOMs',b'Oppdater siste pris i alle BOMs'
+b'apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.js +23',b'Medical Record',b'Pasientjournal'
+b'DocType: Vehicle',b'Vehicle',b'Kj\xc3\xb8ret\xc3\xb8y'
+b'DocType: Purchase Invoice',b'In Words',b'I Words'
+b'apps/erpnext/erpnext/hr/doctype/training_result/training_result.py +15',b'{0} must be submitted',b'{0} m\xc3\xa5 sendes'
+b'DocType: POS Profile',b'Item Groups',b'varegruppene'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +221',"b""Today is {0}'s birthday!""",b'I dag er {0} s bursdag!'
+b'DocType: Sales Order Item',b'For Production',b'For Production'
+b'DocType: Payment Request',b'payment_url',b'payment_url'
+b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +186',b'Please add a Temporary Opening account in Chart of Accounts',b'Vennligst legg til en midlertidig \xc3\xa5pningskonto i kontoplan'
+b'DocType: Customer',b'Customer Primary Contact',b'Kundens prim\xc3\xa6re kontakt'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +154',b'Period Closing Journal',b'Periode avsluttende journal'
+b'DocType: Project Task',b'View Task',b'Vis Task'
+b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +22',b'Opp/Lead %',b'Opp / Lead%'
+b'DocType: Material Request',b'MREQ-',b'MREQ-'
+b'DocType: Payment Schedule',b'Invoice Portion',b'Fakturaandel'
+,b'Asset Depreciations and Balances',b'Asset Avskrivninger og Balanserer'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +370',b'Amount {0} {1} transferred from {2} to {3}',b'Mengden {0} {1} overf\xc3\xb8rt fra {2} til {3}'
+b'DocType: Sales Invoice',b'Get Advances Received',b'F\xc3\xa5 Fremskritt mottatt'
+b'DocType: Email Digest',b'Add/Remove Recipients',b'Legg til / fjern Mottakere'
+b'apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.js +19',"b""To set this Fiscal Year as Default, click on 'Set as Default'""","b'For \xc3\xa5 sette dette regnskaps\xc3\xa5ret som standard, klikk p\xc3\xa5 &quot;Angi som standard &#39;'"
+b'DocType: Production Plan',b'Include Subcontracted Items',b'Inkluder underleverte varer'
+b'apps/erpnext/erpnext/projects/doctype/project/project.py +220',b'Join',b'Bli med'
+b'apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +21',b'Shortage Qty',b'Mangel Antall'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +672',b'Cannot change Variant properties after stock transction. You will have to make a new Item to do this.',b'Kan ikke endre Variantegenskaper etter lageroverf\xc3\xb8ring. Du m\xc3\xa5 lage en ny gjenstand for \xc3\xa5 gj\xc3\xb8re dette.'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +714',b'Item variant {0} exists with same attributes',b'Sak variant {0} finnes med samme attributtene'
+b'DocType: Employee Loan',b'Repay from Salary',b'Smelle fra L\xc3\xb8nn'
+b'DocType: Leave Application',b'LAP/',b'RUNDE/'
+b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +360',b'Requesting payment against {0} {1} for amount {2}',b'Ber om betaling mot {0} {1} for mengden {2}'
+b'DocType: Salary Slip',b'Salary Slip',b'L\xc3\xb8nn Slip'
+b'DocType: Lead',b'Lost Quotation',b'mistet sitat'
+b'apps/erpnext/erpnext/utilities/user_progress.py +221',b'Student Batches',b'Studentbatcher'
+b'DocType: Pricing Rule',b'Margin Rate or Amount',b'Margin Rate Bel\xc3\xb8p'
+b'apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +48',"b""'To Date' is required""",b'&#39;To Date&#39; er p\xc3\xa5krevd'
+b'DocType: Packing Slip',"b'Generate packing slips for packages to be delivered. Used to notify package number, package contents and its weight.'","b'Generere pakksedler for pakker som skal leveres. Brukes til \xc3\xa5 varsle pakke nummer, innholdet i pakken og vekten.'"
+b'DocType: Sales Invoice Item',b'Sales Order Item',b'Salgsordre Element'
+b'DocType: Salary Slip',b'Payment Days',b'Betalings Days'
+b'DocType: Stock Settings',b'Convert Item Description to Clean HTML',b'Konverter elementbeskrivelse for \xc3\xa5 rydde HTML'
+b'DocType: Patient',b'Dormant',b'Sovende'
+b'DocType: Salary Slip',b'Total Interest Amount',b'Totalt rentebel\xc3\xb8p'
+b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +124',b'Warehouses with child nodes cannot be converted to ledger',b'N\xc3\xa6ringslokaler med barn noder kan ikke konverteres til Ledger'
+b'DocType: BOM',b'Manage cost of operations',b'Administrer driftskostnader'
+b'DocType: Accounts Settings',b'Stale Days',b'Foreldede dager'
+b'DocType: Notification Control',"b'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.'","b'N\xc3\xa5r noen av de merkede transaksjonene &quot;Skrevet&quot;, en e-pop-up automatisk \xc3\xa5pnet for \xc3\xa5 sende en e-post til den tilh\xc3\xb8rende &quot;Kontakt&quot; i at transaksjonen med transaksjonen som et vedlegg. Brukeren kan eller ikke kan sende e-posten.'"
+b'apps/erpnext/erpnext/config/setup.py +14',b'Global Settings',b'Globale innstillinger'
+b'DocType: Crop',b'Row Spacing UOM',b'Row Spacing UOM'
+b'DocType: Assessment Result Detail',b'Assessment Result Detail',b'Assessment Resultat Detalj'
+b'DocType: Employee Education',b'Employee Education',b'Ansatt Utdanning'
+b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +53',b'Duplicate item group found in the item group table',b'Duplicate varegruppe funnet i varegruppen bordet'
+b'DocType: Land Unit',b'Parent Land Unit',b'Moderselskap'
+b'apps/erpnext/erpnext/public/js/controllers/transaction.js +1113',b'It is needed to fetch Item Details.',b'Det er n\xc3\xb8dvendig \xc3\xa5 hente Element detaljer.'
+b'DocType: Fertilizer',b'Fertilizer Name',b'Navn p\xc3\xa5 gj\xc3\xb8dsel'
+b'DocType: Salary Slip',b'Net Pay',b'Netto L\xc3\xb8nn'
+b'DocType: Cash Flow Mapping Accounts',b'Account',b'Konto'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +217',b'Serial No {0} has already been received',b'Serial No {0} er allerede mottatt'
+,b'Requested Items To Be Transferred',b'Ettersp\xc3\xb8r elementene som skal overf\xc3\xb8res'
+b'DocType: Expense Claim',b'Vehicle Log',b'Vehicle Log'
+b'DocType: Vital Signs',b'Presence of a fever (temp &gt; 38.5 \xc2\xb0C/101.3 \xc2\xb0F or sustained temp &gt; 38 \xc2\xb0C/100.4 \xc2\xb0F)',"b'Tilstedev\xc3\xa6relse av feber (temp&gt; 38,5 \xc2\xb0 C eller vedvarende temp&gt; 38 \xc2\xb0 C / 100,4 \xc2\xb0 F)'"
+b'DocType: Customer',b'Sales Team Details',b'Salgsteam Detaljer'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +1352',b'Delete permanently?',b'Slett permanent?'
+b'DocType: Expense Claim',b'Total Claimed Amount',b'Total Hevdet Bel\xc3\xb8p'
+b'apps/erpnext/erpnext/config/crm.py +17',b'Potential opportunities for selling.',b'Potensielle muligheter for \xc3\xa5 selge.'
+b'DocType: Shareholder',b'Folio no.',b'Folio nr.'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +246',b'Invalid {0}',b'Ugyldig {0}'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +90',b'Sick Leave',b'Sykefrav\xc3\xa6r'
+b'DocType: Email Digest',b'Email Digest',b'E-post Digest'
+b'DocType: Delivery Note',b'Billing Address Name',b'Billing Address Navn'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +22',b'Department Stores',b'Varehus'
+,b'Item Delivery Date',b'Leveringsdato for vare'
+b'DocType: Production Plan',b'Material Requested',b'Materiale som kreves'
+b'DocType: Warehouse',b'PIN',b'PIN'
+b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +116',"b""Error '{0}' occured. Arguments {1}.""",b'Feil &#39;{0}&#39; oppstod. Argumenter {1}.'
+b'DocType: Bin',b'Reserved Qty for sub contract',b'Reservert antall for kontrakt'
+b'DocType: Patient Service Unit',b'Patinet Service Unit',b'Patinet Service Unit'
+b'DocType: Sales Invoice',b'Base Change Amount (Company Currency)',b'Base Endre Bel\xc3\xb8p (Selskap Valuta)'
+b'apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +304',b'No accounting entries for the following warehouses',b'Ingen regnskapspostene for f\xc3\xb8lgende varehus'
+b'apps/erpnext/erpnext/projects/doctype/project/project.js +95',b'Save the document first.',b'Lagre dokumentet f\xc3\xb8rst.'
+b'apps/erpnext/erpnext/shopping_cart/cart.py +74',b'Only {0} in stock for item {1}',b'Kun {0} p\xc3\xa5 lager for varen {1}'
+b'DocType: Account',b'Chargeable',b'Avgift'
+b'DocType: Company',b'Change Abbreviation',b'Endre Forkortelse'
+b'apps/erpnext/erpnext/templates/pages/integrations/gocardless_checkout.py +66',b'Pay {0} {1}',b'Betal {0} {1}'
+b'DocType: Expense Claim Detail',b'Expense Date',b'Expense Dato'
+b'DocType: Item',b'Max Discount (%)',b'Max Rabatt (%)'
+b'apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +30',b'Credit Days cannot be a negative number',b'Kredittdager kan ikke v\xc3\xa6re et negativt nummer'
+b'apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +70',b'Last Order Amount',b'Siste ordrebel\xc3\xb8p'
+b'DocType: Cash Flow Mapper',b'e.g Adjustments for:',b'f.eks. justeringer for:'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +275',"b' {0} Retain Sample is based on batch, please check Has Batch No to retain sample of item'","b'{0} Behold pr\xc3\xb8ve er basert p\xc3\xa5 batch, vennligst sjekk Har batch nr for \xc3\xa5 beholde pr\xc3\xb8ve av element'"
+b'DocType: Task',b'Is Milestone',b'Er Milestone'
+b'DocType: Delivery Stop',b'Email Sent To',b'E-post sendt \xc3\x85'
+b'DocType: Budget',b'Warn',b'Advare'
+b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +81',b'Are you sure you want to unregister?',b'Er du sikker p\xc3\xa5 at du vil avregistrere?'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +797',b'All items have already been transferred for this Work Order.',b'Alle elementer er allerede overf\xc3\xb8rt for denne arbeidsordren.'
+b'DocType: Appraisal',"b'Any other remarks, noteworthy effort that should go in the records.'","b'Eventuelle andre bemerkninger, bemerkelsesverdig innsats som b\xc3\xb8r g\xc3\xa5 i postene.'"
+b'DocType: Asset Maintenance',b'Manufacturing User',b'Manufacturing User'
+b'DocType: Purchase Invoice',b'Raw Materials Supplied',b'R\xc3\xa5vare Leveres'
+b'DocType: C-Form',b'Series',b'Series'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +282',b'Currency of the price list {0} must be {1} or {2}',b'Valuta p\xc3\xa5 prislisten {0} m\xc3\xa5 v\xc3\xa6re {1} eller {2}'
+b'DocType: Appraisal',b'Appraisal Template',b'Appraisal Mal'
+b'DocType: Soil Texture',b'Ternary Plot',b'Ternary Plot'
+b'DocType: Item Group',b'Item Classification',b'Sak Klassifisering'
+b'DocType: Driver',b'License Number',b'Lisensnummer'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +131',b'Business Development Manager',b'Business Development Manager'
+b'DocType: Maintenance Visit Purpose',b'Maintenance Visit Purpose',b'Vedlikehold Bes\xc3\xb8k Form\xc3\xa5l'
+b'apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +19',b'Invoice Patient Registration',b'Faktura Pasientregistrering'
+b'DocType: Crop',b'Period',b'Periode'
+b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.js +27',b'General Ledger',b'General Ledger'
+b'apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +33',b'Employee {0} on Leave on {1}',b'Employee {0} p\xc3\xa5 La den {1}'
+b'apps/erpnext/erpnext/selling/doctype/campaign/campaign.js +10',b'View Leads',b'Vis Leads'
+b'DocType: Program Enrollment Tool',b'New Program',b'nytt program'
+b'DocType: Item Attribute Value',b'Attribute Value',b'Attributtverdi'
+,b'Itemwise Recommended Reorder Level',b'Itemwise Anbefalt Omgj\xc3\xb8re niv\xc3\xa5'
+b'DocType: Salary Detail',b'Salary Detail',b'l\xc3\xb8nn Detalj'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1070',b'Please select {0} first',b'Vennligst velg {0} f\xc3\xb8rst'
+b'DocType: Appointment Type',b'Physician',b'lege'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +872',b'Batch {0} of Item {1} has expired.',b'Batch {0} av Element {1} er utl\xc3\xb8pt.'
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment_dashboard.py +11',b'Consultations',b'konsultasjoner'
+b'DocType: Sales Invoice',b'Commission',b'Kommisjon'
+b'apps/erpnext/erpnext/config/manufacturing.py +27',b'Time Sheet for manufacturing.',b'Timeregistrering for produksjon.'
+b'apps/erpnext/erpnext/templates/pages/cart.html +37',b'Subtotal',b'delsum'
+b'apps/erpnext/erpnext/config/erpnext_integrations.py +18',b'GoCardless SEPA Mandate',b'GoCardless SEPA Mandat'
+b'DocType: Physician',b'Charges',b'kostnader'
+b'DocType: Production Plan',b'Get Items For Work Order',b'F\xc3\xa5 varer for arbeidsordre'
+b'DocType: Salary Detail',b'Default Amount',b'Standard Bel\xc3\xb8p'
+b'DocType: Lab Test Template',b'Descriptive',b'beskrivende'
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +95',b'Warehouse not found in the system',b'Warehouse ikke funnet i systemet'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +115',"b""This Month's Summary""",b'Denne m\xc3\xa5neden Oppsummering'
+b'DocType: Quality Inspection Reading',b'Quality Inspection Reading',b'Quality Inspection Reading'
+b'apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +25',b'`Freeze Stocks Older Than` should be smaller than %d days.',b'`Freeze Aksjer Eldre Than` b\xc3\xb8r v\xc3\xa6re mindre enn% d dager.'
+b'DocType: Tax Rule',b'Purchase Tax Template',b'Kj\xc3\xb8pe Tax Mal'
+b'apps/erpnext/erpnext/utilities/user_progress.py +48',"b""Set a sales goal you'd like to achieve for your company.""",b'Sett et salgsm\xc3\xa5l du vil oppn\xc3\xa5 for din bedrift.'
+,b'Project wise Stock Tracking',b'Prosjektet klok Stock Tracking'
+b'DocType: GST HSN Code',b'Regional',b'Regional'
+b'apps/erpnext/erpnext/config/healthcare.py +40',b'Laboratory',b'Laboratorium'
+b'DocType: Stock Entry Detail',b'Actual Qty (at source/target)',b'Faktiske antall (ved kilden / target)'
+b'DocType: Item Customer Detail',b'Ref Code',b'Ref Kode'
+b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +75',b'Customer Group is Required in POS Profile',b'Kundegruppe er p\xc3\xa5krevd i POS-profil'
+b'apps/erpnext/erpnext/config/hr.py +12',b'Employee records.',b'Medarbeider poster.'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +98',b'Please set Next Depreciation Date',b'Vennligst sett Neste Avskrivninger Dato'
+b'DocType: HR Settings',b'Payroll Settings',b'L\xc3\xb8nn Innstillinger'
+b'apps/erpnext/erpnext/config/accounts.py +146',b'Match non-linked Invoices and Payments.',b'Matche ikke bundet fakturaer og betalinger.'
+b'DocType: POS Settings',b'POS Settings',b'POS-innstillinger'
+b'apps/erpnext/erpnext/templates/pages/cart.html +16',b'Place Order',b'Legg inn bestilling'
+b'DocType: Email Digest',b'New Purchase Orders',b'Nye innkj\xc3\xb8psordrer'
+b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +24',b'Root cannot have a parent cost center',b'Root kan ikke ha en forelder kostnadssted'
+b'apps/erpnext/erpnext/public/js/stock_analytics.js +54',b'Select Brand...',b'Velg merke ...'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +32',b'Non Profit (beta)',b'Ikke-profitt (beta)'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +18',b'Training Events/Results',b'Treningsarrangementer / resultater'
+b'apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +152',b'Accumulated Depreciation as on',b'Akkumulerte avskrivninger som p\xc3\xa5'
+b'DocType: Sales Invoice',b'C-Form Applicable',b'C-Form Gjelder'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +438',b'Operation Time must be greater than 0 for Operation {0}',b'Operation Tid m\xc3\xa5 v\xc3\xa6re st\xc3\xb8rre enn 0 for operasjon {0}'
+b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +107',b'Warehouse is mandatory',b'Warehouse er obligatorisk'
+b'DocType: Shareholder',b'Address and Contacts',b'Adresse og Kontakt'
+b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +67',b'Failed to create website',b'Kunne ikke opprette nettside'
+b'DocType: Soil Analysis',b'Mg/K',b'Mg / K'
+b'DocType: UOM Conversion Detail',b'UOM Conversion Detail',b'M\xc3\xa5lenheter Conversion Detalj'
+b'apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +924',b'Retention Stock Entry already created or Sample Quantity not provided',b'Retention Stock Entry allerede opprettet eller Sample Quantity ikke oppgitt'
+b'DocType: Program',b'Program Abbreviation',b'program forkortelse'
+b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +52',b'Charges are updated in Purchase Receipt against each item',b'Kostnader er oppdatert i Purchase Mottak mot hvert element'
+b'DocType: Warranty Claim',b'Resolved By',b'L\xc3\xb8st Av'
+b'DocType: Bank Guarantee',b'Start Date',b'Startdato'
+b'apps/erpnext/erpnext/config/hr.py +75',b'Allocate leaves for a period.',b'Bevilge blader for en periode.'
+b'apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +42',b'Cheques and Deposits incorrectly cleared',b'Sjekker og Innskudd feil ryddet'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +46',b'Account {0}: You can not assign itself as parent account',b'Konto {0}: Du kan ikke tildele seg selv som forelder konto'
+b'DocType: Purchase Invoice Item',b'Price List Rate',b'Prisliste Rate'
+b'apps/erpnext/erpnext/utilities/activation.py +72',b'Create customer quotes',b'Opprett kunde sitater'
+b'DocType: Item',"b'Show ""In Stock"" or ""Not in Stock"" based on stock available in this warehouse.'",b'Vis &quot;p\xc3\xa5 lager&quot; eller &quot;Not in Stock&quot; basert p\xc3\xa5 lager tilgjengelig i dette lageret.'
+b'apps/erpnext/erpnext/config/manufacturing.py +38',b'Bill of Materials (BOM)',b'Bill of Materials (BOM)'
+b'DocType: Item',b'Average time taken by the supplier to deliver',b'Gjennomsnittlig tid tatt av leverand\xc3\xb8ren til \xc3\xa5 levere'
+b'DocType: Sample Collection',b'Collected By',b'Samlet inn'
+b'apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.js +35',b'Assessment Result',b'Assessment Resultat'
+b'DocType: Hotel Room Package',b'Hotel Room Package',b'Hotellromspakke'
+b'apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +13',b'Hours',b'Timer'
+b'DocType: Project',b'Expected Start Date',b'Tiltredelse'
+b'DocType: Purchase Invoice',b'04-Correction in Invoice',b'04-korreksjon i faktura'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +963',b'Work Order already created for all items with BOM',b'Arbeidsordre som allerede er opprettet for alle elementer med BOM'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +60',b'Variant Details Report',b'Variant Detaljer Report'
+b'DocType: Setup Progress Action',b'Setup Progress Action',b'Oppsett Progress Action'
+b'apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +36',b'Buying Price List',b'Kj\xc3\xb8pe prisliste'
+b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +49',b'Remove item if charges is not applicable to that item',b'Fjern artikkel om avgifter er ikke aktuelt til dette elementet'
+b'apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +21',b'Please select Maintenance Status as Completed or remove Completion Date',"b'Vennligst velg Vedlikeholdsstatus som Fullf\xc3\xb8rt, eller fjern sluttdato'"
+b'DocType: Supplier',b'Default Payment Terms Template',b'Standard betalingsbetingelser mal'
+b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +34',b'Transaction currency must be same as Payment Gateway currency',b'Transaksjons valuta m\xc3\xa5 v\xc3\xa6re samme som Payment Gateway valuta'
+b'DocType: Payment Entry',b'Receive',b'Motta'
+b'apps/erpnext/erpnext/templates/pages/rfq.html +75',b'Quotations: ',b'sitater:'
+b'DocType: Maintenance Visit',b'Fully Completed',b'Fullt Fullf\xc3\xb8rt'
+b'apps/erpnext/erpnext/projects/doctype/project/project_list.js +6',b'{0}% Complete',b'{0}% Komplett'
+b'DocType: Employee',b'Educational Qualification',b'Pedagogiske Kvalifikasjoner'
+b'DocType: Workstation',b'Operating Costs',b'Driftskostnader'
+b'DocType: Budget',b'Action if Accumulated Monthly Budget Exceeded',b'Tiltak hvis Sn\xc3\xb8 M\xc3\xa5nedlig budsjett Skredet'
+b'DocType: Subscription',b'Submit on creation',b'Send inn p\xc3\xa5 skapelse'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +483',b'Currency for {0} must be {1}',b'Valuta for {0} m\xc3\xa5 v\xc3\xa6re {1}'
+b'DocType: Asset',b'Disposal Date',b'Deponering Dato'
+b'DocType: Daily Work Summary Settings',"b'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.'","b'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.'"
+b'DocType: Employee Leave Approver',b'Employee Leave Approver',b'Ansatt La Godkjenner'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +510',b'Row {0}: An Reorder entry already exists for this warehouse {1}',b'Rad {0}: En Omgj\xc3\xb8re oppf\xc3\xb8ring finnes allerede for dette lageret {1}'
+b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +99',"b'Cannot declare as lost, because Quotation has been made.'","b'Kan ikke erkl\xc3\xa6re som tapt, fordi tilbudet er gjort.'"
+b'apps/erpnext/erpnext/hr/doctype/training_event/training_event.js +16',b'Training Feedback',b'trening Tilbakemelding'
+b'DocType: Supplier Scorecard Criteria',b'Supplier Scorecard Criteria',b'Leverand\xc3\xb8r Scorecard Kriterier'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +149',b'Please select Start Date and End Date for Item {0}',b'Vennligst velg startdato og sluttdato for Element {0}'
+b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +55',b'Course is mandatory in row {0}',b'Kurset er obligatorisk i rad {0}'
+b'apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.js +16',b'To date cannot be before from date',b'Til dags dato kan ikke v\xc3\xa6re f\xc3\xb8r fra dato'
+b'DocType: Supplier Quotation Item',b'Prevdoc DocType',b'Prevdoc DOCTYPE'
+b'DocType: Cash Flow Mapper',b'Section Footer',b'Seksjon Footer'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +304',b'Add / Edit Prices',b'Legg til / Rediger priser'
+b'DocType: Batch',b'Parent Batch',b'Parent Batch'
+b'DocType: Cheque Print Template',b'Cheque Print Template',b'Sjekk ut Mal'
+b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +36',b'Chart of Cost Centers',b'Plan Kostnadssteder'
+b'DocType: Lab Test Template',b'Sample Collection',b'Eksempel Innsamling'
+,b'Requested Items To Be Ordered',b'Ettersp\xc3\xb8r Elementer bestilles'
+b'apps/erpnext/erpnext/public/js/hub/hub_page.js +137',b'My Orders',b'Mine bestillinger'
+b'DocType: Price List',b'Price List Name',b'Prisliste Name'
+b'DocType: BOM',b'Manufacturing',b'Manufacturing'
+,b'Ordered Items To Be Delivered',b'Bestilte varer som skal leveres'
+b'DocType: Account',b'Income',b'Inntekt'
+b'DocType: Industry Type',b'Industry Type',b'Industry Type'
+b'apps/erpnext/erpnext/templates/includes/cart.js +150',b'Something went wrong!',b'Noe gikk galt!'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +105',b'Warning: Leave application contains following block dates',b'Advarsel: La programmet inneholder f\xc3\xb8lgende blokk datoer'
+b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +275',b'Sales Invoice {0} has already been submitted',b'Salg Faktura {0} er allerede innsendt'
+b'DocType: Supplier Scorecard Scoring Criteria',b'Score',b'Score'
+b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +25',b'Fiscal Year {0} does not exist',b'Regnskaps\xc3\xa5ret {0} finnes ikke'
+b'DocType: Asset Maintenance Log',b'Completion Date',b'Ferdigstillelse Dato'
+b'DocType: Purchase Invoice Item',b'Amount (Company Currency)',b'Bel\xc3\xb8p (Selskap Valuta)'
+b'DocType: Agriculture Analysis Criteria',b'Agriculture User',b'Landbruker Bruker'
+b'apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +38',b'Valid till date cannot be before transaction date',b'Gyldig til dato kan ikke v\xc3\xa6re f\xc3\xb8r transaksjonsdato'
+b'apps/erpnext/erpnext/stock/stock_ledger.py +381',b'{0} units of {1} needed in {2} on {3} {4} for {5} to complete this transaction.',b'{0} enheter av {1} trengs i {2} p\xc3\xa5 {3} {4} for {5} for \xc3\xa5 fullf\xc3\xb8re denne transaksjonen.'
+b'DocType: Fee Schedule',b'Student Category',b'student Kategori'
+b'DocType: Announcement',b'Student',b'Student'
+b'apps/erpnext/erpnext/config/hr.py +238',b'Organization unit (department) master.',b'Organisasjonsenhet (departement) mester.'
+b'DocType: Shipping Rule',b'Shipping Rule Type',b'Forsendelsestype'
+b'apps/erpnext/erpnext/utilities/user_progress.py +239',b'Go to Rooms',b'G\xc3\xa5 til rom'
+b'apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +75',b'Please enter message before sending',b'Skriv inn meldingen f\xc3\xb8r du sender'
+b'DocType: Purchase Invoice',b'DUPLICATE FOR SUPPLIER',b'DUPLIKATE FOR LEVERAND\xc3\x98R'
+b'DocType: Email Digest',b'Pending Quotations',b'Avventer Sitater'
+b'apps/erpnext/erpnext/config/accounts.py +318',b'Point-of-Sale Profile',b'Point-of-Sale Profile'
+b'apps/erpnext/erpnext/agriculture/doctype/soil_texture/soil_texture.py +25',b'{0} should be a value between 0 and 100',b'{0} skal v\xc3\xa6re en verdi mellom 0 og 100'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +94',b'Next Depreciation Date cannot be before Available-for-use Date',b'Neste avskrivningsdato kan ikke v\xc3\xa6re f\xc3\xb8r Tilgjengelig-til-bruk-dato'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +156',b'Unsecured Loans',b'Usikret l\xc3\xa5n'
+b'DocType: Cost Center',b'Cost Center Name',b'Kostnadssteds Name'
+b'DocType: Student',b'B+',b'B +'
+b'DocType: HR Settings',b'Max working hours against Timesheet',b'Max arbeidstid mot Timeregistrering'
+b'DocType: Maintenance Schedule Detail',b'Scheduled Date',b'Planlagt dato'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +214',b'Total Paid Amt',b'Sum innskutt Amt'
+b'DocType: SMS Center',b'Messages greater than 160 characters will be split into multiple messages',b'Meldinger som er st\xc3\xb8rre enn 160 tegn vil bli delt inn i flere meldinger'
+b'DocType: Purchase Receipt Item',b'Received and Accepted',b'Mottatt og akseptert'
+b'DocType: Hub Settings',b'Company and Seller Profile',b'Bedrift og selgerprofil'
+,b'GST Itemised Sales Register',b'GST Artized Sales Register'
+b'DocType: Soil Texture',b'Silt Loam',b'Silt Loam'
+,b'Serial No Service Contract Expiry',b'Serial No Service kontraktsutl\xc3\xb8p'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +299',b'You cannot credit and debit same account at the same time',b'Du kan ikke kreditt- og debet samme konto samtidig'
+b'DocType: Vital Signs',"b""Adults' pulse rate is anywhere between 50 and 80 beats per minute.""",b'Voksnes pulsrate er hvor som helst mellom 50 og 80 slag per minutt.'
+b'DocType: Naming Series',b'Help HTML',b'Hjelp HTML'
+b'DocType: Student Group Creation Tool',b'Student Group Creation Tool',b'Student Gruppe Creation Tool'
+b'DocType: Item',b'Variant Based On',b'Variant basert p\xc3\xa5'
+b'apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +53',b'Total weightage assigned should be 100%. It is {0}',b'Total weightage tilordnet skal v\xc3\xa6re 100%. Det er {0}'
+b'apps/erpnext/erpnext/utilities/user_progress.py +109',b'Your Suppliers',b'Dine Leverand\xc3\xb8rer'
+b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +6',b'Please correct the',b'Vennligst korrig\xc3\xa9r'
+b'apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +80',b'Cannot set as Lost as Sales Order is made.',b'Kan ikke settes som tapt som Salgsordre er gjort.'
+b'DocType: Request for Quotation Item',b'Supplier Part No',b'Leverand\xc3\xb8r varenummer'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +382',"b""Cannot deduct when category is for 'Valuation' or 'Vaulation and Total'""",b'Kan ikke trekke n\xc3\xa5r kategorien er for verdsetting &#39;eller&#39; Vaulation og Total &#39;'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +377',b'Received From',b'Mottatt fra'
+b'DocType: Lead',b'Converted',b'Omregnet'
+b'DocType: Item',b'Has Serial No',b'Har Serial No'
+b'DocType: Employee',b'Date of Issue',b'Utstedelsesdato'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +222',"b""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}""","b'I henhold til kj\xc3\xb8psinnstillingene hvis kj\xc3\xb8p tilbakekj\xc3\xb8pt er n\xc3\xb8dvendig == &#39;JA&#39; og deretter for \xc3\xa5 opprette kj\xc3\xb8pfaktura, m\xc3\xa5 brukeren opprette kj\xc3\xb8psmottak f\xc3\xb8rst for element {0}'"
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +167',b'Row #{0}: Set Supplier for item {1}',b'Row # {0}: Sett Leverand\xc3\xb8r for elementet {1}'
+b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +121',b'Row {0}: Hours value must be greater than zero.',b'Rad {0}: Timer verdien m\xc3\xa5 v\xc3\xa6re st\xc3\xb8rre enn null.'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +195',b'Website Image {0} attached to Item {1} cannot be found',b'Website Bilde {0} festet til Element {1} kan ikke finnes'
+b'DocType: Issue',b'Content Type',b'Innholdstype'
+b'DocType: Asset',b'Assets',b'Eiendeler'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +17',b'Computer',b'Datamaskin'
+b'DocType: Item',b'List this Item in multiple groups on the website.',b'Liste denne vare i flere grupper p\xc3\xa5 nettstedet.'
+b'DocType: Payment Term',b'Due Date Based On',b'Forfallsdato basert p\xc3\xa5'
+b'apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +82',b'Please set default customer group and territory in Selling Settings',b'Vennligst angi standard kundegruppe og territorium i salgsinnstillinger'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +214',b'{0} {1} does not exist',b'{0} {1} finnes ikke'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +323',b'Please check Multi Currency option to allow accounts with other currency',b'Vennligst sjekk Multi Valuta alternativet for \xc3\xa5 tillate kontoer med andre valuta'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +88',b'Item: {0} does not exist in the system',b'Sak: {0} finnes ikke i systemet'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +106',b'You are not authorized to set Frozen value',b'Du er ikke autorisert til \xc3\xa5 sette Frozen verdi'
+b'DocType: Payment Reconciliation',b'Get Unreconciled Entries',b'F\xc3\xa5 avstemte Entries'
+b'DocType: Payment Reconciliation',b'From Invoice Date',b'Fra Fakturadato'
+b'DocType: Healthcare Settings',b'Laboratory Settings',b'Laboratorieinnstillinger'
+b'DocType: Patient Appointment',b'Service Unit',b'Servicenhet'
+b'apps/erpnext/erpnext/buying/report/quoted_item_comparison/quoted_item_comparison.js +97',b'Successfully Set Supplier',b'Vellykket sett leverand\xc3\xb8r'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +75',b'Leave Encashment',b'La Encashment'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +114',b'What does it do?',b'Hva gj\xc3\xb8r det?'
+b'DocType: Crop',b'Byproducts',b'biprodukter'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +84',b'To Warehouse',b'Til Warehouse'
+b'apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +26',b'All Student Admissions',b'Alle Student Opptak'
+,b'Average Commission Rate',b'Gjennomsnittlig kommisjon'
+b'DocType: Share Balance',b'No of Shares',b'Antall aksjer'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +448',"b""'Has Serial No' can not be 'Yes' for non-stock item""",b'\xc2\xabHar Serial No &#39;kan ikke v\xc3\xa6re&#39; Ja &#39;for ikke-lagervare'
+b'apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +59',b'Select Status',b'Velg Status'
+b'apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +41',b'Attendance can not be marked for future dates',b'Oppm\xc3\xb8te kan ikke merkes for fremtidige datoer'
+b'DocType: Pricing Rule',b'Pricing Rule Help',b'Prising Rule Hjelp'
+b'DocType: School House',b'House Name',b'Husnavn'
+b'DocType: Fee Schedule',b'Total Amount per Student',b'Totalt bel\xc3\xb8p per student'
+b'DocType: Purchase Taxes and Charges',b'Account Head',b'Account Leder'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +153',b'Electrical',b'Elektrisk'
+b'apps/erpnext/erpnext/utilities/activation.py +100',b'Add the rest of your organization as your users. You can also add invite Customers to your portal by adding them from Contacts',b'Tilsett resten av organisasjonen som brukerne. Du kan ogs\xc3\xa5 legge invitere kunder til portalen ved \xc3\xa5 legge dem fra Kontakter'
+b'DocType: Stock Entry',b'Total Value Difference (Out - In)',b'Total verdi Difference (ut -)'
+b'DocType: Grant Application',b'Requested Amount',b'\xc3\x98nsket bel\xc3\xb8p'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +348',b'Row {0}: Exchange Rate is mandatory',b'Rad {0}: Exchange Rate er obligatorisk'
+b'apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +27',b'User ID not set for Employee {0}',b'Bruker-ID ikke satt for Employee {0}'
+b'DocType: Vehicle',b'Vehicle Value',b'Vehicle Verdi'
+b'DocType: Crop Cycle',b'Detected Diseases',b'Detekterte sykdommer'
+b'DocType: Stock Entry',b'Default Source Warehouse',b'Standardkilde Warehouse'
+b'DocType: Item',b'Customer Code',b'Kunden Kode'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +220',b'Birthday Reminder for {0}',b'Bursdag P\xc3\xa5minnelse for {0}'
+b'DocType: Asset Maintenance Task',b'Last Completion Date',b'Siste sluttdato'
+b'apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +72',b'Days Since Last Order',b'Dager siden siste Bestill'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +365',b'Debit To account must be a Balance Sheet account',b'Uttak fra kontoen m\xc3\xa5 v\xc3\xa6re en balansekonto'
+b'DocType: Buying Settings',b'Naming Series',b'Navngi Series'
+b'DocType: GoCardless Settings',b'GoCardless Settings',b'GoCardless Innstillinger'
+b'DocType: Leave Block List',b'Leave Block List Name',b'La Block List Name'
+b'apps/erpnext/erpnext/hr/doctype/vehicle/vehicle.py +14',b'Insurance Start date should be less than Insurance End date',b'Forsikring Startdatoen m\xc3\xa5 v\xc3\xa6re mindre enn Forsikring Sluttdato'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +32',b'Stock Assets',b'Aksje Eiendeler'
+b'DocType: Restaurant',b'Active Menu',b'Aktiv meny'
+b'DocType: Target Detail',b'Target Qty',b'Target Antall'
+b'DocType: Shopping Cart Settings',b'Checkout Settings',b'Kasse Innstillinger'
+b'DocType: Student Attendance',b'Present',b'Present'
+b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +37',b'Delivery Note {0} must not be submitted',b'Levering Note {0} m\xc3\xa5 ikke sendes inn'
+b'DocType: Notification Control',b'Sales Invoice Message',b'Salgsfaktura Message'
+b'apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +27',b'Closing Account {0} must be of type Liability / Equity',b'Lukke konto {0} m\xc3\xa5 v\xc3\xa6re av typen Ansvar / Egenkapital'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +325',b'Salary Slip of employee {0} already created for time sheet {1}',b'L\xc3\xb8nn Slip av ansattes {0} allerede opprettet for timeregistrering {1}'
+b'DocType: Vehicle Log',b'Odometer',b'Kilometerteller'
+b'DocType: Production Plan Item',b'Ordered Qty',b'Bestilte Antall'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +744',b'Item {0} is disabled',b'Element {0} er deaktivert'
+b'DocType: Stock Settings',b'Stock Frozen Upto',b'Stock Frozen Opp'
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +930',b'BOM does not contain any stock item',b'BOM inneholder ikke lagervare'
+b'DocType: Chapter',b'Chapter Head',b'Kapittelhode'
+b'DocType: Payment Term',b'Month(s) after the end of the invoice month',b'M\xc3\xa5ned (e) etter slutten av faktura m\xc3\xa5neden'
+b'apps/erpnext/erpnext/config/projects.py +24',b'Project activity / task.',b'Prosjektet aktivitet / oppgave.'
+b'DocType: Vehicle Log',b'Refuelling Details',b'Fylle drivstoff Detaljer'
+b'apps/erpnext/erpnext/config/hr.py +104',b'Generate Salary Slips',b'Generere l\xc3\xb8nnsslipper'
+b'apps/erpnext/erpnext/agriculture/doctype/water_analysis/water_analysis.py +25',b'Lab result datetime cannot be before testing datetime',b'Lab-resultat datetime kan ikke v\xc3\xa6re f\xc3\xb8r testing av datetime'
+b'DocType: POS Profile',b'Allow user to edit Discount',b'Tillat brukeren \xc3\xa5 redigere rabatt'
+b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +55',b'Get customers from',b'F\xc3\xa5 kunder fra'
+b'DocType: Purchase Invoice Item',b'Include Exploded Items',b'Inkluder eksploderte elementer'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +45',"b'Buying must be checked, if Applicable For is selected as {0}'","b'Kj\xc3\xb8per m\xc3\xa5 sjekkes, hvis dette gjelder for er valgt som {0}'"
+b'apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +40',b'Discount must be less than 100',b'Rabatt m\xc3\xa5 v\xc3\xa6re mindre enn 100'
+b'DocType: Shipping Rule',b'Restrict to Countries',b'Begrens til land'
+b'DocType: Purchase Invoice',b'Write Off Amount (Company Currency)',b'Skriv Off Bel\xc3\xb8p (Selskap Valuta)'
+b'DocType: Sales Invoice Timesheet',b'Billing Hours',b'fakturerings~~POS=TRUNC Timer'
+b'DocType: Project',b'Total Sales Amount (via Sales Order)',b'Total salgsbel\xc3\xb8p (via salgsordre)'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +548',b'Default BOM for {0} not found',b'Standard BOM for {0} ikke funnet'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +514',b'Row #{0}: Please set reorder quantity',b'Row # {0}: Vennligst sett omgj\xc3\xb8ring kvantitet'
+b'apps/erpnext/erpnext/public/js/pos/pos.html +20',b'Tap items to add them here',b'Trykk p\xc3\xa5 elementer for \xc3\xa5 legge dem til her'
+b'DocType: Fees',b'Program Enrollment',b'program P\xc3\xa5melding'
+b'DocType: Share Transfer',b'To Folio No',b'Til Folio nr'
+b'DocType: Landed Cost Voucher',b'Landed Cost Voucher',b'Landed Cost Voucher'
+b'apps/erpnext/erpnext/public/js/queries.js +39',b'Please set {0}',b'Vennligst sett {0}'
+b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +37',b'{0} - {1} is inactive student',b'{0} - {1} er inaktiv student'
+b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +37',b'{0} - {1} is inactive student',b'{0} - {1} er inaktiv student'
+b'DocType: Employee',b'Health Details',b'Helse Detaljer'
+b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +24',b'To create a Payment Request reference document is required',b'For \xc3\xa5 opprette en betalingsforesp\xc3\xb8rsel kreves referansedokument'
+b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +24',b'To create a Payment Request reference document is required',b'For \xc3\xa5 opprette en betalingsforesp\xc3\xb8rsel kreves referansedokument'
+b'DocType: Soil Texture',b'Sandy Clay',b'Sandy Clay'
+b'DocType: Grant Application',b'Assessment  Manager',b'Vurderingsleder'
+b'DocType: Payment Entry',b'Allocate Payment Amount',b'Fordele Betalingsbel\xc3\xb8p'
+b'DocType: Employee External Work History',b'Salary',b'L\xc3\xb8nn'
+b'DocType: Serial No',b'Delivery Document Type',b'Levering dokumenttype'
+b'DocType: Sales Order',b'Partly Delivered',b'Delvis Leveres'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +48',b'Item Code &gt; Item Group &gt; Brand',b'Varenummer&gt; Varegruppe&gt; Varemerke'
+b'DocType: Item Variant Settings',b'Do not update variants on save',b'Ikke oppdater varianter p\xc3\xa5 lagre'
+b'DocType: Email Digest',b'Receivables',b'Fordringer'
+b'DocType: Lead Source',b'Lead Source',b'Lead Source'
+b'DocType: Customer',b'Additional information regarding the customer.',b'Ytterligere informasjon om kunden.'
+b'DocType: Quality Inspection Reading',b'Reading 5',b'Reading 5'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +236',"b'{0} {1} is associated with {2}, but Party Account is {3}'","b'{0} {1} er knyttet til {2}, men partikonto er {3}'"
+b'apps/erpnext/erpnext/healthcare/doctype/sample_collection/sample_collection.js +7',b'View Lab Tests',b'Se labtester'
+b'DocType: Purchase Invoice',b'Y',b'Y'
+b'DocType: Maintenance Visit',b'Maintenance Date',b'Vedlikehold Dato'
+b'DocType: Purchase Invoice Item',b'Rejected Serial No',b'Avvist Serial No'
+b'apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +82',b'Year start date or end date is overlapping with {0}. To avoid please set company',b'\xc3\x85r startdato eller sluttdato er overlappende med {0}. For \xc3\xa5 unng\xc3\xa5 vennligst sett selskap'
+b'apps/erpnext/erpnext/selling/doctype/customer/customer.py +122',b'Please mention the Lead Name in Lead {0}',b'Vennligst nevne Lead Name in Lead {0}'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +156',b'Start date should be less than end date for Item {0}',b'Startdato skal v\xc3\xa6re mindre enn sluttdato for Element {0}'
+b'DocType: Item',"b'Example: ABCD.#####\nIf series is set and Serial No is not mentioned in transactions, then automatic serial number will be created based on this series. If you always want to explicitly mention Serial Nos for this item. leave this blank.'","b'Eksempel:. ABCD ##### Hvis serien er satt og serienummer er ikke nevnt i transaksjoner, og deretter automatisk serienummer vil bli opprettet basert p\xc3\xa5 denne serien. Hvis du alltid vil eksplisitt nevne Serial Nos for dette elementet. la dette st\xc3\xa5 tomt.'"
+b'DocType: Upload Attendance',b'Upload Attendance',b'Last opp Oppm\xc3\xb8te'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +579',b'BOM and Manufacturing Quantity are required',b'BOM og Industri Antall kreves'
+b'apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +50',b'Ageing Range 2',b'Aldring Range 2'
+b'DocType: SG Creation Tool Course',b'Max Strength',b'Max Strength'
+b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +28',b'Installing presets',b'Installere forh\xc3\xa5ndsinnstillinger'
+b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +85',b'No Delivery Note selected for Customer {}',b'Ingen leveringsnotering valgt for kunden {}'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +25',b'BOM replaced',b'BOM erstattet'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1052',b'Select Items based on Delivery Date',b'Velg elementer basert p\xc3\xa5 leveringsdato'
+b'DocType: Grant Application',b'Has any past Grant Record',b'Har noen tidligere Grant Record'
+,b'Sales Analytics',b'Salgs Analytics'
+b'apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +127',b'Available {0}',b'Tilgjengelig {0}'
+,b'Prospects Engaged But Not Converted',"b'Utsikter engasjert, men ikke konvertert'"
+,b'Prospects Engaged But Not Converted',"b'Utsikter engasjert, men ikke konvertert'"
+b'DocType: Manufacturing Settings',b'Manufacturing Settings',b'Produksjons Innstillinger'
+b'apps/erpnext/erpnext/config/setup.py +56',b'Setting up Email',b'Sette opp e-post'
+b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +57',b'Guardian1 Mobile No',b'Guardian1 Mobile No'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +106',b'Please enter default currency in Company Master',b'Skriv inn standardvaluta i selskapet Master'
+b'DocType: Stock Entry Detail',b'Stock Entry Detail',b'Stock Entry Detail'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +109',b'Daily Reminders',b'Daglige p\xc3\xa5minnelser'
+b'DocType: Products Settings',b'Home Page is Products',b'Hjemme side er produkter'
+,b'Asset Depreciation Ledger',b'Asset Avskrivninger Ledger'
+b'apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +91',b'Tax Rule Conflicts with {0}',b'Skatteregel Konflikter med {0}'
+b'apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +25',b'New Account Name',b'New Account Name'
+b'DocType: Purchase Invoice Item',b'Raw Materials Supplied Cost',b'R\xc3\xa5vare Leveres Cost'
+b'DocType: Selling Settings',b'Settings for Selling Module',b'Innstillinger for \xc3\xa5 selge Module'
+b'DocType: Hotel Room Reservation',b'Hotel Room Reservation',b'Hotellrombestilling'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +115',b'Customer Service',b'Kundeservice'
+b'DocType: BOM',b'Thumbnail',b'Thumbnail'
+b'DocType: Item Customer Detail',b'Item Customer Detail',b'Sak Customer Detalj'
+b'apps/erpnext/erpnext/config/hr.py +50',b'Offer candidate a Job.',b'Tilbudet kandidat en jobb.'
+b'DocType: Notification Control',b'Prompt for Email on Submission of',b'Sp\xc3\xb8r for E-post om innsending av'
+b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +88',b'Total allocated leaves are more than days in the period',b'Totalt tildelte bladene er mer enn dager i perioden'
+b'DocType: Land Unit',b'Linked Soil Analysis',b'Koblet jordanalyse'
+b'DocType: Pricing Rule',b'Percentage',b'Prosentdel'
+b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +70',b'Item {0} must be a stock Item',b'Elementet {0} m\xc3\xa5 v\xc3\xa6re en lagervare'
+b'DocType: Manufacturing Settings',b'Default Work In Progress Warehouse',b'Standard Work In Progress Warehouse'
+b'apps/erpnext/erpnext/config/accounts.py +288',b'Default settings for accounting transactions.',b'Standardinnstillingene for regnskapsmessige transaksjoner.'
+b'DocType: Maintenance Visit',b'MV',b'MV'
+b'DocType: Restaurant',b'Default Tax Template',b'Standardskattemall'
+b'apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +66',b'{0} Students have been enrolled',b'{0} Studentene har blitt registrert'
+b'DocType: Fees',b'Student Details',b'Studentdetaljer'
+b'DocType: Purchase Invoice Item',b'Stock Qty',b'Varenummer'
+b'DocType: Employee Loan',b'Repayment Period in Months',b'Nedbetalingstid i m\xc3\xa5neder'
+b'apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +26',b'Error: Not a valid id?',b'Feil: Ikke en gyldig id?'
+b'DocType: Naming Series',b'Update Series Number',b'Update-serien Nummer'
+b'DocType: Account',b'Equity',b'Egenkapital'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +78',"b""{0} {1}: 'Profit and Loss' type account {2} not allowed in Opening Entry""",b'{0} {1}: &#39;Resultat&#39; type konto {2} ikke tillatt i \xc3\x85pning Entry'
+b'DocType: Sales Order',b'Printing Details',b'Utskrift Detaljer'
+b'DocType: Task',b'Closing Date',b'Avslutningsdato'
+b'DocType: Sales Order Item',b'Produced Quantity',b'Produsert Antall'
+b'DocType: Timesheet',b'Work Detail',b'Arbeidsdetalj'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +126',b'Engineer',b'Ingeni\xc3\xb8r'
+b'DocType: Journal Entry',b'Total Amount Currency',b'Totalbel\xc3\xb8p Valuta'
+b'apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +38',b'Search Sub Assemblies',b'S\xc3\xb8k Sub Assemblies'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +171',b'Item Code required at Row No {0}',b'Elementkode kreves ved Row Nei {0}'
+b'DocType: GST Account',b'SGST Account',b'SGST-konto'
+b'apps/erpnext/erpnext/utilities/user_progress.py +154',b'Go to Items',b'G\xc3\xa5 til elementer'
+b'DocType: Sales Partner',b'Partner Type',b'Partner Type'
+b'DocType: Purchase Taxes and Charges',b'Actual',b'Faktiske'
+b'DocType: Restaurant Menu',b'Restaurant Manager',b'Restaurantsjef'
+b'DocType: Authorization Rule',b'Customerwise Discount',b'Customerwise Rabatt'
+b'apps/erpnext/erpnext/config/projects.py +46',b'Timesheet for tasks.',b'Timeregistrering for oppgaver.'
+b'DocType: Purchase Invoice',b'Against Expense Account',b'Mot regning'
+b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +282',b'Installation Note {0} has already been submitted',b'Installasjon Merk {0} har allerede blitt sendt'
+b'DocType: Bank Reconciliation',b'Get Payment Entries',b'F\xc3\xa5 Betalings Entries'
+b'DocType: Quotation Item',b'Against Docname',b'Mot Docname'
+b'DocType: SMS Center',b'All Employee (Active)',b'All Employee (Active)'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +9',b'View Now',b'Vis n\xc3\xa5'
+b'DocType: BOM',b'Raw Material Cost',b'Raw Material Cost'
+b'DocType: Item Reorder',b'Re-Order Level',b'Re-Order niv\xc3\xa5'
+b'apps/erpnext/erpnext/projects/doctype/project/project.js +54',b'Gantt Chart',b'Gantt'
+b'DocType: Crop Cycle',b'Cycle Type',b'Syklus type'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +99',b'Part-time',b'Deltid'
+b'DocType: Employee',b'Applicable Holiday List',b'Gjelder Holiday List'
+b'DocType: Employee',b'Cheque',b'Cheque'
+b'DocType: Training Event',b'Employee Emails',b'Medarbeider e-post'
+b'apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +60',b'Series Updated',b'Serien Oppdatert'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +159',b'Report Type is mandatory',b'Rapporter Type er obligatorisk'
+b'DocType: Item',b'Serial Number Series',b'Serienummer Series'
+b'apps/erpnext/erpnext/buying/utils.py +68',b'Warehouse is mandatory for stock Item {0} in row {1}',b'Warehouse er obligatorisk for lager Element {0} i rad {1}'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +45',b'Retail & Wholesale',b'Retail &amp; Wholesale'
+b'DocType: Issue',b'First Responded On',b'F\xc3\xb8rst Svarte P\xc3\xa5'
+b'DocType: Website Item Group',b'Cross Listing of Item in multiple groups',b'Cross Notering av varen i flere grupper'
+b'apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +90',b'Fiscal Year Start Date and Fiscal Year End Date are already set in Fiscal Year {0}',b'Regnskaps\xc3\xa5r Startdato og regnskaps\xc3\xa5r sluttdato er allerede satt i regnskaps\xc3\xa5ret {0}'
+b'DocType: Projects Settings',b'Ignore User Time Overlap',b'Ignorer brukstidens overlapping'
+b'apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +113',b'Clearance Date updated',b'Lagersalg oppdatert'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +146',b'Split Batch',b'Split Batch'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +146',b'Split Batch',b'Split Batch'
+b'DocType: Stock Settings',b'Batch Identification',b'Batchidentifikasjon'
+b'apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +132',b'Successfully Reconciled',b'Vellykket Forsonet'
+b'DocType: Request for Quotation Supplier',b'Download PDF',b'Last ned PDF'
+b'DocType: Work Order',b'Planned End Date',b'Planlagt sluttdato'
+b'DocType: Shareholder',b'Hidden list maintaining the list of contacts linked to Shareholder',b'Skjult liste opprettholder listen over kontakter knyttet til Aksjon\xc3\xa6r'
+b'apps/erpnext/erpnext/config/non_profit.py +63',b'Donor Type information.',b'Donor Type informasjon.'
+b'DocType: Request for Quotation',b'Supplier Detail',b'Leverand\xc3\xb8r Detalj'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +100',b'Error in formula or condition: {0}',b'Feil i formel eller betingelse: {0}'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +99',b'Invoiced Amount',b'Fakturert bel\xc3\xb8p'
+b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +47',b'Criteria weights must add up to 100%',b'Kriterievekter m\xc3\xa5 legge opp til 100%'
+b'apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.js +7',b'Attendance',b'Oppm\xc3\xb8te'
+b'apps/erpnext/erpnext/public/js/pos/pos.html +115',b'Stock Items',b'lager~~POS=TRUNC'
+b'DocType: BOM',b'Materials',b'Materialer'
+b'DocType: Leave Block List',"b'If not checked, the list will have to be added to each Department where it has to be applied.'","b'Hvis ikke sjekket, vil listen m\xc3\xa5 legges til hver avdeling hvor det m\xc3\xa5 brukes.'"
+b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +111',b'Creating {0}',b'Opprette {0}'
+b'apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +28',b'Source and Target Warehouse cannot be same',b'Kilde og Target Warehouse kan ikke v\xc3\xa6re det samme'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +586',b'Posting date and posting time is mandatory',b'Konteringsdato og legger tid er obligatorisk'
+b'apps/erpnext/erpnext/config/buying.py +76',b'Tax template for buying transactions.',b'Skatt mal for \xc3\xa5 kj\xc3\xb8pe transaksjoner.'
+,b'Item Prices',b'Varepriser'
+b'DocType: Purchase Order',b'In Words will be visible once you save the Purchase Order.',b'I Ord vil v\xc3\xa6re synlig n\xc3\xa5r du lagrer innkj\xc3\xb8psordre.'
+b'DocType: Period Closing Voucher',b'Period Closing Voucher',b'Periode Closing Voucher'
+b'DocType: Consultation',b'Review Details',b'Gjennomg\xc3\xa5 detaljer'
+b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +185',b'The shareholder does not belong to this company',b'Aksjon\xc3\xa6ren tilh\xc3\xb8rer ikke dette firmaet'
+b'DocType: Dosage Form',b'Dosage Form',b'Doseringsform'
+b'apps/erpnext/erpnext/config/selling.py +67',b'Price List master.',b'Prisliste mester.'
+b'DocType: Task',b'Review Date',b'Omtale Dato'
+b'DocType: Company',b'Series for Asset Depreciation Entry (Journal Entry)',b'Serie for Asset Depreciation Entry (Journal Entry)'
+b'DocType: Membership',b'Member Since',b'Medlem siden'
+b'DocType: Purchase Invoice',b'Advance Payments',b'Forskudd'
+b'DocType: Purchase Taxes and Charges',b'On Net Total',b'On Net Total'
+b'apps/erpnext/erpnext/controllers/item_variant.py +92',b'Value for Attribute {0} must be within the range of {1} to {2} in the increments of {3} for Item {4}',b'Verdi for Egenskap {0} m\xc3\xa5 v\xc3\xa6re innenfor omr\xc3\xa5det {1} til {2} i trinn p\xc3\xa5 {3} for Element {4}'
+b'DocType: Restaurant Reservation',b'Waitlisted',b'ventelisten'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +124',b'Currency can not be changed after making entries using some other currency',b'Valuta kan ikke endres etter at oppf\xc3\xb8ringer ved hjelp av en annen valuta'
+b'DocType: Shipping Rule',b'Fixed',b'fast'
+b'DocType: Vehicle Service',b'Clutch Plate',b'clutch Plate'
+b'DocType: Company',b'Round Off Account',b'Rund av konto'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +93',b'Administrative Expenses',b'Administrative utgifter'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +18',b'Consulting',b'Consulting'
+b'DocType: Customer Group',b'Parent Customer Group',b'Parent Kundegruppe'
+b'DocType: Journal Entry',b'Subscription',b'Abonnement'
+b'DocType: Purchase Invoice',b'Contact Email',b'Kontakt Epost'
+b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +11',b'Fee Creation Pending',b'Avgiftskapasitet venter'
+b'DocType: Appraisal Goal',b'Score Earned',b'Resultat tjent'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +241',b'Notice Period',b'Oppsigelsestid'
+b'DocType: Asset Category',b'Asset Category Name',b'Asset Category Name'
+b'apps/erpnext/erpnext/setup/doctype/territory/territory.js +13',b'This is a root territory and cannot be edited.',b'Dette er en rot territorium og kan ikke redigeres.'
+b'apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js +5',b'New Sales Person Name',b'New Sales Person navn'
+b'DocType: Packing Slip',b'Gross Weight UOM',b'Bruttovekt m\xc3\xa5lenheter'
+b'DocType: Asset Maintenance Task',b'Preventive Maintenance',b'Forebyggende vedlikehold'
+b'DocType: Delivery Note Item',b'Against Sales Invoice',b'Mot Salg Faktura'
+b'DocType: Purchase Invoice',b'07-Others',b'07-Andre'
+b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +151',b'Please enter serial numbers for serialized item ',b'Vennligst skriv inn serienumre for serialisert element'
+b'DocType: Bin',b'Reserved Qty for Production',b'Reservert Antall for produksjon'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +43',b'EcritureNum',b'EcritureNum'
+b'DocType: Student Group Creation Tool',"b""Leave unchecked if you don't want to consider batch while making course based groups. """,b'La v\xc3\xa6re ukontrollert hvis du ikke vil vurdere batch mens du lager kursbaserte grupper.'
+b'DocType: Student Group Creation Tool',"b""Leave unchecked if you don't want to consider batch while making course based groups. """,b'La v\xc3\xa6re ukontrollert hvis du ikke vil vurdere batch mens du lager kursbaserte grupper.'
+b'DocType: Asset',b'Frequency of Depreciation (Months)',b'Frekvens av Avskrivninger (m\xc3\xa5neder)'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +500',b'Credit Account',b'Credit konto'
+b'DocType: Landed Cost Item',b'Landed Cost Item',b'Landed Cost Element'
+b'apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.js +57',b'Show zero values',b'Vis nullverdier'
+b'DocType: BOM',b'Quantity of item obtained after manufacturing / repacking from given quantities of raw materials',b'Antall element oppn\xc3\xa5dd etter produksjon / nedpakking fra gitte mengder r\xc3\xa5varer'
+b'DocType: Lab Test',b'Test Group',b'Testgruppe'
+b'DocType: Payment Reconciliation',b'Receivable / Payable Account',b'Fordringer / gjeld konto'
+b'DocType: Delivery Note Item',b'Against Sales Order Item',b'Mot kundeordreposisjon'
+b'DocType: Company',b'Company Logo',b'Firmalogo'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +709',b'Please specify Attribute Value for attribute {0}',b'Vennligst oppgi data Verdi for attributtet {0}'
+b'DocType: Item',b'Default Warehouse',b'Standard Warehouse'
+b'apps/erpnext/erpnext/accounts/doctype/budget/budget.py +45',b'Budget cannot be assigned against Group Account {0}',b'Budsjettet kan ikke overdras mot gruppekonto {0}'
+b'DocType: Healthcare Settings',b'Patient Registration',b'Pasientregistrering'
+b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +22',b'Please enter parent cost center',b'Skriv inn forelder kostnadssted'
+b'DocType: Delivery Note',b'Print Without Amount',b'Skriv ut Uten Bel\xc3\xb8p'
+b'apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +57',b'Depreciation Date',b'avskrivninger Dato'
+,b'Work Orders in Progress',b'Arbeidsordrer p\xc3\xa5g\xc3\xa5r'
+b'DocType: Issue',b'Support Team',b'Support Team'
+b'apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +36',b'Expiry (In Days)',b'Utl\xc3\xb8ps (i dager)'
+b'DocType: Appraisal',b'Total Score (Out of 5)',b'Total poengsum (av 5)'
+b'DocType: Fee Structure',b'FS.',b'FS.'
+b'DocType: Student Attendance Tool',b'Batch',b'Parti'
+b'DocType: Donor',b'Donor Type',b'Donor Type'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +27',b'Balance',b'Balanse'
+b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +66',b'Please select the Company',b'Vennligst velg firmaet'
+b'DocType: Room',b'Seating Capacity',b'Antall seter'
+b'DocType: Issue',b'ISS-',b'ISS-'
+b'DocType: Lab Test Groups',b'Lab Test Groups',b'Lab Test Grupper'
+b'DocType: Project',b'Total Expense Claim (via Expense Claims)',b'Total Expense krav (via Utgifts Krav)'
+b'DocType: GST Settings',b'GST Summary',b'GST Sammendrag'
+b'apps/erpnext/erpnext/hr/doctype/daily_work_summary_group/daily_work_summary_group.py +16',b'Please enable default incoming account before creating Daily Work Summary Group',b'Vennligst aktiver standard innkommende konto f\xc3\xb8r du oppretter Daglig arbeidsoppsummeringsgruppe'
+b'DocType: Assessment Result',b'Total Score',b'Total poengsum'
+b'DocType: Journal Entry',b'Debit Note',b'Debitnota'
+b'DocType: Stock Entry',b'As per Stock UOM',b'Pr Stock m\xc3\xa5lenheter'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch_list.js +7',b'Not Expired',b'Ikke utl\xc3\xb8pt'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +49',b'ValidDate',b'Gyldig dato'
+b'DocType: Student Log',b'Achievement',b'Oppn\xc3\xa5else'
+b'DocType: Batch',b'Source Document Type',b'Kilde dokumenttype'
+b'DocType: Batch',b'Source Document Type',b'Kilde dokumenttype'
+b'apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +24',b'Following course schedules were created',b'F\xc3\xb8lgende kursplaner ble opprettet'
+b'DocType: Journal Entry',b'Total Debit',b'Total debet'
+b'DocType: Manufacturing Settings',b'Default Finished Goods Warehouse',b'Standardferdigvarelageret'
+b'apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.js +108',b'Please select Patient',b'Vennligst velg Pasient'
+b'apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +76',b'Sales Person',b'Sales Person'
+b'DocType: Hotel Room Package',b'Amenities',b'fasiliteter'
+b'apps/erpnext/erpnext/config/accounts.py +233',b'Budget and Cost Center',b'Budsjett og kostnadssted'
+b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +65',b'Multiple default mode of payment is not allowed',b'Flere standard betalingsm\xc3\xa5ter er ikke tillatt'
+b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +5',b'for the',b'for'
+,b'Appointment Analytics',b'Avtale Analytics'
+b'DocType: Vehicle Service',b'Half Yearly',b'Halv\xc3\xa5rlig'
+b'DocType: Lead',b'Blog Subscriber',b'Blogg Subscriber'
+b'DocType: Guardian',b'Alternate Number',b'Alternativ nummer'
+b'DocType: Healthcare Settings',b'Consultations in valid days',b'Konsultasjoner i gyldige dager'
+b'DocType: Assessment Plan Criteria',b'Maximum Score',b'maksimal score'
+b'apps/erpnext/erpnext/config/setup.py +83',b'Create rules to restrict transactions based on values.',b'Lage regler for \xc3\xa5 begrense transaksjoner basert p\xc3\xa5 verdier.'
+b'DocType: Cash Flow Mapping Accounts',b'Cash Flow Mapping Accounts',b'Kontantstr\xc3\xb8mmappekontoer'
+b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +49',b' Group Roll No',b'Grupperulle nr'
+b'DocType: Batch',b'Manufacturing Date',b'Produksjonsdato'
+b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +9',b'Fee Creation Failed',b'Fee Creation mislyktes'
+b'DocType: Opening Invoice Creation Tool',b'Create Missing Party',b'Opprett manglende parti'
+b'DocType: Student Group Creation Tool',b'Leave blank if you make students groups per year',b'La v\xc3\xa6re tom hvis du lager studentgrupper hvert \xc3\xa5r'
+b'DocType: Student Group Creation Tool',b'Leave blank if you make students groups per year',b'La v\xc3\xa6re tom hvis du lager studentgrupper hvert \xc3\xa5r'
+b'DocType: HR Settings',"b'If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day'","b'Hvis det er merket, Total nei. arbeidsdager vil omfatte helligdager, og dette vil redusere verdien av L\xc3\xb8nn per dag'"
+b'DocType: Purchase Invoice',b'Total Advance',b'Total Advance'
+b'apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +27',b'Change Template Code',b'Endre malkode'
+b'apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +23',b'The Term End Date cannot be earlier than the Term Start Date. Please correct the dates and try again.',"b'Begrepet Sluttdatoen kan ikke v\xc3\xa6re tidligere enn Term startdato. Korriger datoene, og pr\xc3\xb8v igjen.'"
+b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +19',b'Quot Count',b'Sitatall'
+b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +19',b'Quot Count',b'Sitatall'
+,b'BOM Stock Report',b'BOM aksjerapport'
+b'DocType: Stock Reconciliation Item',b'Quantity Difference',b'Antall Difference'
+b'DocType: Employee Advance',b'EA-',b'EA'
+b'DocType: Opportunity Item',b'Basic Rate',b'Basic Rate'
+b'DocType: GL Entry',b'Credit Amount',b'Credit Bel\xc3\xb8p'
+b'DocType: Cheque Print Template',b'Signatory Position',b'Signataren plassering'
+b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +173',b'Set as Lost',b'Sett som tapte'
+b'DocType: Timesheet',b'Total Billable Hours',b'Totalt fakturerbare timer'
+b'apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +4',b'Payment Receipt Note',b'Betaling Kvittering Note'
+b'apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +6',b'This is based on transactions against this Customer. See timeline below for details',b'Dette er basert p\xc3\xa5 transaksjoner mot denne kunden. Se tidslinjen nedenfor for detaljer'
+b'apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +162',b'Row {0}: Allocated amount {1} must be less than or equals to Payment Entry amount {2}',b'Rad {0}: Avsatt bel\xc3\xb8p {1} m\xc3\xa5 v\xc3\xa6re mindre enn eller lik Betaling Entry mengden {2}'
+b'DocType: Program Enrollment Tool',b'New Academic Term',b'Ny faglig term'
+,b'Course wise Assessment Report',b'Kursbasert vurderingsrapport'
+b'DocType: Purchase Invoice',b'Availed ITC State/UT Tax',b'Availed ITC State / UT skatt'
+b'DocType: Tax Rule',b'Tax Rule',b'Skatt Rule'
+b'DocType: Selling Settings',b'Maintain Same Rate Throughout Sales Cycle',b'Opprettholde samme hastighet Gjennom Salgssyklus'
+b'DocType: Manufacturing Settings',b'Plan time logs outside Workstation Working Hours.',b'Planlegg tids logger utenfor arbeidsstasjon arbeidstid.'
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +115',b'Dr {0} does not have a Physician Schedule. Add it in Physician master',b'Dr {0} har ikke en legeplan. Legg det i lege master'
+b'apps/erpnext/erpnext/public/js/pos/pos.html +98',b'Customers in Queue',b'Kunder i k\xc3\xb8'
+b'DocType: Driver',b'Issuing Date',b'Utstedelsesdato'
+b'DocType: Student',b'Nationality',b'Nasjonalitet'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +109',b'Submit this Work Order for further processing.',b'Send inn denne arbeidsordren for videre behandling.'
+,b'Items To Be Requested',b'Elementer \xc3\xa5 bli forespurt'
+b'DocType: Purchase Order',b'Get Last Purchase Rate',b'F\xc3\xa5 siste kj\xc3\xb8p Ranger'
+b'DocType: Company',b'Company Info',b'Selskap Info'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +1385',b'Select or add new customer',b'Velg eller legg til ny kunde'
+b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +173',b'Cost center is required to book an expense claim',b'Kostnadssted er n\xc3\xb8dvendig \xc3\xa5 bestille en utgift krav'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +9',b'Application of Funds (Assets)',b'Anvendelse av midler (aktiva)'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +6',b'This is based on the attendance of this Employee',b'Dette er basert p\xc3\xa5 tilstedev\xc3\xa6relse av denne Employee'
+b'DocType: Assessment Result',b'Summary',b'Sammendrag'
+b'apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +112',b'Mark Attendance',b'Mark Attendance'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +494',b'Debit Account',b'Debet konto'
+b'DocType: Fiscal Year',b'Year Start Date',b'\xc3\x85r Startdato'
+b'DocType: Attendance',b'Employee Name',b'Ansattes Navn'
+b'DocType: Restaurant Order Entry Item',b'Restaurant Order Entry Item',b'Restaurant Bestillingsinngang'
+b'DocType: Purchase Invoice',b'Rounded Total (Company Currency)',b'Avrundet Total (Selskap Valuta)'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +96',b'Cannot covert to Group because Account Type is selected.',b'Kan ikke covert til konsernet fordi Kontotype er valgt.'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +260',b'{0} {1} has been modified. Please refresh.',b'{0} {1} har blitt endret. Vennligst oppdater.'
+b'DocType: Leave Block List',b'Stop users from making Leave Applications on following days.',b'Stoppe brukere fra \xc3\xa5 gj\xc3\xb8re La Applications p\xc3\xa5 f\xc3\xb8lgende dager.'
+b'DocType: Asset Maintenance Team',b'Maintenance Team Members',b'Vedlikeholdsteammedlemmer'
+b'apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +63',b'Purchase Amount',b'kj\xc3\xb8pesummen'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +261',b'Supplier Quotation {0} created',b'Leverand\xc3\xb8r sitat {0} er opprettet'
+b'apps/erpnext/erpnext/accounts/report/financial_statements.py +103',b'End Year cannot be before Start Year',b'Slutt \xc3\x85r kan ikke v\xc3\xa6re f\xc3\xb8r start \xc3\x85r'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +234',b'Employee Benefits',b'Ytelser til ansatte'
+b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +264',b'Packed quantity must equal quantity for Item {0} in row {1}',b'Pakket mengde m\xc3\xa5 v\xc3\xa6re lik mengde for Element {0} i rad {1}'
+b'DocType: Work Order',b'Manufactured Qty',b'Produsert Antall'
+b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +78',"b""The shares don't exist with the {0}""",b'Aksjene eksisterer ikke med {0}'
+b'apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +64',b'Invoice Created',b'Faktura er opprettet'
+b'DocType: Asset',b'Out of Order',b'I ustand'
+b'DocType: Purchase Receipt Item',b'Accepted Quantity',b'Akseptert Antall'
+b'DocType: Projects Settings',b'Ignore Workstation Time Overlap',b'Ignorer arbeidsstasjonstidoverlapping'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +242',b'Please set a default Holiday List for Employee {0} or Company {1}',b'Vennligst angi en standard Holiday Liste for Employee {0} eller selskapet {1}'
+b'apps/erpnext/erpnext/accounts/party.py +30',b'{0}: {1} does not exists',b'{0}: {1} ikke eksisterer'
+b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +76',b'Select Batch Numbers',b'Velg batchnumre'
+b'apps/erpnext/erpnext/config/accounts.py +12',b'Bills raised to Customers.',b'Regninger hevet til kundene.'
+b'apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26',b'Project Id',b'Prosjekt Id'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +534',b'Row No {0}: Amount cannot be greater than Pending Amount against Expense Claim {1}. Pending Amount is {2}',b'Row Nei {0}: Bel\xc3\xb8pet kan ikke v\xc3\xa6re st\xc3\xb8rre enn utest\xc3\xa5ende bel\xc3\xb8pet mot Expense krav {1}. Avventer Bel\xc3\xb8p er {2}'
+b'DocType: Patient Service Unit',b'Medical Administrator',b'Medisinsk administrator'
+b'DocType: Assessment Plan',b'Schedule',b'Tidsplan'
+b'DocType: Account',b'Parent Account',b'Parent konto'
+b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +266',b'Available',b'Tilgjengelig'
+b'DocType: Quality Inspection Reading',b'Reading 3',b'Reading 3'
+b'DocType: Stock Entry',b'Source Warehouse Address',b'Source Warehouse Adresse'
+,b'Hub',b'Hub'
+b'DocType: GL Entry',b'Voucher Type',b'Kupong Type'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +1717',b'Price List not found or disabled',b'Prisliste ikke funnet eller deaktivert'
+b'DocType: Student Applicant',b'Approved',b'Godkjent'
+b'apps/erpnext/erpnext/public/js/pos/pos_selected_item.html +15',b'Price',b'Pris'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +267',"b""Employee relieved on {0} must be set as 'Left'""",b'Ansatt lettet p\xc3\xa5 {0} m\xc3\xa5 v\xc3\xa6re angitt som &quot;venstre&quot;'
+b'DocType: Hub Settings',b'Last Sync On',b'Sist synk p\xc3\xa5'
+b'DocType: Guardian',b'Guardian',b'Guardian'
+b'DocType: Opening Invoice Creation Tool',b'Create missing customer or supplier.',b'Opprett manglende kunde eller leverand\xc3\xb8r.'
+b'apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +42',b'Appraisal {0} created for Employee {1} in the given date range',b'Appraisal {0} skapt for Employee {1} i den gitte datointervall'
+b'DocType: Academic Term',b'Education',b'Utdanning'
+b'apps/erpnext/erpnext/public/js/pos/pos.html +89',b'Del',b'del'
+b'DocType: Selling Settings',b'Campaign Naming By',b'Kampanje Naming Av'
+b'DocType: Employee',b'Current Address Is',b'Gjeldende adresse Er'
+b'apps/erpnext/erpnext/utilities/user_progress.py +51',b'Monthly Sales Target (',b'M\xc3\xa5nedlig salgsm\xc3\xa5l ('
+b'DocType: Physician Service Unit Schedule',b'Physician Service Unit Schedule',b'Leger Service Unit Schedule'
+b'apps/erpnext/erpnext/templates/includes/projects/project_tasks.html +9',b'modified',b'modifisert'
+b'apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +43',"b""Optional. Sets company's default currency, if not specified.""","b'Valgfritt. Setter selskapets standardvaluta, hvis ikke spesifisert.'"
+b'DocType: Sales Invoice',b'Customer GSTIN',b'Kunde GSTIN'
+b'DocType: Crop Cycle',"b""List of diseases detected on the field. When selected it'll automatically add a list of tasks to deal with the disease ""","b'Liste over sykdommer oppdaget p\xc3\xa5 feltet. N\xc3\xa5r den er valgt, vil den automatisk legge til en liste over oppgaver for \xc3\xa5 h\xc3\xa5ndtere sykdommen'"
+b'DocType: Asset Repair',b'Repair Status',b'Reparasjonsstatus'
+b'apps/erpnext/erpnext/config/accounts.py +67',b'Accounting journal entries.',b'Regnskap posteringer.'
+b'DocType: Delivery Note Item',b'Available Qty at From Warehouse',b'Tilgjengelig Antall p\xc3\xa5 From Warehouse'
+b'DocType: POS Profile',b'Account for Change Amount',b'Konto for Change Bel\xc3\xb8p'
+b'DocType: Purchase Invoice',b'input service',b'inntjeningstjeneste'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +217',b'Row {0}: Party / Account does not match with {1} / {2} in {3} {4}',b'Rad {0}: Party / Account samsvarer ikke med {1} / {2} i {3} {4}'
+b'DocType: Maintenance Team Member',b'Maintenance Team Member',b'Vedlikeholdsteammedlem'
+b'DocType: Agriculture Analysis Criteria',b'Soil Analysis',b'Jordanalyse'
+b'apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +13',b'Course Code: ',b'Bankkode:'
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +240',b'Please enter Expense Account',b'Skriv inn Expense konto'
+b'DocType: Account',b'Stock',b'Lager'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1095',"b'Row #{0}: Reference Document Type must be one of Purchase Order, Purchase Invoice or Journal Entry'","b'Row # {0}: Reference Document Type m\xc3\xa5 v\xc3\xa6re en av innkj\xc3\xb8psordre, faktura eller bilagsregistrering'"
+b'DocType: Employee',b'Current Address',b'N\xc3\xa5v\xc3\xa6rende Adresse'
+b'DocType: Item',"b'If item is a variant of another item then description, image, pricing, taxes etc will be set from the template unless explicitly specified'","b'Hvis elementet er en variant av et annet element da beskrivelse, image, priser, avgifter osv vil bli satt fra malen uten eksplisitt spesifisert'"
+b'DocType: Serial No',b'Purchase / Manufacture Details',b'Kj\xc3\xb8p / Produksjon Detaljer'
+b'DocType: Assessment Group',b'Assessment Group',b'Assessment Group'
+b'apps/erpnext/erpnext/config/stock.py +329',b'Batch Inventory',b'Batch Lager'
+b'DocType: Employee',b'Contract End Date',b'Kontraktssluttdato'
+b'DocType: Sales Order',b'Track this Sales Order against any Project',b'Spor dette Salgsordre mot ethvert prosjekt'
+b'DocType: Sales Invoice Item',b'Discount and Margin',b'Rabatt og Margin'
+b'DocType: Lab Test',b'Prescription',b'Resept'
+b'DocType: Project',b'Second Email',b'Andre e-post'
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +111',b'Not Available',b'Ikke Tilgjengelig'
+b'DocType: Pricing Rule',b'Min Qty',b'Min Antall'
+b'apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +36',b'Disable Template',b'Deaktiver mal'
+b'DocType: GL Entry',b'Transaction Date',b'Transaksjonsdato'
+b'DocType: Production Plan Item',b'Planned Qty',b'Planlagt Antall'
+b'apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +121',b'Total Tax',b'Total Skatte'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +204',b'For Quantity (Manufactured Qty) is mandatory',b'For Mengde (Produsert Stk) er obligatorisk'
+b'DocType: Stock Entry',b'Default Target Warehouse',b'Standard Target Warehouse'
+b'DocType: Purchase Invoice',b'Net Total (Company Currency)',b'Net Total (Selskap Valuta)'
+b'apps/erpnext/erpnext/education/doctype/academic_year/academic_year.py +14',b'The Year End Date cannot be earlier than the Year Start Date. Please correct the dates and try again.',"b'\xc3\x85ret Sluttdatoen kan ikke v\xc3\xa6re tidligere enn \xc3\xa5ret startdato. Korriger datoene, og pr\xc3\xb8v igjen.'"
+b'DocType: Notification Control',b'Purchase Receipt Message',b'Kvitteringen Message'
+b'DocType: BOM',b'Scrap Items',b'skrap Items'
+b'DocType: Work Order',b'Actual Start Date',b'Faktisk startdato'
+b'DocType: Sales Order',b'% of materials delivered against this Sales Order',b'% Av materialer leveres mot denne kundeordre'
+b'apps/erpnext/erpnext/config/manufacturing.py +18',b'Generate Material Requests (MRP) and Work Orders.',b'Generere materialforesp\xc3\xb8rsler (MRP) og arbeidsordre.'
+b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +62',b'Set default mode of payment',b'Angi standard betalingsm\xc3\xa5te'
+b'DocType: Grant Application',b'Withdrawn',b'Tilbaketrukket'
+b'DocType: Hub Settings',b'Hub Settings',b'Hub-innstillinger'
+b'DocType: Project',b'Gross Margin %',b'Bruttomargin%'
+b'DocType: BOM',b'With Operations',b'Med Operations'
+b'apps/erpnext/erpnext/accounts/party.py +259',b'Accounting entries have already been made in currency {0} for company {1}. Please select a receivable or payable account with currency {0}.',b'Regnskapspostene har allerede blitt gjort i valuta {0} for selskap {1}. Vennligst velg en fordring eller betales konto med valuta {0}.'
+b'DocType: Asset',b'Is Existing Asset',b'Er Eksisterende Asset'
+b'DocType: Salary Detail',b'Statistical Component',b'Statistisk komponent'
+b'DocType: Salary Detail',b'Statistical Component',b'Statistisk komponent'
+b'DocType: Warranty Claim',b'If different than customer address',b'Hvis annerledes enn kunden adresse'
+b'DocType: Purchase Invoice',b'Without Payment of Tax',b'Uten betaling av skatt'
+b'DocType: BOM Operation',b'BOM Operation',b'BOM Operation'
+b'apps/erpnext/erpnext/config/stock.py +141',b'Fulfilment',b'Oppfyllelse'
+b'DocType: Purchase Taxes and Charges',b'On Previous Row Amount',b'P\xc3\xa5 Forrige Row Bel\xc3\xb8p'
+b'DocType: Item',b'Has Expiry Date',b'Har utl\xc3\xb8psdato'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.js +282',b'Transfer Asset',b'Transfer Asset'
+b'DocType: POS Profile',b'POS Profile',b'POS Profile'
+b'DocType: Training Event',b'Event Name',b'Aktivitetsnavn'
+b'DocType: Physician',b'Phone (Office)',b'Telefon (kontor)'
+b'apps/erpnext/erpnext/hooks.py +151',b'Admission',b'Adgang'
+b'apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +29',b'Admissions for {0}',b'Innleggelser for {0}'
+b'apps/erpnext/erpnext/config/accounts.py +257',"b'Seasonality for setting budgets, targets etc.'","b'Sesong for \xc3\xa5 sette budsjetter, m\xc3\xa5l etc.'"
+b'DocType: Supplier Scorecard Scoring Variable',b'Variable Name',b'Variabelt navn'
+b'apps/erpnext/erpnext/stock/get_item_details.py +144',"b'Item {0} is a template, please select one of its variants'","b'Element {0} er en mal, kan du velge en av variantene'"
+b'DocType: Asset',b'Asset Category',b'Asset Kategori'
+b'apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +31',b'Net pay cannot be negative',b'Nettol\xc3\xb8nn kan ikke v\xc3\xa6re negativ'
+b'DocType: Purchase Order',b'Advance Paid',b'Advance Betalt'
+b'DocType: Item',b'Item Tax',b'Sak Skatte'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +883',b'Material to Supplier',b'Materiale til Leverand\xc3\xb8r'
+b'DocType: Soil Texture',b'Loamy Sand',b'Loamy Sand'
+b'DocType: Production Plan',b'Material Request Planning',b'Material Request Planning'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +638',b'Excise Invoice',b'Vesenet Faktura'
+b'apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py +16',b'Treshold {0}% appears more than once',b'Treshold {0}% kommer mer enn \xc3\xa9n gang'
+b'DocType: Expense Claim',b'Employees Email Id',b'Ansatte Email Id'
+b'DocType: Employee Attendance Tool',b'Marked Attendance',b'merket Oppm\xc3\xb8te'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +138',b'Current Liabilities',b'Kortsiktig gjeld'
+b'apps/erpnext/erpnext/config/selling.py +297',b'Send mass SMS to your contacts',b'Sende masse SMS til kontaktene dine'
+b'DocType: Patient',b'A Positive',b'En positiv'
+b'DocType: Program',b'Program Name',b'Programnavn'
+b'DocType: Purchase Taxes and Charges',b'Consider Tax or Charge for',b'Tenk Skatte eller Charge for'
+b'DocType: Driver',b'Driving License Category',b'Kj\xc3\xb8relisens kategori'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +158',b'No Reference',b'Ingen referanse'
+b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +57',b'Actual Qty is mandatory',b'Selve Antall er obligatorisk'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +92',"b'{0} currently has a {1} Supplier Scorecard standing, and Purchase Orders to this supplier should be issued with caution.'","b'{0} har for \xc3\xb8yeblikket en {1} leverand\xc3\xb8r scorecard, og innkj\xc3\xb8psordre til denne leverand\xc3\xb8ren skal utstedes med forsiktighet.'"
+b'DocType: Asset Maintenance Team',b'Asset Maintenance Team',b'Asset Maintenance Team'
+b'DocType: Employee Loan',b'Loan Type',b'l\xc3\xa5ne~~POS=TRUNC'
+b'DocType: Scheduling Tool',b'Scheduling Tool',b'planlegging Tool'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +180',b'Credit Card',b'Kredittkort'
+b'DocType: BOM',b'Item to be manufactured or repacked',b'Elementet som skal produseres eller pakkes'
+b'DocType: Employee Education',b'Major/Optional Subjects',b'Store / valgfrie emner'
+b'DocType: Sales Invoice Item',b'Drop Ship',b'Drop Ship'
+b'DocType: Driver',b'Suspended',b'suspendert'
+b'DocType: Training Event',b'Attendees',b'Deltakere'
+b'DocType: Employee',"b'Here you can maintain family details like name and occupation of parent, spouse and children'","b'Her kan du opprettholde familie informasjon som navn og okkupasjon av foreldre, ektefelle og barn'"
+b'DocType: Academic Term',b'Term End Date',b'Term Sluttdato'
+b'DocType: Purchase Invoice',b'Taxes and Charges Deducted (Company Currency)',b'Skatter og avgifter fratrukket (Company Valuta)'
+b'DocType: Item Group',b'General Settings',b'Generelle Innstillinger'
+b'apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py +23',b'From Currency and To Currency cannot be same',b'Fra Valuta og til valuta kan ikke v\xc3\xa6re det samme'
+b'DocType: Stock Entry',b'Repack',b'Pakk'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +6',b'You must Save the form before proceeding',b'Du m\xc3\xa5 Lagre skjemaet f\xc3\xb8r du fortsetter'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +113',b'Please select the Company first',b'Vennligst velg selskapet f\xc3\xb8rst'
+b'DocType: Item Attribute',b'Numeric Values',b'Numeriske verdier'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +56',b'Attach Logo',b'Fest Logo'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +51',b'Stock Levels',b'lagerniv\xc3\xa5er'
+b'DocType: Customer',b'Commission Rate',b'Kommisjon'
+b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +187',b'Created {0} scorecards for {1} between: ',b'Lagde {0} scorecards for {1} mellom:'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +505',b'Make Variant',b'Gj\xc3\xb8r Variant'
+b'apps/erpnext/erpnext/config/hr.py +87',b'Block leave applications by department.',b'Block permisjon applikasjoner ved avdelingen.'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +155',"b'Payment Type must be one of Receive, Pay and Internal Transfer'","b'Betalingstype m\xc3\xa5 v\xc3\xa6re en av Motta, L\xc3\xb8nn og Internal Transfer'"
+b'apps/erpnext/erpnext/config/selling.py +184',b'Analytics',b'Analytics'
+b'apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html +25',b'Cart is Empty',b'Handlevognen er tom'
+b'DocType: Vehicle',b'Model',b'Modell'
+b'DocType: Work Order',b'Actual Operating Cost',b'Faktiske driftskostnader'
+b'DocType: Payment Entry',b'Cheque/Reference No',b'Sjekk / referansenummer'
+b'DocType: Soil Texture',b'Clay Loam',b'Clay Loam'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +81',b'Root cannot be edited.',b'Root kan ikke redigeres.'
+b'DocType: Item',b'Units of Measure',b'M\xc3\xa5leenheter'
+b'DocType: Manufacturing Settings',b'Allow Production on Holidays',b'Tillat Produksjonen p\xc3\xa5 helligdager'
+b'DocType: Sales Invoice',"b""Customer's Purchase Order Date""",b'Kundens Purchase Order Date'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +163',b'Capital Stock',b'Kapitalbeholdningen'
+b'DocType: Shopping Cart Settings',b'Show Public Attachments',b'Vis offentlige vedlegg'
+b'DocType: Packing Slip',b'Package Weight Details',b'Pakken vektdetaljer'
+b'DocType: Restaurant Reservation',b'Reservation Time',b'Reservasjonstid'
+b'DocType: Payment Gateway Account',b'Payment Gateway Account',b'Betaling Gateway konto'
+b'DocType: Shopping Cart Settings',b'After payment completion redirect user to selected page.',b'Etter betaling ferdigstillelse omdirigere brukeren til valgt side.'
+b'DocType: Company',b'Existing Company',b'eksisterende selskapet'
+b'DocType: Healthcare Settings',b'Result Emailed',b'Resultat sendt'
+b'apps/erpnext/erpnext/controllers/buying_controller.py +87',"b'Tax Category has been changed to ""Total"" because all the Items are non-stock items'",b'Skattekategori har blitt endret til &quot;Totalt&quot; fordi alle elementene er ikke-varelager'
+b'apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +103',b'Please select a csv file',b'Vennligst velg en csv-fil'
+b'DocType: Student Leave Application',b'Mark as Present',b'Merk som Present'
+b'DocType: Supplier Scorecard',b'Indicator Color',b'Indikatorfarge'
+b'DocType: Purchase Order',b'To Receive and Bill',b'\xc3\x85 motta og Bill'
+b'apps/erpnext/erpnext/controllers/buying_controller.py +445',b'Row #{0}: Reqd by Date cannot be before Transaction Date',b'Row # {0}: Reqd by Date kan ikke v\xc3\xa6re f\xc3\xb8r transaksjonsdato'
+b'apps/erpnext/erpnext/templates/pages/home.html +14',b'Featured Products',b'Utvalgte produkter'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +136',b'Designer',b'Designer'
+b'apps/erpnext/erpnext/config/selling.py +163',b'Terms and Conditions Template',b'Betingelser Mal'
+b'DocType: Serial No',b'Delivery Details',b'Levering Detaljer'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +495',b'Cost Center is required in row {0} in Taxes table for type {1}',b'Kostnadssted er n\xc3\xb8dvendig i rad {0} i skatter tabell for typen {1}'
+b'DocType: Program',b'Program Code',b'programkode'
+b'DocType: Terms and Conditions',b'Terms and Conditions Help',b'Betingelser Hjelp'
+,b'Item-wise Purchase Register',b'Element-messig Purchase Register'
+b'DocType: Driver',b'Expiry Date',b'Utl\xc3\xb8psdato'
+b'DocType: Healthcare Settings',b'Employee name and designation in print',b'Ansattes navn og betegnelse p\xc3\xa5 trykk'
+,b'accounts-browser',b'kontoer-browser'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +368',b'Please select Category first',b'Vennligst f\xc3\xb8rste velg kategori'
+b'apps/erpnext/erpnext/config/projects.py +13',b'Project master.',b'Prosjektet mester.'
+b'apps/erpnext/erpnext/controllers/status_updater.py +212',"b'To allow over-billing or over-ordering, update ""Allowance"" in Stock Settings or the Item.'","b'\xc3\x85 tillate overfakturering eller over-bestilling, oppdatere &quot;Fradrag&quot; p\xc3\xa5 lager Innstillinger eller elementet.'"
+b'DocType: Global Defaults',b'Do not show any symbol like $ etc next to currencies.',b'Ikke viser noen symbol som $ etc ved siden av valutaer.'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +431',b' (Half Day)',b'(Halv Dag)'
+b'DocType: Payment Term',b'Credit Days',b'Kreditt Days'
+b'apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +145',b'Please select Patient to get Lab Tests',b'Vennligst velg Pasient for \xc3\xa5 f\xc3\xa5 Lab Tests'
+b'apps/erpnext/erpnext/utilities/activation.py +128',b'Make Student Batch',b'Gj\xc3\xb8r Student Batch'
+b'DocType: Fee Schedule',b'FRQ.',b'FRQ.'
+b'DocType: Leave Type',b'Is Carry Forward',b'Er fremf\xc3\xb8ring'
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +841',b'Get Items from BOM',b'F\xc3\xa5 Elementer fra BOM'
+b'apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +40',b'Lead Time Days',b'Ledetid Days'
+b'DocType: Cash Flow Mapping',b'Is Income Tax Expense',b'Er inntektsskatt utgift'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +621',b'Row #{0}: Posting Date must be same as purchase date {1} of asset {2}',b'Row # {0}: konteringsdato m\xc3\xa5 v\xc3\xa6re det samme som kj\xc3\xb8psdato {1} av eiendelen {2}'
+b'DocType: Program Enrollment',"b""Check this if the Student is residing at the Institute's Hostel.""",b'Sjekk dette hvis studenten er bosatt ved instituttets Hostel.'
+b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +125',b'Please enter Sales Orders in the above table',b'Fyll inn salgsordrer i tabellen ovenfor'
+,b'Stock Summary',b'Stock oppsummering'
+b'apps/erpnext/erpnext/config/assets.py +54',b'Transfer an asset from one warehouse to another',b'Overf\xc3\xb8r en eiendel fra en lagerbygning til en annen'
+b'DocType: Vehicle',b'Petrol',b'Bensin'
+b'apps/erpnext/erpnext/config/learn.py +217',b'Bill of Materials',b'Bill of Materials'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +105',b'Row {0}: Party Type and Party is required for Receivable / Payable account {1}',b'Rad {0}: Party Type og Party er n\xc3\xb8dvendig for fordringer / gjeld kontoen {1}'
+b'apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +94',b'Ref Date',b'Ref Dato'
+b'DocType: Employee',b'Reason for Leaving',b'Grunn til \xc3\xa5 forlate'
+b'DocType: BOM Operation',b'Operating Cost(Company Currency)',b'Driftskostnader (Selskap Valuta)'
+b'DocType: Employee Loan Application',b'Rate of Interest',b'Rente'
+b'DocType: Expense Claim Detail',b'Sanctioned Amount',b'Sanksjonert Bel\xc3\xb8p'
+b'DocType: Item',b'Shelf Life In Days',b'Holdbarhet i dager'
+b'DocType: GL Entry',b'Is Opening',b'Er \xc3\x85pnings'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +196',b'Row {0}: Debit entry can not be linked with a {1}',b'Rad {0}: Debet oppf\xc3\xb8ring kan ikke v\xc3\xa6re knyttet til en {1}'
+b'DocType: Journal Entry',b'Subscription Section',b'Abonnementsseksjon'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +177',b'Account {0} does not exist',b'Konto {0} finnes ikke'
+b'DocType: Training Event',b'Training Program',b'Treningsprogram'
+b'DocType: Account',b'Cash',b'Kontanter'
+b'DocType: Employee',b'Short biography for website and other publications.',b'Kort biografi for hjemmeside og andre publikasjoner.'
