DocType: Accounting Period,Period Name,Periode Navn
DocType: Employee,Salary Mode,Lønn Mode
apps/erpnext/erpnext/public/js/hub/marketplace.js +109,Register,Registrere
DocType: Patient,Divorced,Skilt
DocType: Support Settings,Post Route Key,Legg inn rute nøkkel
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +89,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Vennligst oppsett nummereringsserie for Tilstedeværelse via Oppsett&gt; Nummereringsserie
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: Supplier Scorecard,Notify Supplier,Informer Leverandør
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.js +52,Please select Party Type first,Vennligst velg Partiet Type først
DocType: Item,Customer Items,Kunde Items
DocType: Project,Costing and Billing,Kalkulasjon og fakturering
apps/erpnext/erpnext/hr/doctype/employee_advance/employee_advance.py +43,Advance account currency should be same as company currency {0},Forhåndskonto valuta må være den samme som selskapets valuta {0}
apps/erpnext/erpnext/accounts/doctype/account/account.py +55,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/hr/doctype/leave_application/leave_application.py +271,Cannot find active Leave Period,Kan ikke finne aktiv permisjonstid
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +22,Evaluation,evaluering
DocType: Item,Default Unit of Measure,Standard måleenhet
DocType: SMS Center,All Sales Partner Contact,All Sales Partner Kontakt
DocType: Department,Leave Approvers,La godkjennere
DocType: Employee,Bio / Cover Letter,Bio / Cover Letter
DocType: Patient Encounter,Investigations,undersøkelser
DocType: Restaurant Order Entry,Click Enter To Add,Klikk på Enter for å legge til
apps/erpnext/erpnext/erpnext_integrations/doctype/shopify_settings/shopify_settings.py +29,"Missing value for Password, API Key or Shopify URL","Manglende verdi for Password, API Key eller Shopify URL"
DocType: Employee,Rented,Leide
apps/erpnext/erpnext/public/js/setup_wizard.js +243,All Accounts,Alle kontoer
apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py +15,Cannot transfer Employee with status Left,Kan ikke overføre medarbeider med status til venstre
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +216,"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 +338,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/hr/doctype/job_offer/job_offer.js +26,Show Employee,Vis medarbeider
DocType: Exchange Rate Revaluation Account,New Exchange Rate,Ny valutakurs
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +38,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: Delivery Trip,MAT-DT-.YYYY.-,MAT-DT-.YYYY.-
DocType: Purchase Order,Customer Contact,Kundekontakt
DocType: Patient Appointment,Check availability,Sjekk tilgjengelighet
DocType: Retention Bonus,Bonus Payment Date,Bonus Betalingsdato
DocType: Employee,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
DocType: Manufacturing Settings,Overproduction Percentage For Work Order,Overproduksjonsprosent for arbeidsordre
DocType: Landed Cost Voucher,MAT-LCV-.YYYY.-,MAT-LCV-.YYYY.-
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +362,Legal,Juridisk
DocType: Shopify Settings,Sales Order Series,Salgsordre Serie
DocType: Vital Signs,Tongue,Tunge
apps/erpnext/erpnext/hr/utils.py +221,"More than one selection for {0} not \
			allowed",Mer enn ett valg for {0} ikke \ tillatt
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +204,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: Allowed To Transact With,Allowed To Transact With,Tillat å transaksere med
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: Asset Category,Finance Book Detail,Finansbokdetaljer
DocType: Purchase Order,% Billed,% Fakturert
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +41,Exchange Rate must be same as {0} {1} ({2}),Exchange Rate må være samme som {0} {1} ({2})
DocType: Employee Tax Exemption Declaration,HRA Exemption,HRA-fritak
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: Employee Tax Exemption Declaration,HRA as per Salary Structure,HRA som per lønnsstruktur
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 +197,Outstanding for {0} cannot be less than zero ({1}),Enestående for {0} kan ikke være mindre enn null ({1})
apps/erpnext/erpnext/public/js/controllers/transaction.js +809,Service Stop Date cannot be before Service Start Date,Service Stop Date kan ikke være før service startdato
DocType: Manufacturing Settings,Default 10 mins,Standard 10 minutter
DocType: Leave Type,Leave Type Name,La Type Navn
apps/erpnext/erpnext/templates/pages/projects.js +62,Show open,Vis åpen
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +163,Series Updated Successfully,Serien er oppdatert
apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html +6,Checkout,Sjekk ut
apps/erpnext/erpnext/controllers/accounts_controller.py +770,{0} in row {1},{0} i rad {1}
DocType: Asset Finance Book,Depreciation Start Date,Avskrivning Startdato
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 +84,Expected End Date can not be less than Expected Start Date,Forventet Sluttdato kan ikke være mindre enn Tiltredelse
DocType: Amazon MWS Settings,Amazon MWS Settings,Amazon MWS Innstillinger
apps/erpnext/erpnext/utilities/transaction_base.py +115,Row #{0}: Rate must be same as {1}: {2} ({3} / {4}) ,Row # {0}: Pris må være samme som {1}: {2} ({3} / {4})
,Batch Item Expiry Status,Batch Element Utløps Status
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +160,Bank Draft,Bank Draft
DocType: Journal Entry,ACC-JV-.YYYY.-,ACC-JV-.YYYY.-
DocType: Mode of Payment Account,Mode of Payment Account,Modus for betaling konto
apps/erpnext/erpnext/config/healthcare.py +8,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 +21,Sales and Returns,Salg og retur
apps/erpnext/erpnext/stock/doctype/item/item.js +58,Show Variants,Vis Varianter
DocType: Academic Term,Academic Term,semester
DocType: Employee Tax Exemption Sub Category,Employee Tax Exemption Sub Category,Deltakelsesavgift for arbeidstakere
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py +14,Material,Materiale
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +71,Making website,Å lage nettside
apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py +58,"Maximum benefit of employee {0} exceeds {1} by the sum {2} of benefit application pro-rata component\
			amount and previous claimed amount",Maksimal nytte av arbeidstakeren {0} overstiger {1} med summen {2} av fordelingsprogrammet pro rata komponent \ beløp og tidligere påkrevd beløp
DocType: Opening Invoice Creation Tool Item,Quantity,Antall
,Customers Without Any Sales Transactions,Kunder uten salgstransaksjoner
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +590,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 +164,Loans (Liabilities),Lån (gjeld)
DocType: Patient Encounter,Encounter Time,Møtetid
DocType: Staffing Plan Detail,Total Estimated Cost,Totalt estimert kostnad
DocType: Employee Education,Year of Passing,Year of Passing
DocType: Routing,Routing Name,Rutingsnavn
DocType: Item,Country of Origin,Opprinnelsesland
DocType: Soil Texture,Soil Texture Criteria,Kriterier for jordstruktur
apps/erpnext/erpnext/templates/includes/product_page.js +34,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 Plan Item,Production Plan Item,Produksjonsplan Sak
apps/erpnext/erpnext/hr/doctype/employee/employee.py +159,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: Delivery Note,Issue Credit Note,Utstedelseskreditnotat
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 +1002,Serial Number: {0} is already referenced in Sales Invoice: {1},Serienummer: {0} er allerede referert i salgsfaktura: {1}
DocType: Bank Statement Transaction Invoice Item,Invoice,Faktura
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 +257,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 +78,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 +172,Please select Price List,Vennligst velg Prisliste
DocType: Accounts Settings,Currency Exchange Settings,Valutavekslingsinnstillinger
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +94,Row #{0}: Payment document is required to complete the trasaction,Row # {0}: Betaling dokumentet er nødvendig for å fullføre trasaction
DocType: Work 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: Item Price,Minimum Qty ,Minimum antall
DocType: Finance Book,Finance Book,Finansbok
DocType: Patient Encounter,HLC-ENC-.YYYY.-,HLC-ENC-.YYYY.-
DocType: Daily Work Summary Group,Holiday List,Holiday List
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +115,Accountant,Accountant
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +55,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 +62,Selling Rate,Selgingsfrekvens
DocType: Cost Center,Stock User,Stock User
DocType: Soil Analysis,(Ca+Mg)/K,(Ca + Mg) / K
DocType: Delivery Stop,Contact Information,Kontaktinformasjon
DocType: Company,Phone No,Telefonnr
DocType: Delivery Trip,Initial Email Notification Sent,Innledende e-postvarsling sendt
DocType: Bank Statement Settings,Statement Header Mapping,Statement Header Mapping
,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 +50,Abbreviation cannot have more than 5 characters,Forkortelse kan ikke ha mer enn fem tegn
DocType: Amazon MWS Settings,AU,AU
apps/erpnext/erpnext/accounts/doctype/payment_order/payment_order.js +7,Payment Request,Betaling Request
apps/erpnext/erpnext/config/accounts.py +56,To view logs of Loyalty Points assigned to a Customer.,For å vise logger over lojalitetspoeng som er tilordnet en kunde.
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 +46,Attendance date can not be less than employee's joining date,Oppmøte dato kan ikke være mindre enn ansattes bli dato
DocType: Grading Scale,Grading Scale Name,Grading Scale Name
apps/erpnext/erpnext/public/js/hub/marketplace.js +148,Add Users to Marketplace,Legg til brukere på markedsplassen
apps/erpnext/erpnext/accounts/doctype/account/account.js +37,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: Subscription,Subscription Start Date,Abonnements startdato
DocType: Healthcare Settings,Default receivable accounts to be used if not set in Patient to book Appointment charges.,Standardfordelbare kontoer som skal brukes hvis ikke satt inn i pasienten for å bestille avtalekostnader.
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/regional/report/eway_bill/eway_bill.py +192,From Address 2,Fra adresse 2
apps/erpnext/erpnext/accounts/utils.py +74,{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/accounts/report/consolidated_financial_statement/consolidated_financial_statement.py +360,{0} {1} is not present in the parent company,{0} {1} er ikke til stede i morselskapet
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +215,Trial Period End Date Cannot be before Trial Period Start Date,Prøveperiode Sluttdato kan ikke være før startdato for prøveperiode
apps/erpnext/erpnext/utilities/user_progress.py +146,Kg,Kg
DocType: Tax Withholding Category,Tax Withholding Category,Skattelettende kategori
apps/erpnext/erpnext/assets/doctype/asset_value_adjustment/asset_value_adjustment.py +23,Cancel the journal entry {0} first,Avbryt journalinngangen {0} først
DocType: Purchase Invoice,ACC-PINV-.YYYY.-,ACC-PINV-.YYYY.-
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +113,BOM is not specified for subcontracting item {0} at row {1},BOM er ikke spesifisert for underleverandørelementet {0} på rad {1}
DocType: Vital Signs,Reflexes,reflekser
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/templates/pages/search_help.py +13,Help Results for,Hjelpresultater for
apps/erpnext/erpnext/public/js/stock_analytics.js +58,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 +617,Get items from,Få elementer fra
DocType: Price List,Price Not UOM Dependant,Pris Ikke UOM Avhengig
DocType: Purchase Invoice,Apply Tax Withholding Amount,Påfør gjeldsbeløp
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +538,Stock cannot be updated against Delivery Note {0},Stock kan ikke oppdateres mot følgeseddel {0}
apps/erpnext/erpnext/accounts/report/tds_computation_summary/tds_computation_summary.py +124,Total Amount Credited,Totalt beløp krevet
apps/erpnext/erpnext/templates/pages/home.py +25,Product {0},Produkt {0}
apps/erpnext/erpnext/templates/generators/item_group.html +33,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
DocType: Exchange Rate Revaluation Account,Gain/Loss,Gevinst / tap
DocType: Crop,Perennial,Flerårig
DocType: Patient Appointment,Procedure,Fremgangsmåte
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 +1768,Not items found,Ikke elementer funnet
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +267,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 +284,"""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
,Completed Work Orders,Fullførte arbeidsordrer
DocType: Support Settings,Forum Posts,Foruminnlegg
apps/erpnext/erpnext/controllers/taxes_and_totals.py +598,Taxable Amount,Skattepliktig beløp
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +161,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: Leave Policy,Leave Policy Details,Legg til policyinformasjon
DocType: BOM,Item Image (if not slideshow),Sak Image (hvis ikke show)
DocType: Work Order Operation,(Hour Rate / 60) * Actual Operation Time,(Timepris / 60) * Faktisk Operation Tid
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1136,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 +1050,Select BOM,Velg BOM
DocType: SMS Log,SMS Log,SMS Log
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +27,Cost of Delivered Items,Kostnad for leverte varer
apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +39,The holiday on {0} is not between From Date and To Date,Ferien på {0} er ikke mellom Fra dato og Til dato
DocType: Inpatient Record,Admission Scheduled,Opptak planlagt
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/hr/report/employee_leave_balance/employee_leave_balance.py +27,Opening,Åpning
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +36,From {0} to {1},Fra {0} til {1}
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +234,Program: ,Program:
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: 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: 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 +145,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 +38,No leave record found for employee {0} for {1},Ingen forlater plate funnet for ansatt {0} og {1}
DocType: Company,Unrealized Exchange Gain/Loss Account,Urealisert Exchange Gain / Loss-konto
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 +626,Please select Company first,Vennligst velg selskapet først
DocType: Employee Education,Under Graduate,Under Graduate
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +291,Please set default template for Leave Status Notification in HR Settings.,Vennligst angi standardmal for statusmeldingsstatus i HR-innstillinger.
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: Salary Slip,Employee Loan,Medarbeider Loan
DocType: Additional Salary,HR-ADS-.YY.-.MM.-,HR-ADS-.YY .-. MM.-
DocType: Fee Schedule,Send Payment Request Email,Send betalingsanmodning e-post
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +277,Item {0} does not exist in the system or has expired,Element {0} finnes ikke i systemet eller er utløpt
DocType: Supplier,Leave blank if the Supplier is blocked indefinitely,La være tom hvis leverandøren er blokkert på ubestemt tid
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 +351,"Available qty is {0}, you need {1}","Tilgjengelig stk er {0}, må du {1}"
DocType: Expense Claim Detail,Claim Amount,Krav Beløp
DocType: Patient,HLC-PAT-.YYYY.-,HLC-PAT-.YYYY.-
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +644,Work Order has been {0},Arbeidsordre har vært {0}
DocType: Budget,Applicable on Purchase Order,Gjelder på innkjøpsordre
DocType: Item,STO-ITEM-.YYYY.-,STO-SAK-.YYYY.-
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
DocType: Location,Location Name,Stedsnavn
DocType: Naming Series,Prefix,Prefix
apps/erpnext/erpnext/hr/notification/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 +71,Consumable,Konsum
DocType: Student,B-,B-
DocType: Assessment Result,Grade,grade
DocType: Restaurant Table,No of Seats,Antall plasser
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/setup/setup_wizard/operations/install_fixtures.py +213,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 +424,{0} {1} is frozen,{0} {1} er frosset
apps/erpnext/erpnext/setup/doctype/company/company.py +152,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 +84,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 +87,Please enter Preferred Contact Email,Fyll inn foretrukne e-
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 +136,"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 +421,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: Item,Supply Raw Materials for Purchase,Leverer råvare til Purchase
DocType: Agriculture Analysis Criteria,Fertilizer,Gjødsel
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +427,"Cannot ensure delivery by Serial No as \
				Item {0} is added with and without Ensure Delivery by \
				Serial No.",Kan ikke garantere levering med serienummer som \ Item {0} er lagt til med og uten Sikre Levering med \ Serienr.
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +203,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: Bank Statement Transaction Invoice Item,Bank Statement Transaction Invoice Item,Bankkonto Transaksjonsfaktura
DocType: Products Settings,Show Products as a List,Vis produkter på en liste
DocType: Salary Detail,Tax on flexible benefit,Skatt på fleksibel fordel
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.py +43,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 +190,Example: Basic Mathematics,Eksempel: Grunnleggende matematikk
DocType: Customer,Primary Address,hoved adresse
apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.py +39,Diff Qty,Diff Antall
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 +868,"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"
DocType: SMS Center,SMS Center,SMS-senter
DocType: Payroll Entry,Validate Attendance,Bekreft tilstedeværelse
DocType: Sales Invoice,Change Amount,endring Beløp
DocType: Party Tax Withholding Config,Certificate Received,Sertifikat mottatt
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/healthcare/doctype/patient_appointment/patient_appointment.js +243,Prescribed Procedures,Foreskrevne prosedyrer
apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js +36,Show only POS,Vis bare POS
DocType: Supplier Group,Supplier Group Name,Leverandørgruppens navn
DocType: Driver,Driving License Categories,Kjørelisenskategorier
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +123,Please enter Delivery Date,Vennligst oppgi Leveringsdato
DocType: Depreciation Schedule,Make Depreciation Entry,Gjør Avskrivninger Entry
DocType: Closed Document,Closed Document,Lukket dokument
DocType: HR Settings,Leave Settings,Forlat innstillinger
apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.js +76,Number of positions cannot be less then current count of employees,Antall stillinger kan ikke være mindre enn nåværende antall ansatte
DocType: Appraisal Template Goal,KRA,KRA
DocType: Lead,Request Type,Forespørsel Type
DocType: Purpose of Travel,Purpose of Travel,Hensikt med reisen
DocType: Payroll Period,Payroll Periods,Lønn Perioder
apps/erpnext/erpnext/hr/doctype/job_offer/job_offer.js +18,Make Employee,Gjør Employee
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +14,Broadcasting,Kringkasting
apps/erpnext/erpnext/config/accounts.py +351,Setup mode of POS (Online / Offline),Oppsettmodus for POS (Online / Offline)
DocType: Manufacturing Settings,Disables creation of time logs against Work Orders. Operations shall not be tracked against Work Order,Deaktiverer opprettelse av tidslogger mot arbeidsordre. Operasjoner skal ikke spores mot arbeidsordre
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +167,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: Patient Medical Record,HLC-PMR-.YYYY.-,HLC-PMR-.YYYY.-
DocType: Drug Prescription,Interval,intervall
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +234,Preference,Preference
DocType: Supplier,Individual,Individuell
DocType: Academic Term,Academics User,akademikere Bruker
DocType: Cheque Print Template,Amount In Figure,Beløp I figur
DocType: 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: Support Settings,Search APIs,Søk APIer
DocType: Share Transfer,Share Transfer,Del overføring
,Expiring Memberships,Utløpende medlemsskap
DocType: POS Profile,Customer Groups,kunde~~POS=TRUNC grupper~~POS=HEADCOMP
apps/erpnext/erpnext/public/js/financial_statements.js +53,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: Practitioner 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
DocType: Shift Assignment,Shift Request,Skiftforespørsel
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
DocType: Job Offer,Select Terms and Conditions,Velg Vilkår
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +80,Out Value,ut Verdi
DocType: Bank Statement Settings Item,Bank Statement Settings Item,Innstillingsinnstillinger for bankkontoen
DocType: Woocommerce Settings,Woocommerce Settings,Innstillinger for WoCommerce
DocType: Production Plan,Sales Orders,Salgsordrer
apps/erpnext/erpnext/selling/doctype/customer/customer.py +203,Multiple Loyalty Program found for the Customer. Please select manually.,Flere lojalitetsprogram funnet for kunden. Vennligst velg manuelt.
DocType: Purchase Taxes and Charges,Valuation,Verdivurdering
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +436,Set as Default,Satt som standard
,Purchase Order Trends,Innkjøpsordre Trender
apps/erpnext/erpnext/utilities/user_progress.py +78,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
DocType: SG Creation Tool Course,SG Creation Tool Course,SG Creation Tool Course
DocType: Bank Statement Transaction Invoice Item,Payment Description,Betalingsbeskrivelse
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +353,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 Account,Bank Account,Bankkonto
DocType: Travel Itinerary,Check-out Date,Utsjekkingsdato
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;
apps/erpnext/erpnext/public/js/utils.js +254,Select Alternate Item,Velg alternativt element
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: Work Order Operation,Updated via 'Time Log',Oppdatert via &#39;Time Logg&#39;
apps/erpnext/erpnext/accounts/doctype/bank_guarantee/bank_guarantee.py +13,Select the customer or supplier.,Velg kunden eller leverandøren.
apps/erpnext/erpnext/controllers/taxes_and_totals.py +444,Advance amount cannot be greater than {0} {1},Advance beløpet kan ikke være større enn {0} {1}
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js +55,"Time slot skiped, the slot {0} to {1} overlap exisiting slot {2} to {3}","Tidsluke hoppet over, sporet {0} til {1} overlapper eksisterende spor {2} til {3}"
DocType: Naming Series,Series List for this Transaction,Serien Liste for denne transaksjonen
DocType: Company,Enable Perpetual Inventory,Aktiver evigvarende beholdning
DocType: Bank Guarantee,Charges Incurred,Avgifter opphørt
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: Company,Arrear Component,Arrear Component
DocType: Supplier Scorecard,Criteria Setup,Kriterieoppsett
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +199,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: Codification Table,Medical Code,Medisinsk kode
apps/erpnext/erpnext/config/integrations.py +37,Connect Amazon with ERPNext,Koble Amazon med ERPNext
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
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +98,Net Cash from Financing,Netto kontantstrøm fra finansierings
apps/erpnext/erpnext/accounts/page/pos/pos.js +2386,"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: Party Tax Withholding Config,Party Tax Withholding Config,Party Tax Withholding Config
DocType: Lab Test,Custom Result,Tilpasset resultat
DocType: Delivery Stop,Contact Name,Kontakt Navn
DocType: Course Assessment Criteria,Course Assessment Criteria,Kursvurderingskriteriene
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +31,Tax Id: ,Skatte-ID:
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +216,Student ID: ,Student ID:
DocType: POS Customer Group,POS Customer Group,POS Kundegruppe
DocType: Healthcare Practitioner,Practitioner Schedules,Utøverplaner
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: POS Closing Voucher Details,Collected Amount,Samlet belø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
,Open Work Orders,Åpne arbeidsordre
DocType: Healthcare Practitioner,Out Patient Consulting Charge Item,Out Patient Consulting Charge Item
DocType: Payment Term,Credit Months,Kredittmåneder
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +494,Net Pay cannot be less than 0,Nettolønn kan ikke være mindre enn 0
DocType: Contract,Fulfilled,Oppfylt
DocType: Inpatient Record,Discharge Scheduled,Utslipp planlagt
apps/erpnext/erpnext/hr/doctype/employee/employee.py +131,Relieving Date must be greater than Date of Joining,Lindrende Dato må være større enn tidspunktet for inntreden
DocType: POS Closing Voucher,Cashier,Kasserer
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +221,Leaves per Year,Later per år
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +162,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 +243,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 +147,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 +76,Please setup Students under Student Groups,Vennligst oppsett Studentene under Student Grupper
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.js +31,Complete Job,Fullstendig jobb
DocType: Item Website Specification,Item Website Specification,Sak Nettsted Spesifikasjon
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +546,Leave Blocked,La Blokkert
apps/erpnext/erpnext/stock/doctype/item/item.py +798,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 +82,Bank Entries,Bank Entries
DocType: Customer,Is Internal Customer,Er intern kunde
DocType: Crop,Annual,Årlig
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js +27,"If Auto Opt In is checked, then the customers will be automatically linked with the concerned Loyalty Program (on save)","Hvis Auto Opt In er merket, blir kundene automatisk koblet til det berørte lojalitetsprogrammet (ved lagring)"
DocType: Stock Reconciliation Item,Stock Reconciliation Item,Stock Avstemming Element
DocType: Stock Entry,Sales Invoice No,Salg Faktura Nei
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +142,Supply Type,Forsyningstype
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 +210,People who teach at your organisation,Folk som underviser i organisasjonen
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +123,Software Developer,Programvareutvikler
DocType: Item,Minimum Order Qty,Minimum Antall
DocType: Supplier,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 +820,Item {0} is cancelled,Element {0} er kansellert
apps/erpnext/erpnext/assets/doctype/asset/asset.py +206,Depreciation Row {0}: Depreciation Start Date is entered as past date,Avskrivningsrute {0}: Avskrivnings startdato er oppgitt som siste dato
DocType: Contract Template,Fulfilment Terms and Conditions,Oppfyllingsvilkår
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1067,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 +490,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
,BOM Variance Report,BOM Variansrapport
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
DocType: Inpatient Record,Admitted Datetime,Admitted Datetime
DocType: Work Order,Backflush raw materials from work-in-progress warehouse,Backflush råmaterialer fra lager i gang
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +79,Open Orders,Åpne bestillinger
apps/erpnext/erpnext/healthcare/setup.py +187,Low Sensitivity,Lav følsomhet
apps/erpnext/erpnext/erpnext_integrations/doctype/shopify_log/shopify_log.js +16,Order rescheduled for sync,Ordre omlagt for synkronisering
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 +308,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}
apps/erpnext/erpnext/patches/v11_0/add_healthcare_service_unit_tree_root.py +9,All Healthcare Service Units,Alle helsevesenetjenestene
DocType: Bank Account,Address HTML,Adresse HTML
DocType: Lead,Mobile No.,Mobile No.
apps/erpnext/erpnext/selling/doctype/pos_closing_voucher/closing_voucher_details.html +35,Mode of Payments,Betalingsmåte
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 +149,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 +42,Latest,Siste
DocType: Asset Maintenance Task,2 Yearly,2 årlig
DocType: Education Settings,Education Settings,Utdanning Innstillinger
DocType: Vehicle Service,Inspection,Undersøkelse
DocType: Leave Allocation,HR-LAL-.YYYY.-,HR-LAL-.YYYY.-
DocType: Exchange Rate Revaluation Account,Balance In Base Currency,Balanse i basisvaluta
DocType: Supplier Scorecard Scoring Standing,Max Grade,Maksimal karakter
DocType: Email Digest,New Quotations,Nye Sitater
apps/erpnext/erpnext/hr/doctype/attendance_request/attendance_request.py +60,Attendance not submitted for {0} as {1} on leave.,Tilstedeværelse ikke sendt for {0} som {1} på permisjon.
DocType: Journal Entry,Payment Order,Betalingsordre
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: Tax Rule,Shipping County,Shipping fylke
DocType: Currency Exchange,For Selling,For Selg
apps/erpnext/erpnext/config/desktop.py +159,Learn,Lære
DocType: Purchase Invoice Item,Enable Deferred Expense,Aktiver utsatt utgift
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 +794,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 +566,Row #{0}: {1} can not be negative for item {2},Rad # {0}: {1} ikke kan være negativ for elementet {2}
apps/erpnext/erpnext/setup/doctype/company/company.js +129,Wrong Password,Feil Passord
DocType: Stock Reconciliation,MAT-RECO-.YYYY.-,MAT-RECO-.YYYY.-
DocType: Item,Variant Of,Variant av
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +387,Completed Qty can not be greater than 'Qty to Manufacture',Fullført Antall kan ikke være større enn &quot;Antall å Manufacture &#39;
DocType: Period Closing Voucher,Closing Account Head,Lukke konto Leder
DocType: Employee,External Work History,Ekstern Work History
apps/erpnext/erpnext/projects/doctype/task/task.py +111,Circular Reference Error,Rundskriv Reference Error
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +206,Student Report Card,Studentrapportkort
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +204,From Pin Code,Fra Pin Code
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: BOM Item,Rate & Amount,Pris og beløp
DocType: BOM,Transfer Material Against Job Card,Overfør materiale mot jobbkort
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 +191,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: Bank Statement Transaction Invoice Item,Invoice Type,Faktura Type
DocType: Employee Benefit Claim,Expense Proof,Utgiftsbevis
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +990,Delivery Note,Levering Note
DocType: Patient Encounter,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 +149,Cost of Sold Asset,Cost of Selges Asset
DocType: Volunteer,Morning,Morgen
apps/erpnext/erpnext/accounts/utils.py +374,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 +496,{0} entered twice in Item Tax,{0} registrert to ganger i pkt Skatte
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +121,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 +116,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 +114,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
DocType: Certified Consultant,Certified Consultant,Sertifisert konsulent
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 +57,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
DocType: Certification Application,Not Certified,Ikke sertifisert
DocType: Asset Value Adjustment,New Asset Value,Ny aktiv verdi
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 +682,Row #{0}: Purchase Invoice cannot be made against an existing asset {1},Row # {0}: Kjøp Faktura kan ikke gjøres mot en eksisterende eiendel {1}
DocType: Crop Cycle,LInked Analysis,Analyse
DocType: POS Closing Voucher,POS Closing Voucher,POS Closing Voucher
DocType: Contract,Lapsed,bortfalt
DocType: Item Tax,Tax Rate,Skattesats
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +107,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 +73,{0} already allocated for Employee {1} for period {2} to {3},{0} allerede bevilget for Employee {1} for perioden {2} til {3}
DocType: Buying Settings,Backflush Raw Materials of Subcontract Based On,Backflush råmaterialer av underleverandør basert på
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +145,Purchase Invoice {0} is already submitted,Fakturaen {0} er allerede sendt
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +90,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
DocType: Leave Type,Allow Encashment,Tillat Encashment
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +101,Convert to non-Group,Konverter til ikke-konsernet
DocType: Project Update,Good/Steady,Good / Steady
DocType: Bank Statement Transaction Invoice Item,Invoice Date,Fakturadato
DocType: GL Entry,Debit Amount,Debet Beløp
apps/erpnext/erpnext/accounts/party.py +276,There can only be 1 Account per Company in {0} {1},Det kan bare være en konto per Company i {0} {1}
DocType: Support Search Source,Response Result Key Path,Response Result Key Path
DocType: Journal Entry,Inter Company Journal Entry,Inter Company Journal Entry
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +530,For quantity {0} should not be grater than work order quantity {1},For kvantitet {0} bør ikke være rifler enn arbeidsordre mengde {1}
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +524,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 +131,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,ACC-ASS-.YYYY.-,ACC-ASS-.YYYY.-
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/education/doctype/student_report_generation_tool/student_report_generation_tool.html +225,Student Name: ,Student navn:
DocType: POS Closing Voucher Details,Difference,Forskjell
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/erpnext_integrations/doctype/gocardless_settings/gocardless_settings.py +97,"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.","Det ser ut til å være et problem med serverens GoCardless-konfigurasjon. Ikke bekymre deg, i tilfelle feil, vil beløpet bli refundert til kontoen din."
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: Leave Application,Leave Approver Name,La Godkjenner Name
DocType: Depreciation Schedule,Schedule Date,Schedule Date
DocType: Amazon MWS Settings,FR,FR
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 +20,Mandatory field - Get Students From,Obligatorisk felt - Få studenter fra
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +20,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/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html +10,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 +1548,Create a new Customer,Opprett en ny kunde
apps/erpnext/erpnext/non_profit/report/expiring_memberships/expiring_memberships.py +17,Expiring On,Utløper på
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 +116,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 +186,Reason for losing,Grunnen for å tape
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1751,Please select Drug,Vennligst velg Drug
apps/erpnext/erpnext/crm/doctype/lead/lead.py +44,Lead Owner cannot be same as the Lead,Bly Eier kan ikke være det samme som Lead
apps/erpnext/erpnext/accounts/utils.py +380,Allocated amount can not greater than unadjusted amount,Avsatt beløp kan ikke større enn ujustert beløp
DocType: Announcement,Receiver,mottaker
DocType: Location,Area UOM,Område UOM
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 +34,Opportunities,Muligheter
DocType: Lab Test Template,Single,Enslig
DocType: Compensatory Leave Request,Work From Date,Arbeid fra dato
DocType: Salary Slip,Total Loan Repayment,Total Loan Nedbetaling
DocType: Account,Cost of Goods Sold,Varekostnad
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +231,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 +67,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 +230,Classrooms/ Laboratories etc where lectures can be scheduled.,Klasserom / Laboratorier etc hvor forelesningene kan planlegges.
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +1301,Company currencies of both the companies should match for Inter Company Transactions.,Bedriftsvalutaer for begge selskapene bør samsvare for Inter Company Transactions.
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +95,Please enter company name first,Skriv inn firmanavn først
DocType: Travel Itinerary,Non-Vegetarian,Ikke-Vegetarisk
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: HR Settings,Show Leaves Of All Department Members In Calendar,Vis blader av alle avdelingsmedlemmer i kalender
DocType: Purchase Invoice,01-Sales Return,01-salgs retur
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js +15,Temporarily on Hold,Midlertidig på vent
DocType: Account,Is Group,Is Gruppe
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +324,Credit Note {0} has been created automatically,Kreditt notat {0} er opprettet automatisk
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: Leave Encashment,Leave Balance,Forlat balanse
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: Certification Application,Non Profit,Non Profit
DocType: Production Plan,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 +24,Mandatory field - Academic Year,Obligatorisk felt - akademisk år
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +24,Mandatory field - Academic Year,Obligatorisk felt - akademisk år
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +221,{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/manufacturing/doctype/job_card/job_card.py +56,Row {0} : Operation is required against the raw material item {1},Row {0}: Drift er nødvendig mot råvareelementet {1}
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +180,Please set default payable account for the company {0},Vennligst angi standard betalbar konto for selskapet {0}
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +604,Transaction not allowed against stopped Work Order {0},Transaksjon ikke tillatt mot stoppet Arbeidsordre {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 +758,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
DocType: Amazon MWS Settings,UK,Storbritannia
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: Bank Statement Settings,Statement Headers,Statement Headers
DocType: Travel Request,Costing,Costing
DocType: Tax Rule,Billing County,Billings County
DocType: Purchase Taxes and Charges,"If checked, the tax amount will be considered as already included in the Print Rate / Print Amount","Hvis det er merket, vil skattebeløpet betraktes som allerede er inkludert i Print Rate / Print Beløp"
DocType: Request for Quotation,Message for Supplier,Beskjed til Leverandør
DocType: Job Card,Work Order,Arbeidsordre
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 +30,Securities and Deposits,Verdipapirer og innskudd
apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +47,"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"
DocType: Student Report Generation Tool,Attended by Parents,Deltatt av foreldre
apps/erpnext/erpnext/hr/doctype/shift_assignment/shift_assignment.py +39,Employee {0} has already applied for {1} on {2} : ,Ansatt {0} har allerede søkt om {1} på {2}:
DocType: Inpatient Record,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 +118,Pending activities for today,Ventende aktiviteter for i dag
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: Loan,Total Payment,totalt betaling
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +117,Cannot cancel transaction for Completed Work Order.,Kan ikke avbryte transaksjonen for fullført arbeidsordre.
DocType: Manufacturing Settings,Time Between Operations (in mins),Time Between Operations (i minutter)
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +823,PO already created for all sales order items,PO allerede opprettet for alle salgsordreelementer
DocType: Healthcare Service Unit,Occupied,opptatt
DocType: Clinical Procedure,Consumables,forbruks~~POS=TRUNC
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +130,{0} {1} is cancelled so the action cannot be completed,"{0} {1} er kansellert, slik at handlingen ikke kan fullføres"
DocType: Customer,Buyer of Goods and Services.,Kjøper av varer og tjenester.
DocType: Journal Entry,Accounts Payable,Leverandørgjeld
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +55,The amount of {0} set in this payment request is different from the calculated amount of all payment plans: {1}. Make sure this is correct before submitting the document.,"Beløpet på {0} som er angitt i denne betalingsanmodningen, er forskjellig fra det beregnede beløpet for alle betalingsplaner: {1}. Pass på at dette er riktig før du sender dokumentet."
DocType: Patient,Allergies,allergi
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +43,The selected BOMs are not for the same item,De valgte stykklister er ikke for den samme varen
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js +32,Change Item Code,Endre varenummer
DocType: Supplier Scorecard Standing,Notify Other,Varsle Andre
DocType: Vital Signs,Blood Pressure (systolic),Blodtrykk (systolisk)
DocType: Item Price,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 +67,List a few of your customers. They could be organizations or individuals.,Liste noen av kundene dine. De kan være organisasjoner eller enkeltpersoner.
DocType: Employee Tax Exemption Proof Submission,Rented From Date,Leid fra dato
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/assets/doctype/asset/asset.py +185,Row {0}: Depreciation Start Date is required,Row {0}: Avskrivnings startdato er nødvendig
DocType: Purchase Invoice Item,Service Start Date,Service Startdato
DocType: Subscription Invoice,Subscription Invoice,Abonnementsfaktura
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +135,Direct Income,Direkte Inntekt
DocType: Patient Appointment,Date TIme,Dato tid
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +53,"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 +118,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 +410,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: Work 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 +569,"To merge, following properties must be same for both items","Å fusjonere, må følgende egenskaper være lik for begge elementene"
DocType: Supplier,Block Supplier,Blokker leverandør
DocType: Shipping Rule,Net Weight,Netto Vekt
DocType: Job Opening,Planned number of Positions,Planlagt antall posisjoner
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 +180,Student Application,Student søknad
DocType: Bank Statement Transaction Payment Item,Payment Reference,Betalingsreferanse
DocType: Supplier,Hold Type,Hold Type
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: Bank Statement Transaction Payment Item,Bank Statement Transaction Payment Item,Bankkonto Transaksjonsbetalingselement
DocType: Sales Order,To Deliver,Å Levere
DocType: Purchase Invoice Item,Item,Sak
apps/erpnext/erpnext/healthcare/setup.py +188,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
DocType: Travel Request,Costing Details,Kostnadsdetaljer
apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.js +64,Show Return Entries,Vis returinnlegg
apps/erpnext/erpnext/accounts/page/pos/pos.js +2566,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: Bank Guarantee,Providing,Gir
DocType: Account,Profit and Loss,Gevinst og tap
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +99,"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
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +317,Stock Entries already created for Work Order ,Lageroppføringer allerede opprettet for arbeidsordre
DocType: Vital Signs,Respiratory rate,Respirasjonsfrekvens
apps/erpnext/erpnext/config/stock.py +337,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
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +292,Cannot cancel {0} {1} because Serial No {2} does not belong to the warehouse {3},Kan ikke kansellere {0} {1} fordi serienummer {2} ikke tilhører lageret {3}
DocType: Detected Disease,Disease,Sykdom
DocType: Company,Default Deferred Expense Account,Standard utsatt utgiftskonto
apps/erpnext/erpnext/config/projects.py +29,Define Project type.,Definer Prosjekttype.
DocType: Supplier Scorecard,Weighting Function,Vekting Funksjon
DocType: Healthcare Practitioner,OP Consulting Charge,OP-konsulentkostnad
apps/erpnext/erpnext/utilities/user_progress.py +28,Setup your ,Oppsett din
DocType: Student Report Generation Tool,Show Marks,Vis karakterer
DocType: Support Settings,Get Latest Query,Få siste søk
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 +74,Account {0} does not belong to company: {1},Konto {0} tilhører ikke selskapet: {1}
apps/erpnext/erpnext/setup/doctype/company/company.py +56,Abbreviation already used for another company,Forkortelse allerede brukt for et annet selskap
DocType: Selling Settings,Default Customer Group,Standard Kundegruppe
DocType: Employee,IFSC Code,IFSC-kode
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: Bank Statement Transaction Entry,Match Transaction to Invoices,Match transaksjon til fakturaer
DocType: Sales Order Item,Gross Profit,Bruttofortjeneste
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +802,Unblock Invoice,Fjern blokkering av faktura
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 +366,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
DocType: Inpatient Record,HLC-INP-.YYYY.-,HLC-INP-.YYYY.-
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +162,"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 +271,Closing (Cr),Lukking (Cr)
apps/erpnext/erpnext/hr/notification/training_feedback/training_feedback.html +1,Hello,Hallo
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +118,Move Item,Flytt element
DocType: Employee Incentive,Incentive Amount,Incentivbeløp
DocType: Serial No,Warranty Period (Days),Garantiperioden (dager)
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +76,Total Credit/ Debit Amount should be same as linked Journal Entry,Totalt kreditt / debetbeløp skal være det samme som koblet journalinngang
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 +428,{0} {1} is not active,{0} {1} er ikke aktiv
DocType: Woocommerce Settings,Freight and Forwarding Account,Frakt- og videresendingskonto
apps/erpnext/erpnext/config/accounts.py +310,Setup cheque dimensions for printing,Oppsett sjekk dimensjoner for utskrift
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +33,Create Salary Slips,Opprett lønnsslipp
DocType: Vital Signs,Bloated,oppblåst
DocType: Salary Slip,Salary Slip Timesheet,Lønn Slip Timeregistrering
apps/erpnext/erpnext/controllers/buying_controller.py +188,Supplier Warehouse mandatory for sub-contracted Purchase Receipt,Leverandør Warehouse obligatorisk for underleverandør Kjøpskvittering
DocType: Item Price,Valid From,Gyldig Fra
DocType: Sales Invoice,Total Commission,Total Commission
DocType: Tax Withholding Account,Tax Withholding Account,Skattebetalingskonto
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
DocType: Delivery Note,Rail,Rail
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +263,Target warehouse in row {0} must be same as Work Order,Mållager i rad {0} må være det samme som Arbeidsordre
apps/erpnext/erpnext/stock/doctype/item/item.py +169,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 +36,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 +331,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 +166,"Sorry, Serial Nos cannot be merged","Sorry, kan Serial Nos ikke bli slått sammen"
DocType: Shopify Settings,Customer Group will set to selected group while syncing customers from Shopify,Kundegruppe vil sette til valgt gruppe mens du synkroniserer kunder fra Shopify
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
DocType: Hub User,Hub User,Hub Bruker
apps/erpnext/erpnext/utilities/activation.py +83,Make Sales Order,Gjør Salgsordre
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +537,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
DocType: Loyalty Point Entry Redemption,Redeemed Points,Innløste poeng
,Lead Id,Lead Id
DocType: C-Form Invoice Detail,Grand Total,Grand Total
DocType: Assessment Plan,Course,Kurs
apps/erpnext/erpnext/accounts/report/tds_computation_summary/tds_computation_summary.py +105,Section Code,Seksjonskode
DocType: Timesheet,Payslip,payslip
apps/erpnext/erpnext/hr/doctype/attendance_request/attendance_request.py +18,Half day date should be in between from date and to date,Halvdagsdagen bør være mellom dato og dato
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: Employee,Personal Bio,Personlig Bio
DocType: C-Form,IV,IV
apps/erpnext/erpnext/non_profit/report/expiring_memberships/expiring_memberships.py +15,Membership ID,Medlemskaps-ID
apps/erpnext/erpnext/templates/pages/order.html +77,Delivered: {0},Levering: {0}
DocType: Bank Statement Transaction Entry,Payable Account,Betales konto
DocType: Payment Entry,Type of Payment,Type Betaling
apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py +18,Half Day Date is mandatory,Halvdagsdato er obligatorisk
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 Plan,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 +896,Sales Return,Sales Return
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +110,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
DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,Angi antall i transaksjoner basert på serienummerinngang
,Total Stock Summary,Totalt lageroppsummering
apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.py +68,"You can only plan for upto {0} vacancies and budget {1} \
				for {2} as per staffing plan {3} for parent company {4}.",Du kan bare planlegge opptil {0} ledige stillinger og budsjett {1} \ for {2} i henhold til personaleplan {3} for morselskapet {4}.
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 Å
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +305,Middle Income,Middle Income
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +243,Opening (Cr),Åpning (Cr)
apps/erpnext/erpnext/stock/doctype/item/item.py +930,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 +378,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: Amazon MWS Settings,AWS Access Key ID,AWS Access Key ID
DocType: Employee Tax Exemption Declaration,Monthly House Rent,Månedlig husleie
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.
apps/erpnext/erpnext/hr/doctype/loan/loan.js +134,Principal Amount,hovedstol
DocType: Loan Application,Total Payable Interest,Total skyldige renter
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +58,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 +150,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"
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +642,An error occurred during the update process,Det oppsto en feil under oppdateringsprosessen
DocType: Restaurant Reservation,Restaurant Reservation,Restaurantreservasjon
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +166,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 +43,Notify Customers via Email,Meld kundene via e-post
DocType: Item,Batch Number Series,Batchnummer Serie
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +54,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
DocType: Travel Itinerary,Departure Datetime,Avreise Datetime
DocType: Customer,CUST-.YYYY.-,CUST-.YYYY.-
DocType: Travel Request Costing,Travel Request Costing,Reiseforespørsel Kostnad
apps/erpnext/erpnext/config/education.py +180,Masters,Masters
DocType: Employee Onboarding,Employee Onboarding Template,Medarbeider på bordet
DocType: Assessment Plan,Maximum Assessment Score,Maksimal Assessment Score
apps/erpnext/erpnext/config/accounts.py +161,Update Bank Transaction Dates,Oppdater Banktransaksjons Datoer
apps/erpnext/erpnext/config/projects.py +41,Time Tracking,Time Tracking
DocType: Purchase Invoice,DUPLICATE FOR TRANSPORTER,DUPLIKERER FOR TRANSPORTER
apps/erpnext/erpnext/hr/doctype/employee_advance/employee_advance.py +57,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: Employee Grade,Default Salary Structure,Standard Lønnsstruktur
apps/erpnext/erpnext/hr/report/daily_work_summary_replies/daily_work_summary_replies.py +23,Replies,svar
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 +763,"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: Supplier Scorecard Period,PU-SSP-.YYYY.-,PU-SSP-.YYYY.-
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 +95,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
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 +84,{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 +22,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 +163,"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."
DocType: Employee Promotion,Employee Promotion Details,Oppdragsgivere
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +83,Net Change in Inventory,Netto endring i varelager
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 +112,Manager,Manager
DocType: Payment Entry,Payment From / To,Betaling fra / til
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js +8,From Fiscal Year,Fra regnskapsåret
apps/erpnext/erpnext/selling/doctype/customer/customer.py +185,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 +447,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,"""Basert på"" og ""Grupper etter"" ikke kan være det samme"
DocType: Sales Person,Sales Person Targets,Sales Person Targets
DocType: Work Order Operation,In minutes,I løpet av minutter
DocType: Issue,Resolution Date,Oppløsning Dato
DocType: Lab Test Template,Compound,forbindelse
DocType: Opportunity,Probability (%),Sannsynlighet (%)
apps/erpnext/erpnext/patches/v11_0/add_default_dispatch_notification_template.py +11,Dispatch Notification,Forsendelsesvarsling
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js +56,Select Property,Velg Egenskap
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 +339,Timesheet created:,Timeregistrering opprettet:
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +1206,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
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +81,Currency should be same as Price List Currency: {0},Valuta bør være den samme som Prisliste Valuta: {0}
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 +105,Convert to Group,Konverter til konsernet
DocType: Activity Cost,Activity Type,Aktivitetstype
DocType: Request for Quotation,For individual supplier,For enkelte leverandør
DocType: BOM Operation,Base Hour Rate(Company Currency),Base Hour Rate (Selskap Valuta)
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +48,Delivered Amount,Leveres Beløp
DocType: Loyalty Point Entry Redemption,Redemption Date,Innløsningsdato
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.
DocType: Contract,Contract Template,Kontraktsmal
DocType: Clinical Procedure Item,Transfer Qty,Overføringsnummer
DocType: Purchase Invoice Item,Asset Location,Asset Location
DocType: Tax Rule,Shipping Zipcode,Fraktkode
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 +252,Maintenance Visit {0} must be cancelled before cancelling this Sales Order,Vedlikehold Besøk {0} må avbestilles før den avbryter denne salgsordre
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.js +14,Material Transfer,Material Transfer
DocType: Cost Center,Cost Center Number,Cost Center Number
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 +236,Opening (Dr),Åpning (Dr)
DocType: Compensatory Leave Request,Work End Date,Arbeid sluttdato
DocType: Loan,Applicant,Søker
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +37,Posting timestamp must be after {0},Oppslaget tidsstempel må være etter {0}
apps/erpnext/erpnext/config/accounts.py +44,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: Loan,Total Interest Payable,Total rentekostnader
DocType: Landed Cost Taxes and Charges,Landed Cost Taxes and Charges,Landed Cost skatter og avgifter
DocType: Work Order Operation,Actual Start Time,Faktisk Starttid
DocType: Purchase Invoice Item,Deferred Expense Account,Utsatt kostnadskonto
DocType: BOM Operation,Operation Time,Operation Tid
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +466,Finish,Bli ferdig
DocType: Salary Structure Assignment,Base,Utgangspunkt
DocType: Timesheet,Total Billed Hours,Totalt fakturert timer
DocType: Travel Itinerary,Travel To,Reise til
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1659,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
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.py +39,"Start date and end date is overlapping with the job card <a href=""#Form/Job Card/{0}"">{1}</a>","Startdato og sluttdato overlapper jobbkortet <a href=""#Form/Job Card/{0}"">{1}</a>"
DocType: Vehicle Log,Service Details,Servicedetaljer
DocType: Vehicle Log,Service Details,Servicedetaljer
DocType: Lab Test Template,Grouped,gruppert
DocType: Selling Settings,Delivery Note Required,Levering Note Påkrevd
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +533,Submitting Salary Slips...,Innlevering av lønnsslipp ...
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)
apps/erpnext/erpnext/support/doctype/issue/issue.js +38,Split Issue,Delt utgave
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 +960,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
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +51,Customer &gt; Customer Group &gt; Territory,Kunde&gt; Kundegruppe&gt; Territorium
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 +351,Marketing,Markedsføring
DocType: Sales Invoice,Redeem Loyalty Points,Løs inn lojalitetspoeng
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +348,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 +665,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 +408,Preview Salary Slip,Forhåndsvisning Lønn Slip
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +64,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: Shopping Cart Settings,Show Stock Availability,Vis lager tilgjengelighet
apps/erpnext/erpnext/assets/doctype/asset/asset.py +510,Set {0} in asset category {1} or company {2},Angi {0} i aktivakategori {1} eller firma {2}
DocType: Location,Longitude,lengde~~POS=TRUNC
,Absent Student Report,Fraværende Student Rapporter
DocType: Crop,Crop Spacing UOM,Beskjære plassering UOM
DocType: Loyalty Program,Single Tier Program,Single Tier Program
DocType: Accounts Settings,Only select if you have setup Cash Flow Mapper documents,Bare velg hvis du har installert Cash Flow Mapper-dokumenter
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +186,From Address 1,Fra adresse 1
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 +705,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/accounts/doctype/account/account.py +202,Company {0} does not exist,Selskapet {0} finnes ikke
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +43,{0} has fee validity till {1},{0} har gebyrgyldighet til {1}
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +54,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: 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: Request for Quotation,Link to material requests,Lenke til materiale forespørsler
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 +74,Company and Accounts,Selskapet og regnskap
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +78,In Value,i Verdi
DocType: Asset Settings,Depreciation Options,Avskrivningsalternativer
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +28,Either location or employee must be required,Enten plassering eller ansatt må være påkrevd
apps/erpnext/erpnext/utilities/transaction_base.py +29,Invalid Posting Time,Ugyldig innleggstid
DocType: Salary Component,Condition and Formula,Tilstand og formel
DocType: Lead,Campaign Name,Kampanjenavn
apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py +61,There is no leave period in between {0} and {1},Det er ingen permisjon mellom {0} og {1}
DocType: Fee Validity,Healthcare Practitioner,Helsepersonell
DocType: Hotel Room,Capacity,Kapasitet
DocType: Travel Request Costing,Expense Type,Utgiftstype
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 +86,The field From Shareholder cannot be blank,Feltet fra Aksjonær kan ikke være tomt
DocType: Leave Allocation,Allocation,Tildeling
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 +161,{0} is not a stock Item,{0} er ikke en lagervare
apps/erpnext/erpnext/hr/notification/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 +288,Please select Sample Retention Warehouse in Stock Settings first,Vennligst velg Sample Retention Warehouse i lagerinnstillinger først
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js +62,Please select the Multiple Tier Program type for more than one collection rules.,Vennligst velg flerverdierprogrammet for mer enn ett samlingsreglement.
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/erpnext_integrations/doctype/gocardless_settings/gocardless_settings.py +136,Payment Cancelled. Please check your GoCardless Account for more details,Betaling avbrutt. Vennligst sjekk din GoCardless-konto for mer informasjon
DocType: Contract,N/A,N / A
DocType: Delivery Settings,Send with Attachment,Send med vedlegg
apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +30,Please select weekly off day,Vennligst velg ukentlig off dag
DocType: Inpatient Record,O Negative,O Negativ
DocType: Work 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 +100,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: Clinical Procedure,Consume Stock,Konsumere lager
DocType: Budget,Budget Against,budsjett Against
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 +184,You can not enter current voucher in 'Against Journal Entry' column,Du kan ikke legge inn dagens kupong i &quot;Against Journal Entry-kolonnen
DocType: Employee Benefit Application Detail,Max Benefit Amount,Maksimal fordelbeløp
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/accounts/doctype/sales_invoice/sales_invoice.py +990,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
DocType: Special Test Items,Particulars,opplysninger
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +23,{0}: From {0} of type {1},{0}: Fra {0} av typen {1}
apps/erpnext/erpnext/controllers/buying_controller.py +387,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 +353,"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}"
DocType: Exchange Rate Revaluation,Exchange Rate Revaluation Account,Valutakursreguleringskonto
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +532,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
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.js +106,Please select Company and Posting Date to getting entries,Vennligst velg Company og Posting Date for å få oppføringer
DocType: Asset,Maintenance,Vedlikehold
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +28,Get from Patient Encounter,Få fra Patient Encounter
DocType: Subscriber,Subscriber,abonnent
DocType: Item Attribute Value,Item Attribute Value,Sak data Verdi
apps/erpnext/erpnext/projects/doctype/project/project.py +471,Please Update your Project Status,Vennligst oppdater prosjektstatusen din
apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py +26,Currency Exchange must be applicable for Buying or for Selling.,Valutaveksling må gjelde for kjøp eller salg.
DocType: Item,Maximum sample quantity that can be retained,Maksimal prøvemengde som kan beholdes
DocType: Project Update,How is the Project Progressing Right Now?,Hvordan foregår prosjektet akkurat nå?
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +501,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.
DocType: Project Task,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: 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: Student Report Generation Tool,Student Report Generation Tool,Generasjonsverktøy for Student Report
DocType: Healthcare Schedule Time Slot,Healthcare Schedule Time Slot,Helseplanleggings tidspaus
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +160,Doc Name,Doc Name
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/practitioner_schedule/practitioner_schedule.js +27,Add Timeslots,Legg til Timeslots
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +143,Asset scrapped via Journal Entry {0},Asset kasserte via bilagsregistrering {0}
DocType: Loan,Interest Income Account,Renteinntekter konto
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +61,Max benefits should be greater than zero to dispense benefits,Maksimale fordeler bør være større enn null for å gi fordeler
apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.py +58,Review Invitation Sent,Gjennomgå invitasjon sendt
DocType: Shift Assignment,Shift Assignment,Shift-oppgave
DocType: Employee Transfer Property,Employee Transfer Property,Medarbeideroverføringseiendom
apps/erpnext/erpnext/accounts/doctype/cashier_closing/cashier_closing.py +36,From Time Should Be Less Than To Time,Fra tiden burde være mindre enn til tid
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +13,Biotechnology,Bioteknologi
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1117,"Item {0} (Serial No: {1}) cannot be consumed as is reserverd\
						 to fullfill Sales Order {2}.",Vare {0} (Serienummer: {1}) kan ikke bli brukt som er forbeholdt \ for å fullføre salgsordren {2}.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +116,Office Maintenance Expenses,Kontor Vedlikehold Utgifter
apps/erpnext/erpnext/utilities/user_progress.py +54,Go to ,Gå til
DocType: Shopify Settings,Update Price from Shopify To ERPNext Price List,Oppdater pris fra Shopify til ERPNeste prisliste
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
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +316,Needs Analysis,Trenger analyse
DocType: Asset Repair,Downtime,nedetid
DocType: Account,Liability,Ansvar
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +227,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 +14,Academic Term: ,Faglig semester:
DocType: Salary Component,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 +1283,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 +523,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 +243,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 +810,No Permission,Ingen tillatelse
DocType: Contract Fulfilment Checklist,Contract Fulfilment Checklist,Kontrakt oppfyllelse sjekkliste
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 +75,"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 +46,'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 +146,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/inpatient_record/inpatient_record_dashboard.py +12,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 +669,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: Item,If subcontracted to a vendor,Dersom underleverandør til en leverandør
apps/erpnext/erpnext/education/doctype/student_group/student_group.js +113,Student Group is already updated.,Studentgruppen er allerede oppdatert.
apps/erpnext/erpnext/education/doctype/student_group/student_group.js +113,Student Group is already updated.,Studentgruppen er allerede oppdatert.
apps/erpnext/erpnext/config/projects.py +18,Project Update.,Prosjektoppdatering.
DocType: SMS Center,All Customer Contact,All Kundekontakt
DocType: Location,Tree Details,Tree Informasjon
DocType: Marketplace Settings,Registered,registrert
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 +410,"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 +112,{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 +92,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 +89,{0} {1}: Account {2} cannot be a Group,{0} {1}: Account {2} kan ikke være en gruppe
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +366,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
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +81,Sales Invoice {0} created as paid,Salgsfaktura {0} opprettet som betalt
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 +50,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 +373,C-Form records,C-Form poster
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +74,The shares already exist,Aksjene eksisterer allerede
apps/erpnext/erpnext/config/selling.py +322,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 +412,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: Employee Property History,Employee Property History,Ansattes eiendomshistorie
DocType: Setup Progress Action,Action Doctype,Handling Doctype
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 +408,{0} against Bill {1} dated {2},{0} mot Bill {1} datert {2}
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +210,From State,Fra Stat
apps/erpnext/erpnext/utilities/user_progress.py +27,Setup Institution,Oppsettinstitusjon
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.py +73,Allocating leaves...,Fordeling av blader ...
DocType: Program Enrollment,Vehicle/Bus Number,Kjøretøy / bussnummer
apps/erpnext/erpnext/education/doctype/course/course.js +17,Course Schedule,Kursplan
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +570,"You have to Deduct Tax for Unsubmitted Tax Exemption Proof and Unclaimed \
					Employee Benefits in the last Salary Slip of Payroll Period",Du må trekke fradrag for ikke-innvilget skattefritakelsesbevis og uoppfordrede \ Ansattes fordeler i den siste lønnsløpet av lønnsperioden
DocType: Request for Quotation Supplier,Quote Status,Sitatstatus
DocType: GoCardless Settings,Webhooks Secret,Webhooks Secret
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: Loyalty Program Collection,Tier Name,Tiernavn
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 +135,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: Upload Attendance,Import Attendance,Import Oppmøte
apps/erpnext/erpnext/public/js/pos/pos.html +124,All Item Groups,Alle varegrupper
DocType: Work Order,Item To Manufacture,Element for å produsere
apps/erpnext/erpnext/buying/utils.py +80,{0} {1} status is {2},{0} {1} status er {2}
DocType: 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 +601,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 +135,'Opening',&quot;Opening&quot;
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +130,Open To Do,Åpne for å gjøre
DocType: Issue,Via Customer Portal,Via kundeportalen
DocType: Notification Control,Delivery Note Message,Levering Note Message
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +319,SGST Amount,SGST Beløp
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 +361,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 +101,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
DocType: Vital Signs,Normal,Normal
apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +106,"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"
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 +332,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 +123,"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: Notification Control,Expense Claim Rejected Message,Expense krav Avvist Message
,Available Qty,Tilgjengelig Antall
DocType: Shopify Settings,Default Warehouse to to create Sales Order and Delivery Note,Standard lager for å opprette salgsordre og leveringsnotat
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: Amazon MWS Settings,Always synch your products from Amazon MWS before synching the Orders details,Synkroniser alltid produktene dine fra Amazon MWS før du synkroniserer bestillingsdetaljene
DocType: Delivery Trip,Delivery Stops,Levering stopper
DocType: Salary Slip,Working Days,Arbeidsdager
apps/erpnext/erpnext/accounts/deferred_revenue.py +33,Cannot change Service Stop Date for item in row {0},Kan ikke endre Service Stop Date for element i rad {0}
DocType: Serial No,Incoming Rate,Innkommende Rate
DocType: Packing Slip,Gross Weight,Bruttovekt
DocType: Leave Type,Encashment Threshold Days,Encashment Threshold Days
,Final Assessment Grades,Final Assessment Grades
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 +107,Setup your Institute in ERPNext,Oppsett ditt institutt i ERPNext
DocType: Agriculture Analysis Criteria,Plant Analysis,Plantanalyse
DocType: Job Applicant,Hold,Hold
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +101,Alternate Item,Alternativt element
DocType: Project Update,Progress Details,Fremdriftsdetaljer
DocType: Shopify Log,Request Data,Forespørseldata
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 +858,Purchase Receipt,Kvitteringen
,Received Items To Be Billed,Mottatte elementer å bli fakturert
apps/erpnext/erpnext/config/accounts.py +341,Currency exchange rate master.,Valutakursen mester.
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +210,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 +322,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: Work 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 +621,BOM {0} must be active,BOM {0} må være aktiv
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +427,No Items available for transfer,Ingen elementer tilgjengelig for overføring
DocType: Employee Boarding Activity,Activity Name,Aktivitetsnavn
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +797,Change Release Date,Endre utgivelsesdato
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +214,Finished product quantity <b>{0}</b> and For Quantity <b>{1}</b> cannot be different,Ferdig produktmengde <b>{0}</b> og For kvantitet <b>{1}</b> kan ikke være annerledes
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +250,Closing (Opening + Total),Avslutning (Åpning + Totalt)
DocType: Delivery Settings,Dispatch Notification Attachment,Dispatch Notification Attachment
DocType: Payroll Entry,Number Of Employees,Antall ansatte
DocType: Journal Entry,Depreciation Entry,avskrivninger Entry
apps/erpnext/erpnext/selling/report/sales_person_commission_summary/sales_person_commission_summary.py +31,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: Pricing Rule,Rate or Discount,Pris eller rabatt
DocType: Vital Signs,One Sided,Ensidig
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +218,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
DocType: Marketplace Settings,Custom Data,Tilpassede data
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +126,Warehouses with existing transaction can not be converted to ledger.,Næringslokaler med eksisterende transaksjon kan ikke konverteres til hovedbok.
apps/erpnext/erpnext/controllers/buying_controller.py +570,Serial no is mandatory for the item {0},Serienummer er obligatorisk for varen {0}
DocType: Bank Reconciliation,Total Amount,Totalbeløp
apps/erpnext/erpnext/accounts/report/tds_computation_summary/tds_computation_summary.py +24,From Date and To Date lie in different Fiscal Year,Fra dato og dato ligger i ulike regnskapsår
apps/erpnext/erpnext/healthcare/utils.py +160,The Patient {0} do not have customer refrence to invoice,Pasienten {0} har ikke kunderefusjon til faktura
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 (%)
DocType: Item Group,Item Group Defaults,Vare Gruppe Standard
apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js +102,Please save before assigning task.,Vennligst lagre før du tilordner oppgaven.
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +82,Balance Value,Balanse Verdi
DocType: Lab Test,Lab Technician,Lab tekniker
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +40,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."
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.py +63,Customer isn't enrolled in any Loyalty Program,Kunden er ikke innskrevet i noe lojalitetsprogram
DocType: Bank Reconciliation,Account Currency,Account Valuta
DocType: Lab Test,Sample ID,Eksempel ID
apps/erpnext/erpnext/accounts/general_ledger.py +178,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 +52,Employee {0} is not active or does not exist,Ansatt {0} er ikke aktiv eller ikke eksisterer
DocType: Fee Structure,Components,komponenter
DocType: Support Search Source,Search Term Param Name,Søk term Param Navn
DocType: Item Barcode,Item Barcode,Sak Barcode
DocType: Woocommerce Settings,Endpoints,endepunkter
apps/erpnext/erpnext/stock/doctype/item/item.py +700,Item Variants {0} updated,Sak Varianter {0} oppdatert
DocType: Quality Inspection Reading,Reading 6,Reading 6
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +994,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 +231,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 +284,Define budget for a financial year.,Definer budsjett for et regnskapsår.
DocType: Shopify Tax Account,ERPNext Account,ERPNeste Konto
apps/erpnext/erpnext/controllers/accounts_controller.py +57,{0} is blocked so this transaction cannot proceed,"{0} er blokkert, slik at denne transaksjonen ikke kan fortsette"
DocType: Budget,Action if Accumulated Monthly Budget Exceeded on MR,Handling hvis akkumulert månedlig budsjett oversteg MR
DocType: Employee,Permanent Address Is,Permanent Adresse Er
DocType: Work Order Operation,Operation completed for how many finished goods?,Operasjonen gjennomført for hvor mange ferdigvarer?
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +128,Healthcare Practitioner {0} not available on {1},Helsepersonell {0} er ikke tilgjengelig på {1}
DocType: Payment Terms Template,Payment Terms Template,Betalingsbetingelser mal
apps/erpnext/erpnext/public/js/setup_wizard.js +51,The Brand,The Brand
DocType: Employee Tax Exemption Proof Submission,Rented To Date,Leid til dato
DocType: Manufacturing Settings,Allow Multiple Material Consumption,Tillat flere materialforbruk
DocType: Employee,Exit Interview Details,Exit Intervju Detaljer
DocType: Item,Is Purchase Item,Er Purchase Element
DocType: Bank Statement Transaction Invoice Item,Purchase Invoice,Fakturaen
DocType: Manufacturing Settings,Allow multiple Material Consumption against a Work Order,Tillat flere materialforbruk mot en arbeidsordre
DocType: GL Entry,Voucher Detail No,Kupong Detail Ingen
apps/erpnext/erpnext/accounts/page/pos/pos.js +796,New Sales Invoice,Ny salgsfaktura
DocType: Stock Entry,Total Outgoing Value,Total Utgående verdi
DocType: Healthcare Practitioner,Appointments,avtaler
apps/erpnext/erpnext/public/js/account_tree_grid.js +223,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 +809,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."
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +468,The following Work Orders were created:,Følgende arbeidsordrer ble opprettet:
DocType: Salary Slip,Total in words,Totalt i ord
DocType: Inpatient Record,Discharged,utskrevet
DocType: Material Request Item,Lead Time Date,Lead Tid Dato
,Employee Advance Summary,Ansattsperspektiv
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: Support Settings,Get Started Sections,Komme i gang Seksjoner
DocType: Lead,CRM-LEAD-.YYYY.-,CRM-LEAD-.YYYY.-
DocType: Loan,Sanctioned,sanksjonert
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.js +8,Total Contribution Amount: {0},Totalt bidragsbeløp: {0}
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +179,Row #{0}: Please specify Serial No for Item {1},Row # {0}: Vennligst oppgi serienummer for varen {1}
DocType: Payroll Entry,Salary Slips Submitted,Lønnsslipp legges inn
DocType: Crop Cycle,Crop Cycle,Beskjæringssyklus
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +678,"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: Amazon MWS Settings,BR,BR
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +198,From Place,Fra Sted
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +460,Net Pay cannnot be negative,Netto Pay kan ikke være negativ
DocType: Student Admission,Publish on website,Publiser på nettstedet
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +772,Supplier Invoice Date cannot be greater than Posting Date,Leverandør Fakturadato kan ikke være større enn konteringsdato
DocType: Installation Note,MAT-INS-.YYYY.-,MAT-INS-.YYYY.-
DocType: Subscription,Cancelation Date,Avbestillingsdato
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 +139,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 +76,Variance,Varians
DocType: Employee Promotion,Employee Promotion Detail,Medarbeideropplysning detaljer
,Company Name,Selskapsnavn
DocType: SMS Center,Total Message(s),Total melding (er)
DocType: Share Balance,Purchased,kjøpt
DocType: Item Variant Settings,Rename Attribute Value in Item Attribute.,Endre navn på Attribute Value i Item Attribute.
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/education/doctype/student_report_generation_tool/student_report_generation_tool.js +25,Print Report Card,Skriv ut rapportkort
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 +164,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.
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +96,Total leaves allocated is mandatory for Leave Type {0},Totalt antall permisjoner er obligatorisk for permisjonstype {0}
DocType: BOM,Raw Material Cost(Company Currency),Raw Material Cost (Selskap Valuta)
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +86,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 +86,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 +147,Meter,Måler
DocType: Workstation,Electricity Cost,Elektrisitet Cost
apps/erpnext/erpnext/hr/doctype/additional_salary/additional_salary.py +15,Amount should be greater than zero.,Beløpet skal være større enn null.
apps/erpnext/erpnext/agriculture/doctype/water_analysis/water_analysis.py +23,Lab testing datetime cannot be before collection datetime,Labtesting datetime kan ikke være før datetime samling
DocType: Subscription Plan,Cost,Koste
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/templates/pages/help.html +29,See All Articles,Se alle artikler
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +188,Walk In,Gå Inn
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/setup/setup_wizard/operations/install_fixtures.py +183,White,Hvit
DocType: SMS Center,All Lead (Open),All Lead (Open)
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +348,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
DocType: Supplier,Represents Company,Representerer selskapet
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 +139,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 +549,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: Holiday List,Holiday List Name,Holiday Listenavn
DocType: Repayment Schedule,Balance Loan Amount,Balanse Lånebeløp
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js +132,Added to details,Lagt til detaljer
apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +14,Schedule Course,Schedule Course
DocType: Budget,Applicable on Material Request,Gjelder på materialforespørsel
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +217,Stock Options,Aksjeopsjoner
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +628,No Items added to cart,Ingen varer lagt til i handlekurven
DocType: Journal Entry Account,Expense Claim,Expense krav
apps/erpnext/erpnext/assets/doctype/asset/asset.js +352,Do you really want to restore this scrapped asset?,Har du virkelig ønsker å gjenopprette dette skrotet ressurs?
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +530,Qty for {0},Antall for {0}
DocType: Leave Application,Leave Application,La Application
DocType: Patient,Patient Relation,Pasientrelasjon
DocType: Item,Hub Category to Publish,Hub kategori for publisering
DocType: Leave Block List,Leave Block List Dates,La Block List Datoer
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +297,"Sales Order {0} has reservation for item {1}, you can
		only deliver reserved {1} against {0}. Serial No {2} cannot
		be delivered","Salgsordre {0} har forbehold for element {1}, du kan bare levere reservert {1} mot {0}. Serienummer {2} kan ikke leveres"
DocType: Sales Invoice,Billing Address GSTIN,Faktureringsadresse GSTIN
DocType: Employee Tax Exemption Proof Submission,Total Eligible HRA Exemption,Totalt kvalifisert HRA-fritak
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
DocType: Travel Itinerary,Train,Tog
DocType: Healthcare Service Unit,Inpatient Occupancy,Inpatient Occupancy
DocType: Sample Collection,HLC-SC-.YYYY.-,HLC-SC-.YYYY.-
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 +74,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 +465,Variant creation has been queued.,Variantskaping har vært i kø.
apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py +99,Work Summary for {0},Arbeidssammendrag for {0}
DocType: Department,The first Leave Approver in the list will be set as the default Leave Approver.,Den første permisjonen for permisjon i listen blir satt som standard permisjon for permisjon.
apps/erpnext/erpnext/stock/doctype/item/item.py +754,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 +69,{0} can not be negative,{0} kan ikke være negativ
DocType: Training Event,Self-Study,Selvstudium
DocType: POS Closing Voucher,Period End Date,Periodens sluttdato
apps/erpnext/erpnext/agriculture/doctype/soil_texture/soil_texture.py +27,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 +623,Discount,Rabatt
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +64,Row {0}: {1} is required to create the Opening {2} Invoices,Row {0}: {1} er nødvendig for å opprette {2} Fakturaer
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: Purchase Invoice,Is Return (Debit Note),Er retur (Debit Note)
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 +187,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 +893,Please select a field to edit from numpad,Vennligst velg et felt for å redigere fra numpad
apps/erpnext/erpnext/stock/doctype/item/item.py +279,Cannot be a fixed asset item as Stock Ledger is created.,Kan ikke være en fast eiendelsobjekt når lagerboksen er opprettet.
DocType: Subscription Plan,Fixed rate,Fast rente
apps/erpnext/erpnext/healthcare/doctype/inpatient_record/inpatient_record.js +7,Admit,Innrømme
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
apps/erpnext/erpnext/templates/pages/order.js +31,Pay Remaining,Betal gjenværende
DocType: Item,Manufacturer,Produsent
DocType: Landed Cost Item,Purchase Receipt Item,Kvitteringen Element
DocType: Leave Allocation,Total Leaves Encashed,Samlede blader innhyllet
DocType: POS Profile,Sales Invoice Payment,Salg Faktura Betaling
DocType: Quality Inspection Template,Quality Inspection Template Name,Kvalitetsinspeksjonsmalnavn
DocType: Project,First Email,Første e-post
DocType: Company,Exception Budget Approver Role,Unntak Budget Approver Rolle
DocType: Purchase Invoice,"Once set, this invoice will be on hold till the set date","Når denne er satt, vil denne fakturaen være på vent til den angitte datoen"
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 +69,Selling Amount,Selge Beløp
DocType: Repayment Schedule,Interest Amount,rente~~POS=TRUNC
DocType: Sales Invoice,Loyalty Amount,Lojalitetsbeløp
DocType: Employee Transfer,Employee Transfer Detail,Ansatteoverføringsdetaljer
DocType: Serial No,Creation Document No,Creation Dokument nr
DocType: Location,Location Details,Plasseringsdetaljer
DocType: Share Transfer,Issue,Problem
apps/erpnext/erpnext/healthcare/doctype/patient_encounter/patient_encounter_dashboard.py +11,Records,Records
DocType: Asset,Scrapped,skrotet
DocType: Item,Item Defaults,Elementinnstillinger
DocType: Purchase Invoice,Returns,returer
DocType: Job Card,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 +231,Recruitment,Rekruttering
DocType: Lead,Organization Name,Organization Name
DocType: Support Settings,Show Latest Forum Posts,Vis siste foruminnlegg
DocType: Additional Salary Component,ASC-,ASC-
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 +901,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 +124,Sales Expenses,Salgs Utgifter
DocType: Diagnosis,Diagnosis,Diagnose
apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py +18,Standard Buying,Standard Kjøpe
DocType: Attendance Request,Explanation,Forklaring
DocType: GL Entry,Against,Against
DocType: Item Default,Sales Defaults,Salgsstandard
DocType: Sales Order Item,Work Order Qty,Arbeidsordre Antall
DocType: Item Default,Default Selling Cost Center,Standard Selling kostnadssted
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +594,Disc,Plate
DocType: Buying Settings,Material Transferred for Subcontract,Materialet overført for underleverandør
DocType: Email Digest,Purchase Orders Items Overdue,Innkjøpsordreelementer Forfalt
apps/erpnext/erpnext/accounts/page/pos/pos.js +1638,ZIP Code,Post kode
apps/erpnext/erpnext/controllers/selling_controller.py +262,Sales Order {0} is {1},Salgsordre {0} er {1}
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +256,Select interest income account in loan {0},Velg renteinntekter konto i lån {0}
DocType: Opportunity,Contact Info,Kontaktinfo
apps/erpnext/erpnext/config/stock.py +322,Making Stock Entries,Making Stock Entries
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.py +15,Cannot promote Employee with status Left,Kan ikke markedsføre Medarbeider med status til venstre
DocType: Packing Slip,Net Weight UOM,Vekt målenheter
DocType: Item Default,Default Supplier,Standard Leverandør
DocType: Loan,Repayment Schedule,tilbakebetaling Schedule
DocType: Shipping Rule Condition,Shipping Rule Condition,Shipping Rule Tilstand
apps/erpnext/erpnext/hr/doctype/payroll_period/payroll_period.py +19,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 +250,Invoice can't be made for zero billing hour,Fakturaen kan ikke gjøres for null faktureringstid
DocType: Company,Date of Commencement,Dato for oppstart
DocType: Sales Person,Select company name first.,Velg firmanavn først.
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +205,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 +28,To {0} | {1} {2},Til {0} | {1} {2}
apps/erpnext/erpnext/setup/doctype/supplier_group/supplier_group.js +13,This is a root supplier group and cannot be edited.,Dette er en rotleverandørgruppe og kan ikke redigeres.
DocType: Delivery Trip,Driver Name,Drivernavn
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41,Average Age,Gjennomsnittsalder
DocType: Education Settings,Attendance Freeze Date,Deltagelsesfrysedato
DocType: Education Settings,Attendance Freeze Date,Deltagelsesfrysedato
DocType: Payment Request,Inward,innover
apps/erpnext/erpnext/utilities/user_progress.py +110,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 +32,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 +60,All BOMs,alle stykklister
DocType: Company,Parent Company,Moderselskap
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: Healthcare Practitioner,Default Currency,Standard Valuta
apps/erpnext/erpnext/controllers/selling_controller.py +147,Maximum discount for Item {0} is {1}%,Maksimum rabatt for element {0} er {1}%
DocType: Asset Movement,From Employee,Fra Employee
DocType: Driver,Cellphone Number,Mobiltelefonnummer
DocType: Project,Monitor Progress,Monitor Progress
apps/erpnext/erpnext/controllers/accounts_controller.py +529,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: Supplier Quotation,Auto Repeat Section,Auto Repeat Section
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 +241,{0} {1} must be submitted,{0} {1} må sendes
DocType: Buying Settings,Default Supplier Group,Standard leverandørgruppe
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}
apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py +42,Maximum amount eligible for the component {0} exceeds {1},Maksimumsbeløp som er kvalifisert for komponenten {0} overstiger {1}
DocType: Department Approver,Department Approver,Avdeling Godkjenning
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 +192,Please select BOM in BOM field for Item {0},Vennligst velg BOM i BOM felt for Element {0}
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +22,There isn't any item variant for the selected item,Det er ikke noen varianter for det valgte elementet
DocType: C-Form Invoice Detail,C-Form Invoice Detail,C-Form Faktura Detalj
DocType: Payment Reconciliation Invoice,Payment Reconciliation Invoice,Betaling Avstemming Faktura
DocType: Clinical Procedure,Procedure Template,Prosedyre Mal
apps/erpnext/erpnext/selling/report/sales_person_commission_summary/sales_person_commission_summary.py +75,Contribution %,Bidrag%
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +243,"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}"
,HSN-wise-summary of outward supplies,HSN-vis-oppsummering av utadvendte forsyninger
DocType: Company,Company registration numbers for your reference. Tax numbers etc.,Firmaregistreringsnumre som referanse. Skatte tall osv
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +258,To State,Å statliggjøre
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +145,Distributor,Distributør
DocType: Asset Finance Book,Asset Finance Book,Asset Finance Book
DocType: Shopping Cart Shipping Rule,Shopping Cart Shipping Rule,Handlevogn Shipping Rule
apps/erpnext/erpnext/public/js/controllers/transaction.js +71,Please set 'Apply Additional Discount On',Vennligst sett &#39;Apply Ytterligere rabatt på&#39;
DocType: Party Tax Withholding Config,Applicable Percent,Gjeldende prosentandel
,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 +290,Project Collaboration Invitation,Prosjekt Samarbeid Invitasjon
DocType: Salary Slip,Deductions,Fradrag
DocType: Setup Progress Action,Action Name,Handlingsnavn
apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.js +17,Start Year,start-år
apps/erpnext/erpnext/regional/india/utils.py +28,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 +81,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,Dager uten lønn
DocType: Payment Request,Outward,Ytre
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +366,Capacity Planning Error,Kapasitetsplanlegging Error
,Trial Balance for Party,Trial Balance for partiet
DocType: Lead,Consultant,Konsulent
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +356,Parents Teacher Meeting Attendance,Foreldres lærermøte
DocType: Salary Slip,Earnings,Inntjeningen
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +534,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
DocType: Stock Settings,Default Return Warehouse,Standard Return Warehouse
apps/erpnext/erpnext/public/js/setup_wizard.js +18,Select your Domains,Velg domenene dine
apps/erpnext/erpnext/erpnext_integrations/doctype/shopify_settings/sync_product.py +228,Shopify Supplier,Shopify Leverandør
DocType: Bank Statement Transaction Entry,Payment Invoice Items,Betalingsfakturaelementer
DocType: Payroll Entry,Employee Details,Ansattes detaljer
DocType: Amazon MWS Settings,CN,CN
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',"'Faktisk startdato' kan ikke være større enn ""Faktisk Slutt Dato '"
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +359,Management,Ledelse
DocType: Cheque Print Template,Payer Settings,Payer Innstillinger
apps/erpnext/erpnext/public/js/utils/party.js +193,Select company first,Velg firma først
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: Delivery Note,Is Return,Er Return
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +89,Caution,Forsiktighet
apps/erpnext/erpnext/agriculture/doctype/disease/disease.py +17,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 +823,Return / Debit Note,Retur / debitnota
DocType: Price List Country,Price List Country,Prisliste Land
DocType: Item,UOMs,UOMs
apps/erpnext/erpnext/stock/utils.py +236,{0} valid serial nos for Item {1},{0} gyldig serie nos for Element {1}
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +61,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/healthcare/doctype/clinical_procedure/clinical_procedure.js +9,Please enter Item Code to get Batch Number,Fyll inn Element kode for å få Batch Number
DocType: Loyalty Point Entry,Loyalty Point Entry,Lojalitetspoenginngang
DocType: Stock Settings,Default Item Group,Standard varegruppe
DocType: Job Card,Time In Mins,Tid i min
apps/erpnext/erpnext/config/non_profit.py +93,Grant information.,Gi informasjon.
apps/erpnext/erpnext/config/buying.py +38,Supplier database.,Leverandør database.
DocType: Contract Template,Contract Terms and Conditions,Kontraktsbetingelser
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +415,You cannot restart a Subscription that is not cancelled.,Du kan ikke starte en abonnement som ikke er kansellert.
DocType: Account,Balance Sheet,Balanse
DocType: Leave Type,Is Earned Leave,Er opptjent permisjon
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +797,Cost Center For Item with Item Code ',Koste Center For Element med Element kode &#39;
DocType: Fee Validity,Valid Till,Gyldig til
DocType: Student Report Generation Tool,Total Parents Teacher Meeting,Totalt foreldres lærermøte
apps/erpnext/erpnext/accounts/page/pos/pos.js +2527,"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
DocType: Amazon MWS Settings,MWS Auth Token,MWS Auth Token
apps/erpnext/erpnext/stock/doctype/batch/batch.js +105,Stock Entry {0} created,Stock Entry {0} er opprettet
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.py +110,You don't have enought Loyalty Points to redeem,Du har ikke nok Lojalitetspoeng til å innløse
apps/erpnext/erpnext/accounts/doctype/tax_withholding_category/tax_withholding_category.py +23,Please set associated account in Tax Withholding Category {0} against Company {1},Vennligst sett inn tilknyttet konto i Skatteholdskategori {0} mot firma {1}
apps/erpnext/erpnext/controllers/buying_controller.py +393,Row #{0}: Rejected Qty can not be entered in Purchase Return,Row # {0}: Avvist Antall kan ikke legges inn i innkjøpsliste
apps/erpnext/erpnext/stock/doctype/item/item.js +197,Changing Customer Group for the selected Customer is not allowed.,Endring av kundegruppe for den valgte kunden er ikke tillatt.
,Purchase Order Items To Be Billed,Purchase Order Elementer som skal faktureres
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +71,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 +194,Please select a customer,Vennligst velg en kunde
DocType: Leave Policy,Leave Allocations,Forlate allokeringer
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
DocType: Student Report Generation Tool,Assessment Terms,Vurderingsbetingelser
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +8,Item 1,Sak 1
DocType: Holiday,Holiday,Ferie
apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py +25,Leave Type is madatory,Forlat Type er madatory
DocType: Support Settings,Close Issue After Days,Lukk Issue Etter dager
,Eway Bill,Eway Bill
apps/erpnext/erpnext/public/js/hub/marketplace.js +139,You need to be a user with System Manager and Item Manager roles to add users to Marketplace.,Du må være en bruker med System Manager og Item Manager roller for å legge til brukere på Marketplace.
DocType: Leave Control Panel,Leave blank if considered for all branches,La stå tom hvis vurderes for alle grener
DocType: Job Opening,Staffing Plan,Bemanning Plan
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: Certified Consultant,Name of Consultant,Navn på konsulent
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 Invoice,Group same items,Gruppe samme elementene
DocType: Purchase Invoice,Disable Rounded Total,Deaktiver Avrundet Total
DocType: Marketplace Settings,Sync in Progress,Synkronisering i fremgang
DocType: Department,Parent Department,Foreldreavdeling
DocType: Loan Application,Repayment Info,tilbakebetaling info
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +486,'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 +86,Duplicate row {0} with same {1},Duplicate rad {0} med samme {1}
DocType: Marketplace Settings,Disable Marketplace,Deaktiver Marketplace
,Trial Balance,Balanse Trial
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +463,Fiscal Year {0} not found,Regnskapsåret {0} ikke funnet
apps/erpnext/erpnext/config/hr.py +394,Setting up Employees,Sette opp ansatte
DocType: Hotel Room Reservation,Hotel Reservation User,Hotel Reservation Bruker
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +165,Please select prefix first,Vennligst velg først prefiks
DocType: Contract,Fulfilment Deadline,Oppfyllingsfrist
DocType: Student,O-,O-
DocType: Subscription Settings,Subscription Settings,Abonnementsinnstillinger
DocType: Purchase Invoice,Update Auto Repeat Reference,Oppdater Auto Repeat Reference
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +274,Optional Holiday List not set for leave period {0},Valgfri ferieliste ikke angitt for permisjon {0}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +165,Research,Forskning
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +240,To Address 2,Å adresse 2
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 +56,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
DocType: Bank Statement Transaction Entry,Reconciled Transactions,Avstemte transaksjoner
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +42,Earliest,Tidligste
DocType: Crop Cycle,Linked Location,Tilknyttet plassering
apps/erpnext/erpnext/stock/doctype/item/item.py +543,"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 +106,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/accounts/doctype/sales_invoice/sales_invoice.js +1638,Get Items from Healthcare Services,Få elementer fra helsetjenester
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +112,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 +176,Dividends Paid,Utbytte betalt
apps/erpnext/erpnext/buying/doctype/supplier/supplier.js +39,Accounting Ledger,Regnskap Ledger
DocType: Asset Value Adjustment,Difference Amount,Forskjellen Beløp
DocType: Purchase Invoice,Reverse Charge,Omvendt ladning
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +182,Retained Earnings,Opptjent egenkapital
DocType: Job Card,Timing Detail,Timing Detail
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 +20,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}
apps/erpnext/erpnext/selling/report/sales_person_commission_summary/sales_person_commission_summary.py +81,Commission Rate %,Kommisjon Rate%
DocType: Work 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/accounts/doctype/account/account.js +51,Merge Account,Slå sammen konto
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 +76,Temporary Opening,Midlertidig Åpning
,Employee Leave Balance,Ansatt La Balance
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +148,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 +181,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 +169,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,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/stock/doctype/material_request/material_request.js +970,For Default Supplier (optional),For standardleverandør (valgfritt)
DocType: Supplier Quotation Item,Lead Time in days,Lead Tid i dager
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +82,Accounts Payable Summary,Leverandørgjeld Sammendrag
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +214,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 +146,Lab Test Prescriptions,Lab Test Prescriptions
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +164,"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 +172,Small,Liten
DocType: Shopify Settings,"If Shopify not contains a customer in Order, then while syncing Orders, the system will consider default customer for order","Hvis Shopify ikke inneholder en kunde i ordre, så vil systemet vurdere standardkunden for bestilling mens du synkroniserer ordrer"
DocType: Opening Invoice Creation Tool Item,Opening Invoice Creation Tool Item,Åpning av fakturaopprettingsverktøyet
DocType: Cashier Closing Payments,Cashier Closing Payments,Kasseavslutninger
DocType: Education Settings,Employee Number,Ansatt Number
DocType: Subscription Settings,Cancel Invoice After Grace Period,Avbryt Faktura Etter Grace Period
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: Travel Request,International,Internasjonal
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
DocType: Contract,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 +1242,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 +99,Indirect Expenses,Indirekte kostnader
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +128,Row {0}: Qty is mandatory,Rad {0}: Antall er obligatorisk
DocType: Agriculture Analysis Criteria,Agriculture,Landbruk
apps/erpnext/erpnext/manufacturing/doctype/blanket_order/blanket_order.js +15,Create Sales Order,Opprett salgsordre
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +510,Accounting Entry for Asset,Regnskapsføring for eiendel
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +808,Block Invoice,Blokker faktura
apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.js +16,Quantity to Make,Mengde å lage
apps/erpnext/erpnext/accounts/page/pos/pos.js +801,Sync Master Data,Sync Master Data
DocType: Asset Repair,Repair Cost,Reparasjonskostnad
apps/erpnext/erpnext/utilities/user_progress.py +138,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
apps/erpnext/erpnext/controllers/buying_controller.py +617,Asset {0} created,Asset {0} opprettet
DocType: Special Test Items,Special Test Items,Spesielle testelementer
apps/erpnext/erpnext/public/js/hub/marketplace.js +102,You need to be a user with System Manager and Item Manager roles to register on Marketplace.,Du må være en bruker med System Manager og Item Manager roller for å registrere deg på Marketplace.
DocType: Bank Statement Transaction Payment Item,Mode of Payment,Modus for betaling
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py +25,As per your assigned Salary Structure you cannot apply for benefits,I henhold til din tildelte lønnsstruktur kan du ikke søke om fordeler
apps/erpnext/erpnext/stock/doctype/item/item.py +217,Website Image should be a public file or website URL,Website Bilde bør være en offentlig fil eller nettside URL
DocType: Purchase Invoice Item,BOM,BOM
apps/erpnext/erpnext/setup/doctype/item_group/item_group.js +71,This is a root item group and cannot be edited.,Dette er en rot varegruppe og kan ikke redigeres.
apps/erpnext/erpnext/accounts/doctype/account/account.js +133,Merge,Slå sammen
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/controllers/accounts_controller.py +775,Rows with duplicate due dates in other rows were found: {0},Rader med dupliserte forfallsdatoer i andre rader ble funnet: {0}
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +535,"{0}: Employee email not found, hence email not sent","{0}: Ansattes e-post ikke funnet, derav e-posten ikke sendt"
apps/erpnext/erpnext/hr/doctype/leave_encashment/leave_encashment.py +55,No Salary Structure assigned for Employee {0} on given date {1},Ingen lønnskostnad tildelt for ansatt {0} på gitt dato {1}
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/regional/report/eway_bill/eway_bill.py +173,From Party Name,Fra Festnavn
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 +177,"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/accounts/doctype/sales_invoice/sales_invoice.py +659,Delivery Note {0} is not submitted,Levering Note {0} er ikke innsendt
apps/erpnext/erpnext/stock/get_item_details.py +167,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 +44,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/work_order/work_order.js +372,Please set the Item Code first,Vennligst sett inn varenummeret først
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +154,Doc Type,Doc Type
apps/erpnext/erpnext/controllers/selling_controller.py +132,Total allocated percentage for sales team should be 100,Totalt bevilget prosent for salgsteam skal være 100
DocType: Subscription Plan,Billing Interval Count,Faktureringsintervalltelling
apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py +10,Appointments and Patient Encounters,Utnevnelser og pasientmøter
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js +135,Value missing,Verdi mangler
DocType: Employee,Department and Grade,Avdeling og karakter
DocType: Sales Invoice Item,Edit Description,Rediger Beskrivelse
DocType: Antibiotic,Antibiotic,Antibiotika
,Team Updates,laget Oppdateringer
apps/erpnext/erpnext/accounts/doctype/payment_order/payment_order.js +39,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}
apps/erpnext/erpnext/stock/report/item_prices/item_prices.js +8,Items Filter,Elementer Filter
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: Bank Statement Transaction Settings Item,Transaction,Transaksjons
DocType: Patient Appointment,Duration,Varighet
apps/erpnext/erpnext/controllers/status_updater.py +160,"For an item {0}, quantity must be positive number",For et element {0} må mengden være positivt tall
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +76,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/hr/doctype/compensatory_leave_request/compensatory_leave_request.py +44,Compensatory leave request days not in valid holidays,Kompensasjonsorlov forespørselsdager ikke i gyldige helligdager
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +53,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/regional/report/eway_bill/eway_bill.py +301,Accessable Value,Tilgjengelig verdi
apps/erpnext/erpnext/stock/utils.py +231,Serial number {0} entered more than once,Serienummer {0} angitt mer enn én gang
DocType: Bank Statement Transaction Invoice Item,Journal Entry,Journal Entry
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +180,From GSTIN,Fra GSTIN
DocType: Expense Claim Advance,Unclaimed amount,Uoppfordret beløp
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +269,{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/stock/doctype/item_alternative/item_alternative.py +23,Alternative item must not be same as item code,Alternativt element må ikke være det samme som varenummer
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +637,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)"
apps/erpnext/erpnext/public/js/setup_wizard.js +254,Collapse All,Skjul alle
apps/erpnext/erpnext/manufacturing/doctype/blanket_order/blanket_order.js +27,Create Purchase Order,Opprett innkjøpsordre
DocType: Quality Inspection Reading,Reading 8,Reading 8
DocType: Inpatient Record,Discharge Note,Utladningsnotat
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 +143,Hardware,Hardware
DocType: Prescription Dosage,Prescription Dosage,Reseptdosering
DocType: Contract,HR Manager,HR Manager
apps/erpnext/erpnext/accounts/party.py +195,Please select a Company,Vennligst velg et selskap
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +95,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 +91,You need to enable Shopping Cart,Du må aktivere Handlevogn
DocType: Payment Entry,Writeoff,writeoff
DocType: Maintenance Visit,MAT-MVS-.YYYY.-,MAT-MVS-.YYYY.-
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 +188,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 +322,Food,Mat
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +69,Ageing Range 3,Aldring Range 3
DocType: POS Closing Voucher Details,POS Closing Voucher Details,POS Closing Voucher Detaljer
DocType: Shopify Log,Shopify Log,Shopify Log
DocType: Inpatient Occupancy,Check In,Sjekk inn
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
DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,Kontraktsmall Fulfillment Vilkår
,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 +64,Warehouse cannot be changed for Serial No.,Warehouse kan ikke endres for Serial No.
DocType: Authorization Rule,Average Discount,Gjennomsnittlig Rabatt
DocType: Project Update,Great/Quickly,Great / raskt
DocType: Purchase Invoice Item,UOM,målenheter
DocType: Employee Tax Exemption Declaration,Annual HRA Exemption,Årlig HRA-fritak
DocType: Rename Tool,Utilities,Verktøy
DocType: POS Profile,Accounting,Regnskap
DocType: Asset,Purchase Receipt Amount,Kjøpsbevisbeløp
DocType: Employee Separation,Exit Interview Summary,Avslutt Intervju Sammendrag
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +140,Please select batches for batched item ,Vennligst velg batch for batched item
DocType: Asset,Depreciation Schedules,avskrivninger tidsplaner
apps/erpnext/erpnext/erpnext_integrations/doctype/shopify_settings/shopify_settings.py +37,"Support for public app is deprecated. Please setup private app, for more details refer user manual","Støtte for offentlig app er utdatert. Vennligst sett opp privat app, for flere detaljer, se brukerhåndboken"
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py +202,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 +104,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 +33,From {0} | {1} {2},Fra {0} | {1} {2}
apps/erpnext/erpnext/public/js/hub/marketplace.js +164,Some emails are invalid,Noen e-poster er ugyldige
DocType: Work 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
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +64,Approval Status must be 'Approved' or 'Rejected',Godkjenningsstatus må være &quot;Godkjent&quot; eller &quot;Avvist&quot;
DocType: Healthcare Practitioner,Contacts and Address,Kontakter og adresse
DocType: Salary Structure,Max Benefits (Amount),Maksimal fordel (beløp)
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
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.js +107,No data for this period,Ingen data for denne perioden
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
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 +92,Net Change in Fixed Asset,Netto endring i Fixed Asset
apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.py +38,Reqd Qty,Reqd Antall
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 +874,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/work_order/work_order.js +531,Max: {0},Max: {0}
apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py +24,From Datetime,Fra Datetime
DocType: Shopify Settings,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.
DocType: Supplier Scorecard Scoring Variable,Supplier Scorecard Scoring Variable,Leverandør Scorecard Scoring Variable
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +70,Buying Amount,Kjøpe Beløp
DocType: POS Closing Voucher,Modes of Payment,Betalingsmåter
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
DocType: Department,The first Expense Approver in the list will be set as the default Expense Approver.,Den første utgiftsgodkjenningen i listen blir satt som standard utgiftsgodkjent.
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +611,cannot be greater than 100,kan ikke være større enn 100
apps/erpnext/erpnext/public/js/hub/marketplace.js +97,You need to be a user other than Administrator with System Manager and Item Manager roles to register on Marketplace.,Du må være en annen bruker enn Administrator med System Manager og Item Manager roller for å registrere deg på Marketplace.
apps/erpnext/erpnext/stock/doctype/item/item.py +810,Item {0} is not a stock Item,Element {0} er ikke en lagervare
DocType: Packing Slip,MAT-PAC-.YYYY.-,MAT-PAC-.YYYY.-
DocType: Maintenance Visit,Unscheduled,Ikke planlagt
DocType: Employee,Owned,Eies
DocType: Salary Component,Depends on Leave Without Pay,Avhengig av dager uten lønn
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
DocType: Travel Itinerary,Gluten Free,Glutenfri
DocType: Loyalty Program Collection,Minimum Total Spent,Minimum totalt brukt
apps/erpnext/erpnext/stock/doctype/batch/batch.py +222,"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: Loyalty Program,Expiry Duration (in days),Utløpsvarighet (i dager)
DocType: Inpatient Record,Discharge Date,Utladningsdato
DocType: Subscription Plan,Price Determination,Prisbestemmelse
DocType: Vehicle,License Plate,Bilskilt
apps/erpnext/erpnext/hr/doctype/department/department_tree.js +18,New Department,Ny avdeling
DocType: Compensatory Leave Request,Worked On Holiday,Jobbet på ferie
DocType: Appraisal,Goals,Mål
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +399,Select POS Profile,Velg POS-profil
DocType: Warranty Claim,Warranty / AMC Status,Garanti / AMC Status
,Accounts Browser,Kontoer Browser
DocType: Procedure Prescription,Referral,Referral
DocType: Payment Entry Reference,Payment Entry Reference,Betaling Entry Reference
DocType: GL Entry,GL Entry,GL Entry
DocType: Support Search Source,Response Options,Svaralternativer
DocType: HR Settings,Employee Settings,Medarbeider Innstillinger
apps/erpnext/erpnext/templates/pages/integrations/gocardless_checkout.html +13,Loading Payment System,Laster inn betalingssystem
,Batch-Wise Balance History,Batch-Wise Balance Historie
apps/erpnext/erpnext/controllers/accounts_controller.py +1062,Row #{0}: Cannot set Rate if amount is greater than billed amount for Item {1}.,Row # {0}: Kan ikke sette Rate hvis beløpet er større enn fakturert beløp for element {1}.
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 +108,Apprentice,Lærling
DocType: Purchase Invoice,Company GSTIN,Firma GSTIN
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +106,Negative Quantity is not allowed,Negative Antall er ikke tillatt
DocType: Purchase Invoice Item,"Tax detail table fetched from item master as a string and stored in this field.
Used for Taxes and Charges","Tax detalj tabell hentet fra elementet Hoved som en streng, og som er lagret på dette feltet. Brukes for skatter og avgifter"
apps/erpnext/erpnext/hr/doctype/employee/employee.py +164,Employee cannot report to himself.,Arbeidstaker kan ikke rapportere til seg selv.
DocType: Leave Type,Max Leaves Allowed,Maks. Blader tillatt
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 +268,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: HR Settings,Leave Approver Mandatory In Leave Application,La godkjenning være obligatorisk i permisjon
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 +206,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 +76,Show unclosed fiscal year's P&L balances,Vis unclosed regnskapsårets P &amp; L balanserer
DocType: Item,Asset Naming Series,Asset Naming Series
DocType: Appraisal,HR-APR-.YY.-.MM.,HR-APR-.YY.-.MM.
apps/erpnext/erpnext/regional/india/utils.py +179,House rented dates should be atleast 15 days apart,Husleide datoer skal være minst 15 dager fra hverandre
DocType: Clinical Procedure Template,Collection Details,Samlingsdetaljer
DocType: POS Profile,Allow Print Before Pay,Tillat utskrift før betaling
DocType: Linked Soil Texture,Linked Soil Texture,Koblet jordstruktur
DocType: Shipping Rule,Shipping Account,Shipping konto
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +93,{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: Bank Statement Transaction Entry,Bank Transaction Entries,Bankoverføringsoppføringer
DocType: Quality Inspection,Readings,Readings
DocType: Stock Entry,Total Additional Costs,Samlede merkostnader
apps/erpnext/erpnext/crm/report/lead_conversion_time/lead_conversion_time.py +47,No of Interactions,Ingen interaksjoner
DocType: BOM,Scrap Material Cost(Company Currency),Skrap Material Cost (Selskap Valuta)
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +69,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: Loyalty Program,Loyalty Program Type,Lojalitetsprogramtype
DocType: Asset Movement,Stock Manager,Stock manager
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +246,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 +906,Packing Slip,Pakkseddel
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +117,Office Rent,Kontor Leie
apps/erpnext/erpnext/config/setup.py +105,Setup SMS gateway settings,Oppsett SMS gateway-innstillinger
DocType: Disease,Common Name,Vanlig navn
DocType: Employee Boarding Activity,Employee Boarding Activity,Ansatte ombordstigningsaktivitet
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 +113,Analyst,Analytiker
apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py +20,{0} is not in a valid Payroll Period,{0} er ikke i en gyldig lønnsperiode
DocType: Employee Benefit Application,Max Benefits (Yearly),Maksimal fordel (årlig)
DocType: Item,Inventory,Inventar
DocType: Item,Sales Details,Salgs Detaljer
DocType: Opportunity,With Items,Med Items
DocType: Asset Maintenance,Maintenance Team,Vedlikeholdsteam
DocType: Salary Component,Is Additional Component,Er tilleggskomponent
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 +135,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
DocType: Asset Movement,Source Location,Kildeplassering
apps/erpnext/erpnext/public/js/setup_wizard.js +64,Institute Name,Institute Name
apps/erpnext/erpnext/hr/doctype/loan/loan.py +127,Please enter repayment Amount,Fyll inn gjenværende beløpet
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js +18,There can be multiple tiered collection factor based on the total spent. But the conversion factor for redemption will always be same for all the tier.,Det kan være flere lagdelt innsamlingsfaktor basert på totalt brukt. Men konverteringsfaktoren for innløsning vil alltid være den samme for alle nivåer.
apps/erpnext/erpnext/config/stock.py +312,Item Variants,Element Varianter
apps/erpnext/erpnext/public/js/setup_wizard.js +29,Services,Tjenester
DocType: Payment Order,PMO-,PMO-
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 +1028,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"
DocType: Shopify Settings,Import Delivery Notes from Shopify on Shipment,Importer leveringsnotater fra Shopify på forsendelse
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 +276,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/setup/doctype/email_digest/templates/default.html +70,Open Projects,åpne Prosjekter
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +297,Packing Slip(s) cancelled,Pakking Slip (s) kansellert
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +90,Cash Flow from Investing,Kontantstrøm fra investerings
DocType: Program Course,Program Course,program Course
DocType: Healthcare Service Unit,Allow Appointments,Tillat avtaler
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +106,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 +28,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
DocType: Employee Advance,HR-EAD-.YYYY.-,HR-EAD-.YYYY.-
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +55,Setting defaults,Angir standardinnstillinger
DocType: Loyalty Program,Auto Opt In (For all customers),Auto Opt In (For alle kunder)
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 +515,POS Profile is required to use Point-of-Sale,POS-profilen kreves for å bruke Point-of-Sale
DocType: Cashier Closing,Net Amount,Nettobeløp
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +139,{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: Support Search Source,Result Route Field,Resultatrutefelt
DocType: Supplier,PAN,PANNE
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
,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 +100,"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: Bank Account,Is Company Account,Er selskapskonto
apps/erpnext/erpnext/hr/doctype/leave_encashment/leave_encashment.py +58,Leave Type {0} is not encashable,Forlatype {0} er ikke innrykkbar
DocType: Landed Cost Voucher,Landed Cost Help,Landed Cost Hjelp
DocType: Vehicle Log,HR-VLOG-.YYYY.-,HR-vlog-.YYYY.-
DocType: Purchase Invoice,Select Shipping Address,Velg leveringsadresse
DocType: Timesheet Detail,Expected Hrs,Forventet tid
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 +194,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 +119,Accounts Receivable Summary,Kundefordringer Sammendrag
DocType: POS Closing Voucher,Linked Invoices,Koblede fakturaer
DocType: 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
DocType: Contract,Contract Details,Kontraktsdetaljer
DocType: Employee,Leave Details,Legg igjen detaljer
apps/erpnext/erpnext/hr/doctype/employee/employee.py +211,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
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +234,To Address 1,Å adresse 1
DocType: GST HSN Code,HSN Code,HSN kode
apps/erpnext/erpnext/selling/report/sales_person_commission_summary/sales_person_commission_summary.py +87,Contribution Amount,Bidrag Beløp
DocType: Inpatient Record,Patient Encounter,Pasientmøte
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.
apps/erpnext/erpnext/erpnext_integrations/utils.py +22,Unverified Webhook Data,Uverifiserte Webhook-data
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: Item Alternative,Two-way,Toveis
DocType: Project,Day to Send,Dag å sende
DocType: Healthcare Settings,Manage Sample Collection,Administrer prøveinnsamling
DocType: Production Plan,Ignore Existing Ordered Quantity,Ignorer eksisterende bestilt antall
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +73,Please set the series to be used.,Vennligst sett serien som skal brukes.
DocType: Patient,Tobacco Past Use,Tidligere bruk av tobakk
DocType: Travel Itinerary,Mode of Travel,Reisemåte
DocType: Sales Invoice Item,Brand Name,Merkenavn
DocType: Purchase Receipt,Transporter Details,Transporter Detaljer
apps/erpnext/erpnext/accounts/page/pos/pos.js +2711,Default warehouse is required for selected item,Standardlager er nødvendig til den valgte artikkelen
apps/erpnext/erpnext/utilities/user_progress.py +146,Box,Eske
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1025,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
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +419,"No active BOM found for item {0}. Delivery by \
						Serial No cannot be ensured",Ingen aktiv BOM funnet for elementet {0}. Levering med \ Serienummer kan ikke sikres
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}
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 +79,Row # {0}: Returned Item {1} does not exists in {2} {3},Row # {0}: Returned Element {1} ikke eksisterer i {2} {3}
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: Patient Encounter,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/setup/setup_wizard/operations/install_fixtures.py +314,Prospecting,prospecting
apps/erpnext/erpnext/config/stock.py +317,Opening Stock Balance,Åpning Stock Balance
DocType: Asset Category Account,Capital Work In Progress Account,Kapitalarbeid i fremgangskonto
apps/erpnext/erpnext/assets/doctype/asset/asset.js +92,Asset Value Adjustment,Asset Value Adjustment
DocType: Additional Salary,Payroll Date,Lønnsdato
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
DocType: Shipping Rule Condition,From Value,Fra Verdi
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +713,Manufacturing Quantity is mandatory,Manufacturing Antall er obligatorisk
DocType: 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/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/non_profit/report/expiring_memberships/expiring_memberships.py +16,Member ID,Medlem ID
DocType: Employee Tax Exemption Proof Submission,Monthly Eligible Amount,Månedlig kvalifisert beløp
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +97,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
DocType: Pricing Rule,Supplier Group,Leverandørgruppe
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +61,{0} Digest,{0} Fordel
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +151,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 +152,Stock Liabilities,Aksje Gjeld
DocType: Purchase Invoice,Supplier Warehouse,Leverandør Warehouse
DocType: Opportunity,Contact Mobile No,Kontakt Mobile No
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +53,Select Company,Velg firma
,Material Requests for which Supplier Quotations are not created,Materielle Forespørsler som Leverandør Sitater ikke er opprettet
DocType: Student Report Generation Tool,Print Section,Utskriftseksjon
DocType: Staffing Plan Detail,Estimated Cost Per Position,Anslått kostnad per posisjon
DocType: Employee,HR-EMP-,HR-EMP-
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.
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +189,Employee Referral,Ansatt henvisning
DocType: Student Group,Set 0 for no limit,Sett 0 for ingen begrensning
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +191,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.
DocType: Customer,Primary Address and Contact Detail,Primæradresse og kontaktdetaljer
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +21,Resend Payment Email,Sende Betaling Email
apps/erpnext/erpnext/templates/pages/projects.html +27,New task,Ny oppgave
DocType: Clinical Procedure,Appointment,Avtale
apps/erpnext/erpnext/utilities/activation.py +74,Make Quotation,Gjør sitat
apps/erpnext/erpnext/config/education.py +230,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
DocType: Shopify Settings,Shopify Tax Account,Shopify Skattekonto
apps/erpnext/erpnext/stock/doctype/item/item.py +461,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 +258,Leave of type {0} cannot be longer than {1},Permisjon av typen {0} kan ikke være lengre enn {1}
DocType: Delivery Trip,Optimize Route,Optimaliser rute
DocType: Manufacturing Settings,Try planning operations for X days in advance.,Prøv å planlegge operasjoner for X dager i forveien.
apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.py +90,"{0} vacancies and {1} budget for {2} already planned for subsidiary companies of {3}. \
				You can only plan for upto {4} vacancies and and budget {5} as per staffing plan {6} for parent company {3}.",{0} ledige stillinger og {1} budsjett for {2} som allerede er planlagt for datterselskaper av {3}. \ Du kan bare planlegge opptil {4} ledige stillinger og budsjett {5} i henhold til personaleplan {6} for morselskapet {3}.
DocType: HR Settings,Stop Birthday Reminders,Stop bursdagspåminnelser
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +203,Please set Default Payroll Payable Account in Company {0},Vennligst sette Standard Lønn betales konto i selskapet {0}
DocType: Amazon MWS Settings,Get financial breakup of Taxes and charges data by Amazon ,Få økonomisk oppdeling av skatter og avgifter data av Amazon
DocType: SMS Center,Receiver List,Mottaker List
apps/erpnext/erpnext/accounts/page/pos/pos.js +1108,Search Item,Søk Element
DocType: Payment Schedule,Payment Amount,Betalings Beløp
apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py +20,Half Day Date should be in between Work From Date and Work End Date,Halvdagsdato bør være mellom arbeid fra dato og arbeidsdato
DocType: Healthcare Settings,Healthcare Service Items,Helsevesenetjenesteelementer
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +47,Consumed Amount,Forbrukes Beløp
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +69,Net Change in Cash,Netto endring i kontanter
DocType: Assessment Plan,Grading Scale,Grading Scale
apps/erpnext/erpnext/stock/doctype/item/item.py +455,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 +617,Already completed,allerede fullført
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +34,Stock In Hand,Lager i hånd
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py +68,"Please add the remaining benefits {0} to the application as \
				pro-rata component",Vennligst legg de resterende fordelene {0} til applikasjonen som \ pro-rata-komponent
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 +35,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: Healthcare Practitioner,Hospital,Sykehus
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +534,Quantity must not be more than {0},Antall må ikke være mer enn {0}
DocType: Travel Request Costing,Funded Amount,Finansiert beløp
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +120,Previous Financial Year is not closed,Foregående regnskapsår er ikke stengt
DocType: Practitioner Schedule,Practitioner Schedule,Utøverplan
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +69,Age (Days),Alder (dager)
DocType: Instructor,EDU-INS-.YYYY.-,EDU-INS-.YYYY.-
DocType: Additional Salary,Additional Salary,Ekstra lønn
DocType: Quotation Item,Quotation Item,Sitat Element
DocType: Customer,Customer POS Id,Kundens POS-ID
DocType: Account,Account Name,Brukernavn
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +496,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 +203,Serial No {0} quantity {1} cannot be a fraction,Serial No {0} mengde {1} kan ikke være en brøkdel
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.py +96,Please enter Woocommerce Server URL,Vennligst skriv inn Woocommerce Server URL
DocType: Purchase Order Item,Supplier Part Number,Leverandør delenummer
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +136,Conversion rate cannot be 0 or 1,Konverteringsfrekvens kan ikke være 0 eller 1
DocType: Share Balance,To No,Til nr
apps/erpnext/erpnext/hr/doctype/employee_onboarding/employee_onboarding.py +27,All the mandatory Task for employee creation hasn't been done yet.,Alle de obligatoriske oppgavene for oppretting av ansatte er ikke gjort ennå.
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +227,{0} {1} is cancelled or stopped,{0} {1} avbrytes eller stoppes
DocType: Accounts Settings,Credit Controller,Credit Controller
DocType: Loan,Applicant Type,Søker Type
DocType: Purchase Invoice,03-Deficiency in services,03-mangel på tjenester
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 +265,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."
DocType: Purchase Receipt,MAT-PRE-.YYYY.-,MAT-PRE-.YYYY.-
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/hr/doctype/staffing_plan/staffing_plan.py +142,Please select Company and Designation,Vennligst velg Firma og Betegnelse
apps/erpnext/erpnext/config/setup.py +116,Human Resources,Menneskelige Ressurser
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +306,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
DocType: Vital Signs,Full,Full
apps/erpnext/erpnext/hr/doctype/loan/loan.js +69,Make Disbursement Entry,Gjør Utbetaling Entry
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +170,Row {0}: Advance against Supplier must be debit,Rad {0}: Advance mot Leverandøren skal belaste
DocType: Company,Default Values,Standardverdier
DocType: Certification Application,INR,INR
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/hr/doctype/additional_salary/additional_salary.py +21,Payroll date can not be less than employee's joining date,Lønnsdato kan ikke være mindre enn ansattes tilmeldingsdato
apps/erpnext/erpnext/accounts/doctype/payment_order/payment_order.py +87,{0} {1} created,{0} {1} er opprettet
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +46,"Job Openings for designation {0} already open \
					or hiring completed as per Staffing Plan {1}",Jobbåpninger for betegnelse {0} allerede åpen \ eller ansettelse fullført i henhold til personaleplan {1}
DocType: Vital Signs,Constipated,forstoppelse
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +118,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 +483,Asset Movement record {0} created,Asset Movement rekord {0} er opprettet
apps/erpnext/erpnext/utilities/page/leaderboard/leaderboard.js +175,No items found.,Ingen objekter funnet.
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +51,You cannot delete Fiscal Year {0}. Fiscal Year {0} is set as default in Global Settings,Du kan ikke slette regnskapsår {0}. Regnskapsåret {0} er satt som standard i Globale innstillinger
DocType: Share Transfer,Equity/Liability Account,Egenkapital / ansvarskonto
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
DocType: Contract,Inactive,inaktiv
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +224,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 Order,Order Confirmation No,Bekreftelsesbekreftelse nr
DocType: Purchase Invoice,Eligibility For ITC,Kvalifisering for ITC
DocType: Student Applicant,EDU-APP-.YYYY.-,EDU-APP-.YYYY.-
DocType: Journal Entry,Entry Type,Entry Type
,Customer Credit Balance,Customer Credit Balance
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +82,Net Change in Accounts Payable,Netto endring i leverandørgjeld
apps/erpnext/erpnext/selling/doctype/customer/customer.py +257,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 +163,Update bank payment dates with journals.,Oppdatere bankbetalings datoer med tidsskrifter.
apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +26,Pricing,Priser
DocType: Quotation,Term Details,Term Detaljer
DocType: Employee Incentive,Employee Incentive,Ansattes incitament
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/stock/report/item_price_stock/item_price_stock.py +36,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 +67,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 +22,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: Share Transfer,Asset Account,Asset-konto
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
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +411,"Cannot ensure delivery by Serial No as \
					Item {0} is added with and without Ensure Delivery by \
					Serial No.",Kan ikke garantere levering med serienummer som \ Item {0} er lagt til med og uten Sikre Levering med \ Serienr.
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: Asset,Comprehensive Insurance,Omfattende forsikring
DocType: Maintenance Visit,Partially Completed,Delvis Fullført
apps/erpnext/erpnext/selling/doctype/customer/customer.js +118,Loyalty Point: {0},Lojalitetspoeng: {0}
apps/erpnext/erpnext/public/js/event.js +15,Add Leads,Legg til Leads
apps/erpnext/erpnext/healthcare/setup.py +189,Moderate Sensitivity,Moderat følsomhet
DocType: Leave Type,Include holidays within leaves as leaves,Inkluder hellig innen blader som løv
DocType: Loyalty Program,Redemption,Forløsning
DocType: Sales Invoice,Packed Items,Lunsj Items
DocType: Tax Withholding Category,Tax Withholding Rates,Skattefradrag
DocType: Contract,Contract Period,Kontrakt periode
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 +215,'Total',&#39;Total&#39;
DocType: Employee,Permanent Address,Permanent Adresse
DocType: Loyalty Program,Collection Tier,Collection Tier
apps/erpnext/erpnext/hr/utils.py +156,From date can not be less than employee's joining date,Fra datoen kan ikke være mindre enn ansattes tilmeldingsdato
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +292,"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
DocType: Project Update,Challenging/Slow,Utfordrende / Slow
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: Leave Type,Earned Leave,Opptjent permisjon
DocType: Employee,Salary Details,Lønnsdetaljer
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/setup/setup_wizard/data/industry_type.py +39,Online Auctions,Online auksjoner
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +101,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 +101,View in Cart,Vis i handlekurven
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +110,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 +360,"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
DocType: Hub User,Hub Password,Hub Passord
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
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html +3,Allocated Leaves,Tildelte blad
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/practitioner_schedule/practitioner_schedule.js +24,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/public/js/setup_wizard.js +178,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
,Sales Person Commission Summary,Salgs personkommisjon Sammendrag
DocType: Additional Salary Component,Additional Salary Component,Tilleggslønn
DocType: Material Request,Transferred,overført
DocType: Vehicle,Doors,dører
apps/erpnext/erpnext/setup/setup_wizard/operations/defaults_setup.py +118,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 +717,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: Employee,Joining Details,Bli med på detaljer
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 +175,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: Location,Area,Område
apps/erpnext/erpnext/public/js/templates/contact_list.html +37,New Contact,Ny kontakt
DocType: Company,Company Description,foretaksbeskrivelse
DocType: Territory,Parent Territory,Parent Territory
DocType: Purchase Invoice,Place of Supply,Leveringssted
DocType: Quality Inspection Reading,Reading 2,Reading 2
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py +101,Employee {0} already submited an apllication {1} for the payroll period {2},Ansatt {0} har allerede sendt inn en påmelding {1} for lønnsperioden {2}
DocType: Stock Entry,Material Receipt,Materialet Kvittering
DocType: Bank Statement Transaction Entry,Submit/Reconcile Payments,Send / avstem betalinger
DocType: Campaign,SAL-CAM-.YYYY.-,SAL-CAM-.YYYY.-
DocType: Homepage,Products,Produkter
DocType: Announcement,Instructor,Instruktør
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js +95,Select Item (optional),Velg element (valgfritt)
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.py +103,The Loyalty Program isn't valid for the selected company,Lojalitetsprogrammet er ikke gyldig for det valgte selskapet
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
DocType: Compensatory Leave Request,Compensatory Leave Request,Kompenserende permisjon
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +334,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 +45,Warehouse {0} can not be deleted as quantity exists for Item {1},Warehouse {0} kan ikke slettes som kvantitet finnes for Element {1}
DocType: Blanket Order,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 +39,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/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.py +59,Total Target,Total Target
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +319,Perception Analysis,Perception Analysis
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
DocType: Purchase Invoice,Release Date,Utgivelsesdato
DocType: Stock Reconciliation,Reconciliation JSON,Avstemming JSON
apps/erpnext/erpnext/accounts/report/financial_statements.html +5,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: Marketplace Settings,Hub Seller Name,Hub Selger Navn
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +27,Employee Advances,Ansattes fremskritt
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 +263,Main,Hoved
apps/erpnext/erpnext/controllers/buying_controller.py +762,Following item {0} is not marked as {1} item. You can enable them as {1} item from its Item master,Følgende element {0} er ikke merket som {1} element. Du kan aktivere dem som {1} -objekt fra elementmasteren
apps/erpnext/erpnext/stock/doctype/item/item.js +74,Variant,Variant
apps/erpnext/erpnext/controllers/status_updater.py +163,"For an item {0}, quantity must be negative number",For et element {0} må mengden være negativt tall
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 +475,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 +1226,Make Purchase Order,Gjør innkjøpsordre
DocType: SMS Center,Send To,Send Til
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +202,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
DocType: Email Digest,Purchase Orders to Receive,Innkjøpsordre for å motta
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +197,Work-in-Progress Warehouse is required before Submit,Work-in-progress Warehouse er nødvendig før Send
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +71,You can only have Plans with the same billing cycle in a Subscription,Du kan bare ha planer med samme faktureringsperiode i en abonnement
DocType: Bank Statement Transaction Settings Item,Mapped Data,Mappedata
DocType: Purchase Order Item,Warehouse and Reference,Warehouse og Reference
DocType: Payroll Period Date,Payroll Period Date,Lønn Periode Dato
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 +262,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/hr/doctype/staffing_plan/staffing_plan.py +113,"Subsidiary companies have already planned for {1} vacancies at a budget of {2}. \
				Staffing Plan for {0} should allocate more vacancies and budget for {3} than planned for its subsidiary companies",Datterselskaper har allerede planlagt for {1} ledige stillinger på et budsjett på {2}. \ Staffing Plan for {0} bør tildele flere ledige stillinger og budsjett for {3} enn planlagt for datterselskapene
apps/erpnext/erpnext/config/hr.py +166,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 +210,Duplicate Serial No entered for Item {0},Duplisere serie Ingen kom inn for Element {0}
apps/erpnext/erpnext/config/selling.py +179,Track Leads by Lead Source.,Sporledninger av blykilde.
DocType: Shipping Rule Condition,A condition for a Shipping Rule,En forutsetning for en Shipping Rule
apps/erpnext/erpnext/hr/doctype/employee/employee.py +175,Please enter ,Vennligst skriv inn
apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js +64,Maintenance Log,Vedlikeholdslogg
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +242,Please set filter based on Item or Warehouse,Vennligst sette filter basert på varen eller Warehouse
DocType: Packing Slip,The net weight of this package. (calculated automatically as sum of net weight of items),Nettovekten av denne pakken. (Automatisk beregnet som summen av nettovekt elementer)
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +43,Make Inter Company Journal Entry,Lag Inter Company Journal Entry
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +901,Discount amount cannot be greater than 100%,Rabattbeløp kan ikke være større enn 100%
DocType: Opportunity,CRM-OPP-.YYYY.-,CRM-OPP-.YYYY.-
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +26,"Number of new Cost Center, it will be included in the cost center name as a prefix","Antall nye kostnadssenter, det vil bli inkludert i kostnadsområdets navn som et prefiks"
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 +624,BOM {0} must be submitted,BOM {0} må sendes
apps/erpnext/erpnext/config/accounts.py +504,Share Management,Aksjeforvaltning
DocType: Authorization Control,Authorization Control,Autorisasjon kontroll
apps/erpnext/erpnext/controllers/buying_controller.py +404,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 +817,Payment,Betaling
apps/erpnext/erpnext/controllers/stock_controller.py +96,"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: Work Order Operation,Actual Time and Cost,Faktisk leveringstid og pris
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +57,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: Amazon MWS Settings,DE,DE
DocType: Crop,Crop Spacing,Beskjæringsavstand
DocType: Course,Course Abbreviation,Kurs forkortelse
DocType: Budget,Action if Annual Budget Exceeded on PO,Handling hvis årlig budsjett overskrides på PO
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 +288,"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 +31,Employee {0} on Half day on {1},Employee {0} på halv dag {1}
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +59,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: Delivery Settings,Dispatch Settings,Dispatch Settings
DocType: Material Request Plan Item,Actual Qty,Selve Antall
DocType: Sales Invoice Item,References,Referanser
DocType: Quality Inspection Reading,Reading 10,Lese 10
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +48,Serial nos {0} does not belongs to the location {1},Serienummer {0} tilhører ikke posisjonen {1}
DocType: Item,Barcodes,strek~~POS=TRUNC
DocType: Hub Tracked Item,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 +117,Associate,Forbinder
DocType: Asset Movement,Asset Movement,Asset Movement
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +601,Work Order {0} must be submitted,Arbeidsordre {0} må sendes
apps/erpnext/erpnext/accounts/page/pos/pos.js +2225,New Cart,New Handlekurv
DocType: Taxable Salary Slab,From Amount,Fra beløp
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: Leave Type,Encashment,encashment
DocType: Delivery Settings,Delivery Settings,Leveringsinnstillinger
apps/erpnext/erpnext/hr/doctype/leave_policy/leave_policy.py +16,Maximum leave allowed in the leave type {0} is {1},Maksimum permisjon tillatt i permisjonstypen {0} er {1}
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: Sales Invoice Item,Deferred Revenue Account,Utsatt inntektskonto
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 +291,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 +768,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 +37,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/accounts/doctype/payment_entry/payment_entry.js +180,Can refer row only if the charge type is 'On Previous Row Amount' or 'Previous Row Total',Kan referere rad bare hvis belastningen typen er &#39;On Forrige Row beløp &quot;eller&quot; Forrige Row Totals
DocType: Sales Order Item,Delivery Warehouse,Levering Warehouse
DocType: Leave Type,Earned Leave Frequency,Opptjent permisjon
apps/erpnext/erpnext/config/accounts.py +279,Tree of financial Cost Centers.,Tre av finansielle kostnadssteder.
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +148,Sub Type,Undertype
DocType: Serial No,Delivery Document No,Levering Dokument nr
DocType: Sales Order Item,Ensure Delivery Based on Produced Serial No,Sørg for levering basert på produsert serienummer
DocType: Vital Signs,Furry,furry
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +197,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/assets/doctype/asset_movement/asset_movement.py +55,Target Location is required for the asset {0},Målplassering er nødvendig for aktiva {0}
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +42,"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
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +205,Material Consumption is not set in Manufacturing Settings.,Materialforbruk er ikke angitt i produksjonsinnstillinger.
DocType: Quality Inspection,MAT-QA-.YYYY.-,MAT-QA-.YYYY.-
apps/erpnext/erpnext/templates/pages/help.html +46,Visit the forums,Besøk forumene
DocType: Student,Student Mobile Number,Student Mobilnummer
DocType: Item,Has Variants,Har Varianter
DocType: Employee Benefit Claim,Claim Benefit For,Krav til fordel for
apps/erpnext/erpnext/templates/emails/training_event.html +11,Update Response,Oppdater svar
apps/erpnext/erpnext/public/js/utils.js +512,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 +100,Batch ID is mandatory,Batch-ID er obligatorisk
apps/erpnext/erpnext/stock/doctype/batch/batch.py +100,Batch ID is mandatory,Batch-ID er obligatorisk
DocType: Sales Person,Parent Sales Person,Parent Sales Person
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +102,No items to be received are overdue,Ingen elementer som skal mottas er for sent
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +101,The seller and the buyer cannot be the same,Selgeren og kjøperen kan ikke være det samme
DocType: Project,Collect Progress,Samle fremgang
DocType: Delivery Note,MAT-DN-.YYYY.-,MAT-DN-.YYYY.-
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
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +229,Serial no {0} has been already returned,Serienummer {0} har allerede blitt returnert
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
apps/erpnext/erpnext/hr/utils.py +198,A {0} exists between {1} and {2} (,En {0} eksisterer mellom {1} og {2} (
DocType: Vehicle Log,Fuel Price,Fuel Pris
DocType: Bank Guarantee,Margin Money,Marginpenger
DocType: Budget,Budget,Budsjett
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +79,Set Open,Sett inn
apps/erpnext/erpnext/stock/doctype/item/item.py +273,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 +60,"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/hr/utils.py +227,Max exemption amount for {0} is {1},Maks. Fritak for {0} er {1}
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
DocType: Healthcare Settings,Patient Encounters in valid days,Pasientmøter i gyldige dager
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +58,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 +55,Item Group Tree,Varegruppe treet
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +73,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
DocType: Asset,Insurance Start Date,Forsikring Startdato
DocType: Salary Component,Flexible Benefits,Fleksible fordeler
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +344,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 +201,There were errors.,Det var feil.
apps/erpnext/erpnext/hr/doctype/shift_request/shift_request.py +68,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
apps/erpnext/erpnext/accounts/doctype/account/account.js +45,Update Account Name / Number,Oppdater kontonavn / nummer
DocType: Naming Series,Current Value,Nåværende Verdi
apps/erpnext/erpnext/controllers/accounts_controller.py +321,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 +394,Amount {0} {1} deducted against {2},Mengden {0} {1} trukket mot {2}
DocType: Sales Person,Name and Employee ID,Navn og Employee ID
apps/erpnext/erpnext/accounts/party.py +337,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 +546,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 +160,Duties and Taxes,Skatter og avgifter
DocType: Projects Settings,Projects Settings,Prosjekter Innstillinger
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +392,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: Clinical Procedure,HLC-CPR-.YYYY.-,HLC-CPR-.YYYY.-
DocType: Purchase Order Item,Material Request Item,Materialet Request Element
apps/erpnext/erpnext/assets/doctype/asset/asset.py +294,Please cancel Purchase Receipt {0} first,Vennligst avbryt kjøp kvittering {0} først
apps/erpnext/erpnext/config/selling.py +75,Tree of Item Groups.,Tree of varegrupper.
DocType: Production Plan,Total Produced Qty,Totalt produsert antall
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +190,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
DocType: Delivery Note,Vehicle Type,Bil type
DocType: Sales Invoice Payment,Base Amount (Company Currency),Grunnbeløp (Selskap Valuta)
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +931,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
DocType: Shopify Settings,status html,status html
apps/erpnext/erpnext/setup/doctype/company/company.js +133,Delete all the Transactions for this Company,Slett alle transaksjoner for dette selskapet
DocType: Inpatient Record,O Positive,O Positiv
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +72,Investments,Investeringer
DocType: Issue,Resolution Details,Oppløsning Detaljer
apps/erpnext/erpnext/accounts/report/tds_payable_monthly/tds_payable_monthly.py +167,Transaction Type,Transaksjonstype
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
apps/erpnext/erpnext/hr/doctype/loan/loan.py +154,No repayments available for Journal Entry,Ingen tilbakebetalinger tilgjengelig for Journal Entry
DocType: Hub Tracked Item,Image List,Bildeliste
DocType: Item Attribute,Attribute Name,Attributt navn
DocType: BOM,Show In Website,Show I Website
DocType: 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/accounts/doctype/budget/budget.py +44,Another Budget record '{0}' already exists against {1} '{2}' and account '{3}' for fiscal year {4},En annen budsjettrekord &#39;{0}&#39; eksisterer allerede mot {1} &#39;{2}&#39; og konto &#39;{3}&#39; for regnskapsåret {4}
apps/erpnext/erpnext/config/projects.py +36,Gantt chart of all tasks.,Gantt diagram av alle oppgaver.
DocType: Opportunity,Mins to First Response,Minutter til First Response
DocType: Pricing Rule,Margin Type,margin Type
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +15,{0} hours,{0} timer
DocType: Course,Default Grading Scale,Standard Grading Scale
DocType: Appraisal,For Employee Name,For Employee Name
DocType: Holiday List,Clear Table,Clear Table
DocType: Woocommerce Settings,Tax Account,Skattkonto
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +135,Available slots,Tilgjengelige spor
DocType: C-Form Invoice Detail,Invoice No,Faktura Nei
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +408,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 +115,"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 +234,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: Payroll Entry,Deduct Tax For Unsubmitted Tax Exemption Proof,Fradragsskatt for ikke-innvilget skattefrihetsbevis
DocType: Volunteer,Anytime,Når som helst
DocType: Bank Account,Bank Account No,Bankkonto nr
DocType: Employee Tax Exemption Proof Submission,Employee Tax Exemption Proof Submission,Skattefrihetsbevis for arbeidstakere
DocType: Patient,Surgical History,Kirurgisk historie
DocType: Bank Statement Settings Item,Mapped Header,Mapped Header
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 +115,Not Set,Ikke sett
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +417,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 +417,Please set the Date Of Joining for employee {0},Vennligst sett datoen for å bli med på ansatt {0}
DocType: Inpatient Record,Discharge,Utslipp
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: Bank Statement Settings,Mapped Items,Mappede elementer
DocType: Amazon MWS Settings,IT,DEN
DocType: Chapter,Chapter,Kapittel
apps/erpnext/erpnext/utilities/user_progress.py +146,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 +1045,Select BOM and Qty for Production,Velg BOM og Stk for produksjon
DocType: Asset,Depreciation Schedule,avskrivninger Schedule
apps/erpnext/erpnext/config/selling.py +124,Sales Partner Addresses And Contacts,Salgspartneradresser og kontakter
DocType: Bank Reconciliation Detail,Against Account,Mot konto
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +84,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 +135,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 +107,Annual Billing: {0},Årlig Billing: {0}
DocType: Shopify Webhook Detail,Shopify Webhook Detail,Shopify Webhook Detail
apps/erpnext/erpnext/config/accounts.py +228,Goods and Services Tax (GST India),Varer og tjenester skatt (GST India)
DocType: Delivery Note,Excise Page Number,Vesenet Page Number
DocType: Asset,Purchase Date,Kjøpsdato
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js +33,Could not generate Secret,Kunne ikke generere hemmelig
DocType: Volunteer,Volunteer Type,Frivillig Type
DocType: Payment Request,ACC-PRQ-.YYYY.-,ACC-PRQ-.YYYY.-
DocType: Shift Assignment,Shift Type,Shift Type
DocType: Student,Personal Details,Personlig Informasjon
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +199,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 +389,Amount {0} {1} against {2} {3},Mengden {0} {1} mot {2} {3}
,Quotation Trends,Anførsels Trender
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +166,Item Group not mentioned in item master for item {0},Varegruppe ikke nevnt i punkt master for elementet {0}
DocType: GoCardless Mandate,GoCardless Mandate,GoCardless Mandat
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +439,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/public/js/event.js +19,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: Loyalty Program,Conversion Factor,Omregningsfaktor
DocType: Purchase Order,Delivered,Levert
,Vehicle Expenses,Vehicle Utgifter
DocType: Healthcare Settings,Create Lab Test(s) on Sales Invoice Submit,Opprett Lab Test (er) på salgsfaktura Send
DocType: Serial No,Invoice Details,Fakturadetaljer
DocType: Grant Application,Show on Website,Vis på nettstedet
apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +29,Start on,Start på
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +54,Supplier &gt; Supplier Group,Leverandør&gt; Leverandørgruppe
DocType: Hub Tracked Item,Hub Category,Hub kategori
DocType: Purchase Invoice,SEZ,SEZ
DocType: Purchase Receipt,Vehicle Number,Vehicle Number
DocType: Loan,Loan Amount,Lånebeløp
DocType: Student Report Generation Tool,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 +464,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 +112,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: Contract Fulfilment Checklist,Requirement,Krav
DocType: Journal Entry,Accounts Receivable,Kundefordringer
DocType: Travel Itinerary,Meal Preference,Måltidsperspektiv
,Supplier-Wise Sales Analytics,Leverandør-Wise Salgs Analytics
DocType: Purchase Invoice,Availed ITC Central Tax,Availed ITC Central Tax
DocType: Sales Invoice,Company Address Name,Bedriftsadresse Navn
DocType: Work 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
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +331,CESS Amount,CESS-beløp
DocType: Woocommerce Settings,Enable Sync,Aktiver synkronisering
DocType: Tax Withholding Rate,Single Transaction Threshold,Enkelt transaksjonsgrense
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 +102,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
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1797,Get Items from Prescriptions,Få varer fra resepter
DocType: Patient,Patient Details,Pasientdetaljer
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +212,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Vennligst still inn navngivningsserien for {0} via Setup&gt; Settings&gt; Naming Series
DocType: Inpatient Record,B Positive,B Positiv
apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py +31,"Maximum benefit of employee {0} exceeds {1} by the sum {2} of previous claimed\
			amount",Maksimal nytte av arbeidstakeren {0} overstiger {1} med summen {2} av tidligere hevdet \ beløp
apps/erpnext/erpnext/controllers/accounts_controller.py +655,"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 +349,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 +67,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 +85,Total Actual,Total Actual
DocType: Student Siblings,Student Siblings,student Søsken
DocType: Subscription Plan Detail,Subscription Plan Detail,Abonnementsplandetaljer
apps/erpnext/erpnext/utilities/user_progress.py +146,Unit,Enhet
apps/erpnext/erpnext/stock/get_item_details.py +157,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 +125,Please set B2C Limit in GST Settings.,Vennligst sett inn B2C Limit i GST-innstillinger.
DocType: Marketplace Settings,Marketplace Settings,Markedsplassinnstillinger
DocType: Purchase Invoice,Warehouse where you are maintaining stock of rejected items,Warehouse hvor du opprettholder lager avviste elementer
DocType: Work Order,Skip Material Transfer,Hopp over materialoverføring
DocType: Work Order,Skip Material Transfer,Hopp over materialoverføring
apps/erpnext/erpnext/setup/utils.py +112,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
DocType: Employee Tax Exemption Declaration,Total Exemption Amount,Totalt dispensasjonsbeløp
,BOM Search,BOM Søk
DocType: Project,Total Consumed Material Cost  (via Stock Entry),Total forbruket materialkostnad (via lagerinngang)
DocType: Subscription,Subscription Period,Abonnementsperiode
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.js +169,To Date cannot be less than From Date,Til dato kan ikke være mindre enn Fra dato
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å
apps/erpnext/erpnext/controllers/accounts_controller.py +361,Account {0} is invalid. Account Currency must be {1},Konto {0} er ugyldig. Account Valuta må være {1}
apps/erpnext/erpnext/hr/doctype/salary_structure_assignment/salary_structure_assignment.py +31,From Date {0} cannot be after employee's relieving Date {1},Fra dato {0} kan ikke være etter ansattes avlastningsdato {1}
DocType: Supplier,Is Internal Supplier,Er Intern Leverandør
DocType: Employee,Create User Permission,Opprett brukertillatelse
DocType: Employee Benefit Claim,Employee Benefit Claim,Ansattefordelskrav
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 +1120,"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: Loyalty Program,1 Loyalty Points = How much base currency?,1 Lojalitetspoeng = Hvor mye grunnvaluta?
DocType: Salary Component,Deduction,Fradrag
DocType: Item,Retain Sample,Behold prøve
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +109,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 +416,Item Price added for {0} in Price List {1},Varen Pris lagt for {0} i Prisliste {1}
DocType: Delivery Stop,Order Information,BESTILLINGSINFORMASJON
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 +78,In Production,I produksjon
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +66,Difference Amount must be zero,Forskjellen Beløpet må være null
DocType: Project,Gross Margin,Bruttomargin
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +74,{0} applicable after {1} working days,{0} gjelder etter {1} arbeidsdager
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +60,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 +970,Quotation,Sitat
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +971,Cannot set a received RFQ to No Quote,Kan ikke angi en mottatt RFQ til No Quote
DocType: Salary Slip,Total Deduction,Total Fradrag
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +22,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 +213,Cost Updated,Kostnad Oppdatert
DocType: Inpatient Record,Date of Birth,Fødselsdato
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +136,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
DocType: Work Order Operation,Work Order Operation,Arbeidsordreoperasjon
apps/erpnext/erpnext/stock/doctype/item/item.py +248,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: Work 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 +219,Job Description,Stillingsbeskrivelse
DocType: Student Applicant,Applied,Tatt i bruk
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +871,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: Attendance,Attendance Request,Deltakelsesforespørsel
DocType: Purchase Invoice,02-Post Sale Discount,02-post salg rabatt
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +139,"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."
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.py +115,You can't redeem Loyalty Points having more value than the Grand Total.,Du kan ikke innløse Lojalitetspoeng som har mer verdi enn Grand Total.
DocType: Department Approver,Approver,Godkjenner
,SO Qty,SO Antall
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +92,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: Employee,Health Insurance,Helseforsikring
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 +115,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 +243,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/accounts/doctype/bank_account/bank_account.py +24,Company is manadatory for company account,Selskapet er manadatory for selskapskonto
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1021,"Item Code, warehouse, quantity are required on row","Varenummer, lager, antall er påkrevd på rad"
DocType: Bank Guarantee,Supplier,Leverandør
apps/erpnext/erpnext/accounts/doctype/payment_order/payment_order.js +9,Get From,Få Fra
apps/erpnext/erpnext/hr/doctype/department/department.js +9,This is a root department and cannot be edited.,Dette er en rotavdeling og kan ikke redigeres.
apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js +41,Show Payment Details,Vis betalingsdetaljer
apps/erpnext/erpnext/crm/report/lead_conversion_time/lead_conversion_time.py +53,Duration in Days,Varighet i dager
DocType: C-Form,Quarter,Quarter
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +113,Miscellaneous Expenses,Diverse utgifter
DocType: Global Defaults,Default Company,Standard selskapet
DocType: Company,Transactions Annual History,Transaksjoner Årlig Historie
apps/erpnext/erpnext/controllers/stock_controller.py +231,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: Bank,Bank Name,Bank Name
apps/erpnext/erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.py +33,-Above,-Above
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1218,Leave the field empty to make purchase orders for all suppliers,La feltet være tomt for å foreta bestillinger for alle leverandører
DocType: Healthcare Practitioner,Inpatient Visit Charge Item,Inpatient Visit Charge Item
DocType: Vital Signs,Fluid,Væske
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 +107,Item Variant Settings,Variantinnstillinger
apps/erpnext/erpnext/manufacturing/page/production_analytics/production_analytics.js +37,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/accounts/doctype/sales_invoice/sales_invoice.py +505,{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 +218,Please set GST Accounts in GST Settings,Vennligst sett GST-kontoer i GST-innstillinger
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js +46,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 +143,Cost of New Purchase,Kostnad for nye kjøp
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +98,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: Subscription,Discounts,rabatter
DocType: Payment Entry,Unallocated Amount,uallokert Beløp
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +77,Please enable Applicable on Purchase Order and Applicable on Booking Actual Expenses,Vennligst aktiver gjeldende på innkjøpsordre og gjeldende ved bestilling av faktiske kostnader
apps/erpnext/erpnext/templates/includes/product_page.js +101,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 +184,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
DocType: Purchase Order,PUR-ORD-.YYYY.-,PUR-ORD-.YYYY.-
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
DocType: Payment Request,Transaction Details,Transaksjonsdetaljer
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: Blanket Order Item,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
DocType: Item Default,Purchase Defaults,Kjøpsstandarder
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +117,Make Job Card,Lag jobbkort
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +326,"Could not create Credit Note automatically, please uncheck 'Issue Credit Note' and submit again","Kunne ikke opprette kredittnota automatisk, vennligst fjern merket for &quot;Utsted kredittnota&quot; og send igjen"
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 +126,{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 +92,Tree of financial accounts.,Tre av finansregnskap.
DocType: Bank Guarantee,Reference Document Type,Reference Document Type
DocType: Cash Flow Mapping,Cash Flow Mapping,Cash Flow Mapping
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +400,{0} against Sales Order {1},{0} mot Salgsordre {1}
DocType: Account,Fixed Asset,Fast Asset
DocType: Amazon MWS Settings,After Date,Etter dato
apps/erpnext/erpnext/config/stock.py +327,Serialized Inventory,Serialisert Lager
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +1166,Invalid {0} for Inter Company Invoice.,Ugyldig {0} for interfirmafaktura.
,Department Analytics,Avdeling Analytics
apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +74,Email not found in default contact,E-post ikke funnet i standardkontakt
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js +23,Generate Secret,Generer hemmelighet
DocType: 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: Bank Statement Transaction Entry,Receivable Account,Fordring konto
apps/erpnext/erpnext/stock/doctype/item_price/item_price.py +31,Valid From Date must be lesser than Valid Upto Date.,Gyldig fra dato må være mindre enn gyldig utløpsdato.
apps/erpnext/erpnext/controllers/accounts_controller.py +673,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 +327,Sales Order to Payment,Salgsordre til betaling
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +111,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: Exchange Rate Revaluation Account,New Balance In Base Currency,Ny balanse i basisvaluta
DocType: Location,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 +915,Please select correct account,Velg riktig konto
DocType: Salary Structure Assignment,Salary Structure Assignment,Lønnsstrukturoppgave
DocType: Purchase Invoice Item,Weight UOM,Vekt målenheter
apps/erpnext/erpnext/config/accounts.py +510,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 +56,Show Variant Attributes,Vis variantattributter
DocType: Student,Blood Group,Blodgruppe
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +48,The payment gateway account in plan {0} is different from the payment gateway account in this payment request,Betalingsgatewaykontoen i plan {0} er forskjellig fra betalingsgatewaykontoen i denne betalingsanmodningen
DocType: Course,Course Name,Course Name
apps/erpnext/erpnext/accounts/doctype/tax_withholding_category/tax_withholding_category.py +50,No Tax Withholding data found for the current Fiscal Year.,Ingen skattelettende data funnet for det nåværende regnskapsåret.
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 +53,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 +359,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 +101,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
apps/erpnext/erpnext/templates/pages/integrations/gocardless_confirmation.html +13,Payment Confirmation,Betalingsbekreftelse
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 +433,Debit To is required,Debet Å kreves
DocType: Clinical Procedure,Inpatient Record,Inpatient Record
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 +41,Purchase Price List,Kjøp Prisliste
apps/erpnext/erpnext/accounts/report/tds_payable_monthly/tds_payable_monthly.py +161,Date of Transaction,Dato for transaksjon
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
apps/erpnext/erpnext/public/js/utils.js +109,Total Unpaid: {0},Total Ubetalte: {0}
DocType: BOM Website Operation,BOM Website Operation,BOM Nettstedet Operasjon
DocType: Bank Statement Transaction Payment Item,outstanding_amount,utestående beløp
DocType: Supplier Scorecard,Supplier Score,Leverandørpoeng
apps/erpnext/erpnext/healthcare/doctype/patient_encounter/patient_encounter.js +37,Schedule Admission,Planleggingsopptak
DocType: Tax Withholding Rate,Cumulative Transaction Threshold,Kumulativ transaksjonsgrense
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +231,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: Cashier Closing,To Time,Til Time
apps/erpnext/erpnext/hr/utils.py +201,) for {0},) for {0}
DocType: Authorization Rule,Approving Role (above authorized value),Godkjenne Role (ovenfor autorisert verdi)
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +146,Credit To account must be a Payable account,Kreditt til kontoen må være en Betales konto
DocType: Loan,Total Amount Paid,Totalt beløp betalt
DocType: Asset,Insurance End Date,Forsikrings sluttdato
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 +364,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/accounts/doctype/cost_center/cost_center_tree.js +40,Budget List,Budsjettliste
DocType: Work Order Operation,Completed Qty,Fullført Antall
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +180,"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
DocType: Manufacturing Settings,Allow Overtime,Tillat Overtid
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +149,"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 +149,"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 +1295,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/practitioner_schedule/practitioner_schedule.js +7,Add Time Slots,Legg til tidsluker
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +206,{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: Training Event,Advance,Avansere
apps/erpnext/erpnext/config/integrations.py +13,GoCardless payment gateway settings,GoCardless betalings gateway innstillinger
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +129,Exchange Gain/Loss,Valutagevinst / tap
DocType: Opportunity,Lost Reason,Mistet Reason
DocType: Amazon MWS Settings,Enable Amazon,Aktiver Amazon
apps/erpnext/erpnext/controllers/accounts_controller.py +312,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 +411,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/hr/doctype/leave_allocation/leave_allocation.py +40,Total allocated leaves are more days than maximum allocation of {0} leave type for employee {1} in the period,Totalt tildelte blader er flere dager enn maksimal tildeling av {0} permisjonstype for ansatt {1} i perioden
apps/erpnext/erpnext/config/setup.py +66,Users and Permissions,Brukere og tillatelser
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: Payment Request,Subscription Plans,Abonnementsplaner
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
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
DocType: Healthcare Service Unit Type,Healthcare Service Unit Type,Helsesektorenhetstype
apps/erpnext/erpnext/projects/doctype/project/project.py +278,You have been invited to collaborate on the project: {0},Du har blitt invitert til å samarbeide om prosjektet: {0}
DocType: Supplier Group,Parent Supplier Group,Foreldre Leverandørgruppe
DocType: Email Digest,Purchase Orders to Bill,Innkjøpsordrer til Bill
apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.js +47,Accumulated Values in Group Company,Akkumulerte verdier i konsernselskapet
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å
DocType: Employee Tax Exemption Proof Submission Detail,Type of Proof,Type bevis
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 +100,"Create and manage daily, weekly and monthly email digests.","Opprette og administrere daglige, ukentlige og månedlige e-postfordøyer."
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_dashboard.py +6,This is based on transactions against this Sales Person. See timeline below for details,Dette er basert på transaksjoner mot denne selgeren. Se tidslinjen nedenfor for detaljer
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 +59,Buildings,bygninger
apps/erpnext/erpnext/hr/doctype/employee_tax_exemption_declaration/employee_tax_exemption_declaration.py +24,Tax Declaration of {0} for period {1} already submitted.,Skattedeklarasjon av {0} for perioden {1} allerede innlevert.
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.py +76,Leaves has been granted sucessfully,Blader har blitt gitt suksessivt
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 +75,Submit Salary Slip,Send Lønn Slip
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js +13,On Hold,På vent
DocType: Account,Inter Company Account,Inter Company Account
apps/erpnext/erpnext/stock/doctype/item_price/item_price.js +17,Import in Bulk,Import i Bulk
DocType: Sales Partner,Address & Contacts,Adresse og Kontakt
DocType: SMS Log,Sender Name,Avsender Navn
DocType: Vital Signs,Very Hyper,Veldig Hyper
DocType: Agriculture Analysis Criteria,Agriculture Analysis Criteria,Landbruk Analyse Kriterier
DocType: HR Settings,Leave Approval Notification Template,Legg igjen godkjenningsmeldingskjemaet
DocType: POS Profile,[Select],[Velg]
DocType: Staffing Plan Detail,Number Of Positions,Antall posisjoner
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 +62,Softwares,programvare
apps/erpnext/erpnext/crm/doctype/lead/lead.py +53,Next Contact Date cannot be in the past,Neste Kontakt Datoen kan ikke være i fortiden
DocType: Company,For Reference Only.,For referanse.
apps/erpnext/erpnext/accounts/page/pos/pos.js +2592,Select Batch No,Velg batchnummer
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +79,Invalid {0}: {1},Ugyldig {0}: {1}
,GSTR-1,GSTR-en
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
DocType: Asset,Policy number,Politikk nummer
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,New Workplace,Nye arbeidsplassen
DocType: Retention Bonus,Retention Bonus,Retensjonsbonus
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +458,Material Consumption,Materialforbruk
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +17,Set as Closed,Sett som Stengt
apps/erpnext/erpnext/stock/get_item_details.py +146,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
DocType: Tax Withholding Rate,Tax Withholding Rate,Skattefradrag
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +545,Boms,Boms
apps/erpnext/erpnext/stock/doctype/item/item.py +177,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 +45,Ageing Based On,Aldring Based On
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +103,Appointment cancelled,Avtale kansellert
DocType: Item,End of Life,Slutten av livet
apps/erpnext/erpnext/demo/setup/setup_data.py +325,Travel,Reise
DocType: Student Report Generation Tool,Include All Assessment Group,Inkluder alle vurderingsgrupper
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +266,No active or default Salary Structure found for employee {0} for the given dates,Ingen aktive eller standard Lønn Struktur funnet for arbeidstaker {0} for den gitte datoer
DocType: Leave Block List,Allow Users,Gi brukere
DocType: Purchase Order,Customer Mobile No,Kunden Mobile No
DocType: Cash Flow Mapping Template Details,Cash Flow Mapping Template Details,Kontantstrøm kartlegging detaljer
apps/erpnext/erpnext/config/non_profit.py +68,Loan Management,Lånestyring
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 +81,Update Cost,Oppdater Cost
DocType: Item Reorder,Item Reorder,Sak Omgjøre
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +448,Show Salary Slip,Vis Lønn Slip
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +810,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."
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +181,Supplier &gt; Supplier Type,Leverandør&gt; Leverandør Type
DocType: Travel Request,Any other details,Eventuelle andre detaljer
DocType: Water Analysis,Origin,Opprinnelse
apps/erpnext/erpnext/controllers/status_updater.py +207,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 +1221,Please set recurring after saving,Vennligst sett gjentakende etter lagring
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +871,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 +99,Cash Flow from Financing,Kontantstrøm fra finansierings
DocType: Budget Account,Budget Account,budsjett konto
DocType: Quality Inspection,Verified By,Verified by
DocType: Travel Request,Name of Organizer,Navn på arrangør
apps/erpnext/erpnext/setup/doctype/company/company.py +84,"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: Clinical Procedure,Is Invoiced,Er fakturert
DocType: Stock Entry,Purchase Receipt No,Kvitteringen Nei
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +31,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 +144,Source of Funds (Liabilities),Source of Funds (Gjeld)
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +52,Source and Target Location cannot be same,Kilde og målplassering kan ikke være det samme
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +518,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: Bank Guarantee,Fixed Deposit Number,Fast innskuddsnummer
DocType: Asset Repair,Failure Date,Feil dato
DocType: Support Search Source,Result Title Field,Resultattittelfelt
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 +242,Select Batch,Velg Batch
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +276,{0} {1} is fully billed,{0} {1} er fullt fakturert
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +30,Vital Signs,Livstegn
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.
DocType: BOM Item,Item operation,Vareoperasjon
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +327,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/selling/page/sales_funnel/sales_funnel.js +42,Sales Pipeline,salgs~~POS=TRUNC
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +163,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/subscription/subscription.js +13,Fetch Subscription Updates,Hent abonnementsoppdateringer
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 +707,Specified BOM {0} does not exist for Item {1},Spesifisert BOM {0} finnes ikke for Element {1}
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +301,Course: ,Kurs:
DocType: Soil Texture,Sandy Loam,Sandy Loam
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +242,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: Supplier Quotation,PUR-SQTN-.YYYY.-,PUR-SQTN-.YYYY.-
DocType: Notification Control,Expense Claim Approved,Expense krav Godkjent
DocType: Purchase Invoice,Set Advances and Allocate (FIFO),Angi fremskritt og tilordne (FIFO)
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +231,No Work Orders created,Ingen arbeidsordre opprettet
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +403,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 +144,Pharmaceutical,Pharmaceutical
apps/erpnext/erpnext/hr/doctype/leave_encashment/leave_encashment.py +24,You can only submit Leave Encashment for a valid encashment amount,Du kan kun sende permittering for et gyldig innkjøpsbeløp
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: Employee Separation,Employee Separation Template,Medarbeider separasjonsmal
DocType: Selling Settings,Sales Order Required,Salgsordre Påkrevd
apps/erpnext/erpnext/public/js/hub/marketplace.js +107,Become a Seller,Bli en selger
DocType: Purchase Invoice,Credit To,Kreditt til
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +33,Active Leads / Customers,Aktive Ledninger / Kunder
DocType: Delivery Settings,Leave blank to use the standard Delivery Note format,La stå tomt for å bruke standardleveringsformat
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 +248,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: Support Search Source,Post Title Key,Posttittelnøkkel
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +232,For Job Card,For jobbkort
DocType: Warranty Claim,Raised By,Raised By
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1552,Prescriptions,resepter
DocType: Payment Gateway Account,Payment Account,Betaling konto
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +1042,Please specify Company to proceed,Vennligst oppgi selskapet å fortsette
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +81,Net Change in Accounts Receivable,Netto endring i kundefordringer
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +91,Compensatory Off,Kompenserende Off
DocType: Job Offer,Accepted,Akseptert
DocType: POS Closing Voucher,Sales Invoices Summary,Sammendrag av salgsfakturaer
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +222,To Party Name,Til Festnavn
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_calculated/bom_stock_calculated.js +23,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 +111,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 +101,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/education/doctype/fee_schedule/fee_schedule.js +76,View Fees Records,Se avgifter
apps/erpnext/erpnext/setup/doctype/company/company.js +55,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 +328,Raw Materials cannot be blank.,Råvare kan ikke være blank.
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +1022,Row #{0} (Payment Table): Amount must be negative,Rad # {0} (betalingstabell): beløpet må være negativt
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +569,"Could not update stock, invoice contains drop shipping item.","Kunne ikke oppdatere lager, inneholder faktura slippe frakt element."
DocType: Contract,Fulfilment Status,Oppfyllelsesstatus
DocType: Lab Test Sample,Lab Test Sample,Lab Test prøve
DocType: Item Variant Settings,Allow Rename Attribute Value,Tillat omdøpe attributtverdi
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +533,Quick Journal Entry,Hurtig Journal Entry
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +244,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
apps/erpnext/erpnext/accounts/doctype/account/account.js +140,Update Account Number / Name,Oppdater Kontonummer / Navn
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +413,Assign Salary Structure,Tilordne lønnsstruktur
DocType: Support Settings,Response Key List,Response Key List
DocType: Job Card,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}
DocType: Support Search Source,API,API
DocType: Support Search Source,Result Preview Field,Resultatforhåndsvisningsfelt
DocType: Item Price,Packing Unit,Pakkeenhet
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +273,{0} {1} is not submitted,{0} {1} ikke er sendt
DocType: Subscription,Trialling,Tester ut
DocType: Sales Invoice Item,Deferred Revenue,Utsatt inntekt
DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,Kontantkonto brukes til opprettelse av salgsfaktura
DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,Fritak underkategori
apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +31,Supplier Group / Supplier,Leverandørgruppe / Leverandør
DocType: Member,Membership Expiry Date,Medlemskapets utløpsdato
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +134,{0} must be negative in return document,{0} må være negativ i retur dokument
DocType: Employee Tax Exemption Proof Submission,Submission Date,Innleveringsdato
,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 +45,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)
DocType: Student Admission Program,Naming Series (for Student Applicant),Naming Series (Student søkeren)
apps/erpnext/erpnext/hr/doctype/retention_bonus/retention_bonus.py +16,Bonus Payment Date cannot be a past date,Bonus Betalingsdato kan ikke være en siste dato
DocType: Travel Request,Copy of Invitation/Announcement,Kopi av invitasjon / kunngjøring
DocType: Practitioner Service Unit Schedule,Practitioner Service Unit Schedule,Utøvere Service Unit Schedule
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 +97,Total Absent,Total Fraværende
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1060,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 +194,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 +1013,Opportunity,Opportunity
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 +279,{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 +56,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
,TDS Computation Summary,TDS-beregningsoppsummering
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 +180,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: Job Card,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: Authorization Rule,Applicable To (Role),Gjelder til (Role)
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html +10,Pending Leaves,Venter på bladene
DocType: BOM Update Tool,Replace BOM,Erstatt BOM
apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.py +113,Code {0} already exist,Kode {0} finnes allerede
DocType: Patient Encounter,Procedures,prosedyrer
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py +36,Sales orders are not available for production,Salgsordrer er ikke tilgjengelige for produksjon
DocType: Asset Movement,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: Work Order,Manufacture against Material Request,Produksjon mot Material Request
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +17,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 +328,Leave Without Pay does not match with approved Leave Application records,Dager uten lønn samsvarer ikke med godkjente Dager uten lønn
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +21,Next Steps,Neste skritt
DocType: Travel Request,Domestic,Innenlands
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +783,Please supply the specified items at the best possible rates,Vennligst oppgi de angitte elementene på de best mulige priser
apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py +19,Employee Transfer cannot be submitted before Transfer Date ,Ansatteoverføring kan ikke sendes før overføringsdato
DocType: Certification Application,USD,USD
apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.js +7,Make Invoice,Gjør Faktura
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +103,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 +83,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 +515,Barcode {0} is not a valid {1} code,Strekkode {0} er ikke en gyldig {1} kode
apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.js +25,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 +134,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: 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 +412,{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 +55,Ageing Range 1,Aldring Range 1
DocType: Shopify Settings,Enable Shopify,Aktiver Shopify
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +219,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
DocType: Grant Application,Grant Application Details ,Gi søknadsdetaljer
DocType: Employee Separation,Employee Separation,Ansattes separasjon
DocType: BOM Item,Original Item,Originalelement
DocType: Purchase Receipt Item,Recd Quantity,Recd Antall
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +167,Doc Date,Dok dato
apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py +64,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 +1017,Row #{0} (Payment Table): Amount must be positive,Row # {0} (Betalingstabell): Beløpet må være positivt
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 +440,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 +583,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 +47,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ønnstype konto
DocType: Global Defaults,Hide Currency Symbol,Skjule Valutasymbol
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.js +281,Sales Opportunities by Source,Salgsmuligheter ved kilde
apps/erpnext/erpnext/config/non_profit.py +58,Donor information.,Donorinformasjon.
apps/erpnext/erpnext/config/accounts.py +368,"e.g. Bank, Cash, Credit Card","f.eks Bank, Cash, Kredittkort"
DocType: Job Applicant,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 +124,"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 +182,{0} is a company holiday,{0} er en firmas ferie
apps/erpnext/erpnext/patches/v11_0/add_default_email_template_for_leave.py +19,Leave Status Notification,Oppgi statusmelding
DocType: Patient Appointment,Procedure Prescription,Prosedyre Forskrift
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +50,Furnitures and Fixtures,Møbler og inventar
DocType: Travel Request,Travel Type,Reisetype
DocType: Item,Manufacture,Produksjon
DocType: Blanket Order,MFG-BLR-.YYYY.-,MFG-BLR-.YYYY.-
apps/erpnext/erpnext/utilities/user_progress.py +27,Setup Company,Oppsett Company
,Lab Test Report,Lab Test Report
DocType: Employee Benefit Application,Employee Benefit Application,Ansattes fordel søknad
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 Component,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 +115,Clearance Date not mentioned,Klaring Dato ikke nevnt
DocType: Payroll Period,Taxable Salary Slabs,Skattepliktig lønnsplater
apps/erpnext/erpnext/config/manufacturing.py +7,Production,Produksjon
DocType: Guardian,Occupation,Okkupasjon
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +210,For Quantity must be less than quantity {0},For Mengde må være mindre enn mengde {0}
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: Salary Component,Max Benefit Amount (Yearly),Maksimal fordelbeløp (Årlig)
apps/erpnext/erpnext/accounts/report/tds_computation_summary/tds_computation_summary.py +118,TDS Rate %,TDS Rate%
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/utilities/user_progress.py +31,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/controllers/accounts_controller.py +362, 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 +127,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 +253,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
apps/erpnext/erpnext/patches/v11_0/add_default_email_template_for_leave.py +7,Leave Approval Notification,Legg igjen godkjenningsvarsling
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 +49,Buying Rate,Kjøpspris
apps/erpnext/erpnext/controllers/buying_controller.py +590,Row {0}: Enter location for the asset item {1},Row {0}: Angi plassering for aktivelementet {1}
DocType: Request for Quotation,PUR-RFQ-.YYYY.-,PUR-RFQ-.YYYY.-
DocType: Company,About the Company,Om selskapet
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 +245,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 +245,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: Asset Maintenance Log,ACC-AML-.YYYY.-,ACC-AML-.YYYY.-
DocType: Payroll Entry,Select Employees,Velg Medarbeidere
DocType: Shopify Settings,Sales Invoice Series,Salgsfaktura-serien
DocType: Opportunity,Potential Sales Deal,Potensielle Sales Deal
DocType: Complaint,Complaints,klager
DocType: Employee Tax Exemption Declaration,Employee Tax Exemption Declaration,Ansvarserklæring om ansattes skattefradrag
DocType: Payment Entry,Cheque/Reference Date,Sjekk / Reference Date
DocType: Purchase Invoice,Total Taxes and Charges,Totale skatter og avgifter
apps/erpnext/erpnext/assets/doctype/asset/asset.py +89,Available-for-use Date is entered as past date,Tilgjengelig for bruk Dato er oppgitt som siste dato
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 +78,Ledger,Ledger
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;."
DocType: Journal Entry,Paid Loan,Betalt lån
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
DocType: Leave Type,Applicable After (Working Days),Gjelder etter (arbeidsdager)
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 +351,Not Paid and Not Delivered,Ikke betalt og ikke levert
DocType: Product Bundle,Parent Item,Parent Element
DocType: Account,Account Type,Kontotype
DocType: Shopify Settings,Webhooks Details,Webhooks Detaljer
apps/erpnext/erpnext/templates/pages/projects.html +58,No time sheets,Ingen timelister
DocType: GoCardless Mandate,GoCardless Customer,GoCardless kunde
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +160,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
DocType: Leave Encashment,Payroll,lønn
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +209,"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"
DocType: Healthcare Service Unit,Parent Service Unit,Foreldre Service Unit
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
DocType: Bank Reconciliation,Include POS Transactions,Inkluder POS-transaksjoner
DocType: Purchase Invoice,Inter Company Invoice Reference,Interfirma faktura referanse
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +883,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 +77,Arrear,etterskudd
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +173,Depreciation Amount during the period,Avskrivningsbeløpet i perioden
DocType: Sales Invoice,Is Return (Credit Note),Er retur (kredittnota)
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.js +26,Start Job,Start jobb
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +32,Serial no is required for the asset {0},Serienummer er nødvendig for aktiva {0}
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 +290,For row {0}: Enter planned qty,For rad {0}: Skriv inn planlagt antall
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 +880,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/public/js/event.js +23,Add Suppliers,Legg til leverandører
DocType: Sales Invoice,ACC-SINV-.YYYY.-,ACC-SINV-.YYYY.-
DocType: Loyalty Program,Help Section,Hjelpseksjon
apps/erpnext/erpnext/templates/generators/item_group.html +26,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 +163,Set default inventory account for perpetual inventory,Angi standard beholdningskonto for evigvarende beholdning
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +261,"Cannot deliver Serial No {0} of item {1} as it is reserved to \
												fullfill Sales Order {2}",Kan ikke levere serienummeret {0} av elementet {1} som det er reservert for \ fullfill salgsordre {2}
DocType: Item Reorder,Material Request Type,Materialet Request Type
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 +859,"LocalStorage is full, did not save","Localstorage er full, ikke redde"
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +130,Row {0}: UOM Conversion Factor is mandatory,Rad {0}: målenheter omregningsfaktor er obligatorisk
DocType: Employee Benefit Claim,Claim Date,Krav på dato
apps/erpnext/erpnext/utilities/user_progress.py +235,Room Capacity,Romkapasitet
apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py +28,Already record exists for the item {0},Det finnes allerede en post for elementet {0}
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html +28,Ref,Ref
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js +48,You will lose records of previously generated invoices. Are you sure you want to restart this subscription?,Du vil miste oversikt over tidligere genererte fakturaer. Er du sikker på at du vil starte dette abonnementet på nytt?
DocType: Lab Test,LP-,LP-
DocType: Healthcare Settings,Registration Fee,Registreringsavgift
DocType: Loyalty Program Collection,Loyalty Program Collection,Lojalitetsprogram samling
DocType: Stock Entry Detail,Subcontracted Item,Underleverandør
apps/erpnext/erpnext/education/__init__.py +9,Student {0} does not belong to group {1},Student {0} tilhører ikke gruppe {1}
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
DocType: Purchase Invoice,Total Quantity,Totalt antall
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
DocType: Shopify Settings,Shopify Settings,Shopify Innstillinger
DocType: Amazon MWS Settings,Market Place ID,Markedsplass ID
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +122,Head of Marketing and Sales,Head of Marketing and Sales
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +75,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 +101,Go to Letterheads,Gå til Letterheads
DocType: Subscription,Cancel At End Of Period,Avbryt ved slutten av perioden
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js +114,Property already added,Eiendom allerede lagt til
DocType: Item Supplier,Item Supplier,Sak Leverandør
apps/erpnext/erpnext/public/js/controllers/transaction.js +1322,Please enter Item Code to get batch no,Skriv inn Element kode for å få batch no
apps/erpnext/erpnext/selling/doctype/quotation/quotation.js +928,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 +432,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 +244,"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 +130,Gain/Loss on Asset Disposal,Gevinst / Tap på Asset Avhending
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.js +24,"Only the Student Applicant with the status ""Approved"" will be selected in the table below.",Kun Student søker med statusen &quot;Godkjent&quot; vil bli valgt i tabellen nedenfor.
DocType: Tax Withholding Category,Rates,Priser
apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +118,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: Normal Test Items,Result Value,Resultat Verdi
DocType: Hotel Room,Hotels,hoteller
DocType: Delivery Note,Transporter Date,Transportør Dato
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 +31,Not in Stock,Ikke på lager
DocType: Volunteer,Volunteer Skills,Frivillig Ferdigheter
DocType: Additional Salary,HR User,HR User
DocType: Bank Guarantee,Reference Document Name,Referansedokumentnavn
DocType: Purchase Invoice,Taxes and Charges Deducted,Skatter og avgifter fratrukket
DocType: Support Settings,Issues,Problemer
DocType: Loyalty Program,Loyalty Program Name,Lojalitetsprogramnavn
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
,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 +420,{0} {1} is disabled,{0} {1} er deaktivert
DocType: Supplier,Billing Currency,Faktureringsvaluta
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +175,Extra Large,Extra large
DocType: Loan,Loan Application,Lånesøknad
DocType: Crop,Scientific Name,Vitenskapelig navn
DocType: Healthcare Service Unit,Service Unit Type,Tjenestenhetstype
DocType: Bank Account,Branch Code,Bransjekode
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +97,Total Leaves,Totalt Leaves
DocType: Customer,"Reselect, if the chosen contact is edited after save",Velg hvis den valgte kontakten redigeres etter lagre
DocType: Patient Encounter,In print,I papirutgave
,Profit and Loss Statement,Resultatregnskap
DocType: Bank Reconciliation Detail,Cheque Number,Sjekk Antall
apps/erpnext/erpnext/healthcare/utils.py +264,The item referenced by {0} - {1} is already invoiced,Varen som er referert til av {0} - {1} er allerede fakturert
,Sales Browser,Salg Browser
DocType: Journal Entry,Total Credit,Total Credit
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +586,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 +174,Large,Stor
DocType: Bank Statement Settings,Bank Statement Settings,Innstillingsinnstillinger
DocType: Shopify Settings,Customer Settings,Kundeinnstillinger
DocType: Homepage Featured Product,Homepage Featured Product,Hjemmeside Aktuelle produkter
apps/erpnext/erpnext/manufacturing/doctype/blanket_order/blanket_order.js +12,View Orders,Se bestillinger
DocType: Marketplace Settings,Marketplace URL (to hide and update label),Markedsplass-URL (for å skjule og oppdatere etikett)
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +229,All Assessment Groups,Alle Assessment grupper
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js +15,New Warehouse Name,New Warehouse navn
DocType: Shopify Settings,App Type,App Type
apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.py +384,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/accounts/report/budget_variance_report/budget_variance_report.js +59,Show Cumulative Amount,Vis kumulativ beløp
apps/erpnext/erpnext/setup/doctype/company/company.js +174,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: Stock Entry,Target Warehouse Name,Mållagernavn
DocType: Work Order Operation,Planned Start Time,Planlagt Starttid
DocType: Course,Assessment,Assessment
DocType: Payment Entry Reference,Allocated,Avsatt
apps/erpnext/erpnext/config/accounts.py +305,Close Balance Sheet and book Profit or Loss.,Lukk Balanse og bok resultatet.
DocType: Student Applicant,Application Status,søknad Status
DocType: Additional Salary,Salary Component Type,Lønn Komponenttype
DocType: Sensitivity Test Items,Sensitivity Test Items,Sensitivitetstestelementer
DocType: Project Update,Project Update,Prosjektoppdatering
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 +164,Quotation {0} is cancelled,Sitat {0} er kansellert
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +132,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 +40,Please register the SIREN number in the company information file,Vennligst registrer SIREN-nummeret i bedriftsinformasjonsfilen
DocType: Email Digest,Sales Orders to Bill,Salgsordre til regning
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.
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1114,Link to Material Request,Link til materialforespørsel
apps/erpnext/erpnext/templates/pages/help.html +35,Forum Activity,Forumaktivitet
,S.O. No.,SO No.
DocType: Bank Statement Transaction Settings Item,Bank Statement Transaction Settings Item,Bankoversikt Transaksjonsinnstillinger
apps/erpnext/erpnext/hr/utils.py +158,To date can not greater than employee's relieving date,Til dags dato kan ikke større enn ansattes avlastningsdato
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +242,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/hr/doctype/leave_application/leave_application.py +46,Only Leave Applications with status 'Approved' and 'Rejected' can be submitted,Bare La Applikasjoner med status &#39;Godkjent&#39; og &#39;Avvist&#39; kan sendes inn
apps/erpnext/erpnext/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: Budget,Action if Accumulated Monthly Budget Exceeded on PO,Handling hvis akkumulert månedlig budsjett oversteg PO
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +246,To Place,Å sette
DocType: Exchange Rate Revaluation,Exchange Rate Revaluation,Valutakursomskrivning
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 +68,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 +237,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 +253,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 +177,Name error: {0},Navn feil: {0}
DocType: Healthcare Service Unit Type,Item Details,Elementdetaljer
DocType: Cash Flow Mapping,Is Finance Cost,Er finansieringskostnad
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +19,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
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.js +41,Chart,Chart
DocType: Subscription,Net Total,Net Total
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +527,Default BOM not found for Item {0} and Project {1},Standard BOM ikke funnet for element {0} og prosjekt {1}
apps/erpnext/erpnext/config/non_profit.py +74,Define various loan types,Definere ulike typer lån
DocType: Bin,FCFS Rate,FCFS Rate
DocType: Bank Statement Transaction Invoice 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 +128,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 +137,Cost as on,Koste så på
apps/erpnext/erpnext/hr/doctype/employee_loan_application/employee_loan_application.py +34,Repayment amount {} should be greater than monthly interest amount {},Tilbakebetalingsbeløpet {} skal være større enn månedlig rentebelø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 +305,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 +97,The fields From Shareholder and To Shareholder cannot be blank,Feltene fra Aksjonær og Til Aksjonær kan ikke være tomme
DocType: Cashier Closing,Cashier Closing,Cashier Closing
DocType: Tax Rule,Use for Shopping Cart,Brukes til handlekurv
apps/erpnext/erpnext/controllers/item_variant.py +101,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 +81,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: Travel Request,Require Full Funding,Krev full finansiering
DocType: Maintenance Visit,Purposes,Formål
DocType: Stock Entry,MAT-STE-.YYYY.-,MAT-STE-.YYYY.-
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +110,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
DocType: Travel Itinerary,Lodging Required,Overnatting påkrevd
,Requested,Spurt
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +121,No Remarks,Nei Anmerkninger
DocType: Asset,In Maintenance,Ved vedlikehold
DocType: Amazon MWS Settings,Click this button to pull your Sales Order data from Amazon MWS.,Klikk denne knappen for å trekke dine salgsordre data fra Amazon MWS.
DocType: Vital Signs,Abdomen,Mage
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 +91,Root Account must be a group,Root-kontoen må være en gruppe
DocType: Drug Prescription,Drug Prescription,Drug Prescription
DocType: Loan,Repaid/Closed,Tilbakebetalt / Stengt
DocType: Amazon MWS Settings,CA,CA
DocType: Item,Total Projected Qty,Samlet forventet Antall
DocType: Monthly Distribution,Distribution Name,Distribusjon Name
apps/erpnext/erpnext/stock/stock_ledger.py +478,"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 +341,Quality Inspection required for Item {0},Quality Inspection nødvendig for Element {0}
DocType: Location,Parent Location,Parent Location
DocType: POS Settings,Use POS in Offline Mode,Bruk POS i frakoblet modus
DocType: Supplier Scorecard,Supplier Variables,Leverandørvariabler
apps/erpnext/erpnext/accounts/page/pos/pos.js +77,{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2},{0} er obligatorisk. Kanskje Valutautvekslingsrekord er ikke opprettet for {1} til {2}
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: Patient Service Unit,Patient Service Unit,Pasient Service Unit
DocType: Bank Statement Transaction Invoice Item,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 +500,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: 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.
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +426,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 +49,You have already assessed for the assessment criteria {}.,Du har allerede vurdert for vurderingskriteriene {}.
DocType: Vehicle Service,Engine Oil,Motorolje
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1081,Work Orders Created: {0},Arbeidsordre opprettet: {0}
DocType: Sales Invoice,Sales Team1,Salg TEAM1
apps/erpnext/erpnext/stock/doctype/item/item.py +564,Item {0} does not exist,Element {0} finnes ikke
DocType: Sales Invoice,Customer Address,Kunde Adresse
DocType: Loan,Loan Details,lån Detaljer
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +61,Failed to setup post company fixtures,Kunne ikke opprette postvirksomhetsarmaturer
DocType: Company,Default Inventory Account,Standard lagerkonto
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +193,The folio numbers are not matching,Folio tallene stemmer ikke overens
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +304,Payment Request for {0},Betalingsforespørsel om {0}
DocType: Item Barcode,Barcode Type,Strekkode Type
DocType: Antibiotic,Antibiotic Name,Antibiotisk navn
apps/erpnext/erpnext/config/buying.py +43,Supplier Group master.,Leverandør Gruppemester.
DocType: Healthcare Service Unit,Occupancy Status,Beholdningsstatus
DocType: Purchase Invoice,Apply Additional Discount On,Påfør Ytterligere rabatt på
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +66,Select Type...,Velg type ...
apps/erpnext/erpnext/templates/pages/help.html +52,Your tickets,Dine billetter
DocType: Account,Root Type,Root Type
DocType: Item,FIFO,FIFO
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +558,Close the POS,Lukk POS
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +139,Row # {0}: Cannot return more than {1} for Item {2},Row # {0}: Kan ikke returnere mer enn {1} for Element {2}
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 +252,Target warehouse is mandatory for row {0},Target lageret er obligatorisk for rad {0}
DocType: Cheque Print Template,Primary Settings,primære Innstillinger
DocType: Attendance Request,Work From Home,Jobbe hjemmefra
DocType: Purchase Invoice,Select Supplier Address,Velg Leverandør Adresse
apps/erpnext/erpnext/public/js/event.js +27,Add Employees,Legg Medarbeidere
DocType: Purchase Invoice Item,Quality Inspection,Quality Inspection
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +171,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 +1024,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 +212,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 +794,Can only make payment against unbilled {0},Kan bare gjøre betaling mot fakturert {0}
apps/erpnext/erpnext/controllers/selling_controller.py +111,Commission rate cannot be greater than 100,Kommisjon kan ikke være større enn 100
DocType: Sales Invoice,Allocate Advances Automatically (FIFO),Tilordne forhåndsfordeler automatisk (FIFO)
DocType: Volunteer,Volunteer,Frivillig
DocType: Buying Settings,Subcontract,Underentrepriser
apps/erpnext/erpnext/public/js/utils/party.js +167,Please enter {0} first,Fyll inn {0} først
apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py +103,No replies from,Ingen svar fra
DocType: Work Order Operation,Actual End Time,Faktisk Sluttid
DocType: Item,Manufacturer Part Number,Produsentens varenummer
DocType: Taxable Salary Slab,Taxable Salary Slab,Skattepliktig lønnslab
DocType: Work Order Operation,Estimated Time and Cost,Estimert leveringstid og pris
DocType: Bin,Bin,Bin
DocType: Crop,Crop Name,Beskjære navn
apps/erpnext/erpnext/hub_node/api.py +55,Only users with {0} role can register on Marketplace,Kun brukere med {0} rolle kan registrere seg på Marketplace
DocType: SMS Log,No of Sent SMS,Ingen av Sendte SMS
DocType: Leave Application,HR-LAP-.YYYY.-,HR-LAP-.YYYY.-
apps/erpnext/erpnext/healthcare/doctype/inpatient_record/inpatient_record_dashboard.py +8,Appointments and Encounters,Utnevnelser og møter
DocType: Antibiotic,Healthcare Administrator,Helseadministrator
apps/erpnext/erpnext/utilities/user_progress.py +47,Set a Target,Angi et mål
DocType: Dosage Strength,Dosage Strength,Doseringsstyrke
DocType: Healthcare Practitioner,Inpatient Visit Charge,Inpatient besøksavgift
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 +178,Colour,Farge
DocType: Assessment Plan Criteria,Assessment Plan Criteria,Assessment Plan Kriterier
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card_dashboard.py +8,Transactions,transaksjoner
apps/erpnext/erpnext/stock/doctype/batch/batch.py +123,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 +190,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 +601,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/clinical_procedure_template/clinical_procedure_template.js +88,Change Code,Endre kode
DocType: Purchase Invoice Item,Valuation Rate,Verdivurdering Rate
DocType: Vehicle,Diesel,diesel
apps/erpnext/erpnext/stock/get_item_details.py +546,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/assets/doctype/asset/asset.py +210,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,Avskrivningsraden {0}: Neste avskrivningsdato kan ikke være før kjøpsdato
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 +36,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 +217,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 +134,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
DocType: Selling Settings,How often should project and company be updated based on Sales Transactions.,Hvor ofte skal prosjektet og selskapet oppdateres basert på salgstransaksjoner.
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/hr/doctype/employee_tax_exemption_declaration/employee_tax_exemption_declaration.js +18,Please select {0},Vennligst velg {0}
DocType: C-Form,C-Form No,C-Form Nei
DocType: BOM,Exploded_items,Exploded_items
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +343,Distance,Avstand
apps/erpnext/erpnext/utilities/user_progress.py +139,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: Sales Order,SAL-ORD-.YYYY.-,SAL-ORD-.YYYY.-
DocType: Employee Attendance Tool,Unmarked Attendance,Umerket Oppmøte
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +256,Creating Payment Entries......,Opprette betalingsoppføringer ......
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +125,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}
,Consolidated Financial Statement,Konsernregnskap
apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py +25,Name or Email is mandatory,Navn eller E-post er obligatorisk
DocType: Instructor,Instructor Log,Instruktørlogg
DocType: Clinical Procedure,Clinical Procedure,Klinisk prosedyre
DocType: Shopify Settings,Delivery Note Series,Leveringsnotaserien
DocType: Purchase Order Item,Returned Qty,Returnerte Stk
DocType: Student,Exit,Utgang
apps/erpnext/erpnext/accounts/doctype/account/account.py +163,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
DocType: Healthcare Service Unit Type,UOM Conversion in Hours,UOM Konvertering i timer
DocType: Contract,Signee Details,Signee Detaljer
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: Certified Consultant,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 +398,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 +175,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 +138,Opening Entry Journal,Åpningsoppføring Journal
DocType: Contract,Fulfilment Terms,Oppfyllelsesbetingelser
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 +214,Probationary Period,Prøvetid
DocType: Purchase Taxes and Charges Template,Is Inter State,Er Inter State
apps/erpnext/erpnext/config/hr.py +269,Shift Management,Shift Management
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: Department,Expense Approver,Expense Godkjenner
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +168,Row {0}: Advance against Customer must be credit,Rad {0}: Advance mot Kunden må være kreditt
DocType: Project,Hourly,Hver time
apps/erpnext/erpnext/accounts/doctype/account/account.js +88,Non-Group to Group,Non-gruppe til gruppe
DocType: Employee,ERPNext User,ERPNext Bruker
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
DocType: Amazon MWS Settings,Enable Scheduled Synch,Aktiver Planlagt synkronisering
apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py +24,To Datetime,Til Datetime
apps/erpnext/erpnext/config/selling.py +308,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 +241,Printed On,Trykt på
DocType: Clinical Procedure Template,Clinical Procedure Template,Klinisk Prosedyre Mal
DocType: Item,Inspection Required before Delivery,Inspeksjon Påkrevd før Levering
DocType: Item,Inspection Required before Purchase,Inspeksjon Påkrevd før kjøp
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +93,Pending Activities,Ventende Aktiviteter
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test_list.js +41,Create Lab Test,Lag Lab Test
DocType: Patient Appointment,Reminded,minnet
apps/erpnext/erpnext/public/js/setup_wizard.js +126,View Chart of Accounts,Se diagram over kontoer
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
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.py +84,"Skipping Leave Allocation for the following employees, as Leave Allocation records already exists against them. {0}","Hopp over permisjon for de følgende ansatte, ettersom det allerede eksisterer permitteringsoppføringer overfor dem. {0}"
DocType: Fee Component,Fees Category,avgifter Kategori
apps/erpnext/erpnext/hr/doctype/employee/employee.py +144,Please enter relieving date.,Skriv inn lindrende dato.
apps/erpnext/erpnext/controllers/trends.py +149,Amt,Amt
DocType: Travel Request,"Details of Sponsor (Name, Location)","Detaljer om Sponsor (Navn, Sted)"
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/hr/utils.py +154,Future dates not allowed,Fremtidige datoer ikke tillatt
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 +118,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/assets/doctype/asset/asset.py +80,Update stock must be enable for the purchase invoice {0},Oppdateringslager må være aktivert for kjøpsfakturaen {0}
apps/erpnext/erpnext/stock/get_item_details.py +405,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 +135,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/accounts/doctype/loyalty_program/loyalty_program.js +30,One customer can be part of only single Loyalty Program.,En kunde kan være en del av det eneste lojalitetsprogrammet.
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 +88,Duplicate entry,Duplicate entry
apps/erpnext/erpnext/accounts/doctype/bank_guarantee/bank_guarantee.py +19,Enter the name of the Beneficiary before submittting.,Skriv inn mottakerens navn før du sender inn.
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 +530,[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 +216,Limit Crossed,Limit Krysset
apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.js +22,Scheduled Upto,Planlagt Upto
DocType: Woocommerce Settings,Secret,Hemmelig
DocType: Company,Date of Establishment,Dato for etablering
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: Blanket Order Item,Blanket Order Item,Blanket Bestillingsvare
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: Travel Request,Event Details,Eventdetaljer
DocType: Department,Leave Approver,La Godkjenner
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +316,Please select a batch,Vennligst velg en batch
apps/erpnext/erpnext/config/hr.py +145,Travel and Expense Claim,Reise- og kostnadskrav
DocType: Sales Invoice,Redemption Cost Center,Innløsningskostsenter
DocType: Assessment Group,Assessment Group Name,Assessment Gruppenavn
DocType: Manufacturing Settings,Material Transferred for Manufacture,Materialet Overført for Produksjon
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js +60,Add to Details,Legg til detaljer
DocType: Travel Itinerary,Taxi,Taxi
DocType: Shopify Settings,Last Sync Datetime,Siste synkroniseringstid
DocType: Landed Cost Item,Receipt Document Type,Kvittering dokumenttype
DocType: Daily Work Summary Settings,Select Companies,Velg selskaper
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +320,Proposal/Price Quote,Forslag / pris sitat
DocType: Antibiotic,Healthcare,Helsetjenester
DocType: Target Detail,Target Detail,Target Detalj
apps/erpnext/erpnext/stock/doctype/item/item.js +67,Single Variant,Enkelt variant
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +51,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 +65,Period Closing Entry,Periode Closing Entry
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +72,Select Department...,Velg avdeling ...
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +40,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 +376,Amount {0} {1} {2} {3},Mengden {0} {1} {2} {3}
DocType: Account,Depreciation,Avskrivninger
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +103,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 +50,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 +77,Avg. Selling Price List Rate,Nr. Selge prisliste rate
DocType: Loyalty Program Collection,Collection Factor (=1 LP),Samlefaktor (= 1 LP)
DocType: Additional Salary,Salary Component,Lønnstype
apps/erpnext/erpnext/accounts/utils.py +519,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
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py +65,"You can claim only an amount of {0}, the rest amount {1} should be in the application \
				as pro-rata component","Du kan bare kreve en mengde av {0}, resten mengden {1} skal være i applikasjonen \ som pro-rata-komponenten"
DocType: Amazon MWS Settings,Customer Type,Kundetype
DocType: Compensatory Leave Request,Leave Allocation,La Allocation
DocType: Payment Request,Recipient Message And Payment Details,Mottakers Message og betalingsinformasjon
DocType: Support Search Source,Source DocType,Kilde DocType
apps/erpnext/erpnext/templates/pages/help.html +60,Open a new ticket,Åpne en ny billett
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: Bank Account,Address and Contact,Adresse og Kontakt
DocType: Vital Signs,Hyper,Hyper
DocType: Cheque Print Template,Is Account Payable,Er konto Betales
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +304,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 +85,"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 +349,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: Hub Tracked Item,Hub Tracked Item,Hub sporet element
DocType: Purchase Invoice,ORIGINAL FOR RECIPIENT,ORIGINAL FOR RECIPIENT
DocType: Asset Category Account,Accumulated Depreciation Account,Akkumulerte avskrivninger konto
DocType: Certified Consultant,Discuss ID,Diskuter ID
DocType: Stock Settings,Freeze Stock Entries,Freeze Stock Entries
DocType: Program Enrollment,Boarding Student,Studerende Student
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +81,Please enable Applicable on Booking Actual Expenses,Vennligst aktiver gjeldende for bestilling av faktiske kostnader
DocType: Asset Finance Book,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
DocType: Amazon MWS Settings,Amazon will synch data updated after this date,Amazon vil synkronisere data oppdatert etter denne datoen
,Stock Analytics,Aksje Analytics
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +536,Operations cannot be left blank,Operasjoner kan ikke være tomt
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.py +72,Lab Test(s) ,Lab Test (er)
DocType: Maintenance Visit Purpose,Against Document Detail No,Mot Document Detail Nei
apps/erpnext/erpnext/regional/__init__.py +11,Deletion is not permitted for country {0},Sletting er ikke tillatt for land {0}
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +111,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 +491,{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 +89,Net Cash from Investing,Netto kontantstrøm fra investerings
DocType: Work Order,Work-in-Progress Warehouse,Work-in-progress Warehouse
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +116,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 +390,Reference #{0} dated {1},Reference # {0} datert {1}
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +179,Depreciation Eliminated due to disposal of assets,Avskrivninger Slått på grunn av salg av eiendeler
DocType: Employee Transfer,New Employee ID,Ny ansatt-ID
DocType: Loan,Member,Medlem
apps/erpnext/erpnext/templates/includes/cart/cart_address.html +15,Manage Addresses,Administrer Adresser
DocType: Work Order Item,Work Order Item,Arbeid Bestillingselement
DocType: Pricing Rule,Item Code,Sak Kode
DocType: Student,EDU-STU-.YYYY.-,EDU-STU-.YYYY.-
DocType: Serial No,Warranty / AMC Details,Garanti / AMC Detaljer
apps/erpnext/erpnext/education/doctype/student_group/student_group.js +119,Select students manually for the Activity based Group,Velg studenter manuelt for aktivitetsbasert gruppe
DocType: Journal Entry,User Remark,Bruker Remark
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +85,Optimizing routes.,Optimalisering av ruter.
DocType: Travel Itinerary,Non Diary,Ikke-dagbok
apps/erpnext/erpnext/hr/doctype/retention_bonus/retention_bonus.py +14,Cannot create Retention Bonus for left Employees,Kan ikke opprette Beholdningsbonus for venstre Ansatte
DocType: Lead,Market Segment,Markedssegment
DocType: Agriculture Analysis Criteria,Agriculture Manager,Landbruksansvarlig
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +999,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 +264,Closing (Dr),Lukking (Dr)
DocType: Cheque Print Template,Cheque Size,sjekk Size
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +284,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/public/js/pos/pos.html +71,Qty Total,Antall totalt
DocType: Landed Cost Item,Receipt Document,kvittering Document
DocType: Employee Education,School/University,Skole / universitet
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 +187,Closed order cannot be cancelled. Unclose to cancel.,Stengt for kan ikke avbestilles. Unclose å avbryte.
apps/erpnext/erpnext/config/hr.py +120,Payroll Setup,Lønnsoppsett
DocType: Amazon MWS Settings,Synch Products,Synch produkter
DocType: Loyalty Point Entry,Loyalty Program,Lojalitetsprogram
DocType: Student Guardian,Father,Far
apps/erpnext/erpnext/crm/report/lead_conversion_time/lead_conversion_time.py +59,Support Tickets,Støtte Billetter
apps/erpnext/erpnext/controllers/accounts_controller.py +687,'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 +97,{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 +446,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 +164,Material Request {0} is cancelled or stopped,Materialet Request {0} blir kansellert eller stoppet
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +216,Dispatch State,Forsendelsesstat
apps/erpnext/erpnext/config/hr.py +399,Leave Management,La Ledelse
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +17,Groups,Grupper
DocType: Purchase Invoice,Hold Invoice,Hold faktura
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js +37,Please select Employee,Vennligst velg Medarbeider
DocType: Sales Order,Fully Delivered,Fullt Leveres
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +304,Lower Income,Lavere inntekt
DocType: Restaurant Order Entry,Current Order,Nåværende ordre
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +25,Number of serial nos and quantity must be the same,Antall serienummer og antall må være de samme
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +271,Source and target warehouse cannot be same for row {0},Kilden og målet lageret kan ikke være det samme for rad {0}
DocType: Account,Asset Received But Not Billed,"Asset mottatt, men ikke fakturert"
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +244,"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/loan/loan.py +116,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 +176,Go to Programs,Gå til Programmer
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +212,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 +91,Purchase Order number required for Item {0},Innkjøpsordrenummeret som kreves for Element {0}
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +18,'From Date' must be after 'To Date',"""Fra dato"" må være etter 'Til Dato'"
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.js +32,No Staffing Plans found for this Designation,Ingen bemanningsplaner funnet for denne betegnelsen
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1075,Batch {0} of Item {1} is disabled.,Batch {0} i vare {1} er deaktivert.
DocType: Leave Policy Detail,Annual Allocation,Årlig allokering
DocType: Travel Request,Address of Organizer,Adresse til arrangør
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +68,Select Healthcare Practitioner...,Velg helsepersonell ...
DocType: Employee Boarding Activity,Applicable in the case of Employee Onboarding,Gjelder i tilfelle Ansatt ombordstigning
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 +515,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: Clinical Procedure,Patient,Pasient
apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +50,Bypass credit check at Sales Order ,Bypass kreditt sjekk på salgsordre
DocType: Employee Onboarding Activity,Employee Onboarding Activity,Ansatte ombord på aktiviteten
DocType: Location,Check if it is a hydroponic unit,Sjekk om det er en hydroponisk enhet
apps/erpnext/erpnext/config/stock.py +112,Serial No and Batch,Serial No og Batch
DocType: Warranty Claim,From Company,Fra Company
apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py +40,Sum of Scores of Assessment Criteria needs to be {0}.,Summen av Resultater av vurderingskriterier må være {0}.
apps/erpnext/erpnext/assets/doctype/asset/asset.py +198,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 +86,Value or Qty,Verdi eller Stk
DocType: Payment Terms Template,Payment Terms,Betalingsbetingelser
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +470,Productions Orders cannot be raised for:,Productions Bestillinger kan ikke heves for:
apps/erpnext/erpnext/utilities/user_progress.py +147,Minute,Minutt
DocType: Purchase Invoice,Purchase Taxes and Charges,Kjøpe skatter og avgifter
DocType: Chapter,Meetup Embed HTML,Meetup Embed HTML
DocType: Asset,Insured value,Forsikret verdi
apps/erpnext/erpnext/utilities/user_progress.py +121,Go to Suppliers,Gå til Leverandører
DocType: POS Closing Voucher Taxes,POS Closing Voucher Taxes,POS Closing Voucher Skatt
,Qty to Receive,Antall å motta
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +564,"Start and end dates not in a valid Payroll Period, cannot calculate {0}.","Begynn og avslutt datoer ikke i en gyldig lønningsperiode, kan ikke beregne {0}."
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
DocType: Healthcare Service Unit Type,Rate / UOM,Rate / UOM
apps/erpnext/erpnext/patches/v7_0/create_warehouse_nestedset.py +59,All Warehouses,alle Næringslokaler
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +1296,No {0} found for Inter Company Transactions.,Ingen {0} funnet for Inter Company Transactions.
DocType: Travel Itinerary,Rented Car,Lei bil
apps/erpnext/erpnext/public/js/hub/components/profile_dialog.js +15,About your Company,Om firmaet ditt
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +143,Credit To account must be a Balance Sheet account,Kreditt til kontoen må være en balansekonto
DocType: Donor,Donor,donor
DocType: Global Defaults,Disable In Words,Deaktiver I Ord
apps/erpnext/erpnext/stock/doctype/item/item.py +70,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 +101,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 +108,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: Patient,Medical History,Medisinsk historie
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +167,Bank Overdraft Account,Kassekreditt konto
DocType: Patient,Patient ID,Pasient ID
DocType: Practitioner Schedule,Schedule Name,Planleggingsnavn
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.js +302,Sales Pipeline by Stage,Salgspipeline etter trinn
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js +49,Make Salary Slip,Lag Lønn Slip
DocType: Currency Exchange,For Buying,For kjøp
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +827,Add All Suppliers,Legg til alle leverandører
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +95,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 +84,Browse BOM,Bla BOM
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +165,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 +106,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 +79,Available Selling,Tilgjengelig salg
DocType: Loyalty Point Entry Redemption,Loyalty Point Entry Redemption,Innløsning av lojalitetspoeng
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +179,Opening Balance Equity,Åpningsbalanse Equity
DocType: Contract,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: Loan,Loan Account,Lånekonto
DocType: Purchase Invoice,GST Details,GST-detaljer
apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py +6,This is based on transactions against this Healthcare Practitioner.,Dette er basert på transaksjoner mot denne helsepersonell.
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 +12,Academic Year: ,Studieår:
DocType: Inpatient Record,Admission Schedule Date,Opptak Planleggingsdato
DocType: Subscription,Past Due Date,Forfallsdato
apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py +19,Not allow to set alternative item for the item {0},Ikke tillat å angi alternativt element for elementet {0}
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 +65,Create Fees,Opprett gebyrer
DocType: Project,Total Purchase Cost (via Purchase Invoice),Total anskaffelseskost (via fakturaen)
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +549,Select Quantity,Velg Antall
DocType: Loyalty Point Entry,Loyalty Points,Lojalitetspoeng
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 +65,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 +817,Get Suppliers By,Få leverandører av
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +182,{0} not found for Item {1},{0} ikke funnet for element {1}
apps/erpnext/erpnext/utilities/user_progress.py +197,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 +29,Message Sent,Melding Sendt
apps/erpnext/erpnext/accounts/doctype/account/account.py +105,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 +222,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: Work Order,Material Transferred for Manufacturing,Materialet Overført for Manufacturing
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +49,Account {0} does not exists,Konto {0} ikke eksisterer
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1604,Select Loyalty Program,Velg Lojalitetsprogram
DocType: Project,Project Type,Prosjekttype
apps/erpnext/erpnext/projects/doctype/task/task.py +154,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/setup/doctype/sales_person/sales_person.py +17,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 +56,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/erpnext_integrations/doctype/gocardless_settings/gocardless_settings.py +140,Payment Failed. Please check your GoCardless Account for more details,Betalingen feilet. Vennligst sjekk din GoCardless-konto for mer informasjon
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
apps/erpnext/erpnext/accounts/doctype/bank_guarantee/bank_guarantee.py +17,Enter the Bank Guarantee Number before submittting.,Oppgi bankgarantienummeret før du sender inn.
DocType: Driving License Category,Class,Klasse
DocType: Sales Order,Fully Billed,Fullt Fakturert
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +387,Work Order cannot be raised against a Item Template,Arbeidsordre kan ikke heves opp mot en varemaling
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 +142,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: Vital Signs,Cuts,cuts
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: Expense Claim,Approval Status,Godkjenningsstatus
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 +158,Wire Transfer,Wire Transfer
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +93,Check all,Sjekk alt
,Issued Items Against Work Order,Utstedte varer mot arbeidsordre
,BOM Stock Calculated,BOM Stock Beregnet
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 +39,Unclosed Fiscal Years Profit / Loss (Credit),Unclosed regnskapsårene Profit / Loss (Credit)
DocType: Sales Invoice,Time Sheets,timelister
DocType: Healthcare Service Unit Type,Change In Item,Endre i element
DocType: Payment Gateway Account,Default Payment Request Message,Standard betalingsforespørsel Message
DocType: Retention Bonus,Bonus Amount,Bonusbeløp
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 +371,Balance ({0}),Balanse ({0})
DocType: Loyalty Point Entry,Redeem Against,Løs inn mot
apps/erpnext/erpnext/config/accounts.py +157,Banking and Payments,Bank og Betalinger
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.py +99,Please enter API Consumer Key,Vennligst skriv inn API forbrukernøkkel
,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: Project,Twice Daily,To ganger daglig
DocType: Inpatient Record,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 +321,Calls,Samtaler
apps/erpnext/erpnext/utilities/user_progress.py +143,A Product,Et produkt
DocType: Employee Tax Exemption Declaration,Declarations,erklæringer
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +235,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 +261,Purchase Order {0} is not submitted,Purchase Order {0} ikke er sendt
DocType: Account,Expenses Included In Asset Valuation,Utgifter inkludert i eiendelvurdering
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: Work Order Item,Available Qty at WIP Warehouse,Tilgjengelig antall på WIP Warehouse
apps/erpnext/erpnext/stock/doctype/item/item.js +41,Projected,Prosjekterte
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +233,Serial No {0} does not belong to Warehouse {1},Serial No {0} tilhører ikke Warehouse {1}
apps/erpnext/erpnext/controllers/status_updater.py +180,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: Issue,Opening Date,Åpningsdato
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +89,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 +177,Account Type for {0} must be {1},Kontotype for {0} må være {1}
apps/erpnext/erpnext/config/hr.py +34,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 +76,Both Warehouse must belong to same Company,Både Warehouse må tilhøre samme selskapet
DocType: Employee Grade,Default Leave Policy,Standard permisjon
DocType: Shopify Settings,Shop URL,Butikkadresse
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
DocType: Patient Appointment,Get prescribed procedures,Få foreskrevne prosedyrer
DocType: Sales Invoice,Redemption Account,Innløsningskonto
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +233,Debit Note Amt,Debet notat Amt
DocType: Purchase Invoice Item,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 +66,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 +865,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
DocType: Shopping Cart Settings,Show Stock Quantity,Vis lager Antall
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +77,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 +60,"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 +2052,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
DocType: Travel Request,Fully Sponsored,Fullt sponset
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +28,Reverse Journal Entry,Omvendt journalinngang
apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +90,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 +59,Missing Currency Exchange Rates for {0},Mangler valutakurser for {0}
DocType: Employee Health Insurance,Health Insurance Name,Helseforsikringsnavn
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: Subscription Plan,"Number of intervals for the interval field e.g if Interval is 'Days' and Billing Interval Count is 3, invoices will be generated every 3 days","Antall intervaller for intervallfeltet, for eksempel hvis Intervall er &#39;Dager&#39; og Faktureringsintervalltall er 3, vil fakturaene bli generert hver tredje dag"
DocType: Clinical Procedure Template,Allow Stock Consumption,Tillat lagerforbruk
DocType: Asset,Insurance Details,forsikring Detaljer
DocType: Account,Payable,Betales
DocType: Share Balance,Share Type,Del Type
apps/erpnext/erpnext/hr/doctype/loan/loan.py +123,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 +72,Gross Profit %,Bruttofortjeneste%
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +90,Appointment {0} and Sales Invoice {1} cancelled,Avtale {0} og salgsfaktura {1} kansellert
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.js +43,Opportunities by lead source,Muligheter ved blykilde
DocType: Appraisal Goal,Weightage (%),Weightage (%)
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +555,Change POS Profile,Endre POS-profil
DocType: Bank Reconciliation Detail,Clearance Date,Klaring Dato
DocType: Delivery Settings,Dispatch Notification Template,Forsendelsesvarslingsmal
apps/erpnext/erpnext/stock/doctype/item/item.py +722,"Asset is already exists against the item {0}, you cannot change the has serial no value","Eiendom eksisterer allerede mot elementet {0}, du kan ikke endre den har seriell no-verdi"
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +10,Assessment Report,Vurderingsrapport
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +26,Get Employees,Få ansatte
apps/erpnext/erpnext/assets/doctype/asset/asset.py +72,Gross Purchase Amount is mandatory,Bruttobeløpet er obligatorisk
apps/erpnext/erpnext/setup/doctype/company/company.js +115,Company name not same,Firmanavn ikke det samme
DocType: Lead,Address Desc,Adresse Desc
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +114,Party is mandatory,Party er obligatorisk
DocType: Topic,Topic Name,emne Name
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +312,Please set default template for Leave Approval Notification in HR Settings.,Vennligst angi standardmal for godkjenning av varsling i HR-innstillinger.
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +38,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 +308,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 +87,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 +39,As Examiner,Som eksaminator
DocType: Company,Default Expense Claim Payable Account,Standardkostnadskrav Betalbar konto
DocType: Appointment Type,Default Duration,Standard varighet
DocType: BOM Explosion Item,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 +661,Row #{0}: Asset {1} does not belong to company {2},Row # {0}: Asset {1} ikke tilhører selskapet {2}
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +114,Sales Invoice {0} created,Salgsfaktura {0} opprettet
DocType: Employee,Confirmation Date,Bekreftelse Dato
DocType: Inpatient Occupancy,Check Out,Sjekk ut
DocType: C-Form,Total Invoiced Amount,Total Fakturert beløp
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +51,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: Payment Entry,ACC-PAY-.YYYY.-,ACC-PAY-.YYYY.-
DocType: Asset Value Adjustment,Current Asset Value,Nåværende eiendelverdi
DocType: Travel Request,Travel Funding,Reisefinansiering
DocType: Loan Application,Required by Date,Kreves av Dato
DocType: Crop Cycle,A link to all the Locations in which the Crop is growing,En kobling til alle stedene hvor beskjæringen vokser
DocType: Lead,Lead Owner,Lead Eier
DocType: Production Plan,Sales Orders Detail,Salgsordre detalj
DocType: Bin,Requested Quantity,Requested Antall
DocType: Fees,EDU-FEE-.YYYY.-,EDU-FEE-.YYYY.-
DocType: Patient,Marital Status,Sivilstatus
DocType: Stock Settings,Auto Material Request,Auto Materiell Request
DocType: Woocommerce Settings,API consumer secret,API forbruker hemmelig
DocType: Delivery Note Item,Available Batch Qty at From Warehouse,Tilgjengelig Batch Antall på From Warehouse
DocType: Salary Slip,Gross Pay - Total Deduction - Loan Repayment,Brutto lønn - Totalt Fradrag - Loan Nedbetaling
DocType: Bank Account,IBAN,IBAN
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +39,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 +47,Salary Slip ID,Lønn Slip ID
apps/erpnext/erpnext/hr/doctype/employee/employee.py +128,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 +70,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
DocType: Subscription,Trial Period Start Date,Prøveperiode Startdato
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +106,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: Certification Application,Certified,sertifisert
DocType: Monthly Distribution Percentage,Monthly Distribution Percentage,Månedlig Distribution Prosent
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 +526,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 +231,Valuation type charges can not marked as Inclusive,Verdsettelse typen kostnader kan ikke merket som Inclusive
DocType: POS Profile,Update Stock,Oppdater Stock
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +100,Different UOM for items will lead to incorrect (Total) Net Weight value. Make sure that Net Weight of each item is in the same UOM.,Ulik målenheter for elementer vil føre til feil (Total) Netto vekt verdi. Sørg for at nettovekt av hvert element er i samme målenheter.
DocType: Certification Application,Payment Details,Betalingsinformasjon
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +41,BOM Rate,BOM Rate
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +249,"Stopped Work Order cannot be cancelled, Unstop it first to cancel","Stoppet arbeidsordre kan ikke kanselleres, Unstop det først for å avbryte"
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/manufacturing/doctype/work_order/work_order.py +242,Row {0}: select the workstation against the operation {1},Row {0}: velg arbeidsstasjonen mot operasjonen {1}
apps/erpnext/erpnext/accounts/utils.py +496,Journal Entries {0} are un-linked,Journal Entries {0} er un-linked
apps/erpnext/erpnext/accounts/utils.py +825,{0} Number {1} already used in account {2},{0} Tall {1} allerede brukt i konto {2}
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 +181,Please mention Round Off Cost Center in Company,Vennligst oppgi Round Off Cost Center i selskapet
DocType: Purchase Invoice,Terms,Vilkår
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js +10,Select Days,Velg dager
DocType: Academic Term,Term Name,Term Navn
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +365,Credit ({0}),Kreditt ({0})
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +499,Creating Salary Slips...,Opprette lønnsslipp ...
apps/erpnext/erpnext/hr/doctype/department/department.js +14,You cannot edit root node.,Du kan ikke redigere rotknutepunktet.
DocType: Buying Settings,Purchase Order Required,Innkjøpsordre Påkrevd
apps/erpnext/erpnext/public/js/projects/timer.js +5,Timer,Timer
,Item-wise Sales History,Element-messig Sales History
DocType: Expense Claim,Total Sanctioned Amount,Total vedtatte beløp
,Purchase Analytics,Kjøps Analytics
DocType: Sales Invoice Item,Delivery Note Item,Levering Note Element
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +363,Current invoice {0} is missing,Nåværende faktura {0} mangler
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 +22,This is a root sales person and cannot be edited.,Dette er en grunnlegg salg person og kan ikke redigeres.
DocType: Salary Component,"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 Component,"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
DocType: Amazon MWS Settings,MWS Credentials,MWS legitimasjon
apps/erpnext/erpnext/config/hr.py +7,Employee and Attendance,Medarbeider og oppmøte
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +123,Purpose must be one of {0},Hensikten må være en av {0}
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +99,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 +41,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 +85,Reorder Qty,Omgjøre Antall
apps/erpnext/erpnext/assets/doctype/asset/asset.py +283,Depreciation Row {0}: Expected value after useful life must be greater than or equal to {1},Avskrivningsraden {0}: Forventet verdi etter brukstid må være større enn eller lik {1}
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +55,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: Healthcare Service Unit,Allow Overlap,Tillat overlapping
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/assets/doctype/asset/asset.py +86,Enter depreciation details,Skriv inn avskrivningsdetaljer
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 +78,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
DocType: POS Profile,Display Items In Stock,Vis produkter på lager
apps/erpnext/erpnext/config/setup.py +37,Country wise default Address Templates,Country klok standardadresse Maler
DocType: Payment Order,Payment Order Reference,Betalingsordrehenvisning
DocType: Water Analysis,Appearance,Utseende
DocType: HR Settings,Leave Status Notification Template,Meldingsmal for permisjon
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +77,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.
DocType: Identification Document Type,Identification Document Type,Identifikasjonsdokumenttype
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 +87,Asset Maintenance,Asset Maintenance
,Sales Payment Summary,Salgsbetalingssammendrag
DocType: Restaurant,Restaurant,Restaurant
DocType: Woocommerce Settings,API consumer key,API forbrukernøkkel
apps/erpnext/erpnext/accounts/party.py +352,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: Tax Withholding Category,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: Employee Tax Exemption Declaration,Monthly HRA Exemption,Månedlig HRA-fritak
DocType: Clinical Procedure,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
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js +91,Slots for {0} are not added to the schedule,Slots for {0} legges ikke til i timeplanen
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 +42,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%
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +611,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
DocType: Opportunity,Opportunity Amount,Mulighetsbeløp
apps/erpnext/erpnext/assets/doctype/asset/asset.py +203,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
DocType: Purchase Order,Order Confirmation Date,Ordrebekreftelsesdato
DocType: Driver,HR-DRI-.YYYY.-,HR-DRI-.YYYY.-
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +47,Make Maintenance Visit,Gjør Vedlikehold Visit
DocType: Employee Transfer,Employee Transfer Details,Overføringsdetaljer for ansatte
apps/erpnext/erpnext/selling/doctype/customer/customer.py +263,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 +79,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 +179,No Students in,Ingen studenter i
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +180,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 +222,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 +259,Go to Users,Gå til Brukere
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +113,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 +199,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 +19,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: Material Request,MAT-MR-.YYYY.-,MAT-MR-.YYYY.-
DocType: Opportunity,Opportunity Type,Opportunity Type
DocType: Asset Movement,To Employee,Til ansatt
DocType: Employee Transfer,New Company,Nytt firma
apps/erpnext/erpnext/setup/doctype/company/delete_company_transactions.py +19,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.
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +48,Item Code &gt; Item Group &gt; Brand,Varenummer&gt; Varegruppe&gt; Varemerke
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: 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 +122,Date of Birth cannot be greater than today.,Fødselsdato kan ikke være større enn i dag.
,Stock Ageing,Stock Ageing
DocType: Travel Request,"Partially Sponsored, Require Partial Funding","Delvis sponset, krever delvis finansiering"
apps/erpnext/erpnext/education/doctype/student/student.py +40,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
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +243,Batch: ,Parti:
DocType: Volunteer,Afternoon,Ettermiddag
DocType: Loyalty Program,Loyalty Program Help,Lojalitetsprogram Hjelp
apps/erpnext/erpnext/controllers/accounts_controller.py +305,{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
DocType: Loyalty Program,Collection Rules,Innsamlingsregler
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 +133,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 +79,Project {0} already exists,Prosjektet {0} eksisterer allerede
DocType: Clinical Procedure,Nursing User,Sykepleier Bruker
DocType: Employee Benefit Application,Payroll Period,Lønn Periode
DocType: Plant Analysis,Plant Analysis Criterias,Plant Analyse Kriterier
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +239,Serial No {0} does not belong to Batch {1},Serienummer {0} tilhører ikke Batch {1}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +220,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: Account,Capital Work in Progress,Kapitalarbeid pågår
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 +247,Add Users,Legg til brukere
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.py +74,No Lab Test created,Ingen labtest opprettet
DocType: POS Item Group,Item Group,Varegruppe
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +19,Student Group: ,Studentgruppe:
DocType: Depreciation Schedule,Finance Book Id,Finans bok ID
DocType: Item,Safety Stock,Safety Stock
DocType: Healthcare Settings,Healthcare Settings,Helseinstitusjoner
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html +8,Total Allocated Leaves,Totalt tildelte blad
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 +493,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 +54,Item {0} must be a Fixed Asset Item,Element {0} må være et driftsmiddel element
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +283,HSN,HSN
apps/erpnext/erpnext/stock/doctype/item/item.js +421,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 +131,Debit Note Amount,Debet Note Beløp
DocType: Project Update,Not Updated,Ikke oppdatert
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +107,"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/hr/doctype/compensatory_leave_request/compensatory_leave_request.py +39,You are not present all day(s) between compensatory leave request days,Du er ikke til stede hele dagen (e) mellom kompensasjonsorlovsdager
apps/erpnext/erpnext/setup/doctype/company/company.js +109,Please re-type company name to confirm,Vennligst re-type firmanavn for å bekrefte
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +234,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)
DocType: Shopify Settings,eg: frappe.myshopify.com,f.eks .: frappe.myshopify.com
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +324,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
DocType: Salary Structure Assignment,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: Cashier Closing,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 +107,Cash or Bank Account is mandatory for making payment entry,Kontanter eller bankkontoen er obligatorisk for å gjøre betaling oppføring
DocType: Loyalty Program,Multiple Tier Program,Flertallsprogram
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/buying/page/purchase_analytics/purchase_analytics.js +116,All Supplier Groups,Alle leverandørgrupper
DocType: Employee Boarding Activity,Required for Employee Creation,Kreves for ansettelsesskaping
apps/erpnext/erpnext/accounts/doctype/account/account.py +214,Account Number {0} already used in account {1},Kontonummer {0} som allerede er brukt i konto {1}
DocType: GoCardless Mandate,Mandate,mandat
DocType: POS Profile,POS Profile Name,POS profilnavn
DocType: Hotel Room Reservation,Booked,bestilt
DocType: Detected Disease,Tasks Created,Oppgaver opprettet
DocType: Purchase Invoice Item,Rate,Rate
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +107,Intern,Intern
DocType: Delivery Stop,Address Name,Adressenavn
DocType: Stock Entry,From BOM,Fra BOM
DocType: Assessment Code,Assessment Code,Assessment Kode
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +76,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 +154,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 +125,Date of Joining must be greater than Date of Birth,Dato Bli må være større enn fødselsdato
DocType: Subscription,Plans,planer
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 +815,Issue Material,Issue Material
apps/erpnext/erpnext/config/integrations.py +32,Connect Shopify with ERPNext,Koble Shopify med ERPNext
DocType: Material Request Item,For Warehouse,For Warehouse
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +46,Delivery Notes {0} updated,Leveringsnotater {0} oppdatert
DocType: Employee,Offer Date,Tilbudet Dato
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +35,Quotations,Sitater
apps/erpnext/erpnext/accounts/page/pos/pos.js +742,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/hr/doctype/leave_period/leave_period.js +90,Grant,Stipend
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/loan/loan.py +129,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 +59,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: 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 +1979,Enter value must be positive,Oppgi verdien skal være positiv
DocType: Asset,Finance Books,Finansbøker
DocType: Employee Tax Exemption Declaration Category,Employee Tax Exemption Declaration Category,Deklarasjonskategori for ansatt skattefritak
apps/erpnext/erpnext/accounts/doctype/sales_invoice/pos.py +448,All Territories,Alle Territories
apps/erpnext/erpnext/hr/utils.py +215,Please set leave policy for employee {0} in Employee / Grade record,Vennligst sett permitteringslov for ansatt {0} i ansatt / karakteroppføring
apps/erpnext/erpnext/public/js/controllers/transaction.js +1405,Invalid Blanket Order for the selected Customer and Item,Ugyldig ordreordre for den valgte kunden og varen
apps/erpnext/erpnext/projects/doctype/task/task_tree.js +49,Add Multiple Tasks,Legg til flere oppgaver
DocType: Purchase Invoice,Items,Elementer
apps/erpnext/erpnext/crm/doctype/contract/contract.py +38,End Date cannot be before Start Date.,Sluttdato kan ikke være før startdato.
apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py +33,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 +323,There are more holidays than working days this month.,Det er mer ferie enn virkedager denne måneden.
apps/erpnext/erpnext/controllers/buying_controller.py +760,Following items {0} are not marked as {1} item. You can enable them as {1} item from its Item master,Følgende elementer {0} er ikke merket som {1} element. Du kan aktivere dem som {1} -objekt fra elementmasteren
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +101,PDC/LC Ref,PDC / LC Ref
DocType: Production Plan Item,Product Bundle Item,Produktet Bundle Element
DocType: Sales Partner,Sales Partner Name,Sales Partner Name
apps/erpnext/erpnext/hooks.py +141,Request for Quotations,Forespørsel om Sitater
DocType: Payment Reconciliation,Maximum Invoice Amount,Maksimal Fakturert beløp
DocType: Normal Test Items,Normal Test Items,Normale testelementer
DocType: Additional Salary,Overwrite Salary Structure Amount,Overskrive lønnsstrukturbeløp
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 +97,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 +740,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: Contract,Unfulfilled,oppfylt
DocType: Delivery Note Item,From Warehouse,Fra Warehouse
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +64,No employees for the mentioned criteria,Ingen ansatte for de nevnte kriteriene
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1030,No Items with Bill of Materials to Manufacture,Ingen elementer med Bill of Materials til Manufacture
DocType: Shopify Settings,Default Customer,Standardkund
DocType: Sales Stage,Stage Name,Artistnavnet
DocType: Warranty Claim,SER-WRN-.YYYY.-,SER-WRN-.YYYY.-
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
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +264,Ship To State,Send til stat
DocType: Program Enrollment Course,Program Enrollment Course,Programopptakskurs
DocType: Program Enrollment Course,Program Enrollment Course,Programopptakskurs
apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner.py +59,User {0} is already assigned to Healthcare Practitioner {1},Bruker {0} er allerede tildelt Healthcare Practitioner {1}
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +187,Make Sample Retention Stock Entry,Lag prøveinnsamlingens lagerinngang
DocType: Purchase Taxes and Charges,Valuation and Total,Verdivurdering og Total
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +321,Negotiation/Review,Forhandling / omtale
DocType: Leave Encashment,Encashment Amount,Encashment Amount
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py +11,Scorecards,målstyring
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +159,Expired Batches,Utløpte partier
DocType: Employee,This will restrict user access to other employee records,Dette vil begrense brukerens tilgang til andre ansattes poster
DocType: Tax Rule,Shipping City,Shipping by
DocType: Delivery Note,Ship,Skip
DocType: Staffing Plan Detail,Current Openings,Nåværende åpninger
DocType: Notification Control,Customize the Notification,Tilpass varslings
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +78,Cash Flow from Operations,Kontantstrøm fra driften
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +313,CGST Amount,CGST beløp
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 +149,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/erpnext_integrations/doctype/amazon_mws_settings/amazon_methods.py +132,Sync has been temporarily disabled because maximum retries have been exceeded,Synkronisering er midlertidig deaktivert fordi maksimal retries er overskredet
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +944,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 +56,Plants and Machineries,Planter og Machineries
DocType: Purchase Taxes and Charges,Tax Amount After Discount Amount,Skattebeløp Etter Rabattbeløp
DocType: Patient,Inpatient Status,Inpatientstatus
DocType: Daily Work Summary Settings,Daily Work Summary Settings,Daglige arbeid Oppsummering Innstillinger
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +1291,Selected Price List should have buying and selling fields checked.,Valgt prisliste skal ha kjøps- og salgsfelt sjekket.
apps/erpnext/erpnext/controllers/buying_controller.py +681,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 +627,Please select Posting Date first,Vennligst velg Publiseringsdato først
apps/erpnext/erpnext/public/js/account_tree_grid.js +209,Opening Date should be before Closing Date,Åpningsdato bør være før påmeldingsfristens utløp
DocType: Travel Itinerary,Flight,Flygning
DocType: Leave Control Panel,Carry Forward,Fremføring
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +32,Cost Center with existing transactions can not be converted to ledger,Kostnadssted med eksisterende transaksjoner kan ikke konverteres til Ledger
DocType: Budget,Applicable on booking actual expenses,Gjelder på bestilling faktiske utgifter
DocType: Department,Days for which Holidays are blocked for this department.,Dager som Holidays er blokkert for denne avdelingen.
DocType: Amazon MWS Settings,ERPNext Integrations,ERPNext Integrasjoner
DocType: Crop Cycle,Detected Disease,Oppdaget sykdom
,Produced,Produsert
apps/erpnext/erpnext/hr/doctype/loan/loan.py +26,Repayment Start Date cannot be before Disbursement Date.,Tilbakebetaling Startdato kan ikke være før Utbetalingsdato.
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
,TDS Payable Monthly,TDS betales månedlig
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +73,Queued for replacing the BOM. It may take a few minutes.,Kjøtt for å erstatte BOM. Det kan ta noen minutter.
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +385,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 +286,Serial Nos Required for Serialized Item {0},Serial Nos Nødvendig for Serialisert Element {0}
apps/erpnext/erpnext/config/accounts.py +167,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 +96,Add to Cart,Legg til i handlevogn
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +197,Group By,Grupper etter
DocType: Guardian,Interests,Interesser
apps/erpnext/erpnext/config/accounts.py +336,Enable / disable currencies.,Aktivere / deaktivere valutaer.
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +549,Could not submit some Salary Slips,Kunne ikke sende inn noen Lønnsslipp
DocType: Exchange Rate Revaluation,Get Entries,Få oppføringer
DocType: Production Plan,Get Material Request,Få Material Request
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +118,Postal Expenses,Post Utgifter
apps/erpnext/erpnext/selling/doctype/pos_closing_voucher/closing_voucher_details.html +8,Sales Summary,Salgsoppsummering
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
DocType: Payment Request,Is a Subscription,Er en abonnement
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 +97,Total Present,Total Present
DocType: Work Order,MFG-WO-.YYYY.-,MFG-WO-.YYYY.-
apps/erpnext/erpnext/config/accounts.py +122,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 +867,Please select Qty against item {0},Vennligst velg antall til elementet {0}
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +33,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 +183,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 +405,All these items have already been invoiced,Alle disse elementene er allerede blitt fakturert
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +954,Set New Release Date,Angi ny utgivelsesdato
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: Leave Allocation,Leave Period,Permisjonstid
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
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1029,Work Order not created,Arbeidsordre er ikke opprettet
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py +36,"An amount of {0} already claimed for the component {1},\
						 set the amount equal or greater than {2}","En mengde på {0} som allerede er påkrevd for komponenten {1}, \ angi beløpet lik eller større enn {2}"
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: Bank Account,SWIFT number,Raskt nummer
DocType: Payment Entry,Party Name,partiet~~POS=HEADCOMP Name
DocType: Employee Benefit Application,Benefits Applied,Fordeler anvendt
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
DocType: Contract,Signed,signert
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html +1,Opening Invoices Summary,Åpning av fakturaoversikt
DocType: Member,NPO-MEM-.YYYY.-,NPO-MEM-.YYYY.-
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 +153,"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 +153,"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: BOM,Routing,Routing
DocType: Serial No,Asset Details,Eiendomsdetaljer
DocType: Bank Statement Transaction Payment Item,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 +1290,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}.
DocType: Manufacturing Settings,Update BOM Cost Automatically,Oppdater BOM Kostnad automatisk
DocType: Lab Test,Test Name,Testnavn
DocType: Healthcare Settings,Clinical Procedure Consumable Item,Klinisk prosedyre forbruksvarer
apps/erpnext/erpnext/utilities/activation.py +99,Create Users,Lag brukere
apps/erpnext/erpnext/utilities/user_progress.py +147,Gram,Gram
apps/erpnext/erpnext/accounts/doctype/subscriber/subscriber_dashboard.py +10,Subscriptions,abonnementer
DocType: Supplier Scorecard,Per Month,Per måned
DocType: Education Settings,Make Academic Term Mandatory,Gjør faglig semester obligatorisk
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +414,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: Loyalty Program,Customer Group,Kundegruppe
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +296,Row #{0}: Operation {1} is not completed for {2} qty of finished goods in Work Order # {3}. Please update operation status via Time Logs,Rute # {0}: Drift {1} er ikke fullført for {2} Antall ferdige varer i Arbeidsordre # {3}. Oppdater operasjonsstatus via Time Logs
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 +229,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 +101,Net Change in Equity,Netto endring i egenkapital
apps/erpnext/erpnext/assets/doctype/asset/asset.py +291,Please cancel Purchase Invoice {0} first,Vennligst avbryte fakturaen {0} først
apps/erpnext/erpnext/healthcare/doctype/healthcare_service_unit_type/healthcare_service_unit_type.py +25,Not permitted. Please disable the Service Unit Type,Ikke tillatt. Slå av tjenestenhetstype
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
DocType: Asset,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 +383,Transaction reference no {0} dated {1},Transaksjonsreferanse ikke {0} datert {1}
apps/erpnext/erpnext/setup/doctype/supplier_group/supplier_group.js +5,There is nothing to edit.,Det er ingenting å redigere.
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +542,Form View,Formvisning
DocType: HR Settings,Expense Approver Mandatory In Expense Claim,Kostnadsgodkjenning Obligatorisk Utgiftskrav
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +124,Summary for this month and pending activities,Oppsummering for denne måneden og ventende aktiviteter
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.py +91,Please set Unrealized Exchange Gain/Loss Account in Company {0},Vennligst sett Urealisert Exchange Gain / Loss-konto i selskapet {0}
apps/erpnext/erpnext/utilities/user_progress.py +248,"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 +109,No Customers yet!,Ingen kunder ennå!
DocType: Healthcare Service Unit,Healthcare Service Unit,Helsevesenethet
apps/erpnext/erpnext/public/js/financial_statements.js +58,Cash Flow Statement,Kontantstrømoppstilling
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py +467,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 +562,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: Healthcare Practitioner,Phone (R),Telefon (R)
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js +104,Time slots added,Tidsluker lagt til
DocType: Item,Attributes,Egenskaper
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js +36,Enable Template,Aktiver mal
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +254,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: Salary Component,Is Payable,Er betales
DocType: Inpatient Record,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: Amazon MWS Settings,US,OSS
DocType: Holiday List,Add Weekly Holidays,Legg til ukesferier
DocType: Staffing Plan Detail,Vacancies,Ledige stillinger
DocType: Hotel Room,Hotel Room,Hotellrom
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +57,Account {0} does not belongs to company {1},Konto {0} ikke tilhører selskapet {1}
DocType: Leave Type,Rounding,avrunding
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +987,Serial Numbers in row {0} does not match with Delivery Note,Serienumre i rad {0} stemmer ikke overens med leveringsnotat
DocType: Employee Benefit Application,Dispensed Amount (Pro-rated),Dispensed Amount (Pro-vurdert)
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 Group, Campaign, Sales Partner etc.","Deretter blir prisreglene filtrert ut basert på kunde, kundegruppe, territorium, leverandør, leverandørgruppe, kampanje, salgspartner etc."
DocType: Student,Guardian Details,Guardian Detaljer
DocType: C-Form,C-Form,C-Form
DocType: Agriculture Task,Start Day,Start dag
DocType: Vehicle,Chassis No,chassis Nei
DocType: Payment Request,Initiated,Initiert
DocType: Production Plan Item,Planned Start Date,Planlagt startdato
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +642,Please select a BOM,Vennligst velg en BOM
DocType: Purchase Invoice,Availed ITC Integrated Tax,Benyttet ITC Integrated Tax
DocType: Purchase Order Item,Blanket Order Rate,Blanket Bestillingsfrekvens
apps/erpnext/erpnext/hooks.py +157,Certification,sertifisering
DocType: Bank Guarantee,Clauses and Conditions,Klausuler og betingelser
DocType: Serial No,Creation Document Type,Creation dokumenttype
DocType: Project Task,View Timesheet,Se tidsskema
DocType: Amazon MWS Settings,ES,ES
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.js +24,Make Journal Entry,Gjør Journal Entry
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: Journal Entry,Inter Company Journal Entry Reference,Inter Company Journal Entry Reference
DocType: Appraisal Template,Appraisal Template Title,Appraisal Mal Tittel
apps/erpnext/erpnext/utilities/user_progress_utils.py +29,Commercial,Commercial
DocType: Patient,Alcohol Current Use,Alkoholstrømbruk
DocType: Employee Tax Exemption Proof Submission,House Rent Payment Amount,Husleie Betalingsbeløp
DocType: Student Admission Program,Student Admission Program,Studentopptaksprogram
DocType: Employee Tax Exemption Sub Category,Tax Exemption Category,Skattefritakskategori
DocType: Payment Entry,Account Paid To,Konto Betalt for å
DocType: Subscription Settings,Grace Period,Grace Period
DocType: Item Alternative,Alternative Item Name,Alternativt varenavn
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/setup/setup_wizard/operations/install_fixtures.py +187,Website Listing,Nettstedsliste
apps/erpnext/erpnext/config/selling.py +57,All Products or Services.,Alle produkter eller tjenester.
DocType: Email Digest,Open Quotations,Åpne tilbud
DocType: Expense Claim,More Details,Mer informasjon
DocType: Supplier Quotation,Supplier Address,Leverandør Adresse
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +168,{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/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37,Out Qty,Ut Antall
apps/erpnext/erpnext/buying/doctype/supplier/supplier.py +49,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/manufacturing/doctype/work_order/work_order.js +214,For Quantity must be greater than zero,For kvantitet må være større enn null
apps/erpnext/erpnext/config/projects.py +51,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
apps/erpnext/erpnext/public/js/hub/hub_call.js +46,Marketplace Error,Markedsplassfeil
DocType: Complaint,Complaint,Klage
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +533,Warehouse required for stock Item {0},Warehouse nødvendig for lager Element {0}
DocType: Leave Allocation,Unused leaves,Ubrukte blader
apps/erpnext/erpnext/hr/doctype/loan/loan.js +83,Make Repayment Entry,Gjør tilbakebetalingsoppføring
apps/erpnext/erpnext/patches/v11_0/update_department_lft_rgt.py +8,All Departments,Alle avdelinger
DocType: Healthcare Service Unit,Vacant,Ledig
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 +248,Cr,Cr
DocType: Project Update,Problematic/Stuck,Problematisk / Stuck
DocType: Tax Rule,Billing State,Billing State
DocType: Share Transfer,Transfer,Transfer
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +262,Work Order {0} must be cancelled before cancelling this Sales Order,Arbeidsordre {0} må avbestilles før du kansellerer denne salgsordren
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +932,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 +170,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
DocType: Employee Benefit Claim,Benefit Type and Amount,Fordeltype og beløp
apps/erpnext/erpnext/hotels/report/hotel_room_occupancy/hotel_room_occupancy.py +19,Rooms Booked,Rom bestilles
apps/erpnext/erpnext/crm/doctype/lead/lead.py +57,Ends On date cannot be before Next Contact Date.,Slutter på dato kan ikke være før neste kontakt dato.
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: Bank Account,Contact HTML,Kontakt HTML
DocType: Support Settings,Support Portal,Støtteportal
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
DocType: Travel Itinerary,Travel Itinerary,Reiseplan
apps/erpnext/erpnext/education/api.py +336,Result already Submitted,Resultat allerede sendt
apps/erpnext/erpnext/controllers/buying_controller.py +197,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,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: Healthcare Settings,Manage Appointment Invoice Automatically,Administrer avtalefaktura automatisk
DocType: Student Attendance,Absent,Fraværende
DocType: Staffing Plan,Staffing Plan Detail,Bemanning Plan detalj
DocType: Employee Promotion,Promotion Date,Kampanjedato
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +615,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 +244,Row {0}: Invalid reference {1},Rad {0}: Ugyldig referanse {1}
apps/erpnext/erpnext/assets/doctype/location/location_tree.js +23,New Location,Ny plassering
DocType: Purchase Taxes and Charges Template,Purchase Taxes and Charges Template,Kjøpe skatter og avgifter Mal
DocType: Subscription,Current Invoice Start Date,Daglig faktura startdato
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: Budget,Action if Annual Budget Exceeded on MR,Handling hvis årlig budsjett overskrider MR
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 +119,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 +796,Send Supplier Emails,Send Leverandør e-post
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +165,"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: Fiscal Year,Auto Created,Automatisk opprettet
apps/erpnext/erpnext/hr/doctype/employee_onboarding/employee_onboarding.py +19,Submit this to create the Employee record,Send inn dette for å skape medarbeideroppføringen
DocType: Item Default,Item Default,Element Standard
DocType: Chapter Member,Leave Reason,Legg igjen grunn
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +197,Invoice {0} no longer exists,Faktura {0} eksisterer ikke lenger
DocType: Guardian Interest,Guardian Interest,Guardian Rente
DocType: Volunteer,Availability,Tilgjengelighet
apps/erpnext/erpnext/config/accounts.py +357,Setup default values for POS Invoices,Oppsett standardverdier for POS-fakturaer
apps/erpnext/erpnext/config/hr.py +248,Training,Opplæring
DocType: Project,Time to send,Tid til å sende
DocType: Timesheet,Employee Detail,Medarbeider Detalj
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure/clinical_procedure.py +19,Set warehouse for Procedure {0} ,Sett lager for prosedyre {0}
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
DocType: Lab Prescription,Test Code,Testkode
apps/erpnext/erpnext/config/website.py +11,Settings for website homepage,Innstillinger for nettstedet hjemmeside
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +895,{0} is on hold till {1},{0} er ventet til {1}
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}
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html +9,Used Leaves,Brukte blad
DocType: Job Offer,Awaiting Response,Venter på svar
DocType: Course Schedule,EDU-CSH-.YYYY.-,EDU-CSH-.YYYY.-
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +83,Above,Fremfor
DocType: Support Search Source,Link Options,Linkalternativer
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1557,Total Amount {0},Totalt beløp {0}
apps/erpnext/erpnext/controllers/item_variant.py +323,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}
DocType: Training Event Employee,Optional,Valgfri
DocType: Salary Slip,Earning & Deduction,Tjene &amp; Fradrag
DocType: Agriculture Analysis Criteria,Water Analysis,Vannanalyse
apps/erpnext/erpnext/stock/doctype/item/item.js +470,{0} variants created.,{0} varianter opprettet.
DocType: Amazon MWS Settings,Region,Region
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +36,Optional. This setting will be used to filter in various transactions.,Valgfritt. Denne innstillingen vil bli brukt for å filtrere i forskjellige transaksjoner.
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +111,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 +99,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
apps/erpnext/erpnext/hr/report/employee_advance_summary/employee_advance_summary.py +15,No record found,Ingen rekord funnet
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +155,Cost of Scrapped Asset,Kostnad for kasserte Asset
apps/erpnext/erpnext/controllers/stock_controller.py +240,{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 +673,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: Employee Transfer,Re-allocate Leaves,Tildel bladene igjen
DocType: GL Entry,Is Advance,Er Advance
apps/erpnext/erpnext/config/hr.py +202,Employee Lifecycle,Ansattes livssyklus
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 +184,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: Clinical Procedure Item,Clinical Procedure Item,Klinisk prosedyre
DocType: Sales Team,Contact No.,Kontaktnummer.
DocType: Bank Reconciliation,Payment Entries,Betalings Entries
apps/erpnext/erpnext/erpnext_integrations/doctype/shopify_settings/shopify_settings.py +33,Access token or Shopify URL missing,Adkomst token eller Shopify URL mangler
DocType: Location,Latitude,Breddegrad
DocType: Work Order,Scrap Warehouse,skrap Warehouse
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +191,"Warehouse required at Row No {0}, please set default warehouse for the item {1} for the company {2}","Lager som kreves ved rad nr. {0}, angi standardlager for elementet {1} for firmaet {2}"
DocType: Work Order,Check if material transfer entry is not required,Sjekk om materialoverføring ikke er nødvendig
DocType: Work 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 +118,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 +70,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/setup/doctype/email_digest/templates/default.html +186,Purchase Order Items not received on time,Innkjøpsordre Varer ikke mottatt i tide
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 +30,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 +76,Opening Value,åpning Verdi
DocType: Salary Component,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 +196,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 +101,Commission on Sales,Provisjon på salg
DocType: Job Offer Term,Value / Description,Verdi / beskrivelse
apps/erpnext/erpnext/controllers/accounts_controller.py +690,"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 +134,Debit and Credit not equal for {0} #{1}. Difference is {2}.,Debet- og kredittkort ikke lik for {0} # {1}. Forskjellen er {2}.
DocType: Clinical Procedure Item,Invoice Separately as Consumables,Faktura Separat som forbruksvarer
DocType: Budget,Control Action,Kontroller handling
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 +105,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}
DocType: Asset Finance Book,Written Down Value,Skrevet nedverdi
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +232,Sales Invoice {0} must be cancelled before cancelling this Sales Order,Salg Faktura {0} må slettes før den sletter denne salgsordre
DocType: Clinical Procedure,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/selling/page/point_of_sale/point_of_sale.js +1181,Search Item (Ctrl + i),Søkeelement (Ctrl + i)
DocType: C-Form,ACC-CF-.YYYY.-,ACC-CF-.YYYY.-
apps/erpnext/erpnext/accounts/doctype/account/account.py +171,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 +109,Legal Expenses,Rettshjelp
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +147,Please select quantity on row ,Vennligst velg antall på rad
apps/erpnext/erpnext/config/accounts.py +315,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/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +125,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 +150,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 +83,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 +126,Travel Expenses,Reiseutgifter
DocType: Maintenance Visit,Breakdown,Sammenbrudd
DocType: Travel Itinerary,Vegetarian,Vegetarisk
DocType: Patient Encounter,Encounter Date,Encounter Date
apps/erpnext/erpnext/controllers/accounts_controller.py +889,Account: {0} with currency: {1} can not be selected,Konto: {0} med valuta: {1} kan ikke velges
DocType: Bank Statement Transaction Settings Item,Bank Data,Bankdata
DocType: Purchase Receipt Item,Sample Quantity,Prøvekvantitet
DocType: Bank Guarantee,Name of Beneficiary,Navn på mottaker
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: Supplier,SUP-.YYYY.-,SUP-.YYYY.-
DocType: Bank Reconciliation Detail,Cheque Date,Sjekk Dato
apps/erpnext/erpnext/accounts/doctype/account/account.py +57,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 +126,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 +39,As on Date,Som på dato
DocType: Additional Salary,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 +103,Probation,Prøvetid
DocType: Program Enrollment Tool,New Academic Year,Nytt studieår
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +866,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 +130,Total Paid Amount,Totalt innbetalt beløp
DocType: GST Settings,B2C Limit,B2C Limit
DocType: Job Card,Transferred Qty,Overført Antall
apps/erpnext/erpnext/config/learn.py +11,Navigating,Navigere
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +164,Planning,Planlegging
DocType: Contract,Signee,signee
DocType: Share Balance,Issued,Utstedt
DocType: Loan,Repayment Start Date,Tilbakebetaling Startdato
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 +285,Quantity should be greater than 0,Mengden skal være større enn 0
DocType: Journal Entry,Cash Entry,Cash Entry
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js +17,Child nodes can be only created under 'Group' type nodes,Ordnede noder kan bare opprettes under &#39;Gruppe&#39; type noder
DocType: Attendance Request,Half Day Date,Half Day Date
DocType: Academic Year,Academic Year Name,Akademisk År Navn
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +1175,{0} not allowed to transact with {1}. Please change the Company.,{0} ikke lov til å transaksere med {1}. Vennligst endre firmaet.
DocType: Sales Partner,Contact Desc,Kontakt Desc
DocType: Email Digest,Send regular summary reports via Email.,Send vanlige oppsummeringsrapporter via e-post.
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +288,Please set default account in Expense Claim Type {0},Vennligst angi standardkonto i Expense krav Type {0}
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html +11,Available Leaves,Tilgjengelige blader
DocType: Assessment Result,Student Name,Student navn
DocType: Hub Tracked Item,Item Manager,Sak manager
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +150,Payroll Payable,lønn Betales
DocType: Plant Analysis,Collection Datetime,Samling Datetime
DocType: Asset Repair,ACC-ASR-.YYYY.-,ACC-ASR-.YYYY.-
DocType: Work Order,Total Operating Cost,Total driftskostnader
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +172,Note: Item {0} entered multiple times,Merk: Element {0} inngått flere ganger
apps/erpnext/erpnext/config/selling.py +41,All Contacts.,Alle kontakter.
DocType: Accounting Period,Closed Documents,Lukkede dokumenter
DocType: Healthcare Settings,Manage Appointment Invoice submit and cancel automatically for Patient Encounter,Administrer avtalefaktura send inn og avbryt automatisk for pasientmøte
DocType: Patient Appointment,Referring Practitioner,Refererende utøver
apps/erpnext/erpnext/public/js/setup_wizard.js +71,Company Abbreviation,Firma Forkortelse
apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner.py +51,User {0} does not exist,Bruker {0} finnes ikke
DocType: Payment Term,Day(s) after invoice date,Dag (er) etter faktura dato
apps/erpnext/erpnext/setup/doctype/company/company.js +34,Date of Commencement should be greater than Date of Incorporation,Oppstartsdato bør være større enn dato for innlemmelse
DocType: Contract,Signed On,Signert på
DocType: Bank Account,Party Type,Partiet Type
DocType: Payment Schedule,Payment Schedule,Nedbetalingsplan
DocType: Item Attribute Value,Abbreviation,Forkortelse
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +220,Payment Entry already exists,Betaling Entry finnes allerede
DocType: Subscription,Trial Period End Date,Prøveperiode Sluttdato
apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py +36,Not authroized since {0} exceeds limits,Ikke authroized siden {0} overskrider grensene
DocType: Serial No,Asset Status,Asset Status
DocType: Restaurant Order Entry,Restaurant Table,Restaurantbord
DocType: Hotel Room,Hotel Manager,Hotell sjef
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +64,Set Tax Rule for shopping cart,Still skatteregel for shopping cart
DocType: Purchase Invoice,Taxes and Charges Added,Skatter og avgifter legges
apps/erpnext/erpnext/assets/doctype/asset/asset.py +214,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,Avskrivningsraden {0}: Neste avskrivningsdato kan ikke være før Tilgjengelig-til-bruk-dato
,Sales Funnel,Sales trakt
apps/erpnext/erpnext/setup/doctype/company/company.py +53,Abbreviation is mandatory,Forkortelsen er obligatorisk
DocType: Project,Task Progress,Task Progress
apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html +7,Cart,Kurven
DocType: Certified Consultant,GitHub ID,GitHub ID
DocType: Staffing Plan,Total Estimated Budget,Totalt estimert budsjett
,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 +131,All Customer Groups,Alle kundegrupper
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +155,Accumulated Monthly,akkumulert pr måned
DocType: Attendance Request,On Duty,I tjeneste
apps/erpnext/erpnext/controllers/accounts_controller.py +846,{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/hr/doctype/staffing_plan/staffing_plan.py +51,Staffing Plan {0} already exist for designation {1},Bemanningsplan {0} finnes allerede for betegnelse {1}
apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +46,Tax Template is mandatory.,Skatt Mal er obligatorisk.
apps/erpnext/erpnext/accounts/doctype/account/account.py +51,Account {0}: Parent account {1} does not exist,Konto {0}: Parent konto {1} finnes ikke
DocType: POS Closing Voucher,Period Start Date,Periode Startdato
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
apps/erpnext/erpnext/config/accounts.py +50,To make Customer based incentive schemes.,Å gjøre kundebaserte insentivordninger.
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 +120,Customer LPO No.,Kunde LPO nr.
DocType: Amazon MWS Settings,Market Place Account Group,Markedsplass Konto Gruppe
apps/erpnext/erpnext/accounts/doctype/payment_order/payment_order.js +14,Make Payment Entries,Lag betalingsoppføringer
DocType: Program,Courses,kurs
DocType: Monthly Distribution Percentage,Percentage Allocation,Prosentvis Allocation
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +116,Secretary,Sekretær
apps/erpnext/erpnext/regional/india/utils.py +177,House rented dates required for exemption calculation,Husleide datoer som kreves for beregning av unntak
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"
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js +29,This action will stop future billing. Are you sure you want to cancel this subscription?,Denne handlingen stopper fremtidig fakturering. Er du sikker på at du vil avbryte dette abonnementet?
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 +1387,Please set Company,Vennligst sett selskap
DocType: Procedure Prescription,Procedure Created,Prosedyre opprettet
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: Inpatient Record,AB Negative,AB Negativ
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 +147,Creditors,Kreditorer
DocType: Assessment Plan,Assessment Name,Assessment Name
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js +101,Show PDC in Print,Vis PDC i Print
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +95,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
DocType: Employee Onboarding,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 +1086,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 +158,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 +158,Quantity ({0}) cannot be a fraction in row {1},Antall ({0}) kan ikke være en brøkdel i rad {1}
DocType: Contract,Unsigned,usignert
DocType: Selling Settings,Each Transaction,Hver transaksjon
apps/erpnext/erpnext/stock/doctype/item/item.py +509,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
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +72,Varaiance ,Varaiance
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 +100,PDC/LC Date,PDC / LC-dato
DocType: Purchase Order,To Receive,Å Motta
DocType: Leave Period,Holiday List for Optional Leave,Ferieliste for valgfritt permisjon
apps/erpnext/erpnext/utilities/user_progress.py +252,user@example.com,user@example.com
DocType: Asset,Asset Owner,Asset Eier
DocType: Purchase Invoice,Reason For Putting On Hold,Årsak til å sette på hold
DocType: Employee,Personal Email,Personlig e-post
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +86,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 +265,Attendance for employee {0} is already marked for this day,Oppmøte for arbeidstaker {0} er allerede markert for denne dagen
DocType: Work Order Operation,"in Minutes
Updated via 'Time Log'",Minutter Oppdatert via &#39;Time Logg&#39;
DocType: Customer,From Lead,Fra Lead
DocType: Amazon MWS Settings,Synch Orders,Synkroniseringsordrer
apps/erpnext/erpnext/config/manufacturing.py +13,Orders released for production.,Bestillinger frigitt for produksjon.
apps/erpnext/erpnext/public/js/account_tree_grid.js +65,Select Fiscal Year...,Velg regnskapsår ...
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +638,POS Profile required to make POS Entry,POS Profile nødvendig å foreta POS Entry
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js +15,"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.","Lojalitetspoeng beregnes ut fra den brukte ferdige (via salgsfakturaen), basert på innsamlingsfaktor som er nevnt."
DocType: Program Enrollment Tool,Enroll Students,Meld Studenter
DocType: Company,HRA Settings,HRA Innstillinger
DocType: Employee Transfer,Transfer Date,Overføringsdato
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 +240,Atleast one warehouse is mandatory,Minst én lageret er obligatorisk
apps/erpnext/erpnext/healthcare/doctype/healthcare_service_unit_type/healthcare_service_unit_type.py +14,"Configure Item Fields like UOM, Item Group, Description and No of Hours.","Konfigurer produktfelt som UOM, varegruppe, beskrivelse og antall timer."
DocType: Certification Application,Certification Status,Sertifiseringsstatus
apps/erpnext/erpnext/public/js/hub/marketplace.js +45,Marketplace,Marketplace
DocType: Travel Itinerary,Travel Advance Required,Krav på reisefordeling
DocType: Subscriber,Subscriber Name,Abonnentnavn
DocType: Serial No,Out of Warranty,Ut av Garanti
DocType: Cashier Closing,Cashier-closing-,Kasserer-closing-
DocType: Bank Statement Transaction Settings Item,Mapped Data Type,Mappet datatype
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 +396,{0} against Sales Invoice {1},{0} mot Sales Faktura {1}
DocType: Antibiotic,Laboratory User,Laboratoriebruker
DocType: Request for Quotation Item,Project Name,Prosjektnavn
DocType: Customer,Mention if non-standard receivable account,Nevn hvis ikke-standard fordring konto
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py +63,Please add the remaining benefits {0} to any of the existing component,Vennligst legg til de resterende fordelene {0} til en eksisterende komponent
DocType: Journal Entry Account,If Income or Expense,Dersom inntekt eller kostnad
DocType: Bank Statement Transaction Entry,Matching Invoices,Matchende fakturaer
DocType: Work Order,Required Items,nødvendige elementer
DocType: Stock Ledger Entry,Stock Value Difference,Stock Verdi Difference
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +63,Item Row {0}: {1} {2} does not exist in above '{1}' table,Vare Row {0}: {1} {2} finnes ikke i tabellen ovenfor {1}
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
DocType: Payment Order Reference,Bank Account Details,Detaljer om bankkonto
DocType: Purchase Order Item,Blanket Order,Teppe ordre
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +39,Tax Assets,Skattefordel
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +631,Production Order has been {0},Produksjonsordre har vært {0}
apps/erpnext/erpnext/regional/india/utils.py +186,House rent paid days overlap with {0},Husleien betalte dager overlapper med {0}
DocType: BOM Item,BOM No,BOM Nei
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +192,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 +47,Electronic Equipments,elektronisk utstyr
DocType: Asset,Maintenance Required,Vedlikehold kreves
DocType: Account,Debit,Debet
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +63,Leaves must be allocated in multiples of 0.5,"Bladene skal avsettes i multipler av 0,5"
DocType: Work Order,Operation Cost,Operation Cost
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +318,Identifying Decision Makers,Identifisere beslutningstakere
apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +48,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]
DocType: Payment Request,Payment Ordered,Betaling Bestilt
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/hr/doctype/employee/employee_dashboard.py +30,Lifecycle,Livssyklus
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +142,Make BOM,Lag BOM
apps/erpnext/erpnext/controllers/selling_controller.py +158,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: Subscription,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 +355,Paid and Not Delivered,Betalt og ikke levert
DocType: Project,Default Cost Center,Standard kostnadssted
DocType: Delivery Note,Transporter Doc No,Transportør Dok nr
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: Bank Statement Transaction Entry,New Transactions,Nye transaksjoner
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
apps/erpnext/erpnext/assets/doctype/asset/asset.py +75,Please create purchase receipt or purchase invoice for the item {0},Vennligst opprett kvittering eller kjøpsfaktura for elementet {0}
DocType: Employee Advance,Due Advance Amount,Forfallsbeløp
DocType: Maintenance Visit,Customer Feedback,Customer Feedback
DocType: Account,Expense,Expense
apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.js +42,Score cannot be greater than Maximum Score,Score kan ikke være større enn Maksimal poengsum
DocType: Support Search Source,Source Type,Kildetype
apps/erpnext/erpnext/utilities/user_progress.py +129,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: Inpatient Occupancy,Invoiced,fakturert
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +179,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 +149,Item {0} ignored since it is not a stock item,Element {0} ignorert siden det ikke er en lagervare
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 +54,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/work_order/work_order_calendar.js +36,Production Item,Produksjon Element
,Employee Information,Informasjon ansatt
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +242,Healthcare Practitioner not available on {0},Helsepersonell er ikke tilgjengelig på {0}
DocType: Stock Entry Detail,Additional Cost,Tilleggs Cost
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +56,"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 +905,Make Supplier Quotation,Gjør Leverandør sitat
DocType: Quality Inspection,Incoming,Innkommende
apps/erpnext/erpnext/setup/doctype/company/company.js +90,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 +44,Assessment Result record {0} already exists.,Vurderingsresultatrekord {0} eksisterer allerede.
DocType: Item,"Example: ABCD.#####. If series is set and Batch No is not mentioned in transactions, then automatic batch number will be created based on this series. If you always want to explicitly mention Batch No for this item, leave this blank. Note: this setting will take priority over the Naming Series Prefix in Stock Settings.","Eksempel: ABCD. #####. Hvis serier er satt og Batch nr ikke er nevnt i transaksjoner, vil automatisk batchnummer bli opprettet basert på denne serien. Hvis du alltid vil uttrykkelig nevne Batch nr for dette elementet, la dette være tomt. Merk: Denne innstillingen vil ha prioritet i forhold til Naming Series Prefix i lagerinnstillinger."
DocType: BOM,Materials Required (Exploded),Materialer som er nødvendige (Exploded)
DocType: Contract,Party User,Festbruker
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 +68,Posting Date cannot be future date,Publiseringsdato kan ikke være fremtidig dato
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +100,Row # {0}: Serial No {1} does not match with {2} {3},Row # {0}: Serial No {1} samsvarer ikke med {2} {3}
DocType: Stock Entry,Target Warehouse Address,Mållageradresse
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +89,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 +386,Note: {0},Merk: {0}
,Delivery Note Trends,Levering Note Trender
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +120,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
,Daily Work Summary Replies,Daglig arbeidssammendrag Svar
DocType: Delivery Trip,Calculate Estimated Arrival Times,Beregn anslåtte ankomsttider
apps/erpnext/erpnext/accounts/general_ledger.py +113,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: Shopify Settings,Webhooks,Webhooks
DocType: Bank Account,Party,Selskap
DocType: Healthcare Settings,Patient Name,Pasientnavn
DocType: Variant Field,Variant Field,Variantfelt
apps/erpnext/erpnext/assets/doctype/asset/asset.js +370,Target Location,Målplassering
DocType: Sales Order,Delivery Date,Leveringsdato
DocType: Opportunity,Opportunity Date,Opportunity Dato
DocType: Employee,Health Insurance Provider,Helseforsikringsselskap
DocType: Products Settings,Show Availability Status,Vis tilgjengelighet Status
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.
DocType: Employee Grade,Employee Grade,Ansatte grad
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +106,Piecework,Akkord
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +68,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
DocType: Customer,Customer Primary Address,Kunde hovedadresse
apps/erpnext/erpnext/config/learn.py +107,Newsletters,Nyhetsbrev
apps/erpnext/erpnext/accounts/report/tds_payable_monthly/tds_payable_monthly.py +172,Reference No.,Referanse Nei.
DocType: Drug Prescription,Description/Strength,Beskrivelse / styrke
DocType: Bank Statement Transaction Entry,Create New Payment/Journal Entry,Opprett ny betaling / journalinngang
DocType: Certification Application,Certification Application,Sertifiseringsprogram
DocType: Leave Type,Is Optional Leave,Er valgfritt permisjon
DocType: Share Balance,Is Company,Er selskapet
DocType: Stock Ledger Entry,Stock Ledger Entry,Stock Ledger Entry
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +190,{0} on Half day Leave on {1},{0} på halv dag permisjon på {1}
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +86,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 +198,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
DocType: Loyalty Program,Customer Territory,Kundeområde
DocType: Email Digest,Sales Orders to Deliver,Salgsordre for levering
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: 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;"
apps/erpnext/erpnext/hr/utils.py +152,To date can not be less than from date,Til dato kan ikke være mindre enn fra dato
DocType: Opportunity,To Discuss,Å Diskutere
apps/erpnext/erpnext/accounts/doctype/subscriber/subscriber_dashboard.py +6,This is based on transactions against this Subscriber. See timeline below for details,Dette er basert på transaksjoner mot denne abonnenten. Se tidslinjen nedenfor for detaljer
apps/erpnext/erpnext/stock/stock_ledger.py +378,{0} units of {1} needed in {2} to complete this transaction.,{0} enheter av {1} trengs i {2} for å fullføre denne transaksjonen.
DocType: Loan Type,Rate of Interest (%) Yearly,Rente (%) Årlig
DocType: Support Settings,Forum URL,Forum-URL
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +75,Temporary Accounts,Midlertidige kontoer
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +40,Source Location is required for the asset {0},Kildeplassering er nødvendig for aktiva {0}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +182,Black,Svart
DocType: BOM Explosion Item,BOM Explosion Item,BOM Explosion Element
DocType: Shareholder,Contact List,Kontaktliste
DocType: Account,Auditor,Revisor
DocType: Project,Frequency To Collect Progress,Frekvens for å samle fremgang
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +254,{0} items produced,{0} elementer produsert
apps/erpnext/erpnext/utilities/user_progress.py +58,Learn More,Lære mer
DocType: Cheque Print Template,Distance from top edge,Avstand fra øvre kant
DocType: POS Closing Voucher Invoices,Quantity of Items,Antall gjenstander
apps/erpnext/erpnext/stock/get_item_details.py +521,Price List {0} is disabled or does not exist,Prisliste {0} er deaktivert eller eksisterer ikke
DocType: Purchase Invoice,Return,Return
DocType: Pricing Rule,Disable,Deaktiver
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +184,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."
DocType: Leave Type,Maximum Continuous Days Applicable,Maksimum kontinuerlige dager gjelder
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 +118,"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 +90,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
DocType: Job Applicant Source,Job Applicant Source,Jobbsøkerkilde
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +325,IGST Amount,IGST Beløp
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 +152,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 +656,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 +286,Fleet Management,Flåtestyring
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: Healthcare Practitioner,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 +73,Warehouse {0} does not exist,Warehouse {0} finnes ikke
DocType: Cashier Closing,Custody,varetekt
DocType: Employee Tax Exemption Proof Submission Detail,Employee Tax Exemption Proof Submission Detail,Beskjed om innlevering av ansatt skattefritak
DocType: Monthly Distribution,Monthly Distribution Percentages,Månedlig Distribusjonsprosent
apps/erpnext/erpnext/stock/doctype/batch/batch.py +115,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 +158,Explore Sales Cycle,Utforsk salgssyklusen
DocType: Assessment Plan,Supervisor,Supervisor
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +881,Retention Stock Entry,Beholdningsinngang
,Available Stock for Packing Items,Tilgjengelig på lager for pakk gjenstander
DocType: Item Variant,Item Variant,Sak Variant
,Work Order Stock Report,Arbeide ordre lagerrapport
DocType: Purchase Receipt,Auto Repeat Detail,Auto Repeat Detail
DocType: Assessment Result Tool,Assessment Result Tool,Assessment Resultat Tool
apps/erpnext/erpnext/education/doctype/instructor/instructor.js +45,As Supervisor,Som veileder
DocType: Leave Policy Detail,Leave Policy Detail,Forlat politikkdetaljer
DocType: BOM Scrap Item,BOM Scrap Item,BOM Scrap Element
apps/erpnext/erpnext/accounts/page/pos/pos.js +906,Submitted orders can not be deleted,Innsendte bestillinger kan ikke slettes
apps/erpnext/erpnext/accounts/doctype/account/account.py +121,"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 +360,Quality Management,Kvalitetsstyring
apps/erpnext/erpnext/assets/doctype/asset/asset.py +52,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: Loan,Repay Fixed Amount per Period,Smelle fast beløp per periode
DocType: Employee,Health Insurance No,Helseforsikring nr
DocType: Employee Tax Exemption Proof Submission,Tax Exemption Proofs,Skattefritakelsesbevis
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 +233,Credit Note Amt,Kreditt notat Amt
apps/erpnext/erpnext/regional/report/hsn_wise_summary_of_outward_supplies/hsn_wise_summary_of_outward_supplies.py +78,Total Taxable Amount,Sum skattepliktig beløp
DocType: Employee External Work History,Employee External Work History,Ansatt Ekstern Work History
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +689,Job card {0} created,Jobbkort {0} opprettet
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 +18,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 +59,Cost Centers,Kostnadssteder
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js +19,Restart Subscription,Start abonnementet på nytt
DocType: Linked Plant Analysis,Linked Plant Analysis,Linked Plant Analysis
DocType: Delivery Note,Transporter ID,Transporter ID
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +317,Value Proposition,Verdivurdering
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
DocType: Purchase Invoice Item,Service End Date,Tjenestens sluttdato
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: Bank Guarantee,Receiving,motta
DocType: Training Event Employee,Invited,invitert
apps/erpnext/erpnext/config/accounts.py +346,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 +43,Fixed Assets,Anleggsmidler
DocType: Payment Entry,Set Exchange Gain / Loss,Sett valutagevinst / tap
,GST Purchase Register,GST Innkjøpsregister
,Cash Flow,Cash Flow
DocType: Shareholder,ACC-SH-.YYYY.-,ACC-SH-.YYYY.-
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 Default,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: POS Closing Voucher Invoices,POS Closing Voucher Invoices,POS Closing Voucher Fakturaer
DocType: Tax Rule,Sales Tax Template,Merverdiavgift Mal
DocType: Employee Benefit Application Detail,Pay Against Benefit Claim,Betal mot fordelskrav
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +21,Update Cost Center Number,Oppdater kostnadssenternummer
apps/erpnext/erpnext/accounts/page/pos/pos.js +2521,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: Work Order,Planned Operating Cost,Planlagt driftskostnader
DocType: Academic Term,Term Start Date,Term Startdato
apps/erpnext/erpnext/config/accounts.py +515,List of all share transactions,Liste over alle aksje transaksjoner
DocType: Shopify Settings,Import Sales Invoice from Shopify if Payment is marked,Import salgsfaktura fra Shopify hvis Betaling er merket
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +18,Opp Count,Opptelling
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +218,Both Trial Period Start Date and Trial Period End Date must be set,Begge prøveperiodens startdato og prøveperiodens sluttdato må settes
apps/erpnext/erpnext/accounts/report/share_balance/share_balance.py +52,Average Rate,Gjennomsnittlig rente
apps/erpnext/erpnext/controllers/accounts_controller.py +790,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
DocType: Subscription Plan Detail,Plan,Plan
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +34,Bank Statement balance as per General Ledger,Kontoutskrift balanse pr hovedbok
DocType: Job Applicant,Applicant Name,Søkerens navn
DocType: Authorization Rule,Customer / Item Name,Kunde / Navn
DocType: Product Bundle,"Aggregate group of **Items** into another **Item**. This is useful if you are bundling a certain **Items** into a package and you maintain stock of the packed **Items** and not the aggregate **Item**. 

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

For Example: If you are selling Laptops and Backpacks separately and have a special price if the customer buys both, then the Laptop + Backpack will be a new Product Bundle Item.

Note: BOM = Bill of Materials","Samlet gruppe ** Elementer ** i en annen ** Sak **. Dette er nyttig hvis du er bunting en viss ** Elementer ** inn i en pakke, og du opprettholde bestanden av de pakkede ** Elementer ** og ikke samlet ** Sak **. Pakken ** Sak ** vil ha &quot;Er Stock Item&quot; som &quot;Nei&quot; og &quot;Er Sales Item&quot; som &quot;Ja&quot;. For eksempel: Hvis du selger bærbare datamaskiner og ryggsekker separat og har en spesiell pris hvis kunden kjøper begge, så Laptop + Backpack vil være et nytt produkt Bundle varen. Merk: BOM = Bill of Materials"
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +42,Serial No is mandatory for Item {0},Serial No er obligatorisk for Element {0}
DocType: Item Variant Attribute,Attribute,Attributt
DocType: Staffing Plan Detail,Current Count,Nåværende tall
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 +32,Balance (Dr - Cr),Balanse (Dr - Cr)
apps/erpnext/erpnext/public/js/utils.js +56,Add Serial No,Legg Serial No
DocType: Work 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
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +60,Filter based on Cost Center is only applicable if Budget Against is selected as Cost Center,Filter basert på kostnadssenter er kun aktuelt hvis budsjett mot er valgt som kostnadssenter
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1182,"Search by item code, serial number, batch no or barcode","Søk etter varenummer, serienummer, batchnummer eller strekkode"
DocType: Work Order,Warehouses,Næringslokaler
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +19,{0} asset cannot be transferred,{0} eiendelen kan ikke overføres
DocType: Hotel Room Pricing,Hotel Room Pricing,Hotellrompriser
apps/erpnext/erpnext/healthcare/doctype/inpatient_record/inpatient_record.py +121,"Can not mark Inpatient Record Discharged, there are Unbilled Invoices {0}","Kan ikke markere Inpatient Record Discharged, det er Unbilled Fakturaer {0}"
DocType: Subscription,Days Until Due,Dager til forfallsdato
apps/erpnext/erpnext/stock/doctype/item/item.js +82,This Item is a Variant of {0} (Template).,Denne varen er en variant av {0} (mal).
DocType: Workstation,per hour,per time
DocType: Blanket Order,Purchasing,innkjøp
DocType: Announcement,Announcement,Kunngjøring
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +107,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 +50,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: Journal Entry Account,Loan,Låne
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 +121,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 +356,Dispatch,Dispatch
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +75,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 +191,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 +319,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: Stock Entry,Material Consumption for Manufacture,Materialforbruk for produksjon
DocType: Item Alternative,Alternative Item Code,Alternativ produktkode
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 +1065,Select Items to Manufacture,Velg delbetaling Produksjon
DocType: Delivery Stop,Delivery Stop,Leveringsstopp
apps/erpnext/erpnext/accounts/page/pos/pos.js +974,"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
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 +111,Do you want to notify all the customers by email?,Vil du varsle alle kundene via e-post?
DocType: Subscription Plan,Billing Interval,Faktureringsintervall
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/manufacturing/doctype/job_card/job_card.py +76,Actual start date and actual end date is mandatory,Faktisk startdato og faktisk sluttdato er obligatorisk
DocType: Salary Detail,Component,Komponent
apps/erpnext/erpnext/assets/doctype/asset_category/asset_category.py +16,Row {0}: {1} must be greater than 0,Row {0}: {1} må være større enn 0
DocType: Assessment Criteria,Assessment Criteria Group,Vurderingskriterier Gruppe
DocType: Healthcare Settings,Patient Name By,Pasientnavn Av
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +220,Accrual Journal Entry for salaries from {0} to {1},Periodiseringstidspunkt Oppføring for lønn fra {0} til {1}
DocType: Sales Invoice Item,Enable Deferred Revenue,Aktiver utsatt inntekt
apps/erpnext/erpnext/assets/doctype/asset/asset.py +193,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
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.py +20,Actual start date must be less than actual end date,Faktisk startdato må være mindre enn faktisk sluttdato
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å
DocType: Education Settings,"If enabled, field Academic Term will be Mandatory in Program Enrollment Tool.","Hvis aktivert, vil feltet faglig semester være obligatorisk i programopptakingsverktøyet."
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 +103,Uncheck all,Fjern haken ved alle
DocType: POS Profile,Terms and Conditions,Vilkår og betingelser
DocType: Asset,Booked Fixed Asset,Bokført anleggsmiddel
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 +222,Cannot cancel because submitted Stock Entry {0} exists,Kan ikke avbryte fordi innsendt Stock Entry {0} finnes
DocType: Loan,Disbursement Date,Innbetalingsdato
DocType: BOM Update Tool,Update latest price in all BOMs,Oppdater siste pris i alle BOMs
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +24,Medical Record,Pasientjournal
DocType: Vehicle,Vehicle,Kjøretøy
DocType: Purchase Invoice,In Words,I Words
apps/erpnext/erpnext/accounts/doctype/bank_guarantee/bank_guarantee.py +21,Enter the name of the bank or lending institution before submittting.,Skriv inn navnet på banken eller låneinstitusjonen før du sender inn.
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 +238,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
DocType: Exchange Rate Revaluation Account,Balance In Account Currency,Balanse i Konto Valuta
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +188,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
DocType: Project Task,View Task,Vis Task
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +22,Opp/Lead %,Opp / Lead%
DocType: Bank Guarantee,Bank Account Info,Bankkontoinformasjon
DocType: Bank Guarantee,Bank Guarantee Type,Bankgaranti Type
DocType: Payment Schedule,Invoice Portion,Fakturaandel
,Asset Depreciations and Balances,Asset Avskrivninger og Balanserer
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +372,Amount {0} {1} transferred from {2} to {3},Mengden {0} {1} overført fra {2} til {3}
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +200,{0} does not have a Healthcare Practitioner Schedule. Add it in Healthcare Practitioner master,{0} har ikke en helsepersonellplan. Legg det til i helsepersonell mester
DocType: Sales Invoice,Get Advances Received,Få Fremskritt mottatt
DocType: Email Digest,Add/Remove Recipients,Legg til / fjern Mottakere
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.js +19,"To set this Fiscal Year as Default, click on 'Set as Default'","For å sette dette regnskapsåret som standard, klikk på &quot;Angi som standard &#39;"
apps/erpnext/erpnext/accounts/report/tds_computation_summary/tds_computation_summary.py +130,Amount of TDS Deducted,Antallet TDS avviklet
DocType: Production Plan,Include Subcontracted Items,Inkluder underleverte varer
apps/erpnext/erpnext/projects/doctype/project/project.py +280,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 +772,Item variant {0} exists with same attributes,Sak variant {0} finnes med samme attributtene
DocType: Loan,Repay from Salary,Smelle fra Lønn
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +405,Requesting payment against {0} {1} for amount {2},Ber om betaling mot {0} {1} for mengden {2}
DocType: Additional Salary,Salary Slip,Lønn Slip
DocType: Lead,Lost Quotation,mistet sitat
apps/erpnext/erpnext/utilities/user_progress.py +221,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."
apps/erpnext/erpnext/projects/doctype/project/project.py +90,Task weight cannot be negative,Oppgavevekt kan ikke være negativ
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: Payroll Entry,Deduct Tax For Unclaimed Employee Benefits,Fradragsskatt for uopptjente ansattes fordeler
DocType: Salary Slip,Total Interest Amount,Totalt rentebeløp
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +124,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: Travel Itinerary,Arrival Datetime,Ankomst Datetime
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."
DocType: Tax Rule,Billing Zipcode,Fakturering Postnummer
DocType: Attendance,HR-ATT-.YYYY.-,HR-ATT-.YYYY.-
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
apps/erpnext/erpnext/public/js/controllers/transaction.js +1180,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 +222,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: Budget,Action if Accumulated Monthly Budget Exceeded on Actual,Handling hvis akkumulert månedlig budsjett oversteg faktisk
DocType: Salary Component,Create Separate Payment Entry Against Benefit Claim,Opprett separat betalingsoppføring mot fordringsfordring
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 +1366,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 +251,Invalid {0},Ugyldig {0}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +93,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: Selling Settings,Sales Update Frequency,Salgsoppdateringsfrekvens
DocType: Production Plan,Material Requested,Materiale som kreves
DocType: Warehouse,PIN,PIN
DocType: Bin,Reserved Qty for sub contract,Reservert antall for kontrakt
DocType: Patient Service Unit,Patinet Service Unit,Patinet Service Unit
DocType: Sales Invoice,Base Change Amount (Company Currency),Base Endre Beløp (Selskap Valuta)
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +309,No accounting entries for the following warehouses,Ingen regnskapspostene for følgende varehus
apps/erpnext/erpnext/projects/doctype/project/project.js +98,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: Contract,Fulfilment Details,Oppfyllelsesdetaljer
apps/erpnext/erpnext/templates/pages/integrations/gocardless_checkout.py +68,Pay {0} {1},Betal {0} {1}
DocType: Employee Onboarding,Activities,aktiviteter
DocType: Expense Claim Detail,Expense Date,Expense Dato
DocType: Item,No of Months,Antall måneder
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
DocType: Purchase Invoice Item,Service Stop Date,Service Stop Date
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 +290," {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: Certification Application,Yet to appear,Likevel å vises
DocType: Delivery Stop,Email Sent To,E-post sendt Å
DocType: Job Card Item,Job Card Item,Jobbkort-element
DocType: Accounts Settings,Allow Cost Center In Entry of Balance Sheet Account,Tillat kostnadssenter ved innføring av balansekonto
apps/erpnext/erpnext/accounts/doctype/account/account.js +102,Merge with Existing Account,Slå sammen med eksisterende konto
DocType: Budget,Warn,Advare
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +988,All items have already been transferred for this Work Order.,Alle elementer er allerede overført for denne arbeidsordren.
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: Subscription Plan,Payment Plan,Betalingsplan
DocType: Shopping Cart Settings,Enable purchase of items via the website,Aktiver kjøp av varer via nettsiden
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +291,Currency of the price list {0} must be {1} or {2},Valuta på prislisten {0} må være {1} eller {2}
apps/erpnext/erpnext/config/accounts.py +532,Subscription Management,Abonnementsadministrasjon
DocType: Appraisal,Appraisal Template,Appraisal Mal
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +252,To Pin Code,Å pin kode
DocType: Soil Texture,Ternary Plot,Ternary Plot
DocType: Amazon MWS Settings,Check this to enable a scheduled Daily synchronization routine via scheduler,Kontroller dette for å aktivere en planlagt daglig synkroniseringsrutine via planleggeren
DocType: Item Group,Item Classification,Sak Klassifisering
DocType: Driver,License Number,Lisensnummer
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +119,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 +27,General Ledger,General Ledger
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js +16,To Fiscal Year,Til Skatteår
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
DocType: POS Closing Voucher Details,Expected Amount,Forventet beløp
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test_list.js +16,Create Multiple,Lag flere
,Itemwise Recommended Reorder Level,Itemwise Anbefalt Omgjøre nivå
apps/erpnext/erpnext/hr/utils.py +211,Employee {0} of grade {1} have no default leave policy,Medarbeider {0} av klasse {1} har ingen standard permisjon
DocType: Salary Detail,Salary Detail,lønn Detalj
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1103,Please select {0} first,Vennligst velg {0} først
apps/erpnext/erpnext/public/js/hub/marketplace.js +177,Added {0} users,Lagt til {0} brukere
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js +21,"In the case of multi-tier program, Customers will be auto assigned to the concerned tier as per their spent","Når det gjelder flerlagsprogram, vil kundene automatisk bli tilordnet den aktuelle delen som brukt"
DocType: Appointment Type,Physician,lege
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1072,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
apps/erpnext/erpnext/manufacturing/report/bom_variance_report/bom_variance_report.py +36,Finished Good,Ferdig bra
apps/erpnext/erpnext/stock/doctype/item_price/item_price.py +56,"Item Price appears multiple times based on Price List, Supplier/Customer, Currency, Item, UOM, Qty and Dates.","Varepris vises flere ganger basert på prisliste, leverandør / kunde, valuta, varenummer, uom, antall og datoer."
DocType: Sales Invoice,Commission,Kommisjon
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +203,{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0} ({1}) kan ikke være større enn planlagt antall ({2}) i Work Order {3}
DocType: Certification Application,Name of Applicant,Navn på søkeren
apps/erpnext/erpnext/config/manufacturing.py +27,Time Sheet for manufacturing.,Timeregistrering for produksjon.
apps/erpnext/erpnext/templates/pages/cart.html +37,Subtotal,delsum
apps/erpnext/erpnext/stock/doctype/item/item.py +711,Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,Kan ikke endre Variant egenskaper etter aksje transaksjon. Du må lage en ny gjenstand for å gjøre dette.
apps/erpnext/erpnext/config/integrations.py +18,GoCardless SEPA Mandate,GoCardless SEPA Mandat
DocType: Healthcare Practitioner,Charges,kostnader
DocType: Production Plan,Get Items For Work Order,Få varer for arbeidsordre
DocType: Salary Detail,Default Amount,Standard Beløp
DocType: Lab Test Template,Descriptive,beskrivende
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +96,Warehouse not found in the system,Warehouse ikke funnet i systemet
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +123,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 +26,`Freeze Stocks Older Than` should be smaller than %d days.,`frys Aksjer Eldre en` 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 +48,Set a sales goal you'd like to achieve for your company.,Sett et salgsmål du vil oppnå for din bedrift.
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1549,Healthcare Services,Helsetjenester
,Project wise Stock Tracking,Prosjektet klok Stock Tracking
DocType: GST HSN Code,Regional,Regional
DocType: Delivery Note,Transport Mode,Transportmodus
apps/erpnext/erpnext/config/healthcare.py +50,Laboratory,Laboratorium
DocType: UOM Category,UOM Category,UOM kategori
DocType: Clinical Procedure Item,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
DocType: HR Settings,Payroll Settings,Lønn Innstillinger
apps/erpnext/erpnext/config/accounts.py +169,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 +26,Root cannot have a parent cost center,Root kan ikke ha en forelder kostnadssted
apps/erpnext/erpnext/public/js/stock_analytics.js +54,Select Brand...,Velg merke ...
apps/erpnext/erpnext/public/js/setup_wizard.js +32,Non Profit (beta),Ikke-profitt (beta)
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +167,Accumulated Depreciation as on,Akkumulerte avskrivninger som på
DocType: Employee Tax Exemption Category,Employee Tax Exemption Category,Skattefritakskategori for ansatte
DocType: Sales Invoice,C-Form Applicable,C-Form Gjelder
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +419,Operation Time must be greater than 0 for Operation {0},Operation Tid må være større enn 0 for operasjon {0}
DocType: Support Search Source,Post Route String,Legg inn rutestreng
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +105,Warehouse is mandatory,Warehouse er obligatorisk
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +72,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 +936,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 +407,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
apps/erpnext/erpnext/healthcare/doctype/patient_encounter/patient_encounter.js +32,Schedule Discharge,Planlegg utladning
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 +53,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
apps/erpnext/erpnext/public/js/controllers/transaction.js +812,Service Stop Date cannot be after Service End Date,Service Stop Date kan ikke være etter service sluttdato
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: Travel Itinerary,Check-in Date,Ankomstdato
DocType: Sample Collection,Collected By,Samlet inn
apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.js +25,Assessment Result,Assessment Resultat
DocType: Hotel Room Package,Hotel Room Package,Hotellromspakke
DocType: Employee Transfer,Employee Transfer,Medarbeideroverføring
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/selling/doctype/sales_order/sales_order.js +1038,Work Order already created for all items with BOM,Arbeidsordre som allerede er opprettet for alle elementer med BOM
DocType: Payment Request,Party Details,Festdetaljer
apps/erpnext/erpnext/stock/doctype/item/item.js +62,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 +42,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/accounts/doctype/subscription/subscription.js +9,Cancel Subscription,Avbestille abonnementet
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 +40,Transaction currency must be same as Payment Gateway currency,Transaksjons valuta må være samme som Payment Gateway valuta
DocType: Payment Entry,Receive,Motta
DocType: Employee Benefit Application Detail,Earning Component,Spare komponent
apps/erpnext/erpnext/templates/pages/rfq.html +75,Quotations: ,sitater:
DocType: Contract,Partially Fulfilled,Delvis oppfylt
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
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +487,Currency for {0} must be {1},Valuta for {0} må være {1}
apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py +53,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
					to cancel this document","Vennligst slett Medarbeider <a href=""#Form/Employee/{0}"">{0}</a> \ for å avbryte dette dokumentet"
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 +527,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/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +68,CWIP Account,CWIP-konto
apps/erpnext/erpnext/hr/doctype/training_event/training_event.js +16,Training Feedback,trening Tilbakemelding
apps/erpnext/erpnext/config/accounts.py +211,Tax Withholding rates to be applied on transactions.,Skatt Tilbakebetaling satser som skal brukes på transaksjoner.
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}
DocType: Maintenance Schedule,MAT-MSH-.YYYY.-,MAT-MSH-.YYYY.-
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 +353,Add / Edit Prices,Legg til / Rediger priser
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.py +19,Employee Promotion cannot be submitted before Promotion Date ,Medarbeideropprykk kan ikke sendes før Kampanjedato
DocType: Batch,Parent Batch,Parent Batch
DocType: Cheque Print Template,Cheque Print Template,Sjekk ut Mal
DocType: Salary Component,Is Flexible Benefit,Er fleksibel fordel
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +85,Chart of Cost Centers,Plan Kostnadssteder
DocType: Subscription Settings,Number of days after invoice date has elapsed before canceling subscription or marking subscription as unpaid,Antall dager etter fakturadato er gått før du kansellerer abonnement eller markeringsabonnement som ubetalt
DocType: Clinical Procedure Template,Sample Collection,Eksempel Innsamling
,Requested Items To Be Ordered,Etterspør Elementer bestilles
DocType: Price List,Price List Name,Prisliste Name
DocType: Delivery Stop,Dispatch Information,Leveringsinformasjon
DocType: Blanket Order,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 +174,Warning: Leave application contains following block dates,Advarsel: La programmet inneholder følgende blokk datoer
DocType: Bank Statement Settings,Transaction Data Mapping,Transaksjonsdata kartlegging
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +277,Sales Invoice {0} has already been submitted,Salg Faktura {0} er allerede innsendt
DocType: Salary Component,Is Tax Applicable,Er skatt gjeldende
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 +382,{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/healthcare/doctype/clinical_procedure/clinical_procedure.js +98,Stock quantity to start procedure is not available in the warehouse. Do you want to record a Stock Transfer,Lagerkvantitet til startprosedyre er ikke tilgjengelig på lageret. Ønsker du å registrere en Stock Transfer
DocType: Shipping Rule,Shipping Rule Type,Forsendelsestype
apps/erpnext/erpnext/utilities/user_progress.py +239,Go to Rooms,Gå til rom
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +259,"Company, Payment Account, From Date and To Date is mandatory","Firma, Betalingskonto, Fra dato og til dato er obligatorisk"
DocType: Company,Budget Detail,Budsjett Detalj
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: Delivery Note,Distance (KM),Avstand (KM)
DocType: Asset,Custodian,Depotmottaker
apps/erpnext/erpnext/config/accounts.py +356,Point-of-Sale Profile,Point-of-Sale Profile
apps/erpnext/erpnext/agriculture/doctype/soil_texture/soil_texture.py +25,{0} should be a value between 0 and 100,{0} skal være en verdi mellom 0 og 100
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +319,Payment of {0} from {1} to {2},Betaling av {0} fra {1} til {2}
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +166,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 +232,Total Paid Amt,Sum innskutt Amt
DocType: SMS Center,Messages greater than 160 characters will be split into multiple messages,Meldinger som er større enn 160 tegn vil bli delt inn i flere meldinger
DocType: Purchase Receipt Item,Received and Accepted,Mottatt og akseptert
,GST Itemised Sales Register,GST Artized Sales Register
DocType: Staffing Plan,Staffing Plan Details,Bemanning Plandetaljer
DocType: Soil Texture,Silt Loam,Silt Loam
,Serial No Service Contract Expiry,Serial No Service kontraktsutløp
DocType: Employee Health Insurance,Employee Health Insurance,Ansattes helseforsikring
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +331,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}
DocType: Loyalty Point Entry,Loyalty Program Tier,Lojalitetsprogram Tier
apps/erpnext/erpnext/utilities/user_progress.py +109,Your Suppliers,Dine Leverandører
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 +395,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/public/js/hub/components/reviews.js +2,Anonymous,Anonym
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +379,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 +250,"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 +172,Row #{0}: Set Supplier for item {1},Row # {0}: Sett Leverandør for elementet {1}
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +115,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 +210,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: Subscription,Current Invoice End Date,Faktura for sluttfaktura
DocType: Payment Term,Due Date Based On,Forfallsdato basert på
apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +82,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 +215,{0} {1} does not exist,{0} {1} finnes ikke
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +355,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 +88,Item: {0} does not exist in the system,Sak: {0} finnes ikke i systemet
apps/erpnext/erpnext/accounts/doctype/account/account.py +113,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
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +35,Employee {0} is on Leave on {1},Ansatt {0} er på permisjon på {1}
apps/erpnext/erpnext/hr/doctype/loan/loan.py +159,No repayments selected for Journal Entry,Ingen tilbakebetalinger valgt for Journal Entry
DocType: Payment Reconciliation,From Invoice Date,Fra Fakturadato
DocType: Loan,Disbursed,utbetalt
DocType: Healthcare Settings,Laboratory Settings,Laboratorieinnstillinger
DocType: Clinical Procedure,Service Unit,Servicenhet
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
apps/erpnext/erpnext/buying/report/quoted_item_comparison/quoted_item_comparison.js +97,Successfully Set Supplier,Vellykket sett leverandør
DocType: Leave Encashment,Leave Encashment,La Encashment
apps/erpnext/erpnext/public/js/setup_wizard.js +114,What does it do?,Hva gjør det?
apps/erpnext/erpnext/agriculture/doctype/crop_cycle/crop_cycle.py +47,Tasks have been created for managing the {0} disease (on row {1}),Oppgaver er opprettet for å administrere {0} sykdommen (på rad {1})
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
DocType: Taxable Salary Slab,To Amount,Til beløp
apps/erpnext/erpnext/stock/doctype/item/item.py +465,'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 +59,Select Status,Velg Status
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +44,Attendance can not be marked for future dates,Oppmøte kan ikke merkes for fremtidige datoer
DocType: Support Search Source,Post Description Key,Innlegg Beskrivelse Nøkkel
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: Opportunity,Sales Stage,Salgstrinn
DocType: Purchase Taxes and Charges,Account Head,Account Leder
DocType: Company,HRA Component,HRA-komponent
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +142,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 +380,Row {0}: Exchange Rate is mandatory,Rad {0}: Exchange Rate er obligatorisk
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +46,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 +237,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 +436,Debit To account must be a Balance Sheet account,Uttak fra kontoen må være en balansekonto
DocType: Asset,Naming Series,Navngi Series
DocType: Vital Signs,Coated,Coated
apps/erpnext/erpnext/assets/doctype/asset/asset.py +181,Row {0}: Expected Value After Useful Life must be less than Gross Purchase Amount,Row {0}: Forventet verdi etter brukbart liv må være mindre enn brutto innkjøpsbeløp
DocType: GoCardless Settings,GoCardless Settings,GoCardless Innstillinger
DocType: Leave Block List,Leave Block List Name,La Block List Name
DocType: Certified Consultant,Certification Validity,Sertifiserings gyldighet
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
DocType: Shopping Cart Settings,Display Settings,Skjerminnstillinger
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +33,Stock Assets,Aksje Eiendeler
DocType: Restaurant,Active Menu,Aktiv meny
DocType: Target Detail,Target Qty,Target Antall
apps/erpnext/erpnext/hr/doctype/loan/loan.py +37,Against Loan: {0},Mot lån: {0}
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 +407,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 +802,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 +945,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/hr/doctype/salary_structure/salary_structure.py +66,Salary Structure should have flexible benefit component(s) to dispense benefit amount,Lønnsstruktur bør ha fleksible fordelskomponenter for å dispensere ytelsesbeløpet
apps/erpnext/erpnext/config/projects.py +24,Project activity / task.,Prosjektet aktivitet / oppgave.
DocType: Vital Signs,Very Coated,Veldig belagt
DocType: Salary Component,Only Tax Impact (Cannot Claim But Part of Taxable Income),Kun skattepåvirkning (kan ikke kreve men en del av skattepliktig inntekt)
DocType: Vehicle Log,Refuelling Details,Fylle drivstoff Detaljer
apps/erpnext/erpnext/agriculture/doctype/water_analysis/water_analysis.py +25,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 +63,Get customers from,Få kunder fra
DocType: Purchase Invoice Item,Include Exploded Items,Inkluder eksploderte elementer
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +46,"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: Shopify Settings,Shared secret,Delt hemmelighet
DocType: Amazon MWS Settings,Synch Taxes and Charges,Synkeskatter og -kostnader
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 +529,Default BOM for {0} not found,Standard BOM for {0} ikke funnet
apps/erpnext/erpnext/stock/doctype/item/item.py +531,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
DocType: Leave Encashment,Encashable days,Klembare dager
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +30,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 +30,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: Subscription Plan,Subscription Plan,Abonnementsplan
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 +237,"{0} {1} is associated with {2}, but Party Account is {3}","{0} {1} er knyttet til {2}, men partikonto er {3}"
DocType: Bank Statement Settings Item,Bank Header,Bankoverskrift
apps/erpnext/erpnext/healthcare/doctype/sample_collection/sample_collection.js +7,View Lab Tests,Se labtester
DocType: Hub Users,Hub Users,Hub-brukere
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 +137,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 +640,BOM and Manufacturing Quantity are required,BOM og Industri Antall kreves
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +62,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
DocType: Fee Schedule,EDU-FSH-.YYYY.-,EDU-FSH-.YYYY.-
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +99,No Delivery Note selected for Customer {},Ingen leveringsnotering valgt for kunden {}
apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py +17,Employee {0} has no maximum benefit amount,Medarbeider {0} har ingen maksimal ytelsesbeløp
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1128,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 +134,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 +117,Daily Reminders,Daglige påminnelser
apps/erpnext/erpnext/templates/pages/help.html +56,See all open tickets,Se alle åpne billetter
apps/erpnext/erpnext/healthcare/doctype/healthcare_service_unit/healthcare_service_unit.js +21,Healthcare Service Unit Tree,Healthcare Service Unit Tree
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +270,Product,Produkt
DocType: Products Settings,Home Page is Products,Hjemme side er produkter
,Asset Depreciation Ledger,Asset Avskrivninger Ledger
DocType: Salary Structure,Leave Encashment Amount Per Day,Forlat innkjøpsbeløp per dag
DocType: Loyalty Program Collection,For how much spent = 1 Loyalty Point,For hvor mye brukt = 1 Lojalitetspoeng
apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +97,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 +357,Customer Service,Kundeservice
DocType: BOM,Thumbnail,Thumbnail
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +208,No contacts with email IDs found.,Ingen kontakter med e-postadresser funnet.
DocType: Item Customer Detail,Item Customer Detail,Sak Customer Detalj
DocType: Notification Control,Prompt for Email on Submission of,Spør for E-post om innsending av
apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py +36,Maximum benefit amount of employee {0} exceeds {1},Maksimal ytelsesbeløp for ansatt {0} overstiger {1}
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +102,Total allocated leaves are more than days in the period,Totalt tildelte bladene er mer enn dager i perioden
DocType: Linked Soil Analysis,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/healthcare/doctype/practitioner_schedule/practitioner_schedule.js +83,"Schedules for {0} overlaps, do you want to proceed after skiping overlaped slots ?","Tidsplaner for {0} overlapper, vil du fortsette etter å ha hoppet over overlapte spor?"
apps/erpnext/erpnext/config/accounts.py +326,Default settings for accounting transactions.,Standardinnstillingene for regnskapsmessige transaksjoner.
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.js +8,Grant Leaves,Grant Leaves
DocType: Restaurant,Default Tax Template,Standardskattemall
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +71,{0} Students have been enrolled,{0} Studentene har blitt registrert
DocType: Fees,Student Details,Studentdetaljer
DocType: Purchase Invoice Item,Stock Qty,Varenummer
DocType: Contract,Requires Fulfilment,Krever oppfyllelse
DocType: 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 +79,{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: Job Offer,Printing Details,Utskrift Detaljer
DocType: Task,Closing Date,Avslutningsdato
DocType: Sales Order Item,Produced Quantity,Produsert Antall
DocType: Item Price,Quantity  that must be bought or sold per UOM,Mengde som må kjøpes eller selges per UOM
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +114,Engineer,Ingeniør
DocType: Employee Tax Exemption Category,Max Amount,Maks beløp
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 +199,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 +154,Go to Items,Gå til elementer
DocType: Sales Partner,Partner Type,Partner Type
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +72,Actual,Faktiske
DocType: Restaurant Menu,Restaurant Manager,Restaurantsjef
DocType: Authorization Rule,Customerwise Discount,Customerwise Rabatt
apps/erpnext/erpnext/config/projects.py +46,Timesheet for tasks.,Timeregistrering for oppgaver.
DocType: Purchase Invoice,Against Expense Account,Mot regning
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +284,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: Woocommerce Settings,Woocommerce Server URL,Woocommerce Server URL
DocType: Item Reorder,Re-Order Level,Re-Order nivå
DocType: Shopify Tax Account,Shopify Tax/Shipping Title,Shopify Skatt / Shipping Tittel
apps/erpnext/erpnext/projects/doctype/project/project.js +54,Gantt Chart,Gantt
DocType: Crop Cycle,Cycle Type,Syklus type
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +102,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 +67,Series Updated,Serien Oppdatert
apps/erpnext/erpnext/accounts/doctype/account/account.py +166,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
DocType: Accounting Period,Accounting Period,Regnskapsperiode
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +113,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: Work 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
DocType: Exchange Rate Revaluation Account,Current Exchange Rate,Gjeldende valutakurs
DocType: Item,"Sales, Purchase, Accounting Defaults","Salg, kjøp, regnskapsstandarder"
apps/erpnext/erpnext/config/non_profit.py +63,Donor Type information.,Donor Type informasjon.
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +192,{0} on Leave on {1},{0} på permisjon på {1}
apps/erpnext/erpnext/assets/doctype/asset/asset.py +60,Available for use date is required,Tilgjengelig for bruk er nødvendig
DocType: Request for Quotation,Supplier Detail,Leverandør Detalj
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +181,Error in formula or condition: {0},Feil i formel eller betingelse: {0}
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +112,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 +115,Stock Items,lager~~POS=TRUNC
DocType: Sales Invoice,Update Billed Amount in Sales Order,Oppdater fakturert beløp i salgsordre
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/stock/doctype/stock_entry/stock_entry.py +685,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: Holiday List,Add to Holidays,Legg til helligdager
DocType: Woocommerce Settings,Endpoint,Endpoint
DocType: Period Closing Voucher,Period Closing Voucher,Periode Closing Voucher
DocType: Patient Encounter,Review Details,Gjennomgå detaljer
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +186,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: BOM,Allow Alternative Item,Tillat alternativ gjenstand
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
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1748,Please select Healthcare Service,Vennligst velg Healthcare Service
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}
DocType: Restaurant Reservation,Waitlisted,ventelisten
DocType: Employee Tax Exemption Declaration Category,Exemption Category,Fritakskategori
apps/erpnext/erpnext/accounts/doctype/account/account.py +131,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 +100,Administrative Expenses,Administrative utgifter
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +18,Consulting,Consulting
DocType: Subscription Plan,Based on price list,Basert på prisliste
DocType: Customer Group,Parent Customer Group,Parent Kundegruppe
DocType: Vehicle Service,Change,Endre
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +828,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 +222,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: Employee Transfer,Create New Employee Id,Opprett nyansatt ID
apps/erpnext/erpnext/public/js/hub/components/item_publish_dialog.js +26,Set Details,Angi detaljer
DocType: Travel Itinerary,Travel From,Reise fra
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 +158,Please enter serial numbers for serialized item ,Vennligst skriv inn serienumre for serialisert element
DocType: Bin,Reserved Qty for Production,Reservert Antall for produksjon
DocType: Student Group Creation Tool,Leave unchecked if you don't want to consider batch while making course based groups. ,La være ukontrollert hvis du ikke vil vurdere batch mens du lager kursbaserte grupper.
DocType: Student Group Creation Tool,Leave unchecked if you don't want to consider batch while making course based groups. ,La være ukontrollert hvis du ikke vil vurdere batch mens du lager kursbaserte grupper.
DocType: Asset,Frequency of Depreciation (Months),Frekvens av Avskrivninger (måneder)
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +542,Credit Account,Credit konto
DocType: Landed Cost Item,Landed Cost Item,Landed Cost Element
apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.js +58,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 +767,Please specify Attribute Value for attribute {0},Vennligst oppgi data Verdi for attributtet {0}
DocType: Item Default,Default Warehouse,Standard Warehouse
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +55,Budget cannot be assigned against Group Account {0},Budsjettet kan ikke overdras mot gruppekonto {0}
DocType: Shopping Cart Settings,Show Price,Vis pris
DocType: Healthcare Settings,Patient Registration,Pasientregistrering
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +24,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 +92,Depreciation Date,avskrivninger Dato
,Work Orders in Progress,Arbeidsordrer pågår
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: Student Attendance Tool,Batch,Parti
DocType: Support Search Source,Query Route String,Forespørsel Rute String
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1102,Update rate as per last purchase,Oppdateringsfrekvens per siste kjøp
DocType: Donor,Donor Type,Donor Type
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +640,Auto repeat document updated,Automatisk gjentatt dokument oppdatert
apps/erpnext/erpnext/stock/doctype/item/item.js +29,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: Job Card,Job Card,Jobbkort
DocType: Room,Seating Capacity,Antall seter
DocType: Issue,ISS-,ISS-
DocType: Lab Test Groups,Lab Test Groups,Lab Test Grupper
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.py +151,Party Type and Party is mandatory for {0} account,Party Type and Party er obligatorisk for {0} konto
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: Crop Cycle,ISO 8601 standard,ISO 8601 standard
DocType: Journal Entry,Debit Note,Debitnota
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1513,You can only redeem max {0} points in this order.,Du kan bare innløse maksimalt {0} poeng i denne rekkefølgen.
DocType: Expense Claim,HR-EXP-.YYYY.-,HR-EXP-.YYYY.-
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.py +102,Please enter API Consumer Secret,Vennligst skriv inn API Consumer Secret
DocType: Stock Entry,As per Stock UOM,Pr Stock målenheter
apps/erpnext/erpnext/stock/doctype/batch/batch_list.js +7,Not Expired,Ikke utløpt
DocType: Student Log,Achievement,Oppnåelse
DocType: Asset,Insurer,assurandør
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: Employee Onboarding,Employee Onboarding,Medarbeider Onboarding
DocType: Journal Entry,Total Debit,Total debet
DocType: Travel Request Costing,Sponsored Amount,Sponset beløp
DocType: Manufacturing Settings,Default Finished Goods Warehouse,Standardferdigvarelageret
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +316,Please select Patient,Vennligst velg Pasient
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +74,Sales Person,Sales Person
DocType: Hotel Room Package,Amenities,fasiliteter
apps/erpnext/erpnext/config/accounts.py +271,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
DocType: Sales Invoice,Loyalty Points Redemption,Lojalitetspoeng Innløsning
,Appointment Analytics,Avtale Analytics
DocType: Vehicle Service,Half Yearly,Halvårlig
DocType: Lead,Blog Subscriber,Blogg Subscriber
DocType: Guardian,Alternate Number,Alternativ nummer
DocType: Assessment Plan Criteria,Maximum Score,maksimal score
apps/erpnext/erpnext/config/setup.py +83,Create rules to restrict transactions based on values.,Lage regler for å begrense transaksjoner basert på verdier.
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
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +85,Total Budget,Totalt budsjett
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"
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js +25,"Apps using current key won't be able to access, are you sure?","Apper som bruker nåværende nøkkel vil ikke kunne få tilgang til, er du sikker?"
DocType: Subscription Settings,Prorate,prorate
DocType: Purchase Invoice,Total Advance,Total Advance
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js +78,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
DocType: Bank Statement Transaction Entry,Bank Statement,Kontoutskrift
DocType: Employee Benefit Claim,Max Amount Eligible,Maks beløp berettiget
,BOM Stock Report,BOM aksjerapport
DocType: Stock Reconciliation Item,Quantity Difference,Antall Difference
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 +184,Set as Lost,Sett som tapte
DocType: Timesheet,Total Billable Hours,Totalt fakturerbare timer
DocType: Subscription,Number of days that the subscriber has to pay invoices generated by this subscription,Antall dager som abonnenten må betale fakturaer generert av dette abonnementet
DocType: Employee Benefit Application Detail,Employee Benefit Application Detail,Ansatte fordel søknad detalj
apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +4,Payment Receipt Note,Betaling Kvittering Note
apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +6,This is based on transactions against this Customer. See timeline below for details,Dette er basert på transaksjoner mot denne kunden. Se tidslinjen nedenfor for detaljer
DocType: Delivery Note,ODC,ODC
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
apps/erpnext/erpnext/hub_node/api.py +50,Please login as another user to register on Marketplace,Vennligst logg inn som en annen bruker for å registrere deg på Marketplace
DocType: Manufacturing Settings,Plan time logs outside Workstation Working Hours.,Planlegg tids logger utenfor arbeidsstasjon arbeidstid.
apps/erpnext/erpnext/public/js/pos/pos.html +98,Customers in Queue,Kunder i kø
DocType: Driver,Issuing Date,Utstedelsesdato
DocType: Procedure Prescription,Appointment Booked,Avtale booket
DocType: Student,Nationality,Nasjonalitet
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +108,Submit this Work Order for further processing.,Send inn denne arbeidsordren for videre behandling.
,Items To Be Requested,Elementer å bli forespurt
DocType: Company,Company Info,Selskap Info
apps/erpnext/erpnext/accounts/page/pos/pos.js +1399,Select or add new customer,Velg eller legg til ny kunde
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +177,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: Payment Request,Payment Request Type,Betalingsforespørselstype
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +113,Mark Attendance,Mark Attendance
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +536,Debit Account,Debet konto
DocType: Fiscal Year,Year Start Date,År Startdato
DocType: Additional Salary,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 +103,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 +270,{0} {1} has been modified. Please refresh.,{0} {1} har blitt endret. Vennligst oppdater.
DocType: Leave Block List,Stop users from making Leave Applications on following days.,Stoppe brukere fra å gjøre La Applications på følgende dager.
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js +24,"If unlimited expiry for the Loyalty Points, keep the Expiry Duration empty or 0.","Hvis ubegrenset utløper for lojalitetspoengene, hold utløpsvarigheten tom eller 0."
DocType: Asset Maintenance Team,Maintenance Team Members,Vedlikeholdsteammedlemmer
DocType: Loyalty Point Entry,Purchase Amount,kjøpesummen
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +251,"Cannot deliver Serial No {0} of item {1} as it is reserved \
											to fullfill Sales Order {2}",Kan ikke levere serienummeret {0} av elementet {1} som det er reservert \ for å fullføre salgsordren {2}
DocType: Quotation,SAL-QTN-.YYYY.-,SAL-QTN-.YYYY.-
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 +104,End Year cannot be before Start Year,Slutt År kan ikke være før start År
DocType: Employee Benefit Application,Employee Benefits,Ytelser til ansatte
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +266,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: Work Order,Manufactured Qty,Produsert Antall
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +79,The shares don't exist with the {0},Aksjene eksisterer ikke med {0}
DocType: Sales Partner Type,Sales Partner Type,Salgspartner Type
DocType: Shopify Webhook Detail,Webhook ID,Webhook ID
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 +259,Please set a default Holiday List for Employee {0} or Company {1},Vennligst angi en standard Holiday Liste for Employee {0} eller selskapet {1}
apps/erpnext/erpnext/accounts/party.py +30,{0}: {1} does not exists,{0}: {1} ikke eksisterer
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +78,Select Batch Numbers,Velg batchnumre
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +228,To GSTIN,Til GSTIN
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
DocType: Salary Component,Variable Based On Taxable Salary,Variabel basert på skattepliktig lønn
DocType: Company,Basic Component,Grunnleggende komponent
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +578,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: Patient Service Unit,Medical Administrator,Medisinsk administrator
DocType: Assessment Plan,Schedule,Tidsplan
DocType: Account,Parent Account,Parent konto
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +297,Available,Tilgjengelig
DocType: Quality Inspection Reading,Reading 3,Reading 3
DocType: Stock Entry,Source Warehouse Address,Source Warehouse Adresse
DocType: GL Entry,Voucher Type,Kupong Type
DocType: Amazon MWS Settings,Max Retry Limit,Maks. Retry Limit
apps/erpnext/erpnext/accounts/page/pos/pos.js +1731,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 +349,Employee relieved on {0} must be set as 'Left',Ansatt lettet på {0} må være angitt som &quot;venstre&quot;
DocType: Marketplace Settings,Last Sync On,Sist synk på
DocType: Guardian,Guardian,Guardian
apps/erpnext/erpnext/support/doctype/issue/issue.js +48,All communications including and above this shall be moved into the new Issue,All kommunikasjon inkludert og over dette skal flyttes inn i det nye problemet
DocType: Salary Detail,Tax on additional salary,Skatt på ekstra lønn
DocType: Item Alternative,Item Alternative,Element Alternativt
DocType: Healthcare Settings,Default income accounts to be used if not set in Healthcare Practitioner to book Appointment charges.,Standardinntektsregnskap som skal brukes dersom det ikke er satt i Healthcare Practitioner for å bestille Avtalekostnader.
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
DocType: Payroll Entry,Salary Slips Created,Lønnslister opprettet
DocType: Inpatient Record,Expected Discharge,Forventet utladning
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +594,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 +51,Monthly Sales Target (,Månedlig salgsmål (
apps/erpnext/erpnext/templates/includes/projects/project_tasks.html +9,modified,modifisert
DocType: Travel Request,Identification Document Number,Identifikasjonsdokumentnummer
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +41,"Optional. Sets company's default currency, if not specified.","Valgfritt. Setter selskapets standardvaluta, hvis ikke spesifisert."
DocType: Sales Invoice,Customer GSTIN,Kunde GSTIN
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"
apps/erpnext/erpnext/healthcare/doctype/healthcare_service_unit/healthcare_service_unit.js +30,This is a root healthcare service unit and cannot be edited.,Dette er en rotasjonshelsetjenestenhet og kan ikke redigeres.
DocType: Asset Repair,Repair Status,Reparasjonsstatus
apps/erpnext/erpnext/public/js/event.js +31,Add Sales Partners,Legg til salgspartnere
apps/erpnext/erpnext/config/accounts.py +84,Accounting journal entries.,Regnskap posteringer.
DocType: Travel Request,Travel Request,Reiseforespørsel
DocType: Delivery Note Item,Available Qty at From Warehouse,Tilgjengelig Antall på From Warehouse
apps/erpnext/erpnext/hr/doctype/department_approver/department_approver.py +17,Please select Employee Record first.,Vennligst velg Employee Record først.
apps/erpnext/erpnext/hr/doctype/attendance_request/attendance_request.py +52,Attendance not submitted for {0} as it is a Holiday.,Tilstedeværelse ikke innlevert for {0} som det er en ferie.
DocType: POS Profile,Account for Change Amount,Konto for Change Beløp
DocType: Exchange Rate Revaluation,Total Gain/Loss,Total gevinst / tap
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +1168,Invalid Company for Inter Company Invoice.,Ugyldig Company for Inter Company Invoice.
DocType: Purchase Invoice,input service,inntjeningstjeneste
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +249,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: Employee Promotion,Employee Promotion,Medarbeideropplæring
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 +16,Course Code: ,Bankkode:
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +241,Please enter Expense Account,Skriv inn Expense konto
DocType: Account,Stock,Lager
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1128,"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 +332,Batch Inventory,Batch Lager
DocType: Procedure Prescription,Procedure Name,Prosedyre Navn
DocType: Employee,Contract End Date,Kontraktssluttdato
DocType: Amazon MWS Settings,Seller ID,Selger ID
DocType: Sales Order,Track this Sales Order against any Project,Spor dette Salgsordre mot ethvert prosjekt
DocType: Bank Statement Transaction Entry,Bank Statement Transaction Entry,Bankkonto Transaksjonsoppføring
DocType: Sales Invoice Item,Discount and Margin,Rabatt og Margin
DocType: Lab Test,Prescription,Resept
DocType: Company,Default Deferred Revenue Account,Standard Utsatt Inntektskonto
DocType: Project,Second Email,Andre e-post
DocType: Budget,Action if Annual Budget Exceeded on Actual,Handling hvis årlig budsjett overskrider faktisk
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +127,Not Available,Ikke Tilgjengelig
DocType: Pricing Rule,Min Qty,Min Antall
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js +41,Disable Template,Deaktiver mal
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +105,Please select Healthcare Practitioner and Date,Vennligst velg Helsepersonell og Dato
DocType: Bank Statement Transaction Invoice Item,Transaction Date,Transaksjonsdato
DocType: Production Plan Item,Planned Qty,Planlagt Antall
DocType: Company,Date of Incorporation,Stiftelsesdato
apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +121,Total Tax,Total Skatte
apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.py +40,Last Purchase Price,Siste innkjøpspris
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +280,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)
DocType: Delivery Note,Air,Luft
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."
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +278,{0} is not in Optional Holiday List,{0} er ikke i valgfri ferieliste
DocType: Notification Control,Purchase Receipt Message,Kvitteringen Message
DocType: Amazon MWS Settings,JP,JP
DocType: BOM,Scrap Items,skrap Items
DocType: Job Card,Actual Start Date,Faktisk startdato
DocType: Sales Order,% of materials delivered against this Sales Order,% Av materialer leveres mot denne kundeordre
apps/erpnext/erpnext/config/manufacturing.py +18,Generate Material Requests (MRP) and Work Orders.,Generere materialforespørsler (MRP) og arbeidsordre.
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: Support Search Source,Support Search Source,Støtte søkekilde
DocType: Project,Gross Margin %,Bruttomargin%
DocType: BOM,With Operations,Med Operations
DocType: Support Search Source,Post Route Key List,Legg inn rutenøkkelliste
apps/erpnext/erpnext/accounts/party.py +287,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 Component,Statistical Component,Statistisk komponent
DocType: Salary Component,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 +144,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 +367,Transfer Asset,Transfer Asset
DocType: POS Profile,POS Profile,POS Profile
DocType: Training Event,Event Name,Aktivitetsnavn
DocType: Healthcare Practitioner,Phone (Office),Telefon (kontor)
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +21,"Cannot Submit, Employees left to mark attendance","Kan ikke sende inn, Ansatte igjen for å markere fremmøte"
DocType: Inpatient Record,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 +295,"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 +163,"Item {0} is a template, please select one of its variants","Element {0} er en mal, kan du velge en av variantene"
DocType: Purchase Invoice Item,Deferred Expense,Utsatt kostnad
apps/erpnext/erpnext/hr/doctype/salary_structure_assignment/salary_structure_assignment.py +26,From Date {0} cannot be before employee's joining Date {1},Fra dato {0} kan ikke være før ansattes tilmeldingsdato {1}
DocType: Asset,Asset Category,Asset Kategori
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +39,Net pay cannot be negative,Nettolønn kan ikke være negativ
DocType: Purchase Order,Advance Paid,Advance Betalt
DocType: Manufacturing Settings,Overproduction Percentage For Sales Order,Overproduksjonsprosent for salgsordre
DocType: Item,Item Tax,Sak Skatte
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +880,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 +700,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 +145,Current Liabilities,Kortsiktig gjeld
apps/erpnext/erpnext/public/js/projects/timer.js +138,Timer exceeded the given hours.,Timeren oversteg de angitte timene.
apps/erpnext/erpnext/config/selling.py +303,Send mass SMS to your contacts,Sende masse SMS til kontaktene dine
DocType: Inpatient Record,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/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 +89,"{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
apps/erpnext/erpnext/setup/default_success_action.py +13,{0} has been submitted successfully,{0} har blitt sendt inn
DocType: Loan,Loan Type,låne~~POS=TRUNC
DocType: Scheduling Tool,Scheduling Tool,planlegging Tool
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +156,Credit Card,Kredittkort
DocType: BOM,Item to be manufactured or repacked,Elementet som skal produseres eller pakkes
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +766,Syntax error in condition: {0},Syntaksfeil i tilstand: {0}
DocType: Fee Structure,EDU-FST-.YYYY.-,EDU-FST-.YYYY.-
apps/erpnext/erpnext/hr/doctype/employee/employee.py +25,Please setup Employee Naming System in Human Resource &gt; HR Settings,Vennligst oppsett Medarbeiders navngivningssystem i menneskelig ressurs&gt; HR-innstillinger
DocType: Employee Education,Major/Optional Subjects,Store / valgfrie emner
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +121,Please Set Supplier Group in Buying Settings.,Vennligst sett leverandørgruppe i kjøpsinnstillinger.
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +63,"Total flexible benefit component amount {0} should not be less \
				than max benefits {1}",Total fleksibel fordelskomponent mengde {0} bør ikke være mindre enn maksimum fordeler {1}
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: Taxable Salary Slab,Percent Deduction,Prosent avdrag
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 +125,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/accounts/doctype/bank_statement_transaction_entry/bank_statement_transaction_entry.py +240,Successfully created payment entries,Vellykket opprettet betalingsoppføringer
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 +584,Make Variant,Gjør Variant
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +156,"Payment Type must be one of Receive, Pay and Internal Transfer","Betalingstype må være en av Motta, Lønn og Internal Transfer"
DocType: Travel Itinerary,Preferred Area for Lodging,Foretrukket område for innkvartering
apps/erpnext/erpnext/config/selling.py +184,Analytics,Analytics
apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html +25,Cart is Empty,Handlevognen er tom
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +416,"Item {0} has no Serial No. Only serilialized items \
						can have delivery based on Serial No",Vare {0} har ingen serienummer. Kun seriliserte artikler \ kan ha levering basert på serienummer
DocType: Vehicle,Model,Modell
DocType: Work 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 +88,Root cannot be edited.,Root kan ikke redigeres.
DocType: Item,Units of Measure,Måleenheter
DocType: Employee Tax Exemption Declaration,Rented in Metro City,Leid i Metro City
DocType: Supplier,Default Tax Withholding Config,Standard Skatteavdrag Konfig
DocType: Manufacturing Settings,Allow Production on Holidays,Tillat Produksjonen på helligdager
DocType: Sales Invoice,Customer's Purchase Order Date,Kundens Purchase Order Date
DocType: Production Plan,MFG-PP-.YYYY.-,MFG-PP-.YYYY.-
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +173,Capital Stock,Kapitalbeholdningen
DocType: Asset,Default Finance Book,Standard finans bok
DocType: Shopping Cart Settings,Show Public Attachments,Vis offentlige vedlegg
apps/erpnext/erpnext/public/js/hub/components/item_publish_dialog.js +3,Edit Publishing Details,Rediger publiseringsdetaljer
DocType: Packing Slip,Package Weight Details,Pakken vektdetaljer
DocType: Leave Type,Is Compensatory,Er kompenserende
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 +99,"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/leave_period/leave_period.py +35,To date can not be equal or less than from date,Til dato kan ikke være lik eller mindre enn fra dato
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js +118,Nothing to change,Ingenting å forandre seg
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +104,Please select a csv file,Vennligst velg en csv-fil
DocType: Holiday List,Total Holidays,Totalt helligdager
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +109,Missing email template for dispatch. Please set one in Delivery Settings.,Manglende e-postmal for sending. Vennligst sett inn en i Leveringsinnstillinger.
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 +679,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/assets/doctype/asset/asset.js +384,Select Serial No,Velg serienummer
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +124,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 +612,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: Loyalty Point Entry,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 +381,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 +215,"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: Contract,Contract Terms,Kontraktsbetingelser
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/employee_benefit_application/employee_benefit_application.py +89,Maximum benefit amount of component {0} exceeds {1},Maksimal ytelsesbeløp for komponent {0} overstiger {1}
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +529, (Half Day),(Halv Dag)
DocType: Payment Term,Credit Days,Kreditt Days
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +140,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: BOM Explosion Item,Allow Transfer for Manufacture,Tillat Overføring for Produksjon
DocType: Leave Type,Is Carry Forward,Er fremføring
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +921,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/patches/v11_0/add_default_dispatch_notification_template.py +19,Your order is out for delivery!,Din bestilling er ute for levering!
apps/erpnext/erpnext/controllers/accounts_controller.py +677,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 +62,Transfer an asset from one warehouse to another,Overfør en eiendel fra en lagerbygning til en annen
DocType: Vehicle,Petrol,Bensin
DocType: Employee Benefit Application,Remaining Benefits (Yearly),Resterende fordeler (årlig)
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +802,Bill of Materials,Bill of Materials
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +137,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}
DocType: Employee,Leave Policy,Permisjon
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +795,Update Items,Oppdater elementer
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: 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
DocType: Department,Expense Approvers,Utgifter Godkjenninger
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +228,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 +238,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.
