b'DocType: Employee',b'Salary Mode',b'L\xc3\xb8nn Mode'
b'DocType: Patient',b'Divorced',b'Skilt'
b'DocType: Buying Settings',b'Allow Item to be added multiple times in a transaction',b'Tillat Element som skal legges flere ganger i en transaksjon'
b'apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +33',b'Cancel Material Visit {0} before cancelling this Warranty Claim',b'Avbryt Material Bes\xc3\xb8k {0} f\xc3\xb8r den avbryter denne garantikrav'
b'apps/erpnext/erpnext/config/education.py +118',b'Assessment Reports',b'Evalueringsrapporter'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +19',b'Consumer Products',b'Forbrukerprodukter'
b'DocType: Purchase Receipt',b'Subscription Detail',b'Abonnementsdetaljer'
b'DocType: Supplier Scorecard',b'Notify Supplier',b'Informer Leverand\xc3\xb8r'
b'DocType: Item',b'Customer Items',b'Kunde Items'
b'DocType: Project',b'Costing and Billing',b'Kalkulasjon og fakturering'
b'apps/erpnext/erpnext/accounts/doctype/account/account.py +48',b'Account {0}: Parent account {1} can not be a ledger',b'Konto {0}: Parent konto {1} kan ikke v\xc3\xa6re en hovedbok'
b'DocType: Item',b'Publish Item to hub.erpnext.com',b'Publiser varen til hub.erpnext.com'
b'apps/erpnext/erpnext/config/setup.py +88',b'Email Notifications',b'E-postvarsling'
b'apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +26',b'Evaluation',b'evaluering'
b'DocType: Item',b'Default Unit of Measure',b'Standard m\xc3\xa5leenhet'
b'DocType: SMS Center',b'All Sales Partner Contact',b'All Sales Partner Kontakt'
b'DocType: Employee',b'Leave Approvers',b'La godkjennere'
b'DocType: Sales Partner',b'Dealer',b'Dealer'
b'DocType: Work Order',b'WO-',b'WO-'
b'DocType: Consultation',b'Investigations',b'unders\xc3\xb8kelser'
b'DocType: Restaurant Order Entry',b'Click Enter To Add',b'Klikk p\xc3\xa5 Enter for \xc3\xa5 legge til'
b'DocType: Employee',b'Rented',b'Leide'
b'DocType: Purchase Order',b'PO-',b'PO-'
b'DocType: Vehicle Service',b'Mileage',b'Kilometer'
b'apps/erpnext/erpnext/assets/doctype/asset/asset.js +253',b'Do you really want to scrap this asset?',b'Har du virkelig \xc3\xb8nsker \xc3\xa5 hugge denne eiendelen?'
b'DocType: Drug Prescription',b'Update Schedule',b'Oppdater plan'
b'apps/erpnext/erpnext/buying/report/quoted_item_comparison/quoted_item_comparison.js +44',b'Select Default Supplier',b'Velg Standard Leverand\xc3\xb8r'
b'apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +37',b'Currency is required for Price List {0}',b'Valuta er n\xc3\xb8dvendig for Prisliste {0}'
b'DocType: Sales Taxes and Charges Template',b'* Will be calculated in the transaction.',b'* Vil bli beregnet i transaksjonen.'
b'DocType: Purchase Order',b'Customer Contact',b'Kundekontakt'
b'DocType: Patient Appointment',b'Check availability',b'Sjekk tilgjengelighet'
b'DocType: Job Applicant',b'Job Applicant',b'Jobbs\xc3\xb8ker'
b'apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py +6',b'This is based on transactions against this Supplier. See timeline below for details',b'Dette er basert p\xc3\xa5 transaksjoner mot denne leverand\xc3\xb8ren. Se tidslinjen nedenfor for detaljer'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +120',b'Legal',b'Juridisk'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +191',b'Actual type tax cannot be included in Item rate in row {0}',b'Faktiske typen skatt kan ikke inkluderes i Element rente i rad {0}'
b'DocType: Bank Guarantee',b'Customer',b'Kunde'
b'DocType: Purchase Receipt Item',b'Required By',b'Kreves av'
b'DocType: Delivery Note',b'Return Against Delivery Note',b'Tilbake mot f\xc3\xb8lgeseddel'
b'DocType: Purchase Order',b'% Billed',b'% Fakturert'
b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +43',b'Exchange Rate must be same as {0} {1} ({2})',b'Exchange Rate m\xc3\xa5 v\xc3\xa6re samme som {0} {1} ({2})'
b'DocType: Sales Invoice',b'Customer Name',b'Kundenavn'
b'DocType: Vehicle',b'Natural Gas',b'Naturgass'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/company_setup.py +64',b'Bank account cannot be named as {0}',b'Bankkonto kan ikke bli navngitt som {0}'
b'DocType: Account',b'Heads (or groups) against which Accounting Entries are made and balances are maintained.',b'Hoder (eller grupper) mot hvilke regnskapspostene er laget og balanserer opprettholdes.'
b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +196',b'Outstanding for {0} cannot be less than zero ({1})',b'Enest\xc3\xa5ende for {0} kan ikke v\xc3\xa6re mindre enn null ({1})'
b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +348',b'There are no submitted Salary Slips to process.',b'Det er ingen innsendte l\xc3\xb8nnslister \xc3\xa5 behandle.'
b'DocType: Manufacturing Settings',b'Default 10 mins',b'Standard 10 minutter'
b'DocType: Leave Type',b'Leave Type Name',b'La Type Navn'
b'apps/erpnext/erpnext/templates/pages/projects.js +62',b'Show open',b'Vis \xc3\xa5pen'
b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +8',b'It is necessary to take this action today itself for the above mentioned recurring',b'Det er n\xc3\xb8dvendig \xc3\xa5 ta denne handlingen i dag selv for ovennevnte tilbakevendende'
b'apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +156',b'Series Updated Successfully',b'Serien er oppdatert'
b'apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html +6',b'Checkout',b'Sjekk ut'
b'DocType: Pricing Rule',b'Apply On',b'P\xc3\xa5f\xc3\xb8r p\xc3\xa5'
b'DocType: Item Price',b'Multiple Item prices.',b'Flere varepriser.'
,b'Purchase Order Items To Be Received',b'Purchase Order Elementer som skal mottas'
b'DocType: SMS Center',b'All Supplier Contact',b'All Leverand\xc3\xb8r Kontakt'
b'DocType: Support Settings',b'Support Settings',b'st\xc3\xb8tte~~POS=TRUNC Innstillinger'
b'apps/erpnext/erpnext/projects/doctype/project/project.py +75',b'Expected End Date can not be less than Expected Start Date',b'Forventet Sluttdato kan ikke v\xc3\xa6re mindre enn Tiltredelse'
b'apps/erpnext/erpnext/utilities/transaction_base.py +121',b'Row #{0}: Rate must be same as {1}: {2} ({3} / {4}) ',b'Row # {0}: Pris m\xc3\xa5 v\xc3\xa6re samme som {1}: {2} ({3} / {4})'
b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +241',b'New Leave Application',b'New La Application'
,b'Batch Item Expiry Status',b'Batch Element Utl\xc3\xb8ps Status'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +184',b'Bank Draft',b'Bank Draft'
b'DocType: Membership',b'membership validaty section',b'medlemskapsvaliditetsseksjon'
b'DocType: Mode of Payment Account',b'Mode of Payment Account',b'Modus for betaling konto'
b'DocType: Consultation',b'Consultation',b'Konsultasjon'
b'DocType: Accounts Settings',b'Show Payment Schedule in Print',b'Vis betalingsplan i utskrift'
b'apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py +19',b'Sales and Returns',b'Salg og retur'
b'apps/erpnext/erpnext/stock/doctype/item/item.js +56',b'Show Variants',b'Vis Varianter'
b'DocType: Academic Term',b'Academic Term',b'semester'
b'apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py +14',b'Material',b'Materiale'
b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +66',b'Making website',b'\xc3\x85 lage nettside'
b'DocType: Opening Invoice Creation Tool Item',b'Quantity',b'Antall'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +546',b'Accounts table cannot be blank.',b'Regnskap bordet kan ikke v\xc3\xa6re tomt.'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +154',b'Loans (Liabilities)',b'L\xc3\xa5n (gjeld)'
b'DocType: Employee Education',b'Year of Passing',b'Year of Passing'
b'DocType: Item',b'Country of Origin',b'Opprinnelsesland'
b'DocType: Soil Texture',b'Soil Texture Criteria',b'Kriterier for jordstruktur'
b'apps/erpnext/erpnext/templates/includes/product_page.js +25',b'In Stock',b'P\xc3\xa5 Lager'
b'apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js +16',b'Primary Contact Details',b'Prim\xc3\xa6r kontaktdetaljer'
b'apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +46',b'Open Issues',b'\xc3\xa5pne sp\xc3\xb8rsm\xc3\xa5l'
b'DocType: Production Plan Item',b'Production Plan Item',b'Produksjonsplan Sak'
b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +149',b'User {0} is already assigned to Employee {1}',b'Bruker {0} er allerede tildelt Employee {1}'
b'DocType: Lab Test Groups',b'Add new line',b'Legg til ny linje'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +31',b'Health Care',b'Helsevesen'
b'apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +65',b'Delay in payment (Days)',b'Forsinket betaling (dager)'
b'DocType: Payment Terms Template Detail',b'Payment Terms Template Detail',b'Betalingsvilk\xc3\xa5r Maledetaljer'
b'DocType: Hotel Room Reservation',b'Guest Name',b'Gjestenavn'
b'DocType: Lab Prescription',b'Lab Prescription',b'Lab Prescription'
,b'Delay Days',b'Forsinkelsesdager'
b'apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py +26',b'Service Expense',b'tjenesten Expense'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +899',b'Serial Number: {0} is already referenced in Sales Invoice: {1}',b'Serienummer: {0} er allerede referert i salgsfaktura: {1}'
b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +889',b'Invoice',b'Faktura'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +145',b'Make Retention Stock Entry',b'Lag Retention Stock Entry'
b'DocType: Purchase Invoice Item',b'Item Weight Details',b'Vektdetaljer'
b'DocType: Asset Maintenance Log',b'Periodicity',b'Periodisitet'
b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +21',b'Fiscal Year {0} is required',b'Regnskaps\xc3\xa5r {0} er n\xc3\xb8dvendig'
b'DocType: Crop Cycle',b'The minimum distance between rows of plants for optimum growth',b'Minimumsavstanden mellom rader av planter for optimal vekst'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +21',b'Defense',b'Forsvars'
b'DocType: Salary Component',b'Abbr',b'Abbr'
b'DocType: Appraisal Goal',b'Score (0-5)',b'Score (0-5)'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +225',b'Row {0}: {1} {2} does not match with {3}',b'Rad {0}: {1} {2} samsvarer ikke med {3}'
b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +77',b'Row # {0}:',b'Row # {0}:'
b'DocType: Timesheet',b'Total Costing Amount',b'Total koster Bel\xc3\xb8p'
b'DocType: Delivery Note',b'Vehicle No',b'Vehicle Nei'
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +163',b'Please select Price List',b'Vennligst velg Prisliste'
b'DocType: Accounts Settings',b'Currency Exchange Settings',b'Valutavekslingsinnstillinger'
b'apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +94',b'Row #{0}: Payment document is required to complete the trasaction',b'Row # {0}: Betaling dokumentet er n\xc3\xb8dvendig for \xc3\xa5 fullf\xc3\xb8re trasaction'
b'DocType: Work Order Operation',b'Work In Progress',b'Arbeid P\xc3\xa5 G\xc3\xa5r'
b'apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py +13',b'Please select date',b'Vennligst velg dato'
b'DocType: Daily Work Summary Group',b'Holiday List',b'Holiday List'
b'apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +88',b'Please setup numbering series for Attendance via Setup &gt; Numbering Series',b'Vennligst oppsett nummereringsserie for Tilstedev\xc3\xa6relse via Oppsett&gt; Nummereringsserie'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +127',b'Accountant',b'Accountant'
b'DocType: Hub Settings',b'Selling Price List',b'Selge prisliste'
b'DocType: Patient',b'Tobacco Current Use',b'N\xc3\xa5v\xc3\xa6rende bruk av tobakk'
b'apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +56',b'Selling Rate',b'Selgingsfrekvens'
b'DocType: Cost Center',b'Stock User',b'Stock User'
b'DocType: Soil Analysis',b'(Ca+Mg)/K',b'(Ca + Mg) / K'
b'DocType: Company',b'Phone No',b'Telefonnr'
b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +239',b'New {0}: #{1}',b'New {0} # {1}'
b'DocType: Delivery Trip',b'Initial Email Notification Sent',b'Innledende e-postvarsling sendt'
,b'Sales Partners Commission',b'Sales Partners Commission'
b'DocType: Soil Texture',b'Sandy Clay Loam',b'Sandy Clay Loam'
b'DocType: Purchase Invoice',b'Rounding Adjustment',b'Avrundingsjustering'
b'apps/erpnext/erpnext/setup/doctype/company/company.py +46',b'Abbreviation cannot have more than 5 characters',b'Forkortelse kan ikke ha mer enn fem tegn'
b'DocType: Physician Schedule Time Slot',b'Physician Schedule Time Slot',b'Leger Schedule Time Slot'
b'DocType: Payment Request',b'Payment Request',b'Betaling Request'
b'DocType: Asset',b'Value After Depreciation',b'Verdi etter avskrivninger'
b'DocType: Student',b'O+',b'O +'
b'apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan_dashboard.py +8',b'Related',b'I slekt'
b'apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +43',"b""Attendance date can not be less than employee's joining date""",b'Oppm\xc3\xb8te dato kan ikke v\xc3\xa6re mindre enn ansattes bli dato'
b'DocType: Grading Scale',b'Grading Scale Name',b'Grading Scale Name'
b'DocType: Subscription',b'Repeat on Day',b'Gjenta p\xc3\xa5 dagen'
b'apps/erpnext/erpnext/accounts/doctype/account/account.js +41',b'This is a root account and cannot be edited.',b'Dette er en rot konto og kan ikke redigeres.'
b'DocType: Sales Invoice',b'Company Address',b'Firma adresse'
b'DocType: BOM',b'Operations',b'Operasjoner'
b'apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +38',b'Cannot set authorization on basis of Discount for {0}',b'Kan ikke sette autorisasjon p\xc3\xa5 grunnlag av Rabatt for {0}'
b'DocType: Rename Tool',"b'Attach .csv file with two columns, one for the old name and one for the new name'","b'Fest CSV-fil med to kolonner, en for det gamle navnet og en for det nye navnet'"
b'apps/erpnext/erpnext/accounts/utils.py +73',b'{0} {1} not in any active Fiscal Year.',b'{0} {1} ikke i noen aktiv regnskaps\xc3\xa5ret.'
b'DocType: Packed Item',b'Parent Detail docname',b'Parent Detail docname'
b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +69',"b'Reference: {0}, Item Code: {1} and Customer: {2}'","b'Henvisning: {0}, Varenummer: {1} og kunde: {2}'"
b'apps/erpnext/erpnext/utilities/user_progress.py +146',b'Kg',b'Kg'
b'apps/erpnext/erpnext/config/hr.py +45',b'Opening for a Job.',b'\xc3\x85pning for en jobb.'
b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +114',b'BOM is not specified for subcontracting item {0} at row {1}',b'BOM er ikke spesifisert for underleverand\xc3\xb8relementet {0} p\xc3\xa5 rad {1}'
b'apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js +149',b'{0} Result submittted',b'{0} Resultat sendt'
b'DocType: Item Attribute',b'Increment',b'Tilvekst'
b'apps/erpnext/erpnext/utilities/page/leaderboard/leaderboard.js +74',b'Timespan',b'Tidsrom'
b'apps/erpnext/erpnext/public/js/stock_analytics.js +58',b'Select Warehouse...',b'Velg Warehouse ...'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +6',b'Advertising',b'Annonsering'
b'apps/erpnext/erpnext/accounts/doctype/mode_of_payment/mode_of_payment.py +22',b'Same Company is entered more than once',b'Samme firma er angitt mer enn \xc3\xa9n gang'
b'DocType: Patient',b'Married',b'Gift'
b'apps/erpnext/erpnext/accounts/party.py +41',b'Not permitted for {0}',b'Ikke tillatt for {0}'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +593',b'Get items from',b'F\xc3\xa5 elementer fra'
b'DocType: Price List',b'Price Not UOM Dependant',b'Pris Ikke UOM Avhengig'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +467',b'Stock cannot be updated against Delivery Note {0}',b'Stock kan ikke oppdateres mot f\xc3\xb8lgeseddel {0}'
b'apps/erpnext/erpnext/templates/pages/home.py +25',b'Product {0}',b'Produkt {0}'
b'apps/erpnext/erpnext/templates/generators/item_group.html +43',b'No items listed',b'Ingen elementer oppf\xc3\xb8rt'
b'DocType: Asset Repair',b'Error Description',b'Feilbeskrivelse'
b'DocType: Payment Reconciliation',b'Reconcile',b'Forsone'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +30',b'Grocery',b'Dagligvare'
b'DocType: Quality Inspection Reading',b'Reading 1',b'Lesing 1'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +40',b'Pension Funds',b'Pensjonsfondene'
b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +91',b'Next Depreciation Date cannot be before Purchase Date',b'Neste Avskrivninger Datoen kan ikke v\xc3\xa6re f\xc3\xb8r Kj\xc3\xb8psdato'
b'DocType: Crop',b'Perennial',b'Fler\xc3\xa5rig'
b'DocType: Consultation',b'Consultation Date',b'H\xc3\xb8ringsdato'
b'DocType: Accounts Settings',b'Use Custom Cash Flow Format',b'Bruk tilpasset kontantstr\xc3\xb8mformat'
b'DocType: SMS Center',b'All Sales Person',b'All Sales Person'
b'DocType: Monthly Distribution',b'**Monthly Distribution** helps you distribute the Budget/Target across months if you have seasonality in your business.',b'** M\xc3\xa5nedlig Distribusjon ** hjelper deg distribuere Budsjett / Target over m\xc3\xa5neder hvis du har sesongvariasjoner i din virksomhet.'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +1753',b'Not items found',b'Ikke elementer funnet'
b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +184',b'Salary Structure Missing',b'L\xc3\xb8nn Struktur Missing'
b'DocType: Lead',b'Person Name',b'Person Name'
b'DocType: Sales Invoice Item',b'Sales Invoice Item',b'Salg Faktura Element'
b'DocType: Account',b'Credit',b'Credit'
b'DocType: POS Profile',b'Write Off Cost Center',b'Skriv Av kostnadssted'
b'apps/erpnext/erpnext/public/js/setup_wizard.js +117',"b'e.g. ""Primary School"" or ""University""'",b'for eksempel &quot;Primary School&quot; eller &quot;University&quot;'
b'apps/erpnext/erpnext/config/stock.py +28',b'Stock Reports',b'lager rapporter'
b'DocType: Warehouse',b'Warehouse Detail',b'Warehouse Detalj'
b'apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +33',b'The Term End Date cannot be later than the Year End Date of the Academic Year to which the term is linked (Academic Year {}). Please correct the dates and try again.',"b'Begrepet Sluttdato kan ikke v\xc3\xa6re senere enn \xc3\xa5ret sluttdato av studie\xc3\xa5ret som begrepet er knyttet (studie\xc3\xa5ret {}). Korriger datoene, og pr\xc3\xb8v igjen.'"
b'apps/erpnext/erpnext/stock/doctype/item/item.py +269',"b'""Is Fixed Asset"" cannot be unchecked, as Asset record exists against the item'","b'&quot;Er Fixed Asset&quot; ikke kan v\xc3\xa6re ukontrollert, som Asset post eksisterer mot elementet'"
b'DocType: Delivery Trip',b'Departure Time',b'Avgangstid'
b'DocType: Vehicle Service',b'Brake Oil',b'bremse~~POS=TRUNC Oil'
b'DocType: Tax Rule',b'Tax Type',b'Skatt Type'
,b'Completed Work Orders',b'Fullf\xc3\xb8rte arbeidsordrer'
b'apps/erpnext/erpnext/controllers/taxes_and_totals.py +581',b'Taxable Amount',b'Skattepliktig bel\xc3\xb8p'
b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +160',b'You are not authorized to add or update entries before {0}',b'Du er ikke autorisert til \xc3\xa5 legge til eller oppdatere bloggen f\xc3\xb8r {0}'
b'DocType: BOM',b'Item Image (if not slideshow)',b'Sak Image (hvis ikke show)'
b'DocType: Work Order Operation',b'(Hour Rate / 60) * Actual Operation Time',b'(Timepris / 60) * Faktisk Operation Tid'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1103',b'Row #{0}: Reference Document Type must be one of Expense Claim or Journal Entry',b'Row # {0}: Referansedokumenttype m\xc3\xa5 v\xc3\xa6re en av kostnadskrav eller journaloppf\xc3\xb8ring'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +975',b'Select BOM',b'Velg BOM'
b'DocType: SMS Log',b'SMS Log',b'SMS Log'
b'apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +27',b'Cost of Delivered Items',b'Kostnad for leverte varer'
b'apps/erpnext/erpnext/config/hr.py +127',b'Manage advance amount given to the Employee',b'Administrer forh\xc3\xa5ndsbel\xc3\xb8p gitt til Medarbeider'
b'apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +38',b'The holiday on {0} is not between From Date and To Date',b'Ferien p\xc3\xa5 {0} er ikke mellom Fra dato og Til dato'
b'DocType: Student Log',b'Student Log',b'student Log'
b'apps/erpnext/erpnext/config/buying.py +165',b'Templates of supplier standings.',b'Maler av leverand\xc3\xb8rstillinger.'
b'DocType: Lead',b'Interested',b'Interessert'
b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +216',b'Opening',b'\xc3\x85pning'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +32',b'From {0} to {1}',b'Fra {0} til {1}'
b'apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +234',b'Program: ',b'Program:'
b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +50',b'Failed to setup taxes',b'Kunne ikke sette opp skatt'
b'DocType: Item',b'Copy From Item Group',b'Kopier fra varegruppe'
b'DocType: Delivery Trip',b'Delivery Notification',b'Leveringsvarsling'
b'DocType: Journal Entry',b'Opening Entry',b'\xc3\x85pning Entry'
b'apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +25',b'Account Pay Only',b'Bare konto Pay'
b'DocType: Employee Loan',b'Repay Over Number of Periods',b'Betale tilbake over antall perioder'
b'DocType: Stock Entry',b'Additional Costs',b'Tilleggskostnader'
b'apps/erpnext/erpnext/accounts/doctype/account/account.py +138',b'Account with existing transaction can not be converted to group.',b'Konto med eksisterende transaksjon kan ikke konverteres til gruppen.'
b'DocType: Lead',b'Product Enquiry',b'Produkt Foresp\xc3\xb8rsel'
b'DocType: Education Settings',b'Validate Batch for Students in Student Group',b'Valider batch for studenter i studentgruppen'
b'apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +35',b'No leave record found for employee {0} for {1}',b'Ingen forlater plate funnet for ansatt {0} og {1}'
b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +23',b'Please enter company first',b'Skriv inn et selskap f\xc3\xb8rst'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +365',b'Please select Company first',b'Vennligst velg selskapet f\xc3\xb8rst'
b'DocType: Employee Education',b'Under Graduate',b'Under Graduate'
b'apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.js +27',b'Target On',b'Target P\xc3\xa5'
b'DocType: BOM',b'Total Cost',b'Totalkostnad'
b'DocType: Soil Analysis',b'Ca/K',b'Ca / K'
b'DocType: Journal Entry Account',b'Employee Loan',b'Medarbeider Loan'
b'DocType: Fee Schedule',b'Send Payment Request Email',b'Send betalingsanmodning e-post'
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +268',b'Item {0} does not exist in the system or has expired',b'Element {0} finnes ikke i systemet eller er utl\xc3\xb8pt'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +44',b'Real Estate',b'Eiendom'
b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html +1',b'Statement of Account',b'Kontoutskrift'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +41',b'Pharmaceuticals',b'Farmasi'
b'DocType: Purchase Invoice Item',b'Is Fixed Asset',b'Er Fast Asset'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +273',"b'Available qty is {0}, you need {1}'","b'Tilgjengelig stk er {0}, m\xc3\xa5 du {1}'"
b'DocType: Expense Claim Detail',b'Claim Amount',b'Krav Bel\xc3\xb8p'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +653',b'Work Order has been {0}',b'Arbeidsordre har v\xc3\xa6rt {0}'
b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +56',b'Duplicate customer group found in the cutomer group table',b'Duplicate kundegruppen funnet i cutomer gruppetabellen'
b'apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +31',b'Supplier Type / Supplier',b'Leverand\xc3\xb8r Type / leverand\xc3\xb8r'
b'DocType: Naming Series',b'Prefix',b'Prefix'
b'apps/erpnext/erpnext/hr/email_alert/training_scheduled/training_scheduled.html +7',b'Event Location',b'Hendelsessted'
b'DocType: Asset Settings',b'Asset Settings',b'Asset Settings'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +68',b'Consumable',b'Konsum'
b'DocType: Student',b'B-',b'B-'
b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +98',b'Successfully unregistered.',b'Helt uregistrert.'
b'DocType: Assessment Result',b'Grade',b'grade'
b'DocType: Restaurant Table',b'No of Seats',b'Antall plasser'
b'DocType: Subscription',"b'To add dynamic subject, use jinja tags like\n\n<div><pre><code>New {{ doc.doctype }} #{{ doc.name }}</code></pre></div>'","b'For \xc3\xa5 legge til dynamisk emne, bruk jinja-koder som <div><pre> <code>New {{ doc.doctype }} #{{ doc.name }}</code> </pre> </div>'"
b'DocType: Sales Invoice Item',b'Delivered By Supplier',b'Levert av Leverand\xc3\xb8r'
b'DocType: Asset Maintenance Task',b'Asset Maintenance Task',b'Asset Maintenance Task'
b'DocType: SMS Center',b'All Contact',b'All kontakt'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +232',b'Annual Salary',b'\xc3\x85rsl\xc3\xb8nn'
b'DocType: Daily Work Summary',b'Daily Work Summary',b'Daglig arbeid Oppsummering'
b'DocType: Period Closing Voucher',b'Closing Fiscal Year',b'Lukke regnskaps\xc3\xa5r'
b'apps/erpnext/erpnext/accounts/party.py +392',b'{0} {1} is frozen',b'{0} {1} er frosset'
b'apps/erpnext/erpnext/setup/doctype/company/company.py +140',b'Please select Existing Company for creating Chart of Accounts',b'Velg eksisterende selskap for \xc3\xa5 skape Konto'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +80',b'Stock Expenses',b'Aksje Utgifter'
b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +111',b'Select Target Warehouse',b'Velg Target Warehouse'
b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +111',b'Select Target Warehouse',b'Velg Target Warehouse'
b'apps/erpnext/erpnext/hr/doctype/employee/employee.js +80',b'Please enter Preferred Contact Email',b'Fyll inn foretrukne e-'
b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +45',b'CompAuxNum',b'CompAuxNum'
b'DocType: Journal Entry',b'Contra Entry',b'Contra Entry'
b'DocType: Journal Entry Account',b'Credit in Company Currency',b'Kreditt i selskapet Valuta'
b'DocType: Lab Test UOM',b'Lab Test UOM',b'Lab Test UOM'
b'DocType: Delivery Note',b'Installation Status',b'Installasjon Status'
b'DocType: BOM',b'Quality Inspection Template',b'Kvalitetskontrollmaler'
b'apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +135',b'Do you want to update attendance?<br>Present: {0}\\\n\t\t\t\t\t<br>Absent: {1}',b'\xc3\x98nsker du \xc3\xa5 oppdatere oppm\xc3\xb8te? <br> Present: {0} \\ <br> Frav\xc3\xa6rende: {1}'
b'apps/erpnext/erpnext/controllers/buying_controller.py +334',b'Accepted + Rejected Qty must be equal to Received quantity for Item {0}',b'Akseptert + Avvist Antall m\xc3\xa5 v\xc3\xa6re lik mottatt kvantum for Element {0}'
b'DocType: Request for Quotation',b'RFQ-',b'RFQ-'
b'DocType: Item',b'Supply Raw Materials for Purchase',b'Leverer r\xc3\xa5vare til Purchase'
b'DocType: Agriculture Analysis Criteria',b'Fertilizer',b'Gj\xc3\xb8dsel'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +152',b'At least one mode of payment is required for POS invoice.',b'I det minste \xc3\xa9n modus av betaling er n\xc3\xb8dvendig for POS faktura.'
b'DocType: Products Settings',b'Show Products as a List',b'Vis produkter p\xc3\xa5 en liste'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +532',b'Item {0} is not active or end of life has been reached',b'Element {0} er ikke aktiv eller slutten av livet er n\xc3\xa5dd'
b'DocType: Student Admission Program',b'Minimum Age',b'Minimumsalder'
b'apps/erpnext/erpnext/utilities/user_progress.py +190',b'Example: Basic Mathematics',b'Eksempel: Grunnleggende matematikk'
b'DocType: Customer',b'Primary Address',b'hoved adresse'
b'DocType: Production Plan',b'Material Request Detail',b'Material Request Detail'
b'DocType: Selling Settings',b'Default Quotation Validity Days',b'Standard Quotation Gyldighetsdager'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +800',"b'To include tax in row {0} in Item rate, taxes in rows {1} must also be included'","b'For \xc3\xa5 inkludere skatt i rad {0} i Element rente, skatt i rader {1} m\xc3\xa5 ogs\xc3\xa5 inkluderes'"
b'apps/erpnext/erpnext/config/hr.py +223',b'Settings for HR Module',b'Innstillinger for HR Module'
b'DocType: SMS Center',b'SMS Center',b'SMS-senter'
b'DocType: Sales Invoice',b'Change Amount',b'endring Bel\xc3\xb8p'
b'DocType: GST Settings',b'Set Invoice Value for B2C. B2CL and B2CS calculated based on this invoice value.',b'Angi fakturaverdi for B2C. B2CL og B2CS beregnet ut fra denne fakturaverdien.'
b'DocType: BOM Update Tool',b'New BOM',b'New BOM'
b'apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js +36',b'Show only POS',b'Vis bare POS'
b'DocType: Driver',b'Driving License Categories',b'Kj\xc3\xb8relisenskategorier'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +118',b'Please enter Delivery Date',b'Vennligst oppgi Leveringsdato'
b'DocType: Depreciation Schedule',b'Make Depreciation Entry',b'Gj\xc3\xb8r Avskrivninger Entry'
b'DocType: Appraisal Template Goal',b'KRA',b'KRA'
b'DocType: Lead',b'Request Type',b'Foresp\xc3\xb8rsel Type'
b'apps/erpnext/erpnext/hr/doctype/job_offer/job_offer.js +17',b'Make Employee',b'Gj\xc3\xb8r Employee'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +14',b'Broadcasting',b'Kringkasting'
b'apps/erpnext/erpnext/config/accounts.py +313',b'Setup mode of POS (Online / Offline)',b'Oppsettmodus for POS (Online / Offline)'
b'DocType: Manufacturing Settings',b'Disables creation of time logs against Work Orders. Operations shall not be tracked against Work Order',b'Deaktiverer opprettelse av tidslogger mot arbeidsordre. Operasjoner skal ikke spores mot arbeidsordre'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +191',b'Execution',b'Execution'
b'apps/erpnext/erpnext/config/manufacturing.py +62',b'Details of the operations carried out.',b'Detaljene for operasjonen utf\xc3\xb8res.'
b'DocType: Asset Maintenance Log',b'Maintenance Status',b'Vedlikehold Status'
b'apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py +10',b'Membership Details',b'Medlemskapsdetaljer'
b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +56',b'{0} {1}: Supplier is required against Payable account {2}',b'{0} {1}: Leverand\xc3\xb8r er n\xc3\xb8dvendig mot Betales konto {2}'
b'apps/erpnext/erpnext/config/selling.py +52',b'Items and Pricing',b'Elementer og priser'
b'apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +2',b'Total hours: {0}',b'Antall timer: {0}'
b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +43',b'From Date should be within the Fiscal Year. Assuming From Date = {0}',b'Fra dato b\xc3\xb8r v\xc3\xa6re innenfor regnskaps\xc3\xa5ret. Antar Fra Date = {0}'
b'DocType: Drug Prescription',b'Interval',b'intervall'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +253',b'Preference',b'Preference'
b'DocType: Grant Application',b'Individual',b'Individuell'
b'DocType: Academic Term',b'Academics User',b'akademikere Bruker'
b'DocType: Cheque Print Template',b'Amount In Figure',b'Bel\xc3\xb8p I figur'
b'DocType: Employee Loan Application',b'Loan Info',b'l\xc3\xa5n info'
b'apps/erpnext/erpnext/config/maintenance.py +12',b'Plan for maintenance visits.',b'Plan for vedlikeholdsbes\xc3\xb8k.'
b'DocType: Supplier Scorecard Period',b'Supplier Scorecard Period',b'Leverand\xc3\xb8r Scorecard Periode'
b'DocType: Share Transfer',b'Share Transfer',b'Del overf\xc3\xb8ring'
b'DocType: POS Profile',b'Customer Groups',b'kunde~~POS=TRUNC grupper~~POS=HEADCOMP'
b'apps/erpnext/erpnext/public/js/financial_statements.js +51',b'Financial Statements',b'\xc3\x85rsregnskap'
b'DocType: Guardian',b'Students',b'studenter'
b'apps/erpnext/erpnext/config/selling.py +91',b'Rules for applying pricing and discount.',b'Regler for bruk av prising og rabatt.'
b'DocType: Daily Work Summary',b'Daily Work Summary Group',b'Daglig arbeidsoppsummeringsgruppe'
b'DocType: Physician Schedule',b'Time Slots',b'Tidsluker'
b'apps/erpnext/erpnext/stock/doctype/price_list/price_list.py +14',b'Price List must be applicable for Buying or Selling',b'Prisliste m\xc3\xa5 v\xc3\xa6re aktuelt for \xc3\xa5 kj\xc3\xb8pe eller selge'
b'apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +79',b'Installation date cannot be before delivery date for Item {0}',b'Installasjonsdato kan ikke v\xc3\xa6re f\xc3\xb8r leveringsdato for Element {0}'
b'DocType: Pricing Rule',b'Discount on Price List Rate (%)',b'Rabatt p\xc3\xa5 Prisliste Rate (%)'
b'apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +112',b'Item Template',b'Artikkelmal'
b'apps/erpnext/erpnext/healthcare/setup.py +215',b'Biochemistry',b'biokjemi'
b'DocType: Job Offer',b'Select Terms and Conditions',b'Velg Vilk\xc3\xa5r'
b'apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +72',b'Out Value',b'ut Verdi'
b'DocType: Production Plan',b'Sales Orders',b'Salgsordrer'
b'DocType: Purchase Taxes and Charges',b'Valuation',b'Verdivurdering'
b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +390',b'Set as Default',b'Satt som standard'
b'DocType: Production Plan',b'PLN-',b'PLN-'
,b'Purchase Order Trends',b'Innkj\xc3\xb8psordre Trender'
b'apps/erpnext/erpnext/utilities/user_progress.py +78',b'Go to Customers',b'G\xc3\xa5 til Kunder'
b'DocType: Hotel Room Reservation',b'Late Checkin',b'Sen innsjekk'
b'apps/erpnext/erpnext/templates/emails/request_for_quotation.html +7',b'The request for quotation can be accessed by clicking on the following link',b'Anmodningen om sitatet kan n\xc3\xa5s ved \xc3\xa5 klikke p\xc3\xa5 f\xc3\xb8lgende link'
b'apps/erpnext/erpnext/config/hr.py +81',b'Allocate leaves for the year.',b'Bevilge blader for \xc3\xa5ret.'
b'DocType: SG Creation Tool Course',b'SG Creation Tool Course',b'SG Creation Tool Course'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +275',b'Insufficient Stock',b'utilstrekkelig Stock'
b'DocType: Manufacturing Settings',b'Disable Capacity Planning and Time Tracking',b'Deaktiver kapasitetsplanlegging og Time Tracking'
b'DocType: Email Digest',b'New Sales Orders',b'Nye salgsordrer'
b'DocType: Bank Guarantee',b'Bank Account',b'Bankkonto'
b'DocType: Leave Type',b'Allow Negative Balance',b'Tillat negativ saldo'
b'apps/erpnext/erpnext/projects/doctype/project_type/project_type.py +13',"b""You cannot delete Project Type 'External'""",b'Du kan ikke slette Project Type &#39;External&#39;'
b'DocType: Employee',b'Create User',b'Opprett bruker'
b'DocType: Selling Settings',b'Default Territory',b'Standard Territory'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +53',b'Television',b'TV'
b'DocType: Work Order Operation',"b""Updated via 'Time Log'""",b'Oppdatert via &#39;Time Logg&#39;'
b'apps/erpnext/erpnext/controllers/taxes_and_totals.py +430',b'Advance amount cannot be greater than {0} {1}',b'Advance bel\xc3\xb8pet kan ikke v\xc3\xa6re st\xc3\xb8rre enn {0} {1}'
b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +42',b'JournalCode',b'JournalCode'
b'DocType: Naming Series',b'Series List for this Transaction',b'Serien Liste for denne transaksjonen'
b'DocType: Company',b'Enable Perpetual Inventory',b'Aktiver evigvarende beholdning'
b'DocType: Company',b'Default Payroll Payable Account',b'Standard L\xc3\xb8nn betales konto'
b'apps/erpnext/erpnext/education/doctype/student_group/student_group.js +51',b'Update Email Group',b'Oppdater E-postgruppe'
b'DocType: Sales Invoice',b'Is Opening Entry',b'\xc3\x85pner Entry'
b'DocType: Lab Test Template',"b'If unchecked, the item wont be appear in Sales Invoice, but can be used in group test creation. '","b'Hvis ikke merket, vil varen ikke vises i salgsfaktura, men kan brukes i gruppetestopprettelse.'"
b'DocType: Customer Group',b'Mention if non-standard receivable account applicable',b'Nevn hvis ikke-standard fordring konto aktuelt'
b'DocType: Course Schedule',b'Instructor Name',b'instrukt\xc3\xb8r Name'
b'DocType: Supplier Scorecard',b'Criteria Setup',b'Kriterieoppsett'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +206',b'For Warehouse is required before Submit',b'For Warehouse er n\xc3\xb8dvendig f\xc3\xb8r Send'
b'apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +8',b'Received On',b'Mottatt On'
b'DocType: Sales Partner',b'Reseller',b'Reseller'
b'DocType: Codification Table',b'Medical Code',b'Medisinsk kode'
b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +20',b'Please enter Company',b'Skriv inn Firma'
b'DocType: Delivery Note Item',b'Against Sales Invoice Item',b'Mot Salg Faktura Element'
b'DocType: Agriculture Analysis Criteria',b'Linked Doctype',b'Tilknyttet doktype'
b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +44',b'Net Cash from Financing',b'Netto kontantstr\xc3\xb8m fra finansierings'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +2375',"b'LocalStorage is full , did not save'","b'Localstorage er full, ikke spare'"
b'DocType: Lead',b'Address & Contact',b'Adresse og kontakt'
b'DocType: Leave Allocation',b'Add unused leaves from previous allocations',b'Legg ubrukte blader fra tidligere bevilgninger'
b'DocType: Sales Partner',b'Partner website',b'partner nettstedet'
b'DocType: Restaurant Order Entry',b'Add Item',b'Legg til element'
b'DocType: Lab Test',b'Custom Result',b'Tilpasset resultat'
b'DocType: Delivery Stop',b'Contact Name',b'Kontakt Navn'
b'DocType: Course Assessment Criteria',b'Course Assessment Criteria',b'Kursvurderingskriteriene'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +18',b'Tax Id: ',b'Skatte-ID:'
b'apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +216',b'Student ID: ',b'Student ID:'
b'DocType: POS Customer Group',b'POS Customer Group',b'POS Kundegruppe'
b'DocType: Land Unit',b'Land Unit describing various land assets',b'Land Enhet som beskriver ulike eiendeler'
b'DocType: Cheque Print Template',b'Line spacing for amount in words',b'Linjeavstand for bel\xc3\xb8pet i ord'
b'DocType: Vehicle',b'Additional Details',b'ekstra detaljer'
b'apps/erpnext/erpnext/templates/generators/bom.html +85',b'No description given',b'Ingen beskrivelse gitt'
b'apps/erpnext/erpnext/config/buying.py +13',b'Request for purchase.',b'Be for kj\xc3\xb8p.'
b'DocType: Lab Test',b'Submitted Date',b'Innleveringsdato'
b'apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py +6',b'This is based on the Time Sheets created against this project',b'Dette er basert p\xc3\xa5 timelister som er opprettet mot dette prosjektet'
,b'Open Work Orders',b'\xc3\x85pne arbeidsordre'
b'DocType: Payment Term',b'Credit Months',b'Kredittm\xc3\xa5neder'
b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +409',b'Net Pay cannot be less than 0',b'Nettol\xc3\xb8nn kan ikke v\xc3\xa6re mindre enn 0'
b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +5',"b'To stop sending repetitive error notifications from the system, we have checked Disabled field in the subscription'","b'For \xc3\xa5 slutte \xc3\xa5 sende gjentatte feilmeldinger fra systemet, har vi sjekket deaktivert felt i abonnementet'"
b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +121',b'Relieving Date must be greater than Date of Joining',b'Lindrende Dato m\xc3\xa5 v\xc3\xa6re st\xc3\xb8rre enn tidspunktet for inntreden'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +240',b'Leaves per Year',b'Later per \xc3\xa5r'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +130',"b""Row {0}: Please check 'Is Advance' against Account {1} if this is an advance entry.""",b'Rad {0}: Vennligst sjekk &#39;Er Advance &quot;mot Account {1} hvis dette er et forskudd oppf\xc3\xb8ring.'
b'apps/erpnext/erpnext/stock/utils.py +219',b'Warehouse {0} does not belong to company {1}',b'Warehouse {0} ikke tilh\xc3\xb8rer selskapet {1}'
b'DocType: Email Digest',b'Profit & Loss',b'Profitt tap'
b'apps/erpnext/erpnext/utilities/user_progress.py +147',b'Litre',b'liter'
b'DocType: Task',b'Total Costing Amount (via Time Sheet)',b'Total Costing Bel\xc3\xb8p (via Timeregistrering)'
b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.py +76',b'Please setup Students under Student Groups',b'Vennligst oppsett Studentene under Student Grupper'
b'DocType: Item Website Specification',b'Item Website Specification',b'Sak Nettsted Spesifikasjon'
b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +449',b'Leave Blocked',b'La Blokkert'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +740',b'Item {0} has reached its end of life on {1}',b'Element {0} har n\xc3\xa5dd slutten av livet p\xc3\xa5 {1}'
b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +83',b'Bank Entries',b'Bank Entries'
b'DocType: Crop',b'Annual',b'\xc3\x85rlig'
b'DocType: Stock Reconciliation Item',b'Stock Reconciliation Item',b'Stock Avstemming Element'
b'DocType: Stock Entry',b'Sales Invoice No',b'Salg Faktura Nei'
b'DocType: Material Request Item',b'Min Order Qty',b'Min Bestill Antall'
b'DocType: Student Group Creation Tool Course',b'Student Group Creation Tool Course',b'Student Gruppe Creation Tool Course'
b'DocType: Lead',b'Do Not Contact',b'Ikke kontakt'
b'apps/erpnext/erpnext/utilities/user_progress.py +210',b'People who teach at your organisation',b'Folk som underviser i organisasjonen'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +135',b'Software Developer',b'Programvareutvikler'
b'DocType: Item',b'Minimum Order Qty',b'Minimum Antall'
b'DocType: Pricing Rule',b'Supplier Type',b'Leverand\xc3\xb8r Type'
b'DocType: Course Scheduling Tool',b'Course Start Date',b'Kursstart'
,b'Student Batch-Wise Attendance',b'Student Batch-Wise Oppm\xc3\xb8te'
b'DocType: POS Profile',b'Allow user to edit Rate',b'Tillater brukeren \xc3\xa5 redigere Ranger'
b'DocType: Item',b'Publish in Hub',b'Publisere i Hub'
b'DocType: Student Admission',b'Student Admission',b'student Entre'
,b'Terretory',b'Terretory'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +762',b'Item {0} is cancelled',b'Element {0} er kansellert'
b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1064',b'Material Request',b'Materialet Request'
b'DocType: Bank Reconciliation',b'Update Clearance Date',b'Oppdater Lagersalg Dato'
,b'GSTR-2',b'GSTR-2'
b'DocType: Item',b'Purchase Details',b'Kj\xc3\xb8ps Detaljer'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +407',"b""Item {0} not found in 'Raw Materials Supplied' table in Purchase Order {1}""",b'Element {0} ble ikke funnet i &#39;R\xc3\xa5vare Leveres&#39; bord i innkj\xc3\xb8psordre {1}'
b'DocType: Salary Slip',b'Total Principal Amount',b'Sum hovedbel\xc3\xb8p'
b'DocType: Student Guardian',b'Relation',b'Relasjon'
b'DocType: Student Guardian',b'Mother',b'Mor'
b'DocType: Restaurant Reservation',b'Reservation End Time',b'Reservasjons sluttid'
b'DocType: Crop',b'Biennial',b'Biennial'
b'apps/erpnext/erpnext/config/selling.py +18',b'Confirmed orders from Customers.',b'Bekreftede bestillinger fra kunder.'
b'DocType: Purchase Receipt Item',b'Rejected Quantity',b'Avvist Antall'
b'apps/erpnext/erpnext/education/doctype/fees/fees.py +80',b'Payment request {0} created',b'Betalingsforesp\xc3\xb8rsel {0} opprettet'
b'apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +72',b'Open Orders',b'\xc3\x85pne bestillinger'
b'apps/erpnext/erpnext/healthcare/setup.py +255',b'Low Sensitivity',b'Lav f\xc3\xb8lsomhet'
b'DocType: Notification Control',b'Notification Control',b'Varsling kontroll'
b'apps/erpnext/erpnext/templates/emails/training_event.html +17',b'Please confirm once you have completed your training',b'Vennligst bekreft n\xc3\xa5r du har fullf\xc3\xb8rt treningen'
b'DocType: Lead',b'Suggestions',b'Forslag'
b'DocType: Territory',b'Set Item Group-wise budgets on this Territory. You can also include seasonality by setting the Distribution.',b'Set varegruppe-messig budsjetter p\xc3\xa5 dette territoriet. Du kan ogs\xc3\xa5 inkludere sesongvariasjoner ved \xc3\xa5 sette Distribution.'
b'DocType: Payment Term',b'Payment Term Name',b'Betalingsnavn'
b'DocType: Healthcare Settings',b'Create documents for sample collection',b'Lag dokumenter for pr\xc3\xb8veinnsamling'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +276',b'Payment against {0} {1} cannot be greater than Outstanding Amount {2}',b'Betaling mot {0} {1} kan ikke v\xc3\xa6re st\xc3\xb8rre enn utest\xc3\xa5ende bel\xc3\xb8p {2}'
b'DocType: Shareholder',b'Address HTML',b'Adresse HTML'
b'DocType: Lead',b'Mobile No.',b'Mobile No.'
b'DocType: Maintenance Schedule',b'Generate Schedule',b'Generere Schedule'
b'DocType: Purchase Invoice Item',b'Expense Head',b'Expense Leder'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +138',b'Please select Charge Type first',b'Vennligst velg Charge Type f\xc3\xb8rst'
b'DocType: Crop',"b'You can define all the tasks which need to carried out for this crop here. The day field is used to mention the day on which the task needs to be carried out, 1 being the 1st day, etc.. '","b'Du kan definere alle oppgavene som m\xc3\xa5 utf\xc3\xb8res for denne avlingen her. Dagfeltet brukes til \xc3\xa5 nevne hvilken dag oppgaven m\xc3\xa5 utf\xc3\xb8res, 1 er 1. dag, osv.'"
b'DocType: Student Group Student',b'Student Group Student',b'Student Gruppe Student'
b'apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41',b'Latest',b'Siste'
b'DocType: Asset Maintenance Task',b'2 Yearly',b'2 \xc3\xa5rlig'
b'DocType: Education Settings',b'Education Settings',b'Utdanning Innstillinger'
b'DocType: Vehicle Service',b'Inspection',b'Unders\xc3\xb8kelse'
b'DocType: Supplier Scorecard Scoring Standing',b'Max Grade',b'Maksimal karakter'
b'DocType: Email Digest',b'New Quotations',b'Nye Sitater'
b'DocType: HR Settings',b'Emails salary slip to employee based on preferred email selected in Employee',b'E-poster l\xc3\xb8nn slip til ansatte basert p\xc3\xa5 foretrukne e-post valgt i Employee'
b'DocType: Employee',b'The first Leave Approver in the list will be set as the default Leave Approver',b'Den f\xc3\xb8rste La Godkjenner i listen vil bli definert som standard La Godkjenner'
b'DocType: Tax Rule',b'Shipping County',b'Shipping fylke'
b'apps/erpnext/erpnext/config/desktop.py +167',b'Learn',b'L\xc3\xa6re'
b'DocType: Asset',b'Next Depreciation Date',b'Neste Avskrivninger Dato'
b'apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js +3',b'Activity Cost per Employee',b'Aktivitet Kostnad per Employee'
b'DocType: Accounts Settings',b'Settings for Accounts',b'Innstillinger for kontoer'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +673',b'Supplier Invoice No exists in Purchase Invoice {0}',b'Leverand\xc3\xb8r Faktura Ingen eksisterer i fakturaen {0}'
b'apps/erpnext/erpnext/config/selling.py +118',b'Manage Sales Person Tree.',b'Administrer Sales Person treet.'
b'DocType: Job Applicant',b'Cover Letter',b'Cover Letter'
b'apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +37',b'Outstanding Cheques and Deposits to clear',b'Utest\xc3\xa5ende Sjekker og Innskudd \xc3\xa5 t\xc3\xb8mme'
b'DocType: Item',b'Synced With Hub',b'Synkronisert Med Hub'
b'DocType: Driver',b'Fleet Manager',b'Fl\xc3\xa5tesjef'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +542',b'Row #{0}: {1} can not be negative for item {2}',b'Rad # {0}: {1} ikke kan v\xc3\xa6re negativ for elementet {2}'
b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +59',b'Wrong Password',b'Feil Passord'
b'DocType: Item',b'Variant Of',b'Variant av'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +406',"b""Completed Qty can not be greater than 'Qty to Manufacture'""",b'Fullf\xc3\xb8rt Antall kan ikke v\xc3\xa6re st\xc3\xb8rre enn &quot;Antall \xc3\xa5 Manufacture &#39;'
b'DocType: Period Closing Voucher',b'Closing Account Head',b'Lukke konto Leder'
b'DocType: Employee',b'External Work History',b'Ekstern Work History'
b'apps/erpnext/erpnext/projects/doctype/task/task.py +111',b'Circular Reference Error',b'Rundskriv Reference Error'
b'apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +206',b'Student Report Card',b'Studentrapportkort'
b'DocType: Appointment Type',b'Is Inpatient',b'Er pasient'
b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +55',b'Guardian1 Name',b'Guardian1 Name'
b'DocType: Delivery Note',b'In Words (Export) will be visible once you save the Delivery Note.',b'I Words (eksport) vil v\xc3\xa6re synlig n\xc3\xa5r du lagrer f\xc3\xb8lgeseddel.'
b'DocType: Cheque Print Template',b'Distance from left edge',b'Avstand fra venstre kant'
b'apps/erpnext/erpnext/utilities/bot.py +29',b'{0} units of [{1}](#Form/Item/{1}) found in [{2}](#Form/Warehouse/{2})',b'{0} enheter av [{1}] (# Form / post / {1}) finnes i [{2}] (# Form / Lager / {2})'
b'DocType: Lead',b'Industry',b'Industry'
b'DocType: Employee',b'Job Profile',b'Job Profile'
b'DocType: BOM Item',b'Rate & Amount',b'Pris og bel\xc3\xb8p'
b'apps/erpnext/erpnext/setup/doctype/company/company_dashboard.py +6',b'This is based on transactions against this Company. See timeline below for details',b'Dette er basert p\xc3\xa5 transaksjoner mot dette selskapet. Se tidslinjen nedenfor for detaljer'
b'DocType: Stock Settings',b'Notify by Email on creation of automatic Material Request',b'Varsle p\xc3\xa5 e-post om opprettelse av automatisk Material Request'
b'apps/erpnext/erpnext/healthcare/setup.py +259',b'Resistant',b'Resistant'
b'apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.py +77',b'Please set Hotel Room Rate on {}',b'Vennligst sett inn hotellrenten p\xc3\xa5 {}'
b'DocType: Journal Entry',b'Multi Currency',b'Multi Valuta'
b'DocType: Opening Invoice Creation Tool',b'Invoice Type',b'Faktura Type'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +939',b'Delivery Note',b'Levering Note'
b'DocType: Consultation',b'Encounter Impression',b'Encounter Impression'
b'apps/erpnext/erpnext/config/learn.py +82',b'Setting up Taxes',b'Sette opp skatter'
b'apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +134',b'Cost of Sold Asset',b'Cost of Selges Asset'
b'DocType: Volunteer',b'Morning',b'Morgen'
b'apps/erpnext/erpnext/accounts/utils.py +350',b'Payment Entry has been modified after you pulled it. Please pull it again.',b'Betaling Entry har blitt endret etter at du trakk den. Kan trekke det igjen.'
b'DocType: Program Enrollment Tool',b'New Student Batch',b'Ny studentbatch'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +479',b'{0} entered twice in Item Tax',b'{0} registrert to ganger i pkt Skatte'
b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +113',b'Summary for this week and pending activities',b'Oppsummering for denne uken og ventende aktiviteter'
b'DocType: Student Applicant',b'Admitted',b'innr\xc3\xb8mmet'
b'DocType: Workstation',b'Rent Cost',b'Rent Cost'
b'apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +81',b'Amount After Depreciation',b'Mengde etter avskrivninger'
b'apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +97',b'Upcoming Calendar Events',b'Kommende kalenderhendelser'
b'apps/erpnext/erpnext/public/js/templates/item_quick_entry.html +1',b'Variant Attributes',b'Variant attributter'
b'apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +85',b'Please select month and year',b'Velg m\xc3\xa5ned og \xc3\xa5r'
b'DocType: Employee',b'Company Email',b'Selskapet E-post'
b'DocType: GL Entry',b'Debit Amount in Account Currency',b'Debet bel\xc3\xb8p p\xc3\xa5 kontoen Valuta'
b'DocType: Supplier Scorecard',b'Scoring Standings',b'Scoring Steder'
b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +21',b'Order Value',b'Bestillingsverdi'
b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +21',b'Order Value',b'Bestillingsverdi'
b'apps/erpnext/erpnext/config/accounts.py +27',b'Bank/Cash transactions against party or for internal transfer',b'Bank / kontanter transaksjoner mot part eller for intern overf\xc3\xb8ring'
b'DocType: Shipping Rule',b'Valid for Countries',b'Gyldig for Land'
b'apps/erpnext/erpnext/stock/doctype/item/item.js +55',"b""This Item is a Template and cannot be used in transactions. Item attributes will be copied over into the variants unless 'No Copy' is set""","b'Denne varen er en mal, og kan ikke brukes i transaksjoner. Element attributter vil bli kopiert over i varianter med mindre &#39;No Copy&#39; er satt'"
b'DocType: Grant Application',b'Grant Application',b'Grant s\xc3\xb8knad'
b'apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +69',b'Total Order Considered',b'Total Bestill Regnes'
b'apps/erpnext/erpnext/config/hr.py +243',"b'Employee designation (e.g. CEO, Director etc.).'","b'Ansatt betegnelse (f.eks CEO, direkt\xc3\xb8r etc.).'"
b'DocType: Sales Invoice',"b""Rate at which Customer Currency is converted to customer's base currency""",b'Hastigheten som Kunden Valuta omdannes til kundens basisvaluta'
b'DocType: Course Scheduling Tool',b'Course Scheduling Tool',b'Kurs Planlegging Tool'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +623',b'Row #{0}: Purchase Invoice cannot be made against an existing asset {1}',b'Row # {0}: Kj\xc3\xb8p Faktura kan ikke gj\xc3\xb8res mot en eksisterende eiendel {1}'
b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +257',b'[Urgent] Error while creating recurring %s for %s',b'[Urgent] Feil mens du oppretter tilbakevendende% s for% s'
b'DocType: Land Unit',b'LInked Analysis',b'Analyse'
b'DocType: Item Tax',b'Tax Rate',b'Skattesats'
b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +73',b'Application period cannot be across two allocation records',b'S\xc3\xb8knadsperioden kan ikke v\xc3\xa6re over to allokeringsregister'
b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +59',b'{0} already allocated for Employee {1} for period {2} to {3}',b'{0} allerede bevilget for Employee {1} for perioden {2} til {3}'
b'apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +141',b'Purchase Invoice {0} is already submitted',b'Fakturaen {0} er allerede sendt'
b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +92',b'Row # {0}: Batch No must be same as {1} {2}',b'Row # {0}: Batch No m\xc3\xa5 v\xc3\xa6re samme som {1} {2}'
b'DocType: Material Request Plan Item',b'Material Request Plan Item',b'Materialforesp\xc3\xb8rselsplan'
b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +52',b'Convert to non-Group',b'Konverter til ikke-konsernet'
b'DocType: Project Update',b'Good/Steady',b'Good / Steady'
b'DocType: C-Form Invoice Detail',b'Invoice Date',b'Fakturadato'
b'DocType: GL Entry',b'Debit Amount',b'Debet Bel\xc3\xb8p'
b'apps/erpnext/erpnext/accounts/party.py +248',b'There can only be 1 Account per Company in {0} {1}',b'Det kan bare v\xc3\xa6re en konto per Company i {0} {1}'
b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +426',b'Please see attachment',b'Vennligst se vedlegg'
b'DocType: Purchase Order',b'% Received',b'% Mottatt'
b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js +3',b'Create Student Groups',b'Opprett studentgrupper'
b'DocType: Volunteer',b'Weekends',b'helger'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +118',b'Credit Note Amount',b'Kreditt Note Bel\xc3\xb8p'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +187',b'{0} ({1}) cannot be greater than planned quanitity ({2}) in Work Order {3}',b'{0} ({1}) kan ikke v\xc3\xa6re st\xc3\xb8rre enn planlagt quanitity ({2}) i Work Order {3}'
b'DocType: Setup Progress Action',b'Action Document',b'Handlingsdokument'
b'DocType: Chapter Member',b'Website URL',b'Website URL'
,b'Finished Goods',b'Ferdigvarer'
b'DocType: Delivery Note',b'Instructions',b'Bruksanvisning'
b'DocType: Quality Inspection',b'Inspected By',b'Inspisert av'
b'DocType: Asset Maintenance Log',b'Maintenance Type',b'Vedlikehold Type'
b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +45',b'{0} - {1} is not enrolled in the Course {2}',b'{0} - {1} er ikke p\xc3\xa5meldt kurset {2}'
b'apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +225',b'Student Name: ',b'Student navn:'
b'apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +59',b'Serial No {0} does not belong to Delivery Note {1}',b'Serial No {0} tilh\xc3\xb8rer ikke f\xc3\xb8lgeseddel {1}'
b'apps/erpnext/erpnext/erpnext_integrations/doctype/gocardless_settings/gocardless_settings.py +97',"b""There seems to be an issue with the server's GoCardless configuration. Don't worry, in case of failure, the amount will get refunded to your account.""","b'Det ser ut til \xc3\xa5 v\xc3\xa6re et problem med serverens GoCardless-konfigurasjon. Ikke bekymre deg, i tilfelle feil, vil bel\xc3\xb8pet bli refundert til kontoen din.'"
b'apps/erpnext/erpnext/templates/pages/demo.html +47',b'ERPNext Demo',b'ERPNext Demo'
b'apps/erpnext/erpnext/public/js/utils/item_selector.js +20',b'Add Items',b'Legg varer'
b'DocType: Item Quality Inspection Parameter',b'Item Quality Inspection Parameter',b'Sak Quality Inspection Parameter'
b'DocType: Depreciation Schedule',b'Schedule Date',b'Schedule Date'
b'apps/erpnext/erpnext/config/hr.py +116',"b'Earnings, Deductions and other Salary components'","b'Inntjening, fradrag og andre L\xc3\xb8nn komponenter'"
b'DocType: Packed Item',b'Packed Item',b'Pakket Element'
b'DocType: Job Offer Term',b'Job Offer Term',b'Jobbtilbudsperiode'
b'apps/erpnext/erpnext/config/buying.py +65',b'Default settings for buying transactions.',b'Standardinnstillingene for \xc3\xa5 kj\xc3\xb8pe transaksjoner.'
b'apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +29',b'Activity Cost exists for Employee {0} against Activity Type - {1}',b'Aktivitet Kostnad finnes for Employee {0} mot Activity Type - {1}'
b'apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +15',b'Mandatory field - Get Students From',b'Obligatorisk felt - F\xc3\xa5 studenter fra'
b'apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +15',b'Mandatory field - Get Students From',b'Obligatorisk felt - F\xc3\xa5 studenter fra'
b'DocType: Program Enrollment',b'Enrolled courses',b'P\xc3\xa5meldte kurs'
b'DocType: Program Enrollment',b'Enrolled courses',b'P\xc3\xa5meldte kurs'
b'DocType: Currency Exchange',b'Currency Exchange',b'Valutaveksling'
b'DocType: Opening Invoice Creation Tool Item',b'Item Name',b'Navn'
b'DocType: Authorization Rule',b'Approving User  (above authorized value)',b'Godkjenne Bruker (ovenfor autorisert verdi)'
b'DocType: Email Digest',b'Credit Balance',b'Credit Balance'
b'DocType: Employee',b'Widowed',b'Enke'
b'DocType: Request for Quotation',b'Request for Quotation',b'Foresp\xc3\xb8rsel om kostnadsoverslag'
b'DocType: Healthcare Settings',b'Require Lab Test Approval',b'Krever godkjenning av laboratorietest'
b'DocType: Salary Slip Timesheet',b'Working Hours',b'Arbeidstid'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +59',b'Total Outstanding',b'Totalt Utest\xc3\xa5ende'
b'DocType: Naming Series',b'Change the starting / current sequence number of an existing series.',b'Endre start / str\xc3\xb8m sekvensnummer av en eksisterende serie.'
b'DocType: Dosage Strength',b'Strength',b'Styrke'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +1534',b'Create a new Customer',b'Opprett en ny kunde'
b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +59',"b'If multiple Pricing Rules continue to prevail, users are asked to set Priority manually to resolve conflict.'","b'Hvis flere Pris Regler fortsette \xc3\xa5 r\xc3\xa5de, blir brukerne bedt om \xc3\xa5 sette Priority manuelt for \xc3\xa5 l\xc3\xb8se konflikten.'"
b'apps/erpnext/erpnext/utilities/activation.py +90',b'Create Purchase Orders',b'Opprette innkj\xc3\xb8psordrer'
,b'Purchase Register',b'Kj\xc3\xb8p Register'
b'apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +116',b'Patient not found',b'Pasient ikke funnet'
b'DocType: Scheduling Tool',b'Rechedule',b'Rechedule'
b'DocType: Landed Cost Item',b'Applicable Charges',b'Gjeldende avgifter'
b'DocType: Workstation',b'Consumable Cost',b'Forbrukskostnads'
b'DocType: Purchase Receipt',b'Vehicle Date',b'Vehicle Dato'
b'DocType: Student Log',b'Medical',b'Medisinsk'
b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +175',b'Reason for losing',b'Grunnen for \xc3\xa5 tape'
b'apps/erpnext/erpnext/accounts/doctype/account/account.js +52',b'Update Account Number',b'Oppdater kontonummer'
b'apps/erpnext/erpnext/crm/doctype/lead/lead.py +44',b'Lead Owner cannot be same as the Lead',b'Bly Eier kan ikke v\xc3\xa6re det samme som Lead'
b'apps/erpnext/erpnext/accounts/utils.py +356',b'Allocated amount can not greater than unadjusted amount',b'Avsatt bel\xc3\xb8p kan ikke st\xc3\xb8rre enn ujustert bel\xc3\xb8p'
b'DocType: Announcement',b'Receiver',b'mottaker'
b'apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +83',b'Workstation is closed on the following dates as per Holiday List: {0}',b'Workstation er stengt p\xc3\xa5 f\xc3\xb8lgende datoer som per Holiday Liste: {0}'
b'apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +32',b'Opportunities',b'Muligheter'
b'DocType: Lab Test Template',b'Single',b'Enslig'
b'DocType: Salary Slip',b'Total Loan Repayment',b'Total Loan Nedbetaling'
b'DocType: Account',b'Cost of Goods Sold',b'Varekostnad'
b'DocType: Subscription',b'Yearly',b'\xc3\x85rlig'
b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +230',b'Please enter Cost Center',b'Skriv inn kostnadssted'
b'DocType: Drug Prescription',b'Dosage',b'Dosering'
b'DocType: Journal Entry Account',b'Sales Order',b'Salgsordre'
b'apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +69',b'Avg. Selling Rate',b'Avg. Salgskurs'
b'DocType: Assessment Plan',b'Examiner Name',b'Examiner Name'
b'DocType: Lab Test Template',b'No Result',b'Ingen resultater'
b'DocType: Purchase Invoice Item',b'Quantity and Rate',b'Kvantitet og Rate'
b'DocType: Delivery Note',b'% Installed',b'% Installert'
b'apps/erpnext/erpnext/utilities/user_progress.py +230',b'Classrooms/ Laboratories etc where lectures can be scheduled.',b'Klasserom / Laboratorier etc hvor forelesningene kan planlegges.'
b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +46',b'Please enter company name first',b'Skriv inn firmanavn f\xc3\xb8rst'
b'DocType: Purchase Invoice',b'Supplier Name',b'Leverand\xc3\xb8r Name'
b'apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +25',b'Read the ERPNext Manual',b'Les ERPNext Manual'
b'DocType: Purchase Invoice',b'01-Sales Return',b'01-salgs retur'
b'DocType: Account',b'Is Group',b'Is Gruppe'
b'DocType: Email Digest',b'Pending Purchase Orders',b'Avventer innkj\xc3\xb8psordrer'
b'DocType: Stock Settings',b'Automatically Set Serial Nos based on FIFO',b'Automatisk Sett Serial Nos basert p\xc3\xa5 FIFO'
b'DocType: Accounts Settings',b'Check Supplier Invoice Number Uniqueness',b'Sjekk Leverand\xc3\xb8r fakturanummer Unikhet'
b'apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js +34',b'Primary Address Details',b'Prim\xc3\xa6radresse detaljer'
b'DocType: Vehicle Service',b'Oil Change',b'Oljeskift'
b'DocType: Asset Maintenance Log',b'Asset Maintenance Log',b'Asset Maintenance Log'
b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +57',"b""'To Case No.' cannot be less than 'From Case No.'""",b'&#39;Til sak nr&#39; kan ikke v\xc3\xa6re mindre enn &quot;From sak nr &#39;'
b'DocType: Chapter',b'Non Profit',b'Non Profit'
b'DocType: Production Plan',b'Not Started',b'Ikke i gang'
b'DocType: Lead',b'Channel Partner',b'Channel Partner'
b'DocType: Account',b'Old Parent',b'Gammel Parent'
b'apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +19',b'Mandatory field - Academic Year',b'Obligatorisk felt - akademisk \xc3\xa5r'
b'apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +19',b'Mandatory field - Academic Year',b'Obligatorisk felt - akademisk \xc3\xa5r'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +220',b'{0} {1} is not associated with {2} {3}',b'{0} {1} er ikke knyttet til {2} {3}'
b'DocType: Notification Control',b'Customize the introductory text that goes as a part of that email. Each transaction has a separate introductory text.',b'Tilpass innledende tekst som g\xc3\xa5r som en del av e-posten. Hver transaksjon har en egen innledende tekst.'
b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +176',b'Please set default payable account for the company {0}',b'Vennligst angi standard betalbar konto for selskapet {0}'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +511',b'Transaction not allowed against stopped Work Order {0}',b'Transaksjon ikke tillatt mot stoppet Arbeidsordre {0}'
b'DocType: Setup Progress Action',b'Min Doc Count',b'Min Doc-tall'
b'apps/erpnext/erpnext/config/manufacturing.py +84',b'Global settings for all manufacturing processes.',b'Globale innstillinger for alle produksjonsprosesser.'
b'DocType: Accounts Settings',b'Accounts Frozen Upto',b'Regnskap Frozen Opp'
b'DocType: SMS Log',b'Sent On',b'Sendte P\xc3\xa5'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +700',b'Attribute {0} selected multiple times in Attributes Table',b'Attributtet {0} valgt flere ganger i attributter Table'
b'DocType: HR Settings',b'Employee record is created using selected field. ',b'Ansatt posten er opprettet ved hjelp av valgte feltet.'
b'DocType: Sales Order',b'Not Applicable',b'Gjelder ikke'
b'apps/erpnext/erpnext/config/hr.py +70',b'Holiday master.',b'Holiday mester.'
b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +85',b'Opening Invoice Item',b'\xc3\x85pning av fakturaelement'
b'DocType: Request for Quotation Item',b'Required Date',b'N\xc3\xb8dvendig Dato'
b'DocType: Delivery Note',b'Billing Address',b'Fakturaadresse'
b'DocType: BOM',b'Costing',b'Costing'
b'DocType: Tax Rule',b'Billing County',b'Billings County'
b'DocType: Purchase Taxes and Charges',"b'If checked, the tax amount will be considered as already included in the Print Rate / Print Amount'","b'Hvis det er merket, vil skattebel\xc3\xb8pet betraktes som allerede er inkludert i Print Rate / Print Bel\xc3\xb8p'"
b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +46',b'PieceRef',b'PieceRef'
b'DocType: Request for Quotation',b'Message for Supplier',b'Beskjed til Leverand\xc3\xb8r'
b'apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js +40',b'Work Order',b'Arbeidsordre'
b'DocType: Driver',b'DRIVER-.#####',b'SJ\xc3\x85F\xc3\x98R-.#####'
b'DocType: Sales Invoice',b'Total Qty',b'Total Antall'
b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +62',b'Guardian2 Email ID',b'Guardian2 Email ID'
b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +62',b'Guardian2 Email ID',b'Guardian2 Email ID'
b'DocType: Item',b'Show in Website (Variant)',b'Vis i Website (Variant)'
b'DocType: Employee',b'Health Concerns',b'Helse Bekymringer'
b'DocType: Payroll Entry',b'Select Payroll Period',b'Velg L\xc3\xb8nn Periode'
b'DocType: Purchase Invoice',b'Unpaid',b'Ubetalte'
b'apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +49',b'Reserved for sale',b'Reservert for salg'
b'DocType: Packing Slip',b'From Package No.',b'Fra Package No.'
b'DocType: Item Attribute',b'To Range',b'Range'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +29',b'Securities and Deposits',b'Verdipapirer og innskudd'
b'apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +46',"b""Can't change valuation method, as there are transactions against some items which does not have it's own valuation method""","b'Kan ikke endre verdsettelsesmetoden, da det er transaksjoner mot enkelte poster som ikke har egen verdsettelsesmetode'"
b'DocType: Student Report Generation Tool',b'Attended by Parents',b'Deltatt av foreldre'
b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +82',b'Total leaves allocated is mandatory',b'Totalt blader tildelte er obligatorisk'
b'DocType: Patient',b'AB Positive',b'AB Positiv'
b'DocType: Job Opening',b'Description of a Job Opening',b'Beskrivelse av en ledig jobb'
b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +110',b'Pending activities for today',b'Ventende aktiviteter for i dag'
b'apps/erpnext/erpnext/config/hr.py +24',b'Attendance record.',b'Tilskuerrekord.'
b'DocType: Salary Structure',b'Salary Component for timesheet based payroll.',b'L\xc3\xb8nn Component for timebasert l\xc3\xb8nn.'
b'DocType: Sales Order Item',b'Used for Production Plan',b'Brukes for Produksjonsplan'
b'DocType: Employee Loan',b'Total Payment',b'totalt betaling'
b'DocType: Manufacturing Settings',b'Time Between Operations (in mins)',b'Time Between Operations (i minutter)'
b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +132',b'{0} {1} is cancelled so the action cannot be completed',"b'{0} {1} er kansellert, slik at handlingen ikke kan fullf\xc3\xb8res'"
b'DocType: Customer',b'Buyer of Goods and Services.',b'Kj\xc3\xb8per av varer og tjenester.'
b'DocType: Journal Entry',b'Accounts Payable',b'Leverand\xc3\xb8rgjeld'
b'DocType: Patient',b'Allergies',b'allergi'
b'apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +33',b'The selected BOMs are not for the same item',b'De valgte stykklister er ikke for den samme varen'
b'DocType: Supplier Scorecard Standing',b'Notify Other',b'Varsle Andre'
b'DocType: Vital Signs',b'Blood Pressure (systolic)',b'Blodtrykk (systolisk)'
b'DocType: Pricing Rule',b'Valid Upto',b'Gyldig Opp'
b'DocType: Training Event',b'Workshop',b'Verksted'
b'DocType: Supplier Scorecard Scoring Standing',b'Warn Purchase Orders',b'Varsle innkj\xc3\xb8psordrer'
b'apps/erpnext/erpnext/utilities/user_progress.py +67',b'List a few of your customers. They could be organizations or individuals.',b'Liste noen av kundene dine. De kan v\xc3\xa6re organisasjoner eller enkeltpersoner.'
b'apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py +23',b'Enough Parts to Build',b'Nok Deler bygge'
b'DocType: POS Profile User',b'POS Profile User',b'POS Profil Bruker'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +128',b'Direct Income',b'Direkte Inntekt'
b'DocType: Patient Appointment',b'Date TIme',b'Dato tid'
b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +45',"b'Can not filter based on Account, if grouped by Account'","b'Kan ikke filtrere basert p\xc3\xa5 konto, hvis gruppert etter konto'"
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +130',b'Administrative Officer',b'Administrative Officer'
b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +39',b'Setting up company and taxes',b'Sette opp selskap og skatter'
b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +22',b'Please select Course',b'Vennligst velg Kurs'
b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +22',b'Please select Course',b'Vennligst velg Kurs'
b'DocType: Codification Table',b'Codification Table',b'Kodifiseringstabell'
b'DocType: Timesheet Detail',b'Hrs',b'timer'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +349',b'Please select Company',b'Vennligst velg selskapet'
b'DocType: Stock Entry Detail',b'Difference Account',b'Forskjellen konto'
b'DocType: Purchase Invoice',b'Supplier GSTIN',b'Leverand\xc3\xb8r GSTIN'
b'apps/erpnext/erpnext/projects/doctype/task/task.py +47',b'Cannot close task as its dependant task {0} is not closed.',b'Kan ikke lukke oppgaven som sin avhengige oppgave {0} er ikke lukket.'
b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +435',b'Please enter Warehouse for which Material Request will be raised',b'Skriv inn Warehouse hvor Material Request vil bli hevet'
b'DocType: Work Order',b'Additional Operating Cost',b'Ekstra driftskostnader'
b'DocType: Lab Test Template',b'Lab Routine',b'Lab Rutine'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +20',b'Cosmetics',b'Kosmetikk'
b'apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +18',b'Please select Completion Date for Completed Asset Maintenance Log',b'Vennligst velg sluttdato for fullf\xc3\xb8rt aktivitetsvedlikeholdslogg'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +552',"b'To merge, following properties must be same for both items'","b'\xc3\x85 fusjonere, m\xc3\xa5 f\xc3\xb8lgende egenskaper v\xc3\xa6re lik for begge elementene'"
b'DocType: Shipping Rule',b'Net Weight',b'Netto Vekt'
b'DocType: Employee',b'Emergency Phone',b'Emergency Phone'
b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +82',b'{0} {1} does not exist.',b'{0} {1} eksisterer ikke.'
b'apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +29',b'Buy',b'Kj\xc3\xb8pe'
,b'Serial No Warranty Expiry',b'Ingen garanti Utl\xc3\xb8psserie'
b'DocType: Sales Invoice',b'Offline POS Name',b'Offline POS Name'
b'apps/erpnext/erpnext/utilities/user_progress.py +180',b'Student Application',b'Student s\xc3\xb8knad'
b'apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py +20',b'Please define grade for Threshold 0%',b'Vennligst definer karakter for Terskel 0%'
b'apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py +20',b'Please define grade for Threshold 0%',b'Vennligst definer karakter for Terskel 0%'
b'DocType: Sales Order',b'To Deliver',b'\xc3\x85 Levere'
b'DocType: Purchase Invoice Item',b'Item',b'Sak'
b'apps/erpnext/erpnext/healthcare/setup.py +256',b'High Sensitivity',b'H\xc3\xb8y f\xc3\xb8lsomhet'
b'apps/erpnext/erpnext/config/non_profit.py +48',b'Volunteer Type information.',b'Frivillig Type informasjon.'
b'DocType: Cash Flow Mapping Template',b'Cash Flow Mapping Template',b'Cash Flow Mapping Template'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +2555',b'Serial no item cannot be a fraction',b'Serie ingen element kan ikke v\xc3\xa6re en br\xc3\xb8kdel'
b'DocType: Journal Entry',b'Difference (Dr - Cr)',b'Forskjellen (Dr - Cr)'
b'DocType: Account',b'Profit and Loss',b'Gevinst og tap'
b'apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +104',"b'Not permitted, configure Lab Test Template as required'","b'Ikke tillatt, konfigurer Lab Test Template etter behov'"
b'DocType: Patient',b'Risk Factors',b'Risikofaktorer'
b'DocType: Patient',b'Occupational Hazards and Environmental Factors',b'Arbeidsfare og milj\xc3\xb8faktorer'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +239',b'Stock Entries already created for Work Order ',b'Lageroppf\xc3\xb8ringer allerede opprettet for arbeidsordre'
b'DocType: Vital Signs',b'Respiratory rate',b'Respirasjonsfrekvens'
b'apps/erpnext/erpnext/config/stock.py +334',b'Managing Subcontracting',b'Administrerende Underleverand\xc3\xb8rer'
b'DocType: Vital Signs',b'Body Temperature',b'Kroppstemperatur'
b'DocType: Project',b'Project will be accessible on the website to these users',b'Prosjektet vil v\xc3\xa6re tilgjengelig p\xc3\xa5 nettstedet til disse brukerne'
b'DocType: Detected Disease',b'Disease',b'Sykdom'
b'apps/erpnext/erpnext/config/projects.py +29',b'Define Project type.',b'Definer Prosjekttype.'
b'DocType: Supplier Scorecard',b'Weighting Function',b'Vekting Funksjon'
b'DocType: Physician',b'OP Consulting Charge',b'OP-konsulentkostnad'
b'apps/erpnext/erpnext/utilities/user_progress.py +28',b'Setup your ',b'Oppsett din'
b'DocType: Student Report Generation Tool',b'Show Marks',b'Vis karakterer'
b'DocType: Quotation',"b""Rate at which Price list currency is converted to company's base currency""",b'Hastigheten som Prisliste valuta er konvertert til selskapets hovedvaluta'
b'apps/erpnext/erpnext/setup/doctype/company/company.py +70',b'Account {0} does not belong to company: {1}',b'Konto {0} tilh\xc3\xb8rer ikke selskapet: {1}'
b'apps/erpnext/erpnext/setup/doctype/company/company.py +52',b'Abbreviation already used for another company',b'Forkortelse allerede brukt for et annet selskap'
b'DocType: Selling Settings',b'Default Customer Group',b'Standard Kundegruppe'
b'DocType: Asset Repair',b'ARLOG-',b'ARLOG-'
b'DocType: Global Defaults',"b""If disable, 'Rounded Total' field will not be visible in any transaction""","b'Hvis deaktivere, &#39;Rounded Total-feltet ikke vil v\xc3\xa6re synlig i enhver transaksjon'"
b'DocType: BOM',b'Operating Cost',b'Driftskostnader'
b'DocType: Crop',b'Produced Items',b'Produserte varer'
b'DocType: Sales Order Item',b'Gross Profit',b'Bruttofortjeneste'
b'apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +49',b'Increment cannot be 0',b'Tilveksten kan ikke v\xc3\xa6re 0'
b'DocType: Company',b'Delete Company Transactions',b'Slett transaksjoner'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +364',b'Reference No and Reference Date is mandatory for Bank transaction',b'Referansenummer og Reference Date er obligatorisk for Bank transaksjon'
b'DocType: Purchase Receipt',b'Add / Edit Taxes and Charges',b'Legg til / Rediger skatter og avgifter'
b'DocType: Payment Entry Reference',b'Supplier Invoice No',b'Leverand\xc3\xb8r Faktura Nei'
b'DocType: Territory',b'For reference',b'For referanse'
b'DocType: Healthcare Settings',b'Appointment Confirmation',b'Avtalebekreftelse'
b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +158',"b'Cannot delete Serial No {0}, as it is used in stock transactions'","b'Kan ikke slette Serial No {0}, slik det brukes i aksjetransaksjoner'"
b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +256',b'Closing (Cr)',b'Lukking (Cr)'
b'apps/erpnext/erpnext/hr/email_alert/training_feedback/training_feedback.html +1',b'Hello',b'Hallo'
b'apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +118',b'Move Item',b'Flytt element'
b'DocType: Serial No',b'Warranty Period (Days)',b'Garantiperioden (dager)'
b'DocType: Installation Note Item',b'Installation Note Item',b'Installasjon Merk Element'
b'DocType: Production Plan Item',b'Pending Qty',b'Venter Stk'
b'DocType: Budget',b'Ignore',b'Ignorer'
b'apps/erpnext/erpnext/accounts/party.py +396',b'{0} {1} is not active',b'{0} {1} er ikke aktiv'
b'apps/erpnext/erpnext/config/accounts.py +272',b'Setup cheque dimensions for printing',b'Oppsett sjekk dimensjoner for utskrift'
b'DocType: Salary Slip',b'Salary Slip Timesheet',b'L\xc3\xb8nn Slip Timeregistrering'
b'apps/erpnext/erpnext/controllers/buying_controller.py +160',b'Supplier Warehouse mandatory for sub-contracted Purchase Receipt',b'Leverand\xc3\xb8r Warehouse obligatorisk for underleverand\xc3\xb8r Kj\xc3\xb8pskvittering'
b'DocType: Pricing Rule',b'Valid From',b'Gyldig Fra'
b'DocType: Sales Invoice',b'Total Commission',b'Total Commission'
b'DocType: Pricing Rule',b'Sales Partner',b'Sales Partner'
b'apps/erpnext/erpnext/config/buying.py +150',b'All Supplier scorecards.',b'Alle leverand\xc3\xb8rens scorecards.'
b'DocType: Buying Settings',b'Purchase Receipt Required',b'Kvitteringen P\xc3\xa5krevd'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +188',b'Target warehouse in row {0} must be same as Work Order',b'M\xc3\xa5llager i rad {0} m\xc3\xa5 v\xc3\xa6re det samme som Arbeidsordre'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +155',b'Valuation Rate is mandatory if Opening Stock entered',b'Verdsettelse Rate er obligatorisk hvis \xc3\x85pning Stock oppgitt'
b'apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +143',b'No records found in the Invoice table',b'Ingen poster ble funnet i Faktura tabellen'
b'apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js +34',b'Please select Company and Party Type first',b'Vennligst velg f\xc3\xb8rst selskapet og Party Type'
b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +31',"b'Already set default in pos profile {0} for user {1}, kindly disabled default'","b'Sett allerede standard i pos profil {0} for bruker {1}, vennligst deaktivert standard'"
b'apps/erpnext/erpnext/config/accounts.py +293',b'Financial / accounting year.',b'Finansiell / regnskap \xc3\xa5r.'
b'apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.js +9',b'Accumulated Values',b'akkumulerte verdier'
b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +162',"b'Sorry, Serial Nos cannot be merged'","b'Sorry, kan Serial Nos ikke bli sl\xc3\xa5tt sammen'"
b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +72',b'Territory is Required in POS Profile',b'Omr\xc3\xa5de er p\xc3\xa5krevd i POS-profil'
b'DocType: Supplier',b'Prevent RFQs',b'Forhindre RFQs'
b'apps/erpnext/erpnext/utilities/activation.py +83',b'Make Sales Order',b'Gj\xc3\xb8r Salgsordre'
b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +168',b'Salary Slip submitted for period from {0} to {1}',b'L\xc3\xb8nnsslipp legges inn for perioden fra {0} til {1}'
b'DocType: Project Task',b'Project Task',b'Prosjektet Task'
,b'Lead Id',b'Lead Id'
b'DocType: C-Form Invoice Detail',b'Grand Total',b'Grand Total'
b'DocType: Assessment Plan',b'Course',b'Kurs'
b'DocType: Timesheet',b'Payslip',b'payslip'
b'apps/erpnext/erpnext/public/js/pos/pos.html +4',b'Item Cart',b'Sak Handlekurv'
b'apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +38',b'Fiscal Year Start Date should not be greater than Fiscal Year End Date',b'Regnskaps\xc3\xa5r Startdato b\xc3\xb8r ikke v\xc3\xa6re st\xc3\xb8rre enn regnskaps\xc3\xa5ret Sluttdato'
b'DocType: Issue',b'Resolution',b'Oppl\xc3\xb8sning'
b'DocType: C-Form',b'IV',b'IV'
b'apps/erpnext/erpnext/templates/pages/order.html +76',b'Delivered: {0}',b'Levering: {0}'
b'DocType: Expense Claim',b'Payable Account',b'Betales konto'
b'DocType: Payment Entry',b'Type of Payment',b'Type Betaling'
b'DocType: Sales Order',b'Billing and Delivery Status',b'Fakturering og levering Status'
b'DocType: Job Applicant',b'Resume Attachment',b'Fortsett Vedlegg'
b'apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +58',b'Repeat Customers',b'Gjenta kunder'
b'DocType: Leave Control Panel',b'Allocate',b'Bevilge'
b'apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +108',b'Create Variant',b'Opprett variant'
b'DocType: Sales Invoice',b'Shipping Bill Date',b'Fraktregningsdato'
b'DocType: Production Plan',b'Production Plan',b'Produksjonsplan'
b'DocType: Opening Invoice Creation Tool',b'Opening Invoice Creation Tool',b'\xc3\x85pning av fakturaopprettingsverkt\xc3\xb8y'
b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +853',b'Sales Return',b'Sales Return'
b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +96',"b""Note: Total allocated leaves {0} shouldn't be less than already approved leaves {1} for the period""",b'Merk: Totalt tildelte blader {0} b\xc3\xb8r ikke v\xc3\xa6re mindre enn allerede innvilgede permisjoner {1} for perioden'
,b'Total Stock Summary',b'Totalt lageroppsummering'
b'DocType: Announcement',b'Posted By',b'Postet av'
b'DocType: Item',b'Delivered by Supplier (Drop Ship)',b'Levert av Leverand\xc3\xb8r (Drop Ship)'
b'DocType: Healthcare Settings',b'Confirmation Message',b'Bekreftelsesmelding'
b'apps/erpnext/erpnext/config/crm.py +12',b'Database of potential customers.',b'Database med potensielle kunder.'
b'DocType: Authorization Rule',b'Customer or Item',b'Kunden eller Element'
b'apps/erpnext/erpnext/config/selling.py +28',b'Customer database.',b'Kundedatabase.'
b'DocType: Quotation',b'Quotation To',b'Sitat \xc3\x85'
b'DocType: Lead',b'Middle Income',b'Middle Income'
b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +228',b'Opening (Cr)',b'\xc3\x85pning (Cr)'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +872',b'Default Unit of Measure for Item {0} cannot be changed directly because you have already made some transaction(s) with another UOM. You will need to create a new Item to use a different Default UOM.',b'Standard Enhet for Element {0} kan ikke endres direkte fordi du allerede har gjort noen transaksjon (er) med en annen m\xc3\xa5lenheter. Du m\xc3\xa5 opprette et nytt element for \xc3\xa5 bruke et annet standardm\xc3\xa5lenheter.'
b'apps/erpnext/erpnext/accounts/utils.py +354',b'Allocated amount can not be negative',b'Bevilget bel\xc3\xb8pet kan ikke v\xc3\xa6re negativ'
b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +11',b'Please set the Company',b'Vennligst sett selskapet'
b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +11',b'Please set the Company',b'Vennligst sett selskapet'
b'DocType: Share Balance',b'Share Balance',b'Andelsbalanse'
b'DocType: Purchase Order Item',b'Billed Amt',b'Billed Amt'
b'DocType: Training Result Employee',b'Training Result Employee',b'Trening Resultat Medarbeider'
b'DocType: Warehouse',b'A logical Warehouse against which stock entries are made.',b'En logisk Warehouse mot som lager oppf\xc3\xb8ringer er gjort.'
b'DocType: Repayment Schedule',b'Principal Amount',b'hovedstol'
b'DocType: Employee Loan Application',b'Total Payable Interest',b'Total skyldige renter'
b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +57',b'Total Outstanding: {0}',b'Totalt utest\xc3\xa5ende: {0}'
b'DocType: Sales Invoice Timesheet',b'Sales Invoice Timesheet',b'Salg Faktura Timeregistrering'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +118',b'Reference No & Reference Date is required for {0}',b'Referansenummer og Reference Date er n\xc3\xb8dvendig for {0}'
b'DocType: Payroll Entry',b'Select Payment Account to make Bank Entry',b'Velg betalingskonto \xc3\xa5 lage Bank Entry'
b'DocType: Hotel Settings',b'Default Invoice Naming Series',b'Standard Faktura Naming Series'
b'apps/erpnext/erpnext/utilities/activation.py +136',"b'Create Employee records to manage leaves, expense claims and payroll'","b'Lag personalregistre for \xc3\xa5 h\xc3\xa5ndtere blader, refusjonskrav og l\xc3\xb8nn'"
b'DocType: Restaurant Reservation',b'Restaurant Reservation',b'Restaurantreservasjon'
b'DocType: Land Unit',b'Land Unit Name',b'Land Enhetsnavn'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +190',b'Proposal Writing',b'Forslaget Writing'
b'DocType: Payment Entry Deduction',b'Payment Entry Deduction',b'Betaling Entry Fradrag'
b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +14',b'Wrapping up',b'Innpakning'
b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +35',b'Notify Customers via Email',b'Meld kundene via e-post'
b'apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +35',b'Another Sales Person {0} exists with the same Employee id',b'En annen Sales Person {0} finnes med samme Employee id'
b'DocType: Employee Advance',b'Claimed Amount',b'P\xc3\xa5krevd bel\xc3\xb8p'
b'apps/erpnext/erpnext/config/education.py +180',b'Masters',b'Masters'
b'DocType: Assessment Plan',b'Maximum Assessment Score',b'Maksimal Assessment Score'
b'apps/erpnext/erpnext/config/accounts.py +138',b'Update Bank Transaction Dates',b'Oppdater Banktransaksjons Datoer'
b'apps/erpnext/erpnext/config/projects.py +41',b'Time Tracking',b'Time Tracking'
b'DocType: Purchase Invoice',b'DUPLICATE FOR TRANSPORTER',b'DUPLIKERER FOR TRANSPORTER'
b'apps/erpnext/erpnext/hr/doctype/employee_advance/employee_advance.py +49',b'Row {0}# Paid Amount cannot be greater than requested advance amount',b'R\xc3\xa5 {0} # Betalt bel\xc3\xb8p kan ikke v\xc3\xa6re st\xc3\xb8rre enn \xc3\xb8nsket bel\xc3\xb8p'
b'DocType: Fiscal Year Company',b'Fiscal Year Company',b'Regnskaps\xc3\xa5ret selskapet'
b'DocType: Packing Slip Item',b'DN Detail',b'DN Detalj'
b'DocType: Training Event',b'Conference',b'Konferanse'
b'DocType: Timesheet',b'Billed',b'Fakturert'
b'DocType: Batch',b'Batch Description',b'Batch Beskrivelse'
b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js +12',b'Creating student groups',b'Opprette studentgrupper'
b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js +12',b'Creating student groups',b'Opprette studentgrupper'
b'apps/erpnext/erpnext/accounts/utils.py +727',"b'Payment Gateway Account not created, please create one manually.'","b'Betaling Gateway konto ikke opprettet, kan du opprette en manuelt.'"
b'DocType: Supplier Scorecard',b'Per Year',b'Per \xc3\xa5r'
b'apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +51',b'Not eligible for the admission in this program as per DOB',b'Ikke kvalifisert for opptak i dette programmet i henhold til DOB'
b'DocType: Sales Invoice',b'Sales Taxes and Charges',b'Salgs Skatter og avgifter'
b'DocType: Employee',b'Organization Profile',b'Organisasjonsprofil'
b'DocType: Vital Signs',b'Height (In Meter)',b'H\xc3\xb8yde (i meter)'
b'DocType: Student',b'Sibling Details',b's\xc3\xb8sken Detaljer'
b'DocType: Vehicle Service',b'Vehicle Service',b'Vehicle service'
b'apps/erpnext/erpnext/config/setup.py +101',b'Automatically triggers the feedback request based on conditions.',b'Automatisk utl\xc3\xb8ser tilbakemeldinger foresp\xc3\xb8rsel basert p\xc3\xa5 forholdene.'
b'DocType: Employee',b'Reason for Resignation',b'Grunnen til Resignasjon'
b'apps/erpnext/erpnext/config/hr.py +152',b'Template for performance appraisals.',b'Mal for medarbeidersamtaler.'
b'DocType: Sales Invoice',b'Credit Note Issued',b'Kreditnota Utstedt'
b'DocType: Project Task',b'Weight',b'Vekt'
b'DocType: Payment Reconciliation',b'Invoice/Journal Entry Details',b'Faktura / Journal Entry Detaljer'
b'apps/erpnext/erpnext/accounts/utils.py +83',"b""{0} '{1}' not in Fiscal Year {2}""",b'{0} {1} ikke i regnskaps\xc3\xa5ret {2}'
b'DocType: Buying Settings',b'Settings for Buying Module',b'Innstillinger for kj\xc3\xb8p Module'
b'apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +21',b'Asset {0} does not belong to company {1}',b'Asset {0} tilh\xc3\xb8rer ikke selskapet {1}'
b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +70',b'Please enter Purchase Receipt first',b'Skriv inn Kj\xc3\xb8pskvittering f\xc3\xb8rst'
b'DocType: Buying Settings',b'Supplier Naming By',b'Leverand\xc3\xb8r Naming Av'
b'DocType: Activity Type',b'Default Costing Rate',b'Standard Koster Rate'
b'DocType: Maintenance Schedule',b'Maintenance Schedule',b'Vedlikeholdsplan'
b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +36',"b'Then Pricing Rules are filtered out based on Customer, Customer Group, Territory, Supplier, Supplier Type, Campaign, Sales Partner etc.'","b'Da reglene for prissetting filtreres ut basert p\xc3\xa5 Kunden, Kundens Group, Territory, leverand\xc3\xb8r, leverand\xc3\xb8r Type, Kampanje, Sales Partner etc.'"
b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +29',b'Net Change in Inventory',b'Netto endring i varelager'
b'apps/erpnext/erpnext/config/hr.py +162',b'Employee Loan Management',b'Ansattes l\xc3\xa5n Ledelse'
b'DocType: Employee',b'Passport Number',b'Passnummer'
b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +60',b'Relation with Guardian2',b'Relasjon med Guardian2'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +124',b'Manager',b'Manager'
b'DocType: Payment Entry',b'Payment From / To',b'Betaling fra / til'
b'apps/erpnext/erpnext/selling/doctype/customer/customer.py +170',b'New credit limit is less than current outstanding amount for the customer. Credit limit has to be atleast {0}',b'Ny kredittgrensen er mindre enn dagens utest\xc3\xa5ende bel\xc3\xb8p for kunden. Kredittgrense m\xc3\xa5 v\xc3\xa6re atleast {0}'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +428',b'Please set account in Warehouse {0}',b'Vennligst sett inn konto i Lager {0}'
b'apps/erpnext/erpnext/controllers/trends.py +39',"b""'Based On' and 'Group By' can not be same""",b'&quot;Based On&quot; og &quot;Grupper etter&quot; ikke kan v\xc3\xa6re det samme'
b'DocType: Sales Person',b'Sales Person Targets',b'Sales Person Targets'
b'DocType: Installation Note',b'IN-',b'I-'
b'DocType: Work Order Operation',b'In minutes',b'I l\xc3\xb8pet av minutter'
b'DocType: Issue',b'Resolution Date',b'Oppl\xc3\xb8sning Dato'
b'DocType: Lab Test Template',b'Compound',b'forbindelse'
b'DocType: Student Batch Name',b'Batch Name',b'batch Name'
b'DocType: Fee Validity',b'Max number of visit',b'Maks antall bes\xc3\xb8k'
,b'Hotel Room Occupancy',b'Hotellrom Occupancy'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +358',b'Timesheet created:',b'Timeregistrering opprettet:'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +931',b'Please set default Cash or Bank account in Mode of Payment {0}',b'Vennligst angi standard kontanter eller bankkontoen i modus for betaling {0}'
b'apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +24',b'Enroll',b'Registrere'
b'DocType: GST Settings',b'GST Settings',b'GST-innstillinger'
b'DocType: Selling Settings',b'Customer Naming By',b'Kunden Naming Av'
b'DocType: Student Leave Application',b'Will show the student as Present in Student Monthly Attendance Report',b'Vil vise studenten som Tilstede i Student M\xc3\xa5nedlig fremm\xc3\xb8terapport'
b'DocType: Depreciation Schedule',b'Depreciation Amount',b'avskrivninger Bel\xc3\xb8p'
b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +56',b'Convert to Group',b'Konverter til konsernet'
b'DocType: Delivery Trip',b'TOUR-.#####',b'TOUR -. #####'
b'DocType: Activity Cost',b'Activity Type',b'Aktivitetstype'
b'DocType: Request for Quotation',b'For individual supplier',b'For enkelte leverand\xc3\xb8r'
b'DocType: BOM Operation',b'Base Hour Rate(Company Currency)',b'Base Hour Rate (Selskap Valuta)'
b'apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +47',b'Delivered Amount',b'Leveres Bel\xc3\xb8p'
b'DocType: Quotation Item',b'Item Balance',b'Sak Balance'
b'DocType: Sales Invoice',b'Packing List',b'Pakkeliste'
b'apps/erpnext/erpnext/config/buying.py +28',b'Purchase Orders given to Suppliers.',b'Innkj\xc3\xb8psordrer gis til leverand\xc3\xb8rer.'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +43',b'Publishing',b'Publisering'
b'DocType: Accounts Settings',b'Report Settings',b'Rapporter innstillinger'
b'DocType: Activity Cost',b'Projects User',b'Prosjekter User'
b'apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +40',b'Consumed',b'Forbrukes'
b'apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +158',b'{0}: {1} not found in Invoice Details table',b'{0}: {1} ble ikke funnet i Fakturadetaljer tabellen'
b'DocType: Asset',b'Asset Owner Company',b'Asset Owner Company'
b'DocType: Company',b'Round Off Cost Center',b'Rund av kostnadssted'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +242',b'Maintenance Visit {0} must be cancelled before cancelling this Sales Order',b'Vedlikehold Bes\xc3\xb8k {0} m\xc3\xa5 avbestilles f\xc3\xb8r den avbryter denne salgsordre'
b'DocType: Asset Maintenance Log',b'AML-',b'AML-'
b'DocType: Item',b'Material Transfer',b'Material Transfer'
b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard_variable/supplier_scorecard_variable.py +24',b'Could not find path for ',b'Kunne ikke finne banen for'
b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +221',b'Opening (Dr)',b'\xc3\x85pning (Dr)'
b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +39',b'Posting timestamp must be after {0}',b'Oppslaget tidsstempel m\xc3\xa5 v\xc3\xa6re etter {0}'
b'apps/erpnext/erpnext/config/accounts.py +39',b'To make recurring documents',b'\xc3\x85 gj\xc3\xb8re gjentatte dokumenter'
,b'GST Itemised Purchase Register',b'GST Artized Purchase Register'
b'DocType: Course Scheduling Tool',b'Reschedule',b'Planlegge p\xc3\xa5 nytt'
b'DocType: Employee Loan',b'Total Interest Payable',b'Total rentekostnader'
b'DocType: Landed Cost Taxes and Charges',b'Landed Cost Taxes and Charges',b'Landed Cost skatter og avgifter'
b'DocType: Work Order Operation',b'Actual Start Time',b'Faktisk Starttid'
b'DocType: BOM Operation',b'Operation Time',b'Operation Tid'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +316',b'Finish',b'Bli ferdig'
b'apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +412',b'Base',b'Utgangspunkt'
b'DocType: Timesheet',b'Total Billed Hours',b'Totalt fakturert timer'
b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1530',b'Write Off Amount',b'Skriv Off Bel\xc3\xb8p'
b'DocType: Leave Block List Allow',b'Allow User',b'Tillat User'
b'DocType: Journal Entry',b'Bill No',b'Bill Nei'
b'DocType: Company',b'Gain/Loss Account on Asset Disposal',b'Gevinst / tap-konto p\xc3\xa5 Asset Avhending'
b'DocType: Vehicle Log',b'Service Details',b'Servicedetaljer'
b'DocType: Vehicle Log',b'Service Details',b'Servicedetaljer'
b'DocType: Subscription',b'Quarterly',b'Quarterly'
b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +47',b'EcritureLib',b'EcritureLib'
b'DocType: Lab Test Template',b'Grouped',b'gruppert'
b'DocType: Selling Settings',b'Delivery Note Required',b'Levering Note P\xc3\xa5krevd'
b'DocType: Bank Guarantee',b'Bank Guarantee Number',b'Bankgaranti nummer'
b'DocType: Bank Guarantee',b'Bank Guarantee Number',b'Bankgaranti nummer'
b'DocType: Assessment Criteria',b'Assessment Criteria',b'Vurderingskriterier'
b'DocType: BOM Item',b'Basic Rate (Company Currency)',b'Basic Rate (Company Valuta)'
b'DocType: Student Attendance',b'Student Attendance',b'student Oppm\xc3\xb8te'
b'DocType: Sales Invoice Timesheet',b'Time Sheet',b'Tids skjema'
b'DocType: Manufacturing Settings',b'Backflush Raw Materials Based On',b'Spylings R\xc3\xa5vare basert p\xc3\xa5'
b'DocType: Sales Invoice',b'Port Code',b'Portkode'
b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +957',b'Reserve Warehouse',b'Reserve Warehouse'
b'DocType: Lead',b'Lead is an Organization',b'Bly er en organisasjon'
b'DocType: Guardian Interest',b'Interest',b'Renter'
b'apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +10',b'Pre Sales',b'F\xc3\xb8r salg'
b'DocType: Instructor Log',b'Other Details',b'Andre detaljer'
b'apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +18',b'Suplier',b'suplier'
b'DocType: Lab Test',b'Test Template',b'Testmal'
b'DocType: Restaurant Order Entry Item',b'Served',b'serveres'
b'apps/erpnext/erpnext/config/non_profit.py +13',b'Chapter information.',b'Kapittelinformasjon.'
b'DocType: Account',b'Accounts',b'Kontoer'
b'DocType: Vehicle',b'Odometer Value (Last)',b'Kilometerstand (Siste)'
b'apps/erpnext/erpnext/config/buying.py +160',b'Templates of supplier scorecard criteria.',b'Maler med leverand\xc3\xb8rpoengkriterier.'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +109',b'Marketing',b'Markedsf\xc3\xb8ring'
b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +303',b'Payment Entry is already created',b'Betaling Entry er allerede opprettet'
b'DocType: Request for Quotation',b'Get Suppliers',b'F\xc3\xa5 leverand\xc3\xb8rer'
b'DocType: Purchase Receipt Item Supplied',b'Current Stock',b'N\xc3\xa5v\xc3\xa6rende Stock'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +610',b'Row #{0}: Asset {1} does not linked to Item {2}',b'Row # {0}: Asset {1} ikke knyttet til Element {2}'
b'apps/erpnext/erpnext/education/doctype/instructor/instructor.py +15',b'Please setup Instructor Naming System in Education &gt; Education Settings',b'Vennligst oppsett Instrukt\xc3\xb8r Navngivningssystem under utdanning&gt; Utdanningsinnstillinger'
b'apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +394',b'Preview Salary Slip',b'Forh\xc3\xa5ndsvisning L\xc3\xb8nn Slip'
b'apps/erpnext/erpnext/accounts/doctype/budget/budget.py +54',b'Account {0} has been entered multiple times',b'Konto {0} er angitt flere ganger'
b'DocType: Account',b'Expenses Included In Valuation',b'Kostnader som inng\xc3\xa5r i verdivurderings'
b'apps/erpnext/erpnext/non_profit/doctype/membership/membership.py +37',b'You can only renew if your membership expires within 30 days',b'Du kan bare fornye hvis medlemskapet ditt utl\xc3\xb8per innen 30 dager'
b'DocType: Land Unit',b'Longitude',b'lengde~~POS=TRUNC'
,b'Absent Student Report',b'Frav\xc3\xa6rende Student Rapporter'
b'DocType: Crop',b'Crop Spacing UOM',b'Beskj\xc3\xa6re plassering UOM'
b'DocType: Accounts Settings',b'Only select if you have setup Cash Flow Mapper documents',b'Bare velg hvis du har installert Cash Flow Mapper-dokumenter'
b'DocType: Email Digest',b'Next email will be sent on:',b'Neste post vil bli sendt p\xc3\xa5:'
b'DocType: Supplier Scorecard',b'Per Week',b'Per uke'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +666',b'Item has variants.',b'Elementet har varianter.'
b'apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +154',b'Total Student',b'Totalt Student'
b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +65',b'Item {0} not found',b'Element {0} ikke funnet'
b'DocType: Bin',b'Stock Value',b'Stock Verdi'
b'apps/erpnext/erpnext/accounts/doctype/account/account.py +239',b'Company {0} does not exist',b'Selskapet {0} finnes ikke'
b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +40',b'{0} has fee validity till {1}',b'{0} har gebyrgyldighet til {1}'
b'apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +54',b'Tree Type',b'Tre Type'
b'DocType: BOM Explosion Item',b'Qty Consumed Per Unit',b'Antall som forbrukes per enhet'
b'DocType: GST Account',b'IGST Account',b'IGST-konto'
b'DocType: Serial No',b'Warranty Expiry Date',b'Garantiutl\xc3\xb8psdato'
b'DocType: Material Request Item',b'Quantity and Warehouse',b'Kvantitet og Warehouse'
b'DocType: Hub Settings',b'Unregister',b'Avregistrer'
b'DocType: Sales Invoice',b'Commission Rate (%)',b'Kommisjonen Rate (%)'
b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +24',b'Please select Program',b'Vennligst velg Program'
b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +24',b'Please select Program',b'Vennligst velg Program'
b'DocType: Project',b'Estimated Cost',b'ansl\xc3\xa5tt pris'
b'DocType: Purchase Order',b'Link to material requests',b'Lenke til materiale foresp\xc3\xb8rsler'
b'DocType: Hub Settings',b'Publish',b'publisere'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +7',b'Aerospace',b'Aerospace'
,b'Fichier des Ecritures Comptables [FEC]',b'Fichier des Ecritures Comptables [FEC]'
b'DocType: Journal Entry',b'Credit Card Entry',b'Kredittkort Entry'
b'apps/erpnext/erpnext/config/accounts.py +57',b'Company and Accounts',b'Selskapet og regnskap'
b'apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +70',b'In Value',b'i Verdi'
b'DocType: Asset Settings',b'Depreciation Options',b'Avskrivningsalternativer'
b'apps/erpnext/erpnext/utilities/transaction_base.py +35',b'Invalid Posting Time',b'Ugyldig innleggstid'
b'DocType: Lead',b'Campaign Name',b'Kampanjenavn'
b'DocType: Hotel Room',b'Capacity',b'Kapasitet'
b'DocType: Selling Settings',b'Close Opportunity After Days',b'Lukk mulighet da Days'
,b'Reserved',b'Reservert'
b'DocType: Driver',b'License Details',b'Lisensdetaljer'
b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +85',b'The field From Shareholder cannot be blank',b'Feltet fra Aksjon\xc3\xa6r kan ikke v\xc3\xa6re tomt'
b'DocType: Purchase Order',b'Supply Raw Materials',b'Leverer r\xc3\xa5vare'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +10',b'Current Assets',b'Oml\xc3\xb8psmidler'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +121',b'{0} is not a stock Item',b'{0} er ikke en lagervare'
b'apps/erpnext/erpnext/hr/email_alert/training_feedback/training_feedback.html +6',"b""Please share your feedback to the training by clicking on 'Training Feedback' and then 'New'""",b'Vennligst del din tilbakemelding til treningen ved \xc3\xa5 klikke p\xc3\xa5 &#39;Trenings tilbakemelding&#39; og deretter &#39;Ny&#39;'
b'DocType: Mode of Payment Account',b'Default Account',b'Standard konto'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +273',b'Please select Sample Retention Warehouse in Stock Settings first',b'Vennligst velg Sample Retention Warehouse i lagerinnstillinger f\xc3\xb8rst'
b'DocType: Payment Entry',b'Received Amount (Company Currency)',b'Mottatt bel\xc3\xb8p (Selskap Valuta)'
b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +192',b'Lead must be set if Opportunity is made from Lead',b'Lead m\xc3\xa5 stilles inn hvis Opportunity er laget av Lead'
b'apps/erpnext/erpnext/erpnext_integrations/doctype/gocardless_settings/gocardless_settings.py +136',b'Payment Cancelled. Please check your GoCardless Account for more details',b'Betaling avbrutt. Vennligst sjekk din GoCardless-konto for mer informasjon'
b'apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +29',b'Please select weekly off day',b'Vennligst velg ukentlig off dag'
b'DocType: Patient',b'O Negative',b'O Negativ'
b'DocType: Work Order Operation',b'Planned End Time',b'Planlagt Sluttid'
,b'Sales Person Target Variance Item Group-Wise',b'Sales Person Target Avviks varegruppe-Wise'
b'apps/erpnext/erpnext/accounts/doctype/account/account.py +93',b'Account with existing transaction cannot be converted to ledger',b'Konto med eksisterende transaksjon kan ikke konverteres til Ledger'
b'apps/erpnext/erpnext/config/non_profit.py +33',b'Memebership Type Details',b'Memebership Type Detaljer'
b'DocType: Delivery Note',"b""Customer's Purchase Order No""",b'Kundens innkj\xc3\xb8psordre Nei'
b'DocType: Budget',b'Budget Against',b'budsjett Against'
b'DocType: Employee',b'Cell Number',b'Cell Number'
b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +450',"b""There's no employee for the given criteria. Check that Salary Slips have not already been created.""",b'Det er ingen ansatt for de oppgitte kriteriene. Sjekk at L\xc3\xb8nnslister ikke allerede er opprettet.'
b'apps/erpnext/erpnext/stock/reorder_item.py +194',b'Auto Material Requests Generated',b'Auto Materiell Foresp\xc3\xb8rsler Generert'
b'apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js +7',b'Lost',b'Mistet'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +152',"b""You can not enter current voucher in 'Against Journal Entry' column""",b'Du kan ikke legge inn dagens kupong i &quot;Against Journal Entry-kolonnen'
b'apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +50',b'Reserved for manufacturing',b'Reservert for produksjon'
b'DocType: Soil Texture',b'Sand',b'Sand'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +25',b'Energy',b'Energy'
b'DocType: Opportunity',b'Opportunity From',b'Opportunity Fra'
b'apps/erpnext/erpnext/config/hr.py +98',b'Monthly salary statement.',b'M\xc3\xa5nedsl\xc3\xb8nn uttalelse.'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +887',b'Row {0}: {1} Serial numbers required for Item {2}. You have provided {3}.',b'Row {0}: {1} Serienummer som kreves for element {2}. Du har oppgitt {3}.'
b'apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +79',b'Please select a table',b'Vennligst velg en tabell'
b'DocType: BOM',b'Website Specifications',b'Nettstedet Spesifikasjoner'
b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +78',"b""{0} is an invalid email address in 'Recipients'""",b'{0} er en ugyldig e-postadresse i &quot;Mottakere&quot;'
b'DocType: Special Test Items',b'Particulars',b'opplysninger'
b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +24',b'{0}: From {0} of type {1}',b'{0}: Fra {0} av typen {1}'
b'DocType: Warranty Claim',b'CI-',b'CI-'
b'apps/erpnext/erpnext/controllers/buying_controller.py +300',b'Row {0}: Conversion Factor is mandatory',b'Rad {0}: Omregningsfaktor er obligatorisk'
b'DocType: Student',b'A+',b'A +'
b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +344',"b'Multiple Price Rules exists with same criteria, please resolve conflict by assigning priority. Price Rules: {0}'","b'Flere Pris regler eksisterer med samme kriteriene, kan du l\xc3\xb8se konflikten ved \xc3\xa5 prioritere. Pris Regler: {0}'"
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +519',b'Cannot deactivate or cancel BOM as it is linked with other BOMs',b'Kan ikke deaktivere eller kansellere BOM som det er forbundet med andre stykklister'
b'DocType: Asset',b'Maintenance',b'Vedlikehold'
b'DocType: Item Attribute Value',b'Item Attribute Value',b'Sak data Verdi'
b'apps/erpnext/erpnext/projects/doctype/project/project.py +406',b'Please Update your Project Status',b'Vennligst oppdater prosjektstatusen din'
b'DocType: Item',b'Maximum sample quantity that can be retained',b'Maksimal pr\xc3\xb8vemengde som kan beholdes'
b'DocType: Project Update',b'How is the Project Progressing Right Now?',b'Hvordan foreg\xc3\xa5r prosjektet akkurat n\xc3\xa5?'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +418',b'Row {0}# Item {1} cannot be transferred more than {2} against Purchase Order {3}',b'Row {0} # Item {1} kan ikke overf\xc3\xb8res mer enn {2} mot innkj\xc3\xb8psordre {3}'
b'apps/erpnext/erpnext/config/selling.py +158',b'Sales campaigns.',b'Salgskampanjer.'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +117',b'Make Timesheet',b'Gj\xc3\xb8r Timeregistrering'
b'DocType: Sales Taxes and Charges Template',"b'Standard tax template that can be applied to all Sales Transactions. This template can contain list of tax heads and also other expense / income heads like ""Shipping"", ""Insurance"", ""Handling"" etc.\n\n#### Note\n\nThe tax rate you define here will be the standard tax rate for all **Items**. If there are **Items** that have different rates, they must be added in the **Item Tax** table in the **Item** master.\n\n#### Description of Columns\n\n1. Calculation Type: \n    - This can be on **Net Total** (that is the sum of basic amount).\n    - **On Previous Row Total / Amount** (for cumulative taxes or charges). If you select this option, the tax will be applied as a percentage of the previous row (in the tax table) amount or total.\n    - **Actual** (as mentioned).\n2. Account Head: The Account ledger under which this tax will be booked\n3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.\n4. Description: Description of the tax (that will be printed in invoices / quotes).\n5. Rate: Tax rate.\n6. Amount: Tax amount.\n7. Total: Cumulative total to this point.\n8. Enter Row: If based on ""Previous Row Total"" you can select the row number which will be taken as a base for this calculation (default is the previous row).\n9. Is this Tax included in Basic Rate?: If you check this, it means that this tax will not be shown below the item table, but will be included in the Basic Rate in your main item table. This is useful where you want give a flat price (inclusive of all taxes) price to customers.'","b'Standard skatt mal som kan brukes p\xc3\xa5 alle salgstransaksjoner. Denne malen kan inneholde liste over skatte hoder og ogs\xc3\xa5 andre utgifter / inntekter hoder som &quot;Shipping&quot;, &quot;Forsikring&quot;, &quot;H\xc3\xa5ndtering&quot; osv #### Note Skattesatsen du definerer her vil v\xc3\xa6re standard skattesats for alle ** Elementer **. Hvis det er ** Elementer ** som har forskjellige priser, m\xc3\xa5 de legges i ** Sak Skatt ** bord i ** Sak ** mester. #### Beskrivelse av kolonner 1. Beregning Type: - Dette kan v\xc3\xa6re p\xc3\xa5 ** Net Total ** (som er summen av grunnbel\xc3\xb8pet). - ** P\xc3\xa5 Forrige Row Total / Bel\xc3\xb8p ** (for kumulative skatter eller avgifter). Hvis du velger dette alternativet, vil skatten bli brukt som en prosentandel av forrige rad (i skattetabellen) eller en total. - ** Faktisk ** (som nevnt). 2. Account Head: Konto hovedbok der denne skatten vil bli bokf\xc3\xb8rt 3. Cost Center: Hvis skatt / avgift er en inntekt (som frakt) eller utgifter det m\xc3\xa5 bestilles mot et kostnadssted. 4. Beskrivelse: Beskrivelse av skatt (som vil bli skrevet ut i fakturaer / sitater). 5. Ranger: skattesats. 6. Bel\xc3\xb8p: Skatt bel\xc3\xb8p. 7. Totalt: Akkumulert total til dette punktet. 8. Angi Row: Dersom basert p\xc3\xa5 &quot;Forrige Row Total&quot; du kan velge radnummeret som vil bli tatt som en base for denne beregningen (standard er den forrige rad). 9. Er dette inklusiv i Basic Rate ?: Hvis du sjekke dette, betyr det at denne avgiften ikke vil bli vist under elementet bordet, men vil inng\xc3\xa5 i grunnbel\xc3\xb8pet i din viktigste elementet tabellen. Dette er nyttig n\xc3\xa5r du vil gi en flat pris (inklusive alle avgifter) pris til kundene.'"
b'DocType: Employee',b'Bank A/C No.',b'Bank A / C No.'
b'DocType: Bank Guarantee',b'Project',b'Prosjekt'
b'DocType: Quality Inspection Reading',b'Reading 7',b'Reading 7'
b'apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js +9',b'Partially Ordered',b'delvis Bestilt'
b'DocType: Lab Test',b'Lab Test',b'Lab Test'
b'DocType: Student Report Generation Tool',b'Student Report Generation Tool',b'Generasjonsverkt\xc3\xb8y for Student Report'
b'DocType: Expense Claim Detail',b'Expense Claim Type',b'Expense krav Type'
b'DocType: Shopping Cart Settings',b'Default settings for Shopping Cart',b'Standardinnstillingene for handlekurv'
b'apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +27',b'Add Timeslots',b'Legg til Timeslots'
b'apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +138',b'Asset scrapped via Journal Entry {0}',b'Asset kasserte via bilagsregistrering {0}'
b'DocType: Employee Loan',b'Interest Income Account',b'Renteinntekter konto'
b'apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.py +58',b'Review Invitation Sent',b'Gjennomg\xc3\xa5 invitasjon sendt'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +13',b'Biotechnology',b'Bioteknologi'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +109',b'Office Maintenance Expenses',b'Kontor Vedlikehold Utgifter'
b'apps/erpnext/erpnext/utilities/user_progress.py +54',b'Go to ',b'G\xc3\xa5 til'
b'apps/erpnext/erpnext/config/learn.py +47',b'Setting up Email Account',b'Sette opp e-postkonto'
b'apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js +21',b'Please enter Item first',b'Skriv inn Sak f\xc3\xb8rst'
b'DocType: Asset Repair',b'Downtime',b'nedetid'
b'DocType: Account',b'Liability',b'Ansvar'
b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +220',b'Sanctioned Amount cannot be greater than Claim Amount in Row {0}.',b'Sanksjonert Bel\xc3\xb8pet kan ikke v\xc3\xa6re st\xc3\xb8rre enn krav Bel\xc3\xb8p i Rad {0}.'
b'apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +11',b'Academic Term: ',b'Faglig semester:'
b'DocType: Salary Detail',b'Do not include in total',b'Ikke inkluder i alt'
b'apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +206',b'Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series',b'Vennligst still inn navngivningsserien for {0} via Setup&gt; Settings&gt; Naming Series'
b'DocType: Company',b'Default Cost of Goods Sold Account',b'Standard varekostnader konto'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1019',b'Sample quantity {0} cannot be more than received quantity {1}',b'Pr\xc3\xb8vekvantitet {0} kan ikke v\xc3\xa6re mer enn mottatt mengde {1}'
b'apps/erpnext/erpnext/stock/get_item_details.py +369',b'Price List not selected',b'Prisliste ikke valgt'
b'DocType: Employee',b'Family Background',b'Familiebakgrunn'
b'DocType: Request for Quotation Supplier',b'Send Email',b'Send E-Post'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +228',b'Warning: Invalid Attachment {0}',b'Advarsel: Ugyldig Vedlegg {0}'
b'DocType: Item',b'Max Sample Quantity',b'Maks antall pr\xc3\xb8ver'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +766',b'No Permission',b'Ingen tillatelse'
b'DocType: Vital Signs',b'Heart Rate / Pulse',b'Hjertefrekvens / puls'
b'DocType: Company',b'Default Bank Account',b'Standard Bank Account'
b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +59',"b'To filter based on Party, select Party Type first'","b'Hvis du vil filtrere basert p\xc3\xa5 partiet, velger partiet Skriv inn f\xc3\xb8rst'"
b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +48',"b""'Update Stock' can not be checked because items are not delivered via {0}""",b'&#39;Oppdater Stock&#39; kan ikke kontrolleres fordi elementene ikke er levert via {0}'
b'DocType: Vehicle',b'Acquisition Date',b'Innkj\xc3\xb8psdato'
b'apps/erpnext/erpnext/utilities/user_progress.py +146',b'Nos',b'Nos'
b'DocType: Item',b'Items with higher weightage will be shown higher',b'Elementer med h\xc3\xb8yere weightage vil bli vist h\xc3\xb8yere'
b'apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +14',b'Lab Tests and Vital Signs',b'Lab Tests og Vital Signs'
b'DocType: Bank Reconciliation Detail',b'Bank Reconciliation Detail',b'Bankavstemming Detalj'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +614',b'Row #{0}: Asset {1} must be submitted',b'Row # {0}: Asset {1} m\xc3\xa5 fremlegges'
b'apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +40',b'No employee found',b'Ingen ansatte funnet'
b'DocType: Subscription',b'Stopped',b'Stoppet'
b'DocType: Item',b'If subcontracted to a vendor',b'Dersom underleverand\xc3\xb8r til en leverand\xc3\xb8r'
b'apps/erpnext/erpnext/education/doctype/student_group/student_group.js +111',b'Student Group is already updated.',b'Studentgruppen er allerede oppdatert.'
b'apps/erpnext/erpnext/education/doctype/student_group/student_group.js +111',b'Student Group is already updated.',b'Studentgruppen er allerede oppdatert.'
b'apps/erpnext/erpnext/config/projects.py +18',b'Project Update.',b'Prosjektoppdatering.'
b'DocType: SMS Center',b'All Customer Contact',b'All Kundekontakt'
b'DocType: Land Unit',b'Tree Details',b'Tree Informasjon'
b'DocType: Training Event',b'Event Status',b'Hendelses Status'
b'DocType: Volunteer',b'Availability Timeslot',b'Tilgjengelighet Timeslot'
,b'Support Analytics',b'St\xc3\xb8tte Analytics'
b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +365',"b'If you have any questions, please get back to us.'","b'Hvis du har sp\xc3\xb8rsm\xc3\xa5l, kan du komme tilbake til oss.'"
b'DocType: Cash Flow Mapper',b'Cash Flow Mapper',b'Cash Flow Mapper'
b'DocType: Item',b'Website Warehouse',b'Nettsted Warehouse'
b'DocType: Payment Reconciliation',b'Minimum Invoice Amount',b'Minimum Fakturert bel\xc3\xb8p'
b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +111',b'{0} {1}: Cost Center {2} does not belong to Company {3}',b'{0} {1}: Kostnadssted {2} ikke tilh\xc3\xb8rer selskapet {3}'
b'apps/erpnext/erpnext/utilities/user_progress.py +92',b'Upload your letter head (Keep it web friendly as 900px by 100px)',b'Last opp brevhodet ditt (Hold det nettvennlig som 900px ved 100px)'
b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +88',b'{0} {1}: Account {2} cannot be a Group',b'{0} {1}: Account {2} kan ikke v\xc3\xa6re en gruppe'
b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +63',"b""Item Row {idx}: {doctype} {docname} does not exist in above '{doctype}' table""",b'Sak Row {idx}: {doctype} {DOCNAME} finnes ikke i oven {doctype} tabellen'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +295',b'Timesheet {0} is already completed or cancelled',b'Timeregistrering {0} er allerede gjennomf\xc3\xb8rt eller kansellert'
b'apps/erpnext/erpnext/templates/pages/projects.html +42',b'No tasks',b'ingen oppgaver'
b'DocType: Item Variant Settings',b'Copy Fields to Variant',b'Kopier felt til variant'
b'DocType: Asset',b'Opening Accumulated Depreciation',b'\xc3\x85pning akkumulerte avskrivninger'
b'apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.js +49',b'Score must be less than or equal to 5',b'Score m\xc3\xa5 v\xc3\xa6re mindre enn eller lik 5'
b'DocType: Program Enrollment Tool',b'Program Enrollment Tool',b'Program P\xc3\xa5melding Tool'
b'apps/erpnext/erpnext/config/accounts.py +335',b'C-Form records',b'C-Form poster'
b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +73',b'The shares already exist',b'Aksjene eksisterer allerede'
b'apps/erpnext/erpnext/config/selling.py +316',b'Customer and Supplier',b'Kunde og leverand\xc3\xb8r'
b'DocType: Email Digest',b'Email Digest Settings',b'E-post Digest Innstillinger'
b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +367',b'Thank you for your business!',b'Takk for handelen!'
b'apps/erpnext/erpnext/config/support.py +12',b'Support queries from customers.',b'St\xc3\xb8tte henvendelser fra kunder.'
b'DocType: Setup Progress Action',b'Action Doctype',b'Handling Doctype'
b'DocType: HR Settings',b'Retirement Age',b'Pensjonsalder'
b'DocType: Bin',b'Moving Average Rate',b'Moving Gjennomsnittlig pris'
b'DocType: Production Plan',b'Select Items',b'Velg Items'
b'DocType: Share Transfer',b'To Shareholder',b'Til Aksjon\xc3\xa6r'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +372',b'{0} against Bill {1} dated {2}',b'{0} mot Bill {1} datert {2}'
b'apps/erpnext/erpnext/utilities/user_progress.py +27',b'Setup Institution',b'Oppsettinstitusjon'
b'DocType: Program Enrollment',b'Vehicle/Bus Number',b'Kj\xc3\xb8ret\xc3\xb8y / bussnummer'
b'apps/erpnext/erpnext/education/doctype/course/course.js +17',b'Course Schedule',b'Kursplan'
b'DocType: Request for Quotation Supplier',b'Quote Status',b'Sitatstatus'
b'DocType: GoCardless Settings',b'Webhooks Secret',b'Webhooks Secret'
b'DocType: Maintenance Visit',b'Completion Status',b'Completion Status'
b'DocType: Daily Work Summary Group',b'Select Users',b'Velg Brukere'
b'DocType: Hotel Room Pricing Item',b'Hotel Room Pricing Item',b'Hotellromprisepris'
b'DocType: HR Settings',b'Enter retirement age in years',b'Skriv inn pensjonsalder i \xc3\xa5r'
b'DocType: Crop',b'Target Warehouse',b'Target Warehouse'
b'DocType: Payroll Employee Detail',b'Payroll Employee Detail',b'L\xc3\xb8nnspersonelldetaljer'
b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +128',b'Please select a warehouse',b'Vennligst velg et lager'
b'DocType: Cheque Print Template',b'Starting location from left edge',b'Starter plassering fra venstre kant'
b'DocType: Item',b'Allow over delivery or receipt upto this percent',b'Tillat l\xc3\xb8pet levering eller mottak opp denne prosent'
b'DocType: Stock Entry',b'STE-',b'an- drogene'
b'DocType: Upload Attendance',b'Import Attendance',b'Import Oppm\xc3\xb8te'
b'apps/erpnext/erpnext/public/js/pos/pos.html +124',b'All Item Groups',b'Alle varegrupper'
b'apps/erpnext/erpnext/config/setup.py +89',b'Automatically compose message on submission of transactions.',b'Skriv melding automatisk ved innlevering av transaksjoner.'
b'DocType: Work Order',b'Item To Manufacture',b'Element for \xc3\xa5 produsere'
b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +44',b'CompteLib',b'CompteLib'
b'apps/erpnext/erpnext/buying/utils.py +80',b'{0} {1} status is {2}',b'{0} {1} status er {2}'
b'DocType: Water Analysis',b'Collection Temperature ',b'Samlingstemperatur'
b'DocType: Employee',b'Provide Email Address registered in company',b'Gi e-postadresse som er registrert i selskapets'
b'DocType: Shopping Cart Settings',b'Enable Checkout',b'aktiver kassen'
b'apps/erpnext/erpnext/config/learn.py +202',b'Purchase Order to Payment',b'Bestilling til betaling'
b'apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +48',b'Projected Qty',b'Ansl\xc3\xa5tt Antall'
b'DocType: Sales Invoice',b'Payment Due Date',b'Betalingsfrist'
b'DocType: Drug Prescription',b'Interval UOM',b'Intervall UOM'
b'DocType: Customer',"b'Reselect, if the chosen address is edited after save'",b'Velg hvis den valgte adressen redigeres etter lagre'
b'apps/erpnext/erpnext/stock/doctype/item/item.js +522',b'Item Variant {0} already exists with same attributes',b'Sak Variant {0} finnes allerede med samme attributtene'
b'DocType: Item',b'Hub Publishing Details',b'Hub Publishing Detaljer'
b'apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +117',"b""'Opening'""",b'&quot;Opening&quot;'
b'apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +130',b'Open To Do',b'\xc3\x85pne for \xc3\xa5 gj\xc3\xb8re'
b'DocType: Notification Control',b'Delivery Note Message',b'Levering Note Message'
b'DocType: Lab Test Template',b'Result Format',b'Resultatformat'
b'DocType: Expense Claim',b'Expenses',b'Utgifter'
b'DocType: Item Variant Attribute',b'Item Variant Attribute',b'Sak Variant Egenskap'
,b'Purchase Receipt Trends',b'Kvitteringen Trender'
b'DocType: Payroll Entry',b'Bimonthly',b'annenhver m\xc3\xa5ned'
b'DocType: Vehicle Service',b'Brake Pad',b'Bremsekloss'
b'DocType: Fertilizer',b'Fertilizer Contents',b'Innhold av gj\xc3\xb8dsel'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +119',b'Research & Development',b'Forskning Og Utvikling'
b'apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py +20',b'Amount to Bill',b'Bel\xc3\xb8p til Bill'
b'DocType: Company',b'Registration Details',b'Registrering Detaljer'
b'DocType: Timesheet',b'Total Billed Amount',b'Total Fakturert bel\xc3\xb8p'
b'DocType: Item Reorder',b'Re-Order Qty',b'Re-Order Antall'
b'DocType: Leave Block List Date',b'Leave Block List Date',b'La Block List Dato'
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +94',b'BOM #{0}: Raw material cannot be same as main Item',b'BOM # {0}: R\xc3\xa5materiale kan ikke v\xc3\xa6re det samme som hovedelementet'
b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +92',b'Total Applicable Charges in Purchase Receipt Items table must be same as Total Taxes and Charges',b'Totalt gjeldende avgifter i kvitteringen Elementer tabellen m\xc3\xa5 v\xc3\xa6re det samme som total skatter og avgifter'
b'DocType: Sales Team',b'Incentives',b'Motivasjon'
b'DocType: SMS Log',b'Requested Numbers',b'Ettersp\xc3\xb8r Numbers'
b'DocType: Volunteer',b'Evening',b'Kveld'
b'DocType: Customer',b'Bypass credit limit check at Sales Order',b'Bypass kredittgrense sjekke p\xc3\xa5 salgsordre'
b'apps/erpnext/erpnext/config/hr.py +147',b'Performance appraisal.',b'Medarbeidersamtaler.'
b'apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +100',"b""Enabling 'Use for Shopping Cart', as Shopping Cart is enabled and there should be at least one Tax Rule for Shopping Cart""","b'Aktivering av \xc2\xabBruk for handlekurven&quot;, som Handlevogn er aktivert, og det b\xc3\xb8r v\xc3\xa6re minst en skatteregel for Handlekurv'"
b'apps/erpnext/erpnext/controllers/accounts_controller.py +412',"b'Payment Entry {0} is linked against Order {1}, check if it should be pulled as advance in this invoice.'","b'Betaling Entry {0} er knyttet mot Bestill {1}, sjekk om det b\xc3\xb8r trekkes som forskudd i denne fakturaen.'"
b'DocType: Sales Invoice Item',b'Stock Details',b'Stock Detaljer'
b'apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +29',b'Project Value',b'Prosjektet Verdi'
b'apps/erpnext/erpnext/config/selling.py +326',b'Point-of-Sale',b'Utsalgssted'
b'DocType: Fee Schedule',b'Fee Creation Status',b'Fee Creation Status'
b'DocType: Vehicle Log',b'Odometer Reading',b'Kilometerteller Reading'
b'apps/erpnext/erpnext/accounts/doctype/account/account.py +116',"b""Account balance already in Credit, you are not allowed to set 'Balance Must Be' as 'Debit'""","b'Saldo allerede i Credit, har du ikke lov til \xc3\xa5 sette &quot;Balance m\xc3\xa5 v\xc3\xa6re &#39;som&#39; debet &#39;'"
b'DocType: Account',b'Balance must be',b'Balansen m\xc3\xa5 v\xc3\xa6re'
b'DocType: Hub Settings',b'Publish Pricing',b'Publiser Priser'
b'DocType: Notification Control',b'Expense Claim Rejected Message',b'Expense krav Avvist Message'
,b'Available Qty',b'Tilgjengelig Antall'
b'DocType: Purchase Taxes and Charges',b'On Previous Row Total',b'P\xc3\xa5 Forrige Row Total'
b'DocType: Purchase Invoice Item',b'Rejected Qty',b'avvist Antall'
b'DocType: Setup Progress Action',b'Action Field',b'Handlingsfelt'
b'DocType: Healthcare Settings',b'Manage Customer',b'Administrer kunde'
b'DocType: Delivery Trip',b'Delivery Stops',b'Levering stopper'
b'DocType: Salary Slip',b'Working Days',b'Arbeidsdager'
b'DocType: Serial No',b'Incoming Rate',b'Innkommende Rate'
b'DocType: Packing Slip',b'Gross Weight',b'Bruttovekt'
,b'Final Assessment Grades',b'Final Assessment Grades'
b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +47',b'Enable Hub',b'Aktiver nav'
b'apps/erpnext/erpnext/public/js/setup_wizard.js +110',b'The name of your company for which you are setting up this system.',b'Navnet p\xc3\xa5 firmaet som du setter opp dette systemet.'
b'DocType: HR Settings',b'Include holidays in Total no. of Working Days',b'Inkluder ferier i Total no. arbeidsdager'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/sample_data.py +108',b'Setup your Institute in ERPNext',b'Oppsett ditt institutt i ERPNext'
b'DocType: Agriculture Analysis Criteria',b'Plant Analysis',b'Plantanalyse'
b'DocType: Job Applicant',b'Hold',b'Hold'
b'DocType: Project Update',b'Progress Details',b'Fremdriftsdetaljer'
b'DocType: Employee',b'Date of Joining',b'Dato for Delta'
b'DocType: Naming Series',b'Update Series',b'Update-serien'
b'DocType: Supplier Quotation',b'Is Subcontracted',b'Er underleverand\xc3\xb8r'
b'DocType: Restaurant Table',b'Minimum Seating',b'Minimum sitteplasser'
b'DocType: Item Attribute',b'Item Attribute Values',b'Sak attributtverdier'
b'DocType: Examination Result',b'Examination Result',b'Sensur'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +845',b'Purchase Receipt',b'Kvitteringen'
,b'Received Items To Be Billed',b'Mottatte elementer \xc3\xa5 bli fakturert'
b'apps/erpnext/erpnext/config/accounts.py +303',b'Currency exchange rate master.',b'Valutakursen mester.'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +209',b'Reference Doctype must be one of {0}',b'Referanse DOCTYPE m\xc3\xa5 v\xc3\xa6re en av {0}'
b'apps/erpnext/erpnext/stock/report/warehouse_wise_item_balance_age_and_value/warehouse_wise_item_balance_age_and_value.js +46',b'Filter Total Zero Qty',b'Filter totalt null antall'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +341',b'Unable to find Time Slot in the next {0} days for Operation {1}',b'\xc3\x85 finne tidsluke i de neste {0} dager for Operation klarer {1}'
b'DocType: Work Order',b'Plan material for sub-assemblies',b'Plan materiale for sub-assemblies'
b'apps/erpnext/erpnext/config/selling.py +97',b'Sales Partners and Territory',b'Salgs Partnere og Territory'
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +600',b'BOM {0} must be active',b'BOM {0} m\xc3\xa5 v\xc3\xa6re aktiv'
b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +414',b'No Items available for transfer',b'Ingen elementer tilgjengelig for overf\xc3\xb8ring'
b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +218',b'Closing (Opening + Total)',b'Avslutning (\xc3\x85pning + Totalt)'
b'DocType: Journal Entry',b'Depreciation Entry',b'avskrivninger Entry'
b'apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +32',b'Please select the document type first',b'Velg dokumenttypen f\xc3\xb8rst'
b'apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py +65',b'Cancel Material Visits {0} before cancelling this Maintenance Visit',b'Avbryt Material Bes\xc3\xb8k {0} f\xc3\xb8r den sletter denne Maintenance Visit'
b'DocType: Crop Cycle',b'ISO 8016 standard',b'ISO 8016 standard'
b'DocType: Pricing Rule',b'Rate or Discount',b'Pris eller rabatt'
b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +213',b'Serial No {0} does not belong to Item {1}',b'Serial No {0} tilh\xc3\xb8rer ikke Element {1}'
b'DocType: Purchase Receipt Item Supplied',b'Required Qty',b'P\xc3\xa5krevd antall'
b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +126',b'Warehouses with existing transaction can not be converted to ledger.',b'N\xc3\xa6ringslokaler med eksisterende transaksjon kan ikke konverteres til hovedbok.'
b'DocType: Bank Reconciliation',b'Total Amount',b'Totalbel\xc3\xb8p'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +32',b'Internet Publishing',b'Internett Publisering'
b'DocType: Prescription Duration',b'Number',b'Antall'
b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +25',b'Creating {0} Invoice',b'Opprette {0} faktura'
b'DocType: Medical Code',b'Medical Code Standard',b'Medisinskode Standard'
b'DocType: Soil Texture',b'Clay Composition (%)',b'Leirekomposisjon (%)'
b'apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js +81',b'Please save before assigning task.',b'Vennligst lagre f\xc3\xb8r du tilordner oppgaven.'
b'apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +74',b'Balance Value',b'Balanse Verdi'
b'DocType: Lab Test',b'Lab Technician',b'Lab tekniker'
b'apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +38',b'Sales Price List',b'Salg Prisliste'
b'DocType: Healthcare Settings',"b'If checked, a customer will be created, mapped to Patient.\nPatient Invoices will be created against this Customer. You can also select existing Customer while creating Patient.'","b'Hvis det er merket, vil en kunde bli opprettet, kartlagt til Pasient. Pasientfakturaer vil bli opprettet mot denne kunden. Du kan ogs\xc3\xa5 velge eksisterende kunde mens du oppretter pasient.'"
b'DocType: Bank Reconciliation',b'Account Currency',b'Account Valuta'
b'DocType: Lab Test',b'Sample ID',b'Eksempel ID'
b'apps/erpnext/erpnext/accounts/general_ledger.py +167',b'Please mention Round Off Account in Company',b'Vennligst oppgi Round Off-konto i selskapet'
b'DocType: Purchase Receipt',b'Range',b'Omr\xc3\xa5de'
b'DocType: Supplier',b'Default Payable Accounts',b'Standard Leverand\xc3\xb8rgjeld'
b'apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +49',b'Employee {0} is not active or does not exist',b'Ansatt {0} er ikke aktiv eller ikke eksisterer'
b'DocType: Fee Structure',b'Components',b'komponenter'
b'DocType: Item Barcode',b'Item Barcode',b'Sak Barcode'
b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +329',b'Please enter Asset Category in Item {0}',b'Fyll inn Asset kategori i Element {0}'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +661',b'Item Variants {0} updated',b'Sak Varianter {0} oppdatert'
b'DocType: Quality Inspection Reading',b'Reading 6',b'Reading 6'
b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +9',"b'to be generated. If delayed, you will have to manually change the ""Repeat on Day of Month"" field\nof this'","b'\xc3\xa5 bli generert. Hvis forsinket, m\xc3\xa5 du manuelt endre feltet Repeter p\xc3\xa5 dag i m\xc3\xa5neden av dette'"
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +961',b'Cannot {0} {1} {2} without any negative outstanding invoice',b'Kan ikke {0} {1} {2} uten noen negativ utest\xc3\xa5ende faktura'
b'DocType: Share Transfer',b'From Folio No',b'Fra Folio nr'
b'DocType: Purchase Invoice Advance',b'Purchase Invoice Advance',b'Fakturaen Advance'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +199',b'Row {0}: Credit entry can not be linked with a {1}',b'Rad {0}: Credit oppf\xc3\xb8ring kan ikke v\xc3\xa6re knyttet til en {1}'
b'apps/erpnext/erpnext/config/accounts.py +246',b'Define budget for a financial year.',b'Definer budsjett for et regnskaps\xc3\xa5r.'
b'DocType: Lead',b'LEAD-',b'LEDE-'
b'DocType: Employee',b'Permanent Address Is',b'Permanent Adresse Er'
b'DocType: Work Order Operation',b'Operation completed for how many finished goods?',b'Operasjonen gjennomf\xc3\xb8rt for hvor mange ferdigvarer?'
b'DocType: Payment Terms Template',b'Payment Terms Template',b'Betalingsbetingelser mal'
b'apps/erpnext/erpnext/public/js/setup_wizard.js +51',b'The Brand',b'The Brand'
b'DocType: Employee',b'Exit Interview Details',b'Exit Intervju Detaljer'
b'DocType: Item',b'Is Purchase Item',b'Er Purchase Element'
b'DocType: Journal Entry Account',b'Purchase Invoice',b'Fakturaen'
b'DocType: Stock Ledger Entry',b'Voucher Detail No',b'Kupong Detail Ingen'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +789',b'New Sales Invoice',b'Ny salgsfaktura'
b'DocType: Stock Entry',b'Total Outgoing Value',b'Total Utg\xc3\xa5ende verdi'
b'DocType: Physician',b'Appointments',b'avtaler'
b'apps/erpnext/erpnext/public/js/account_tree_grid.js +223',b'Opening Date and Closing Date should be within same Fiscal Year',b'\xc3\x85pningsdato og sluttdato skal v\xc3\xa6re innenfor samme regnskaps\xc3\xa5r'
b'DocType: Lead',b'Request for Information',b'Sp\xc3\xb8r etter informasjon'
,b'LeaderBoard',b'Leaderboard'
b'DocType: Sales Invoice Item',b'Rate With Margin (Company Currency)',b'Vurder med margin (Bedriftsvaluta)'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +802',b'Sync Offline Invoices',b'Synkroniser Offline Fakturaer'
b'DocType: Payment Request',b'Paid',b'Betalt'
b'DocType: Program Fee',b'Program Fee',b'program Fee'
b'DocType: BOM Update Tool',"b'Replace a particular BOM in all other BOMs where it is used. It will replace the old BOM link, update cost and regenerate ""BOM Explosion Item"" table as per new BOM.\nIt also updates latest price in all the BOMs.'","b'Bytt ut en bestemt BOM i alle andre BOM-er der den brukes. Det vil erstatte den gamle BOM-lenken, oppdatere kostnadene og regenerere &quot;BOM Explosion Item&quot; -tabellen som per ny BOM. Det oppdaterer ogs\xc3\xa5 siste pris i alle BOMene.'"
b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +447',b'The following Work Orders were created:',b'F\xc3\xb8lgende arbeidsordrer ble opprettet:'
b'DocType: Salary Slip',b'Total in words',b'Totalt i ord'
b'DocType: Material Request Item',b'Lead Time Date',b'Lead Tid Dato'
,b'Employee Advance Summary',b'Ansattsperspektiv'
b'DocType: Asset',b'Available-for-use Date',b'Tilgjengelig dato for bruk'
b'DocType: Guardian',b'Guardian Name',b'Guardian navn'
b'DocType: Cheque Print Template',b'Has Print Format',b'Har Print Format'
b'DocType: Employee Loan',b'Sanctioned',b'sanksjonert'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +75',b' is mandatory. Maybe Currency Exchange record is not created for ',b'er obligatorisk. Kanskje Valutaveksling posten ikke er skapt for'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +139',b'Row #{0}: Please specify Serial No for Item {1}',b'Row # {0}: Vennligst oppgi serienummer for varen {1}'
b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +54',b'Supplier &gt; Supplier Type',b'Leverand\xc3\xb8r&gt; Leverand\xc3\xb8r Type'
b'DocType: Crop Cycle',b'Crop Cycle',b'Beskj\xc3\xa6ringssyklus'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +633',"b""For 'Product Bundle' items, Warehouse, Serial No and Batch No will be considered from the 'Packing List' table. If Warehouse and Batch No are same for all packing items for any 'Product Bundle' item, those values can be entered in the main Item table, values will be copied to 'Packing List' table.""","b'For &#39;Produkt Bundle&#39; elementer, Warehouse, serienummer og Batch Ingen vil bli vurdert fra &quot;Pakkeliste&quot; bord. Hvis Warehouse og Batch Ingen er lik for alle pakking elementer for noen &quot;Product Bundle &#39;elementet, kan disse verdiene legges inn i hoved Sak bordet, vil verdiene bli kopiert til&quot; Pakkeliste &quot;bord.'"
b'DocType: Student Admission',b'Publish on website',b'Publiser p\xc3\xa5 nettstedet'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +651',b'Supplier Invoice Date cannot be greater than Posting Date',b'Leverand\xc3\xb8r Fakturadato kan ikke v\xc3\xa6re st\xc3\xb8rre enn konteringsdato'
b'DocType: Purchase Invoice Item',b'Purchase Order Item',b'Innkj\xc3\xb8psordre Element'
b'DocType: Agriculture Task',b'Agriculture Task',b'Landbruk Oppgave'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +132',b'Indirect Income',b'Indirekte inntekt'
b'DocType: Student Attendance Tool',b'Student Attendance Tool',b'Student Oppm\xc3\xb8te Tool'
b'DocType: Restaurant Menu',b'Price List (Auto created)',b'Prisliste (automatisk opprettet)'
b'DocType: Cheque Print Template',b'Date Settings',b'Dato Innstillinger'
b'apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +48',b'Variance',b'Varians'
,b'Company Name',b'Selskapsnavn'
b'DocType: SMS Center',b'Total Message(s)',b'Total melding (er)'
b'DocType: Share Balance',b'Purchased',b'kj\xc3\xb8pt'
b'DocType: Item Variant Settings',b'Rename Attribute Value in Item Attribute.',b'Endre navn p\xc3\xa5 Attribute Value i Item Attribute.'
b'DocType: Purchase Invoice',b'Additional Discount Percentage',b'Ekstra rabatt Prosent'
b'apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +24',b'View a list of all the help videos',b'Vis en liste over alle hjelpevideoer'
b'DocType: Agriculture Analysis Criteria',b'Soil Texture',b'Jordstruktur'
b'DocType: Bank Reconciliation',b'Select account head of the bank where cheque was deposited.',b'Velg kontoen leder av banken der sjekken ble avsatt.'
b'DocType: Selling Settings',b'Allow user to edit Price List Rate in transactions',b'Tillater brukeren \xc3\xa5 redigere Prisliste Rate i transaksjoner'
b'DocType: Pricing Rule',b'Max Qty',b'Max Antall'
b'apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.js +25',b'Print Report Card',b'Skriv ut rapportkort'
b'apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +30',"b'Row {0}: Invoice {1} is invalid, it might be cancelled / does not exist. \\\n\t\t\t\t\t\tPlease enter a valid Invoice'","b'Rad {0}: Faktura {1} er ugyldig, kan det bli kansellert / finnes ikke. \\ Vennligst skriv inn en gyldig faktura'"
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +132',b'Row {0}: Payment against Sales/Purchase Order should always be marked as advance',b'Rad {0}: Betaling mot Salg / innkj\xc3\xb8psordre skal alltid merkes som forskudd'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +16',b'Chemical',b'Kjemisk'
b'DocType: Salary Component Account',b'Default Bank / Cash account will be automatically updated in Salary Journal Entry when this mode is selected.',b'Standard Bank / minibank konto vil bli automatisk oppdatert i L\xc3\xb8nn bilagsregistrering n\xc3\xa5r denne modusen er valgt.'
b'DocType: BOM',b'Raw Material Cost(Company Currency)',b'Raw Material Cost (Selskap Valuta)'
b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +88',b'Row # {0}: Rate cannot be greater than the rate used in {1} {2}',b'Row # {0}: Prisen kan ikke v\xc3\xa6re st\xc3\xb8rre enn frekvensen som brukes i {1} {2}'
b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +88',b'Row # {0}: Rate cannot be greater than the rate used in {1} {2}',b'Row # {0}: Prisen kan ikke v\xc3\xa6re st\xc3\xb8rre enn frekvensen som brukes i {1} {2}'
b'apps/erpnext/erpnext/utilities/user_progress.py +147',b'Meter',b'M\xc3\xa5ler'
b'DocType: Workstation',b'Electricity Cost',b'Elektrisitet Cost'
b'apps/erpnext/erpnext/agriculture/doctype/water_analysis/water_analysis.py +23',b'Lab testing datetime cannot be before collection datetime',b'Labtesting datetime kan ikke v\xc3\xa6re f\xc3\xb8r datetime samling'
b'DocType: HR Settings',"b""Don't send Employee Birthday Reminders""",b'Ikke send Employee bursdagsp\xc3\xa5minnelser'
b'DocType: Expense Claim',b'Total Advance Amount',b'Total forh\xc3\xa5ndsbel\xc3\xb8p'
b'DocType: Delivery Stop',b'Estimated Arrival',b'forventet ankomst'
b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +34',b'Save Settings',b'Lagre innstillinger'
b'DocType: Delivery Stop',b'Notified by Email',b'Meldes via e-post'
b'DocType: Item',b'Inspection Criteria',b'Inspeksjon Kriterier'
b'apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js +14',b'Transfered',b'Overf\xc3\xb8rt'
b'DocType: BOM Website Item',b'BOM Website Item',b'BOM Nettstedet Element'
b'apps/erpnext/erpnext/public/js/setup_wizard.js +52',b'Upload your letter head and logo. (you can edit them later).',b'Last opp din brevhode og logo. (Du kan redigere dem senere).'
b'DocType: Timesheet Detail',b'Bill',b'Regning'
b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +88',b'Next Depreciation Date is entered as past date',b'Neste avskrivningsdato legges inn som siste dato'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +208',b'White',b'Hvit'
b'DocType: SMS Center',b'All Lead (Open)',b'All Lead (Open)'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +270',b'Row {0}: Qty not available for {4} in warehouse {1} at posting time of the entry ({2} {3})',b'Rad {0}: Antall ikke tilgjengelig for {4} i lageret {1} ved \xc3\xa5 legge tidspunktet for innreise ({2} {3})'
b'apps/erpnext/erpnext/accounts/doctype/cash_flow_mapping/cash_flow_mapping.py +18',b'You can only select a maximum of one option from the list of check boxes.',b'Du kan bare velge maksimalt ett alternativ fra listen med avmerkingsbokser.'
b'DocType: Purchase Invoice',b'Get Advances Paid',b'F\xc3\xa5 utbetalt forskudd'
b'DocType: Item',b'Automatically Create New Batch',b'Opprett automatisk ny batch automatisk'
b'DocType: Item',b'Automatically Create New Batch',b'Opprett automatisk ny batch automatisk'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +635',b'Assigning {0} to {1} (row {2})',b'Tilordne {0} til {1} (rad {2})'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +810',b'Make ',b'Gj\xc3\xb8re'
b'DocType: Student Admission',b'Admission Start Date',b'Opptak Startdato'
b'DocType: Journal Entry',b'Total Amount in Words',b'Totalbel\xc3\xb8p i Words'
b'apps/erpnext/erpnext/hr/doctype/employee/employee_tree.js +29',b'New Employee',b'Ny ansatt'
b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +7',"b""There was an error. One probable reason could be that you haven't saved the form. Please contact support@erpnext.com if the problem persists.""",b'Det var en feil. En mulig \xc3\xa5rsak kan v\xc3\xa6re at du ikke har lagret skjemaet. Ta kontakt support@erpnext.com hvis problemet vedvarer.'
b'apps/erpnext/erpnext/templates/pages/cart.html +5',b'My Cart',b'Handlekurv'
b'apps/erpnext/erpnext/controllers/selling_controller.py +130',b'Order Type must be one of {0}',b'Ordretype m\xc3\xa5 v\xc3\xa6re en av {0}'
b'DocType: Lead',b'Next Contact Date',b'Neste Kontakt Dato'
b'apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +36',b'Opening Qty',b'Antall \xc3\xa5pne'
b'DocType: Healthcare Settings',b'Appointment Reminder',b'Avtale p\xc3\xa5minnelse'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +478',b'Please enter Account for Change Amount',b'Vennligst oppgi konto for Change Bel\xc3\xb8p'
b'DocType: Program Enrollment Tool Student',b'Student Batch Name',b'Student Batch Name'
b'DocType: Consultation',b'Doctor',b'Doktor'
b'DocType: Holiday List',b'Holiday List Name',b'Holiday Listenavn'
b'DocType: Repayment Schedule',b'Balance Loan Amount',b'Balanse L\xc3\xa5nebel\xc3\xb8p'
b'apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +14',b'Schedule Course',b'Schedule Course'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +236',b'Stock Options',b'Aksjeopsjoner'
b'DocType: Buying Settings',b'Disable Fetching Last Purchase Details in Purchase Order',b'Deaktiver Henting av siste innkj\xc3\xb8psdetaljer i innkj\xc3\xb8psordre'
b'DocType: Journal Entry Account',b'Expense Claim',b'Expense krav'
b'apps/erpnext/erpnext/assets/doctype/asset/asset.js +267',b'Do you really want to restore this scrapped asset?',b'Har du virkelig \xc3\xb8nsker \xc3\xa5 gjenopprette dette skrotet ressurs?'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +381',b'Qty for {0}',b'Antall for {0}'
b'DocType: Leave Application',b'Leave Application',b'La Application'
b'DocType: Patient',b'Patient Relation',b'Pasientrelasjon'
b'apps/erpnext/erpnext/config/hr.py +80',b'Leave Allocation Tool',b'La Allocation Tool'
b'DocType: Item',b'Hub Category to Publish',b'Hub kategori for publisering'
b'DocType: Leave Block List',b'Leave Block List Dates',b'La Block List Datoer'
b'DocType: Sales Invoice',b'Billing Address GSTIN',b'Faktureringsadresse GSTIN'
b'DocType: Assessment Plan',b'Evaluate',b'Evaluere'
b'DocType: Workstation',b'Net Hour Rate',b'Netto timepris'
b'DocType: Landed Cost Purchase Receipt',b'Landed Cost Purchase Receipt',b'Landed Cost Kj\xc3\xb8pskvittering'
b'DocType: Company',b'Default Terms',b'Standard Terms'
b'DocType: Supplier Scorecard Period',b'Criteria',b'kriterier'
b'DocType: Packing Slip Item',b'Packing Slip Item',b'Pakking Slip Element'
b'DocType: Purchase Invoice',b'Cash/Bank Account',b'Cash / Bank Account'
b'apps/erpnext/erpnext/public/js/queries.js +96',b'Please specify a {0}',b'Vennligst oppgi en {0}'
b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +73',b'Removed items with no change in quantity or value.',b'Fjernet elementer med ingen endring i mengde eller verdi.'
b'DocType: Delivery Note',b'Delivery To',b'Levering \xc3\x85'
b'apps/erpnext/erpnext/stock/doctype/item/item.js +415',b'Variant creation has been queued.',b'Variantskaping har v\xc3\xa6rt i k\xc3\xb8.'
b'apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py +100',b'Work Summary for {0}',b'Arbeidssammendrag for {0}'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +696',b'Attribute table is mandatory',b'Attributt tabellen er obligatorisk'
b'DocType: Production Plan',b'Get Sales Orders',b'F\xc3\xa5 salgsordrer'
b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +68',b'{0} can not be negative',b'{0} kan ikke v\xc3\xa6re negativ'
b'DocType: Training Event',b'Self-Study',b'Selvstudium'
b'apps/erpnext/erpnext/agriculture/doctype/soil_texture/soil_texture.py +27',b'Soil compositions do not add up to 100',b'Jordblandinger legger ikke opp til 100'
b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +558',b'Discount',b'Rabatt'
b'DocType: Membership',b'Membership',b'Medlemskap'
b'DocType: Asset',b'Total Number of Depreciations',b'Totalt antall Avskrivninger'
b'DocType: Sales Invoice Item',b'Rate With Margin',b'Vurder med margin'
b'DocType: Sales Invoice Item',b'Rate With Margin',b'Vurder med margin'
b'DocType: Workstation',b'Wages',b'L\xc3\xb8nn'
b'DocType: Asset Maintenance',b'Maintenance Manager Name',b'Vedlikeholdsansvarlig navn'
b'DocType: Agriculture Task',b'Urgent',b'Haster'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +174',b'Please specify a valid Row ID for row {0} in table {1}',b'Vennligst oppgi en gyldig Row ID for rad {0} i tabellen {1}'
b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py +84',b'Unable to find variable: ',b'Kan ikke finne variabel:'
b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +794',b'Please select a field to edit from numpad',b'Vennligst velg et felt for \xc3\xa5 redigere fra numpad'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +264',b'Cannot be a fixed asset item as Stock Ledger is created.',b'Kan ikke v\xc3\xa6re en fast eiendelsobjekt n\xc3\xa5r lagerboksen er opprettet.'
b'apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +23',b'Go to the Desktop and start using ERPNext',b'G\xc3\xa5 til skrivebordet og begynne \xc3\xa5 bruke ERPNext'
b'DocType: Item',b'Manufacturer',b'Produsent'
b'DocType: Landed Cost Item',b'Purchase Receipt Item',b'Kvitteringen Element'
b'DocType: Purchase Receipt',b'PREC-RET-',b'PREC-RET-'
b'DocType: POS Profile',b'Sales Invoice Payment',b'Salg Faktura Betaling'
b'DocType: Quality Inspection Template',b'Quality Inspection Template Name',b'Kvalitetsinspeksjonsmalnavn'
b'DocType: Project',b'First Email',b'F\xc3\xb8rste e-post'
b'DocType: Production Plan Item',b'Reserved Warehouse in Sales Order / Finished Goods Warehouse',b'Reservert Industribygg i salgsordre / ferdigvarelageret'
b'apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +71',b'Selling Amount',b'Selge Bel\xc3\xb8p'
b'DocType: Repayment Schedule',b'Interest Amount',b'rente~~POS=TRUNC'
b'DocType: Serial No',b'Creation Document No',b'Creation Dokument nr'
b'DocType: Share Transfer',b'Issue',b'Problem'
b'apps/erpnext/erpnext/healthcare/doctype/consultation/consultation_dashboard.py +11',b'Records',b'Records'
b'DocType: Asset',b'Scrapped',b'skrotet'
b'DocType: Purchase Invoice',b'Returns',b'returer'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order_calendar.js +42',b'WIP Warehouse',b'WIP Warehouse'
b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +195',b'Serial No {0} is under maintenance contract upto {1}',b'Serial No {0} er under vedlikeholdskontrakt opp {1}'
b'apps/erpnext/erpnext/config/hr.py +35',b'Recruitment',b'Rekruttering'
b'DocType: Lead',b'Organization Name',b'Organization Name'
b'DocType: Tax Rule',b'Shipping State',b'Shipping State'
,b'Projected Quantity as Source',b'Ansl\xc3\xa5tt Antall som kilde'
b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +61',"b""Item must be added using 'Get Items from Purchase Receipts' button""",b'Elementet m\xc3\xa5 legges til med &quot;Get Elementer fra innkj\xc3\xb8ps Receipts &#39;knappen'
b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +858',b'Delivery Trip',b'Leveringsreise'
b'DocType: Student',b'A-',b'EN-'
b'DocType: Share Transfer',b'Transfer Type',b'Overf\xc3\xb8ringstype'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +117',b'Sales Expenses',b'Salgs Utgifter'
b'DocType: Consultation',b'Diagnosis',b'Diagnose'
b'apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py +18',b'Standard Buying',b'Standard Kj\xc3\xb8pe'
b'DocType: GL Entry',b'Against',b'Against'
b'DocType: Item',b'Default Selling Cost Center',b'Standard Selling kostnadssted'
b'apps/erpnext/erpnext/public/js/pos/pos.html +85',b'Disc',b'Plate'
b'DocType: Sales Partner',b'Implementation Partner',b'Gjennomf\xc3\xb8ring Partner'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +1624',b'ZIP Code',b'Post kode'
b'apps/erpnext/erpnext/controllers/selling_controller.py +252',b'Sales Order {0} is {1}',b'Salgsordre {0} er {1}'
b'DocType: Opportunity',b'Contact Info',b'Kontaktinfo'
b'apps/erpnext/erpnext/config/stock.py +319',b'Making Stock Entries',b'Making Stock Entries'
b'DocType: Packing Slip',b'Net Weight UOM',b'Vekt m\xc3\xa5lenheter'
b'DocType: Item',b'Default Supplier',b'Standard Leverand\xc3\xb8r'
b'DocType: Manufacturing Settings',b'Over Production Allowance Percentage',b'Over Produksjon Fradrag Prosent'
b'DocType: Employee Loan',b'Repayment Schedule',b'tilbakebetaling Schedule'
b'DocType: Shipping Rule Condition',b'Shipping Rule Condition',b'Shipping Rule Tilstand'
b'DocType: Holiday List',b'Get Weekly Off Dates',b'F\xc3\xa5 Ukentlig Off Datoer'
b'apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +33',b'End Date can not be less than Start Date',b'Sluttdato kan ikke v\xc3\xa6re mindre enn startdato'
b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +337',"b""Invoice can't be made for zero billing hour""",b'Fakturaen kan ikke gj\xc3\xb8res for null faktureringstid'
b'DocType: Sales Person',b'Select company name first.',b'Velg firmanavn f\xc3\xb8rst.'
b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +189',b'Email sent to {0}',b'E-post sendt til {0}'
b'apps/erpnext/erpnext/config/buying.py +23',b'Quotations received from Suppliers.',b'Sitater mottatt fra leverand\xc3\xb8rer.'
b'apps/erpnext/erpnext/config/manufacturing.py +74',b'Replace BOM and update latest price in all BOMs',b'Erstatt BOM og oppdater siste pris i alle BOMs'
b'apps/erpnext/erpnext/controllers/selling_controller.py +27',b'To {0} | {1} {2}',b'Til {0} | {1} {2}'
b'DocType: Delivery Trip',b'Driver Name',b'Drivernavn'
b'apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +40',b'Average Age',b'Gjennomsnittsalder'
b'DocType: Education Settings',b'Attendance Freeze Date',b'Deltagelsesfrysedato'
b'DocType: Education Settings',b'Attendance Freeze Date',b'Deltagelsesfrysedato'
b'apps/erpnext/erpnext/utilities/user_progress.py +110',b'List a few of your suppliers. They could be organizations or individuals.',b'Liste noen av dine leverand\xc3\xb8rer. De kan v\xc3\xa6re organisasjoner eller enkeltpersoner.'
b'apps/erpnext/erpnext/templates/pages/home.html +31',b'View All Products',b'Se alle produkter'
b'apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +20',b'Minimum Lead Age (Days)',b'Minimum levealder (dager)'
b'apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +20',b'Minimum Lead Age (Days)',b'Minimum levealder (dager)'
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +60',b'All BOMs',b'alle stykklister'
b'apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.py +35',b'Hotel Rooms of type {0} are unavailable on {1}',b'Hotellrom av typen {0} er utilgjengelig p\xc3\xa5 {1}'
b'DocType: Patient',b'Default Currency',b'Standard Valuta'
b'DocType: Expense Claim',b'From Employee',b'Fra Employee'
b'DocType: Driver',b'Cellphone Number',b'Mobiltelefonnummer'
b'DocType: Project',b'Monitor Progress',b'Monitor Progress'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +472',b'Warning: System will not check overbilling since amount for Item {0} in {1} is zero',b'Advarsel: System vil ikke sjekke billing siden bel\xc3\xb8pet for varen {0} i {1} er null'
b'DocType: Journal Entry',b'Make Difference Entry',b'Gj\xc3\xb8r forskjell Entry'
b'DocType: Upload Attendance',b'Attendance From Date',b'Oppm\xc3\xb8te Fra dato'
b'DocType: Appraisal Template Goal',b'Key Performance Area',b'Key Performance-omr\xc3\xa5det'
b'DocType: Program Enrollment',b'Transportation',b'Transport'
b'apps/erpnext/erpnext/controllers/item_variant.py +94',b'Invalid Attribute',b'Ugyldig Egenskap'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +240',b'{0} {1} must be submitted',b'{0} {1} m\xc3\xa5 sendes'
b'apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +159',b'Quantity must be less than or equal to {0}',b'Antall m\xc3\xa5 v\xc3\xa6re mindre enn eller lik {0}'
b'DocType: SMS Center',b'Total Characters',b'Totalt tegn'
b'DocType: Employee Advance',b'Claimed',b'hevdet'
b'DocType: Crop',b'Row Spacing',b'Row Spacing'
b'apps/erpnext/erpnext/controllers/buying_controller.py +164',b'Please select BOM in BOM field for Item {0}',b'Vennligst velg BOM i BOM felt for Element {0}'
b'DocType: C-Form Invoice Detail',b'C-Form Invoice Detail',b'C-Form Faktura Detalj'
b'DocType: Payment Reconciliation Invoice',b'Payment Reconciliation Invoice',b'Betaling Avstemming Faktura'
b'apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +38',b'Contribution %',b'Bidrag%'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +215',"b""As per the Buying Settings if Purchase Order Required == 'YES', then for creating Purchase Invoice, user need to create Purchase Order first for item {0}""","b'I henhold til kj\xc3\xb8psinnstillingene hvis innkj\xc3\xb8psordre er p\xc3\xa5krevd == &#39;JA&#39; og deretter for \xc3\xa5 opprette Kj\xc3\xb8pfaktura, m\xc3\xa5 brukeren opprette innkj\xc3\xb8psordre f\xc3\xb8rst for element {0}'"
b'DocType: Company',b'Company registration numbers for your reference. Tax numbers etc.',b'Firmaregistreringsnumre som referanse. Skatte tall osv'
b'DocType: Sales Partner',b'Distributor',b'Distribut\xc3\xb8r'
b'DocType: Shopping Cart Shipping Rule',b'Shopping Cart Shipping Rule',b'Handlevogn Shipping Rule'
b'apps/erpnext/erpnext/public/js/controllers/transaction.js +71',"b""Please set 'Apply Additional Discount On'""",b'Vennligst sett &#39;Apply Ytterligere rabatt p\xc3\xa5&#39;'
,b'Ordered Items To Be Billed',b'Bestilte varer til \xc3\xa5 bli fakturert'
b'apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +46',b'From Range has to be less than To Range',b'Fra Range m\xc3\xa5 v\xc3\xa6re mindre enn til kolleksjonen'
b'DocType: Global Defaults',b'Global Defaults',b'Global Defaults'
b'apps/erpnext/erpnext/projects/doctype/project/project.py +230',b'Project Collaboration Invitation',b'Prosjekt Samarbeid Invitasjon'
b'DocType: Salary Slip',b'Deductions',b'Fradrag'
b'DocType: Leave Allocation',b'LAL/',b'LAL /'
b'DocType: Setup Progress Action',b'Action Name',b'Handlingsnavn'
b'apps/erpnext/erpnext/public/js/financial_statements.js +75',b'Start Year',b'start-\xc3\xa5r'
b'apps/erpnext/erpnext/regional/india/utils.py +25',b'First 2 digits of GSTIN should match with State number {0}',b'De to f\xc3\xb8rste sifrene i GSTIN skal samsvare med statens nummer {0}'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +68',b'PDC/LC',b'PDC / LC'
b'DocType: Purchase Invoice',"b""Start date of current invoice's period""",b'Startdato for n\xc3\xa5v\xc3\xa6rende fakturaperiode'
b'DocType: Salary Slip',b'Leave Without Pay',b'La Uten Pay'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +385',b'Capacity Planning Error',b'Kapasitetsplanlegging Error'
,b'Trial Balance for Party',b'Trial Balance for partiet'
b'DocType: Lead',b'Consultant',b'Konsulent'
b'apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +356',b'Parents Teacher Meeting Attendance',b'Foreldres l\xc3\xa6rerm\xc3\xb8te'
b'DocType: Salary Slip',b'Earnings',b'Inntjeningen'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +441',b'Finished Item {0} must be entered for Manufacture type entry',b'Ferdig Element {0} m\xc3\xa5 angis for Produksjon typen oppf\xc3\xb8ring'
b'apps/erpnext/erpnext/config/learn.py +87',b'Opening Accounting Balance',b'\xc3\x85pning Regnskap Balanse'
,b'GST Sales Register',b'GST salgsregistrering'
b'DocType: Sales Invoice Advance',b'Sales Invoice Advance',b'Salg Faktura Advance'
b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +552',b'Nothing to request',b'Ingenting \xc3\xa5 be om'
b'apps/erpnext/erpnext/public/js/setup_wizard.js +18',b'Select your Domains',b'Velg domenene dine'
b'apps/erpnext/erpnext/accounts/doctype/budget/budget.py +34',"b""Another Budget record '{0}' already exists against {1} '{2}' for fiscal year {3}""",b'En annen Budsjett record &#39;{0} finnes allerede mot {1} {2} for regnskaps\xc3\xa5ret {3}'
b'DocType: Item Variant Settings',b'Fields will be copied over only at time of creation.',b'Feltene vil bli kopiert bare p\xc3\xa5 tidspunktet for opprettelsen.'
b'DocType: Setup Progress Action',b'Domains',b'Domener'
b'apps/erpnext/erpnext/projects/doctype/task/task.py +41',"b""'Actual Start Date' can not be greater than 'Actual End Date'""",b'&#39;Faktisk startdato&#39; ikke kan v\xc3\xa6re st\xc3\xb8rre enn &quot;Actual End Date &#39;'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +117',b'Management',b'Ledelse'
b'DocType: Cheque Print Template',b'Payer Settings',b'Payer Innstillinger'
b'DocType: Item Attribute Value',"b'This will be appended to the Item Code of the variant. For example, if your abbreviation is ""SM"", and the item code is ""T-SHIRT"", the item code of the variant will be ""T-SHIRT-SM""'","b'Dette vil bli lagt til Element Code of varianten. For eksempel, hvis din forkortelsen er &quot;SM&quot;, og elementet kode er &quot;T-SHIRT&quot;, elementet koden til variant vil v\xc3\xa6re &quot;T-SHIRT-SM&quot;'"
b'DocType: Salary Slip',b'Net Pay (in words) will be visible once you save the Salary Slip.',b'Nettol\xc3\xb8nn (i ord) vil v\xc3\xa6re synlig n\xc3\xa5r du lagrer L\xc3\xb8nn Slip.'
b'DocType: Purchase Invoice',b'Is Return',b'Er Return'
b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +92',b'Caution',b'Forsiktighet'
b'apps/erpnext/erpnext/agriculture/doctype/disease/disease.py +17',"b""Start day is greater than end day in task '{0}'""",b'Startdagen er st\xc3\xb8rre enn sluttdagen i oppgaven &#39;{0}&#39;'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +815',b'Return / Debit Note',b'Retur / debitnota'
b'DocType: Price List Country',b'Price List Country',b'Prisliste Land'
b'DocType: Item',b'UOMs',b'UOMs'
b'apps/erpnext/erpnext/stock/utils.py +212',b'{0} valid serial nos for Item {1}',b'{0} gyldig serie nos for Element {1}'
b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +57',b'Item Code cannot be changed for Serial No.',b'Elementkode kan ikke endres for Serial No.'
b'DocType: Purchase Invoice Item',b'UOM Conversion Factor',b'M\xc3\xa5lenheter Omregningsfaktor'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +40',b'Please enter Item Code to get Batch Number',b'Fyll inn Element kode for \xc3\xa5 f\xc3\xa5 Batch Number'
b'DocType: Stock Settings',b'Default Item Group',b'Standard varegruppe'
b'DocType: Employee Loan',b'Partially Disbursed',b'delvis Utbetalt'
b'apps/erpnext/erpnext/config/non_profit.py +73',b'Grant information.',b'Gi informasjon.'
b'apps/erpnext/erpnext/config/buying.py +38',b'Supplier database.',b'Leverand\xc3\xb8r database.'
b'DocType: Account',b'Balance Sheet',b'Balanse'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +750',"b""Cost Center For Item with Item Code '""",b'Koste Center For Element med Element kode &#39;'
b'DocType: Fee Validity',b'Valid Till',b'Gyldig til'
b'DocType: Student Report Generation Tool',b'Total Parents Teacher Meeting',b'Totalt foreldres l\xc3\xa6rerm\xc3\xb8te'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +2516',"b'Payment Mode is not configured. Please check, whether account has been set on Mode of Payments or on POS Profile.'","b'Betaling Mode er ikke konfigurert. Kontroller, om kontoen er satt p\xc3\xa5 modus for betalinger eller p\xc3\xa5 POS-profil.'"
b'apps/erpnext/erpnext/buying/utils.py +74',b'Same item cannot be entered multiple times.',b'Samme elementet kan ikke legges inn flere ganger.'
b'apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +30',"b'Further accounts can be made under Groups, but entries can be made against non-Groups'","b'Ytterligere kontoer kan gj\xc3\xb8res under grupper, men oppf\xc3\xb8ringene kan gj\xc3\xb8res mot ikke-grupper'"
b'DocType: Lead',b'Lead',b'Lead'
b'DocType: Email Digest',b'Payables',b'Gjeld'
b'DocType: Course',b'Course Intro',b'kurs Intro'
b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +105',b'Stock Entry {0} created',b'Stock Entry {0} er opprettet'
b'apps/erpnext/erpnext/controllers/buying_controller.py +306',b'Row #{0}: Rejected Qty can not be entered in Purchase Return',b'Row # {0}: Avvist Antall kan ikke legges inn i innkj\xc3\xb8psliste'
b'apps/erpnext/erpnext/stock/doctype/item/item.js +182',b'Changing Customer Group for the selected Customer is not allowed.',b'Endring av kundegruppe for den valgte kunden er ikke tillatt.'
,b'Purchase Order Items To Be Billed',b'Purchase Order Elementer som skal faktureres'
b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +63',b'Updating estimated arrival times.',b'Oppdaterer estimerte ankomsttider.'
b'DocType: Program Enrollment Tool',b'Enrollment Details',b'Registreringsdetaljer'
b'DocType: Purchase Invoice Item',b'Net Rate',b'Net Rate'
b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +152',b'Please select a customer',b'Vennligst velg en kunde'
b'DocType: Purchase Invoice Item',b'Purchase Invoice Item',b'Fakturaen Element'
b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +58',b'Stock Ledger Entries and GL Entries are reposted for the selected Purchase Receipts',b'Arkiv Ledger Oppf\xc3\xb8ringer og GL Oppf\xc3\xb8ringer repostes for de valgte Kj\xc3\xb8ps Receipts'
b'DocType: Student Report Generation Tool',b'Assessment Terms',b'Vurderingsbetingelser'
b'apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +8',b'Item 1',b'Sak 1'
b'DocType: Holiday',b'Holiday',b'Ferie'
b'DocType: Support Settings',b'Close Issue After Days',b'Lukk Issue Etter dager'
b'DocType: Leave Control Panel',b'Leave blank if considered for all branches',b'La st\xc3\xa5 tom hvis vurderes for alle grener'
b'DocType: Bank Guarantee',b'Validity in Days',b'Gyldighet i dager'
b'DocType: Bank Guarantee',b'Validity in Days',b'Gyldighet i dager'
b'apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +21',b'C-form is not applicable for Invoice: {0}',b'C-skjemaet er ikke aktuelt for faktura: {0}'
b'DocType: Payment Reconciliation',b'Unreconciled Payment Details',b'Avstemte Betalingsopplysninger'
b'apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py +6',b'Member Activity',b'Medlemsaktivitet'
b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +20',b'Order Count',b'Ordre Count'
b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +20',b'Order Count',b'Ordre Count'
b'DocType: Global Defaults',b'Current Fiscal Year',b'V\xc3\xa6rende regnskaps\xc3\xa5r'
b'DocType: Purchase Order',b'Group same items',b'Gruppe samme elementene'
b'DocType: Purchase Invoice',b'Disable Rounded Total',b'Deaktiver Avrundet Total'
b'DocType: Employee Loan Application',b'Repayment Info',b'tilbakebetaling info'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +448',"b""'Entries' cannot be empty""",b'&#39;Innlegg&#39; kan ikke v\xc3\xa6re tomt'
b'DocType: Maintenance Team Member',b'Maintenance Role',b'Vedlikeholdsrolle'
b'apps/erpnext/erpnext/utilities/transaction_base.py +92',b'Duplicate row {0} with same {1}',b'Duplicate rad {0} med samme {1}'
,b'Trial Balance',b'Balanse Trial'
b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +443',b'Fiscal Year {0} not found',b'Regnskaps\xc3\xa5ret {0} ikke funnet'
b'apps/erpnext/erpnext/config/hr.py +309',b'Setting up Employees',b'Sette opp ansatte'
b'DocType: Sales Order',b'SO-',b'S\xc3\x85-'
b'DocType: Hotel Room Reservation',b'Hotel Reservation User',b'Hotel Reservation Bruker'
b'apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +158',b'Please select prefix first',b'Vennligst velg f\xc3\xb8rst prefiks'
b'DocType: Student',b'O-',b'O-'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +189',b'Research',b'Forskning'
b'DocType: Maintenance Visit Purpose',b'Work Done',b'Arbeidet Som Er Gjort'
b'apps/erpnext/erpnext/controllers/item_variant.py +35',b'Please specify at least one attribute in the Attributes table',b'Vennligst oppgi minst ett attributt i Attributter tabellen'
b'DocType: Announcement',b'All Students',b'alle studenter'
b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +45',b'Item {0} must be a non-stock item',b'Element {0} m\xc3\xa5 v\xc3\xa6re et ikke-lagervare'
b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +18',b'View Ledger',b'Vis Ledger'
b'DocType: Grading Scale',b'Intervals',b'intervaller'
b'apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41',b'Earliest',b'Tidligste'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +526',"b'An Item Group exists with same name, please change the item name or rename the item group'","b'En varegruppe eksisterer med samme navn, m\xc3\xa5 du endre elementnavnet eller endre navn varegruppen'"
b'DocType: Crop Cycle',b'Less than a year',b'Mindre enn et \xc3\xa5r'
b'apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py +52',b'Student Mobile No.',b'Student Mobile No.'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/defaults_setup.py +105',b'Rest Of The World',b'Resten Av Verden'
b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +81',b'The Item {0} cannot have Batch',b'Element {0} kan ikke ha Batch'
b'DocType: Crop',b'Yield UOM',b'Utbytte UOM'
,b'Budget Variance Report',b'Budsjett Avvik Rapporter'
b'DocType: Salary Slip',b'Gross Pay',b'Brutto L\xc3\xb8nn'
b'DocType: Item',b'Is Item from Hub',b'Er element fra nav'
b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +118',b'Row {0}: Activity Type is mandatory.',b'Rad {0}: Aktivitetstype er obligatorisk.'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +166',b'Dividends Paid',b'Utbytte betalt'
b'apps/erpnext/erpnext/buying/doctype/supplier/supplier.js +36',b'Accounting Ledger',b'Regnskap Ledger'
b'DocType: Stock Reconciliation',b'Difference Amount',b'Forskjellen Bel\xc3\xb8p'
b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +107',b'Dr {0} on Leave on {1}',b'Dr {0} p\xc3\xa5 permisjon p\xc3\xa5 {1}'
b'DocType: Purchase Invoice',b'Reverse Charge',b'Omvendt ladning'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +172',b'Retained Earnings',b'Opptjent egenkapital'
b'DocType: Purchase Invoice',b'05-Change in POS',b'05-Endring i POS'
b'DocType: Vehicle Log',b'Service Detail',b'tjenesten Detalj'
b'DocType: BOM',b'Item Description',b'Element Beskrivelse'
b'DocType: Student Sibling',b'Student Sibling',b'student S\xc3\xb8sken'
b'apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py +18',b'Payment Mode',b'Betaling Mode'
b'DocType: Purchase Invoice',b'Supplied Items',b'Leveringen'
b'apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +85',b'Please set an active menu for Restaurant {0}',b'Vennligst sett inn en aktiv meny for Restaurant {0}'
b'DocType: Student',b'STUD.',b'STUD.'
b'DocType: Work Order',b'Qty To Manufacture',b'Antall \xc3\xa5 produsere'
b'DocType: Email Digest',b'New Income',b'New Inntekt'
b'DocType: Buying Settings',b'Maintain same rate throughout purchase cycle',b'Opprettholde samme tempo gjennom hele kj\xc3\xb8pssyklusen'
b'DocType: Opportunity Item',b'Opportunity Item',b'Opportunity Element'
,b'Student and Guardian Contact Details',b'Student og Guardian Kontaktdetaljer'
b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +53',b'Row {0}: For supplier {0} Email Address is required to send email',b'Rad {0}: For Leverand\xc3\xb8ren p\xc3\xa5legges {0} e-postadresse for \xc3\xa5 sende e-post'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +72',b'Temporary Opening',b'Midlertidig \xc3\x85pning'
b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +10',b'View Hub',b'Se Hub'
,b'Employee Leave Balance',b'Ansatt La Balance'
b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +147',b'Balance for Account {0} must always be {1}',b'Balanse for konto {0} m\xc3\xa5 alltid v\xc3\xa6re {1}'
b'DocType: Patient Appointment',b'More Info',b'Mer Info'
b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +180',b'Valuation Rate required for Item in row {0}',b'Verdsettelse Rate kreves for varen i rad {0}'
b'DocType: Supplier Scorecard',b'Scorecard Actions',b'Scorecard Actions'
b'apps/erpnext/erpnext/utilities/user_progress.py +169',b'Example: Masters in Computer Science',b'Eksempel: Masters i informatikk'
b'DocType: Purchase Invoice',b'Rejected Warehouse',b'Avvist Warehouse'
b'DocType: GL Entry',b'Against Voucher',b'Mot Voucher'
b'DocType: Item',b'Default Buying Cost Center',b'Standard Kj\xc3\xb8pe kostnadssted'
b'apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +6',"b'To get the best out of ERPNext, we recommend that you take some time and watch these help videos.'","b'For \xc3\xa5 f\xc3\xa5 det beste ut av ERPNext, anbefaler vi at du tar litt tid og se p\xc3\xa5 disse hjelpevideoer.'"
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +76',b' to ',b'til'
b'DocType: Supplier Quotation Item',b'Lead Time in days',b'Lead Tid i dager'
b'apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +70',b'Accounts Payable Summary',b'Leverand\xc3\xb8rgjeld Sammendrag'
b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +326',b'Payment of salary from {0} to {1}',b'Utbetaling av l\xc3\xb8nn fra {0} til {1}'
b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +213',b'Not authorized to edit frozen Account {0}',b'Ikke autorisert til \xc3\xa5 redigere fryst kontoen {0}'
b'DocType: Journal Entry',b'Get Outstanding Invoices',b'F\xc3\xa5 utest\xc3\xa5ende fakturaer'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +84',b'Sales Order {0} is not valid',b'Salgsordre {0} er ikke gyldig'
b'DocType: Supplier Scorecard',b'Warn for new Request for Quotations',b'Varsle om ny foresp\xc3\xb8rsel om tilbud'
b'apps/erpnext/erpnext/utilities/activation.py +91',b'Purchase orders help you plan and follow up on your purchases',b'Innkj\xc3\xb8psordrer hjelpe deg \xc3\xa5 planlegge og f\xc3\xb8lge opp kj\xc3\xb8pene'
b'apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +151',b'Lab Test Prescriptions',b'Lab Test Prescriptions'
b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +166',b'The total Issue / Transfer quantity {0} in Material Request {1}  \\\n\t\t\t\t\t\t\tcannot be greater than requested quantity {2} for Item {3}',b'Den totale Issue / Transfer mengde {0} i Material Request {1} \\ kan ikke v\xc3\xa6re st\xc3\xb8rre enn \xc3\xb8nsket antall {2} for Element {3}'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +197',b'Small',b'Liten'
b'DocType: Opening Invoice Creation Tool Item',b'Opening Invoice Creation Tool Item',b'\xc3\x85pning av fakturaopprettingsverkt\xc3\xb8yet'
b'DocType: Education Settings',b'Employee Number',b'Ansatt Number'
b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +67',b'Case No(s) already in use. Try from Case No {0}',b'Tilfellet Nei (e) allerede er i bruk. Pr\xc3\xb8v fra sak nr {0}'
b'DocType: Project',b'% Completed',b'% Fullf\xc3\xb8rt'
,b'Invoiced Amount (Exculsive Tax)',b'Fakturert bel\xc3\xb8p (exculsive Tax)'
b'apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +14',b'Item 2',b'Sak 2'
b'DocType: Supplier',b'SUPP-',b'leve-'
b'DocType: Training Event',b'Training Event',b'trening Hendelses'
b'DocType: Item',b'Auto re-order',b'Auto re-order'
b'apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.py +59',b'Total Achieved',b'Oppn\xc3\xa5dd Total'
b'DocType: Employee',b'Place of Issue',b'Utstedelsessted'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +101',b'Contract',b'Kontrakts'
b'DocType: Plant Analysis',b'Laboratory Testing Datetime',b'Laboratorietesting Datetime'
b'DocType: Email Digest',b'Add Quote',b'Legg Sitat'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +987',b'UOM coversion factor required for UOM: {0} in Item: {1}',b'M\xc3\xa5lenheter coversion faktor n\xc3\xb8dvendig for m\xc3\xa5lenheter: {0} i Sak: {1}'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +92',b'Indirect Expenses',b'Indirekte kostnader'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +98',b'Row {0}: Qty is mandatory',b'Rad {0}: Antall er obligatorisk'
b'DocType: Agriculture Analysis Criteria',b'Agriculture',b'Landbruk'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +794',b'Sync Master Data',b'Sync Master Data'
b'DocType: Asset Repair',b'Repair Cost',b'Reparasjonskostnad'
b'apps/erpnext/erpnext/utilities/user_progress.py +138',b'Your Products or Services',b'Dine produkter eller tjenester'
b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +15',b'Failed to login',b'Kunne ikke logge inn'
b'DocType: Special Test Items',b'Special Test Items',b'Spesielle testelementer'
b'DocType: Mode of Payment',b'Mode of Payment',b'Modus for betaling'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +202',b'Website Image should be a public file or website URL',b'Website Bilde b\xc3\xb8r v\xc3\xa6re en offentlig fil eller nettside URL'
b'DocType: Student Applicant',b'AP',b'AP'
b'DocType: Purchase Invoice Item',b'BOM',b'BOM'
b'apps/erpnext/erpnext/setup/doctype/item_group/item_group.js +37',b'This is a root item group and cannot be edited.',b'Dette er en rot varegruppe og kan ikke redigeres.'
b'DocType: Journal Entry Account',b'Purchase Order',b'Bestilling'
b'DocType: Vehicle',b'Fuel UOM',b'drivstoff m\xc3\xa5lenheter'
b'DocType: Warehouse',b'Warehouse Contact Info',b'Warehouse Kontaktinfo'
b'DocType: Payment Entry',b'Write Off Difference Amount',b'Skriv Off differansebel\xc3\xb8pet'
b'DocType: Volunteer',b'Volunteer Name',b'Frivillig navn'
b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +434',"b'{0}: Employee email not found, hence email not sent'","b'{0}: Ansattes e-post ikke funnet, derav e-posten ikke sendt'"
b'apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +85',b'Shipping rule not applicable for country {0}',b'Fraktregel gjelder ikke for land {0}'
b'DocType: Item',b'Foreign Trade Details',b'Foreign Trade Detaljer'
,b'Assessment Plan Status',b'Evalueringsplan Status'
b'DocType: Email Digest',b'Annual Income',b'\xc3\x85rsinntekt'
b'DocType: Serial No',b'Serial No Details',b'Serie ingen opplysninger'
b'DocType: Purchase Invoice Item',b'Item Tax Rate',b'Sak Skattesats'
b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +89',b'Please select Physician and Date',b'Vennligst velg Leger og dato'
b'DocType: Student Group Student',b'Group Roll Number',b'Gruppe-nummer'
b'DocType: Student Group Student',b'Group Roll Number',b'Gruppe-nummer'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +145',"b'For {0}, only credit accounts can be linked against another debit entry'",b'For {0} kan bare kredittkontoer kobles mot en annen belastning oppf\xc3\xb8ring'
b'apps/erpnext/erpnext/projects/doctype/project/project.py +84',b'Total of all task weights should be 1. Please adjust weights of all Project tasks accordingly',b'Summen av alle oppgave vekter b\xc3\xb8r v\xc3\xa6re 1. Juster vekter av alle prosjektoppgaver tilsvar'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +588',b'Delivery Note {0} is not submitted',b'Levering Note {0} er ikke innsendt'
b'apps/erpnext/erpnext/stock/get_item_details.py +148',b'Item {0} must be a Sub-contracted Item',b'Elementet {0} m\xc3\xa5 v\xc3\xa6re en underleverand\xc3\xb8r Element'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +43',b'Capital Equipments',b'Capital Equipments'
b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +33',"b""Pricing Rule is first selected based on 'Apply On' field, which can be Item, Item Group or Brand.""","b'Prising Rule f\xc3\xb8rst valgt basert p\xc3\xa5 &quot;Apply On-feltet, som kan v\xc3\xa6re varen, varegruppe eller Brand.'"
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +246',b'Please set the Item Code first',b'Vennligst sett inn varenummeret f\xc3\xb8rst'
b'DocType: Item',b'ITEM-',b'PUNKT-'
b'apps/erpnext/erpnext/controllers/selling_controller.py +123',b'Total allocated percentage for sales team should be 100',b'Totalt bevilget prosent for salgsteam skal v\xc3\xa6re 100'
b'DocType: Sales Invoice Item',b'Edit Description',b'Rediger Beskrivelse'
b'DocType: Antibiotic',b'Antibiotic',b'Antibiotika'
,b'Team Updates',b'laget Oppdateringer'
b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +912',b'For Supplier',b'For Leverand\xc3\xb8r'
b'DocType: Account',b'Setting Account Type helps in selecting this Account in transactions.',b'Stille Kontotype hjelper i \xc3\xa5 velge denne kontoen i transaksjoner.'
b'DocType: Purchase Invoice',b'Grand Total (Company Currency)',b'Grand Total (Selskap Valuta)'
b'apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +9',b'Create Print Format',b'Opprett Print Format'
b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +5',b'Fee Created',b'Avgift er opprettet'
b'apps/erpnext/erpnext/utilities/bot.py +39',b'Did not find any item called {0}',b'Fant ikke noe element som heter {0}'
b'DocType: Supplier Scorecard Criteria',b'Criteria Formula',b'Kriterier Formel'
b'apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41',b'Total Outgoing',b'Total Utg\xc3\xa5ende'
b'apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +39',"b'There can only be one Shipping Rule Condition with 0 or blank value for ""To Value""'",b'Det kan bare v\xc3\xa6re \xc3\xa9n Shipping Rule Forhold med 0 eller blank verdi for &quot;\xc3\xa5 verd&quot;'
b'DocType: Authorization Rule',b'Transaction',b'Transaksjons'
b'DocType: Patient Appointment',b'Duration',b'Varighet'
b'apps/erpnext/erpnext/controllers/status_updater.py +160',"b'For an item {0}, quantity must be positive number'",b'For et element {0} m\xc3\xa5 mengden v\xc3\xa6re positivt tall'
b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +27',b'Note: This Cost Center is a Group. Cannot make accounting entries against groups.',b'Merk: Denne Cost Center er en gruppe. Kan ikke gj\xc3\xb8re regnskapspostene mot grupper.'
b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +53',b'Child warehouse exists for this warehouse. You can not delete this warehouse.',b'Barn lager finnes for dette lageret. Du kan ikke slette dette lageret.'
b'DocType: Item',b'Website Item Groups',b'Website varegrupper'
b'DocType: Purchase Invoice',b'Total (Company Currency)',b'Total (Company Valuta)'
b'DocType: Daily Work Summary Group',b'Reminder',b'p\xc3\xa5minnelse'
b'apps/erpnext/erpnext/stock/utils.py +207',b'Serial number {0} entered more than once',b'Serienummer {0} angitt mer enn \xc3\xa9n gang'
b'DocType: Journal Entry',b'Journal Entry',b'Journal Entry'
b'DocType: Expense Claim Advance',b'Unclaimed amount',b'Uoppfordret bel\xc3\xb8p'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +148',b'{0} items in progress',b'{0} elementer i fremgang'
b'DocType: Workstation',b'Workstation Name',b'Arbeidsstasjon Name'
b'DocType: Grading Scale Interval',b'Grade Code',b'grade Kode'
b'DocType: POS Item Group',b'POS Item Group',b'POS Varegruppe'
b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +17',b'Email Digest:',b'E-post Digest:'
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +613',b'BOM {0} does not belong to Item {1}',b'BOM {0} tilh\xc3\xb8rer ikke Element {1}'
b'DocType: Sales Partner',b'Target Distribution',b'Target Distribution'
b'DocType: Purchase Invoice',b'06-Finalization of Provisional assessment',b'06-Finalisering av forel\xc3\xb8pig vurdering'
b'DocType: Salary Slip',b'Bank Account No.',b'Bank Account No.'
b'DocType: Naming Series',b'This is the number of the last created transaction with this prefix',b'Dette er nummeret p\xc3\xa5 den siste laget transaksjonen med dette prefikset'
b'DocType: Supplier Scorecard',"b'Scorecard variables can be used, as well as:\n{total_score} (the total score from that period),\n{period_number} (the number of periods to present day)\n'","b'Scorecard-variabler kan brukes, s\xc3\xa5 vel som: {total_score} (totalpoengsummen fra den perioden), {period_number} (antall perioder i dag)'"
b'DocType: Quality Inspection Reading',b'Reading 8',b'Reading 8'
b'DocType: Sales Partner',b'Agent',b'Agent'
b'DocType: Purchase Invoice',b'Taxes and Charges Calculation',b'Skatter og avgifter Beregning'
b'DocType: Accounts Settings',b'Book Asset Depreciation Entry Automatically',b'Bokf\xc3\xb8ring av aktivavskrivninger automatisk'
b'DocType: Accounts Settings',b'Book Asset Depreciation Entry Automatically',b'Bokf\xc3\xb8ring av aktivavskrivninger automatisk'
b'DocType: BOM Operation',b'Workstation',b'Arbeidsstasjon'
b'DocType: Request for Quotation Supplier',b'Request for Quotation Supplier',b'Foresp\xc3\xb8rsel om prisanslag Leverand\xc3\xb8r'
b'DocType: Healthcare Settings',b'Registration Message',b'Registreringsmelding'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +154',b'Hardware',b'Hardware'
b'DocType: Prescription Dosage',b'Prescription Dosage',b'Reseptdosering'
b'DocType: Attendance',b'HR Manager',b'HR Manager'
b'apps/erpnext/erpnext/accounts/party.py +175',b'Please select a Company',b'Vennligst velg et selskap'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +92',b'Privilege Leave',b'Privilege La'
b'DocType: Purchase Invoice',b'Supplier Invoice Date',b'Leverand\xc3\xb8r Fakturadato'
b'DocType: Asset Settings',b'This value is used for pro-rata temporis calculation',b'Denne verdien brukes til pro rata temporis beregning'
b'apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +90',b'You need to enable Shopping Cart',b'Du m\xc3\xa5 aktivere Handlevogn'
b'DocType: Payment Entry',b'Writeoff',b'writeoff'
b'DocType: Stock Settings',b'Naming Series Prefix',b'Naming Series Prefix'
b'DocType: Appraisal Template Goal',b'Appraisal Template Goal',b'Appraisal Mal Goal'
b'DocType: Salary Component',b'Earning',b'Tjene'
b'DocType: Supplier Scorecard',b'Scoring Criteria',b'Scoringskriterier'
b'DocType: Purchase Invoice',b'Party Account Currency',b'Partiet konto Valuta'
,b'BOM Browser',b'BOM Nettleser'
b'apps/erpnext/erpnext/templates/emails/training_event.html +13',b'Please update your status for this training event',b'Vennligst oppdatere statusen din for denne treningshendelsen'
b'DocType: Item Barcode',b'EAN',b'EAN'
b'DocType: Purchase Taxes and Charges',b'Add or Deduct',b'Legge til eller trekke fra'
b'apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +148',b'Overlapping conditions found between:',b'Overlappende vilk\xc3\xa5r funnet mellom:'
b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +187',b'Against Journal Entry {0} is already adjusted against some other voucher',b'Mot Journal Entry {0} er allerede justert mot en annen kupong'
b'apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +68',b'Total Order Value',b'Total ordreverdi'
b'apps/erpnext/erpnext/demo/setup/setup_data.py +328',b'Food',b'Mat'
b'apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +57',b'Ageing Range 3',b'Aldring Range 3'
b'DocType: Maintenance Schedule Item',b'No of Visits',b'Ingen av bes\xc3\xb8k'
b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +165',b'Maintenance Schedule {0} exists against {1}',b'Vedlikeholdsplan {0} eksisterer mot {1}'
b'apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +36',b'Enrolling student',b'p\xc3\xa5melding student'
b'apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +33',b'Currency of the Closing Account must be {0}',b'Valuta if\xc3\xb8lge kursen konto m\xc3\xa5 v\xc3\xa6re {0}'
b'apps/erpnext/erpnext/hr/doctype/appraisal_template/appraisal_template.py +21',b'Sum of points for all goals should be 100. It is {0}',b'Summen av poeng for alle m\xc3\xa5l b\xc3\xb8r v\xc3\xa6re 100. Det er {0}'
b'DocType: Project',b'Start and End Dates',b'Start- og sluttdato'
,b'Delivered Items To Be Billed',b'Leverte varer til \xc3\xa5 bli fakturert'
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html +16',b'Open BOM {0}',b'\xc3\x85pen BOM {0}'
b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +60',b'Warehouse cannot be changed for Serial No.',b'Warehouse kan ikke endres for Serial No.'
b'DocType: Authorization Rule',b'Average Discount',b'Gjennomsnittlig Rabatt'
b'DocType: Project Update',b'Great/Quickly',b'Great / raskt'
b'DocType: Purchase Invoice Item',b'UOM',b'm\xc3\xa5lenheter'
b'DocType: Rename Tool',b'Utilities',b'Verkt\xc3\xb8y'
b'DocType: POS Profile',b'Accounting',b'Regnskap'
b'DocType: Employee',b'EMP/',b'EMP /'
b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +133',b'Please select batches for batched item ',b'Vennligst velg batch for batched item'
b'DocType: Asset',b'Depreciation Schedules',b'avskrivninger tidsplaner'
b'apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py +192',b'Following accounts might be selected in GST Settings:',b'F\xc3\xb8lgende kontoer kan velges i GST-innstillinger:'
b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +70',b'Application period cannot be outside leave allocation period',b'Tegningsperioden kan ikke v\xc3\xa6re utenfor permisjon tildeling periode'
b'DocType: Activity Cost',b'Projects',b'Prosjekter'
b'DocType: Payment Request',b'Transaction Currency',b'transaksjonsvaluta'
b'apps/erpnext/erpnext/controllers/buying_controller.py +30',b'From {0} | {1} {2}',b'Fra {0} | {1} {2}'
b'DocType: Work Order Operation',b'Operation Description',b'Operasjon Beskrivelse'
b'apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +34',b'Cannot change Fiscal Year Start Date and Fiscal Year End Date once the Fiscal Year is saved.',b'Kan ikke endre regnskaps\xc3\xa5ret Startdato og regnskaps\xc3\xa5r sluttdato n\xc3\xa5r regnskaps\xc3\xa5ret er lagret.'
b'DocType: Quotation',b'Shopping Cart',b'Handlevogn'
b'apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41',b'Avg Daily Outgoing',b'Gjennomsnittlig Daily Utg\xc3\xa5ende'
b'DocType: POS Profile',b'Campaign',b'Kampanje'
b'DocType: Supplier',b'Name and Type',b'Navn og Type'
b'DocType: Physician',b'Contacts and Address',b'Kontakter og adresse'
b'DocType: Purchase Invoice',b'Contact Person',b'Kontaktperson'
b'apps/erpnext/erpnext/projects/doctype/task/task.py +38',"b""'Expected Start Date' can not be greater than 'Expected End Date'""",b'&#39;Tiltredelse&#39; ikke kan v\xc3\xa6re st\xc3\xb8rre enn &quot;Forventet sluttdato'
b'DocType: Course Scheduling Tool',b'Course End Date',b'Kurs Sluttdato'
b'DocType: Holiday List',b'Holidays',b'Ferier'
b'DocType: Sales Order Item',b'Planned Quantity',b'Planlagt Antall'
b'DocType: Purchase Invoice Item',b'Item Tax Amount',b'Sak Skattebel\xc3\xb8p'
b'DocType: Water Analysis',b'Water Analysis Criteria',b'Vannanalysekriterier'
b'DocType: Item',b'Maintain Stock',b'Oppretthold Stock'
b'DocType: Employee',b'Prefered Email',b'foretrukne e-post'
b'DocType: Student Admission',b'Eligibility and Details',b'Kvalifisering og detaljer'
b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +38',b'Net Change in Fixed Asset',b'Netto endring i Fixed Asset'
b'DocType: Leave Control Panel',b'Leave blank if considered for all designations',b'La st\xc3\xa5 tom hvis vurderes for alle betegnelser'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +806',"b""Charge of type 'Actual' in row {0} cannot be included in Item Rate""",b'Charge of type &#39;Actual&#39; i rad {0} kan ikke inkluderes i Element Ranger'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +382',b'Max: {0}',b'Max: {0}'
b'apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py +24',b'From Datetime',b'Fra Datetime'
b'DocType: Email Digest',b'For Company',b'For selskapet'
b'apps/erpnext/erpnext/config/support.py +17',b'Communication log.',b'Kommunikasjonsloggen.'
b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +195',"b'Request for Quotation is disabled to access from portal, for more check portal settings.'",b'Foresp\xc3\xb8rsel om prisanslag er deaktivert tilgang fra portal for flere sjekkportalinnstillingene.'
b'DocType: Supplier Scorecard Scoring Variable',b'Supplier Scorecard Scoring Variable',b'Leverand\xc3\xb8r Scorecard Scoring Variable'
b'apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +72',b'Buying Amount',b'Kj\xc3\xb8pe Bel\xc3\xb8p'
b'DocType: Sales Invoice',b'Shipping Address Name',b'Leveringsadresse Navn'
b'DocType: Material Request',b'Terms and Conditions Content',b'Betingelser innhold'
b'apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +18',b'There were errors creating Course Schedule',b'Det var feil \xc3\xa5 opprette kursplan'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +581',b'cannot be greater than 100',b'kan ikke v\xc3\xa6re st\xc3\xb8rre enn 100'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +752',b'Item {0} is not a stock Item',b'Element {0} er ikke en lagervare'
b'DocType: Maintenance Visit',b'Unscheduled',b'Ikke planlagt'
b'DocType: Employee',b'Owned',b'Eies'
b'DocType: Salary Detail',b'Depends on Leave Without Pay',b'Avhenger La Uten Pay'
b'DocType: Pricing Rule',"b'Higher the number, higher the priority'","b'H\xc3\xb8yere tallet er, h\xc3\xb8yere prioritet'"
,b'Purchase Invoice Trends',b'Fakturaen Trender'
b'DocType: Employee',b'Better Prospects',b'Bedre utsikter'
b'apps/erpnext/erpnext/stock/doctype/batch/batch.py +217',"b'Row #{0}: The batch {1} has only {2} qty. Please select another batch which has {3} qty available or split the row into multiple rows, to deliver/issue from multiple batches'",b'Row # {0}: Batch {1} har bare {2} antall. Vennligst velg en annen batch som har {3} antall tilgjengelig eller del opp raden i flere rader for \xc3\xa5 levere / utf\xc3\xb8re fra flere batcher'
b'DocType: Vehicle',b'License Plate',b'Bilskilt'
b'DocType: Appraisal',b'Goals',b'M\xc3\xa5l'
b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +353',b'Select POS Profile',b'Velg POS-profil'
b'DocType: Warranty Claim',b'Warranty / AMC Status',b'Garanti / AMC Status'
,b'Accounts Browser',b'Kontoer Browser'
b'DocType: Payment Entry Reference',b'Payment Entry Reference',b'Betaling Entry Reference'
b'DocType: GL Entry',b'GL Entry',b'GL Entry'
b'DocType: HR Settings',b'Employee Settings',b'Medarbeider Innstillinger'
,b'Batch-Wise Balance History',b'Batch-Wise Balance Historie'
b'apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +73',b'Print settings updated in respective print format',b'Utskriftsinnstillingene oppdatert i respektive utskriftsformat'
b'DocType: Package Code',b'Package Code',b'pakke kode'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +105',b'Apprentice',b'L\xc3\xa6rling'
b'DocType: Purchase Invoice',b'Company GSTIN',b'Firma GSTIN'
b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +105',b'Negative Quantity is not allowed',b'Negative Antall er ikke tillatt'
b'DocType: Purchase Invoice Item',b'Tax detail table fetched from item master as a string and stored in this field.\nUsed for Taxes and Charges',"b'Tax detalj tabell hentet fra elementet Hoved som en streng, og som er lagret p\xc3\xa5 dette feltet. Brukes for skatter og avgifter'"
b'DocType: Supplier Scorecard Period',b'SSC-',b'SSC-'
b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +159',b'Employee cannot report to himself.',b'Arbeidstaker kan ikke rapportere til seg selv.'
b'DocType: Account',"b'If the account is frozen, entries are allowed to restricted users.'","b'Hvis kontoen er fryst, er oppf\xc3\xb8ringer lov til begrensede brukere.'"
b'DocType: Email Digest',b'Bank Balance',b'Bank Balanse'
b'apps/erpnext/erpnext/accounts/party.py +240',b'Accounting Entry for {0}: {1} can only be made in currency: {2}',b'Regnskap Entry for {0}: {1} kan bare gj\xc3\xb8res i valuta: {2}'
b'DocType: Job Opening',"b'Job profile, qualifications required etc.'","b'Jobb profil, kvalifikasjoner som kreves etc.'"
b'DocType: Journal Entry Account',b'Account Balance',b'Saldo'
b'apps/erpnext/erpnext/config/accounts.py +183',b'Tax Rule for transactions.',b'Skatteregel for transaksjoner.'
b'DocType: Rename Tool',b'Type of document to rename.',b'Type dokument for \xc3\xa5 endre navn.'
b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +53',b'{0} {1}: Customer is required against Receivable account {2}',b'{0} {1}: Kunden er n\xc3\xb8dvendig mot fordringer kontoen {2}'
b'DocType: Purchase Invoice',b'Total Taxes and Charges (Company Currency)',b'Totale skatter og avgifter (Selskapet valuta)'
b'DocType: Weather',b'Weather Parameter',b'V\xc3\xa6rparameter'
b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +60',"b""Show unclosed fiscal year's P&L balances""",b'Vis unclosed regnskaps\xc3\xa5rets P &amp; L balanserer'
b'DocType: Lab Test Template',b'Collection Details',b'Samlingsdetaljer'
b'DocType: POS Profile',b'Allow Print Before Pay',b'Tillat utskrift f\xc3\xb8r betaling'
b'DocType: Land Unit',b'Linked Soil Texture',b'Koblet jordstruktur'
b'DocType: Shipping Rule',b'Shipping Account',b'Shipping konto'
b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +92',b'{0} {1}: Account {2} is inactive',b'{0} {1}: Account {2} er inaktiv'
b'apps/erpnext/erpnext/utilities/activation.py +82',b'Make Sales Orders to help you plan your work and deliver on-time',b'Gj\xc3\xb8r salgsordrer for \xc3\xa5 hjelpe deg med \xc3\xa5 planlegge arbeidet ditt og levere i tide'
b'DocType: Quality Inspection',b'Readings',b'Readings'
b'DocType: Stock Entry',b'Total Additional Costs',b'Samlede merkostnader'
b'DocType: Course Schedule',b'SH',b'SH'
b'DocType: BOM',b'Scrap Material Cost(Company Currency)',b'Skrap Material Cost (Selskap Valuta)'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +66',b'Sub Assemblies',b'Sub Assemblies'
b'DocType: Asset',b'Asset Name',b'Asset Name'
b'DocType: Project',b'Task Weight',b'Task Vekt'
b'DocType: Shipping Rule Condition',b'To Value',b'I Value'
b'DocType: Asset Movement',b'Stock Manager',b'Stock manager'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +171',b'Source warehouse is mandatory for row {0}',b'Kilde lageret er obligatorisk for rad {0}'
b'apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +38',b'The Payment Term at row {0} is possibly a duplicate.',b'Betalingsperioden i rad {0} er muligens en duplikat.'
b'apps/erpnext/erpnext/public/js/setup_wizard.js +30',b'Agriculture (beta)',b'Jordbruk (beta)'
b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +863',b'Packing Slip',b'Pakkseddel'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +110',b'Office Rent',b'Kontor Leie'
b'apps/erpnext/erpnext/config/setup.py +111',b'Setup SMS gateway settings',b'Oppsett SMS gateway-innstillinger'
b'DocType: Disease',b'Common Name',b'Vanlig navn'
b'apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +61',b'Import Failed!',b'Import mislyktes!'
b'apps/erpnext/erpnext/public/js/templates/address_list.html +20',b'No address added yet.',b'Ingen adresse er lagt til enn\xc3\xa5.'
b'DocType: Workstation Working Hour',b'Workstation Working Hour',b'Arbeidsstasjon Working Hour'
b'DocType: Vital Signs',b'Blood Pressure',b'Blodtrykk'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +125',b'Analyst',b'Analytiker'
b'DocType: Item',b'Inventory',b'Inventar'
b'DocType: Item',b'Sales Details',b'Salgs Detaljer'
b'DocType: Quality Inspection',b'QI-',b'QI-'
b'DocType: Opportunity',b'With Items',b'Med Items'
b'DocType: Asset Maintenance',b'Maintenance Team',b'Vedlikeholdsteam'
b'apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37',b'In Qty',b'I Antall'
b'DocType: Education Settings',b'Validate Enrolled Course for Students in Student Group',b'Bekreft innmeldt kurs for studenter i studentgruppen'
b'DocType: Notification Control',b'Expense Claim Rejected',b'Expense krav Avvist'
b'DocType: Item',b'Item Attribute',b'Sak Egenskap'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +147',b'Government',b'Regjeringen'
b'apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +40',b'Expense Claim {0} already exists for the Vehicle Log',b'Expense krav {0} finnes allerede for Vehicle Log'
b'apps/erpnext/erpnext/public/js/setup_wizard.js +64',b'Institute Name',b'Institute Name'
b'apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +117',b'Please enter repayment Amount',b'Fyll inn gjenv\xc3\xa6rende bel\xc3\xb8pet'
b'apps/erpnext/erpnext/config/stock.py +309',b'Item Variants',b'Element Varianter'
b'apps/erpnext/erpnext/public/js/setup_wizard.js +29',b'Services',b'Tjenester'
b'DocType: HR Settings',b'Email Salary Slip to Employee',b'E-post L\xc3\xb8nn Slip til Employee'
b'DocType: Cost Center',b'Parent Cost Center',b'Parent kostnadssted'
b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1041',b'Select Possible Supplier',b'Velg Mulig Leverand\xc3\xb8r'
b'DocType: Sales Invoice',b'Source',b'Source'
b'DocType: Customer',"b'Select, to make the customer searchable with these fields'","b'Velg, for \xc3\xa5 gj\xc3\xb8re kunden s\xc3\xb8kbar med disse feltene'"
b'apps/erpnext/erpnext/templates/pages/projects.html +31',b'Show closed',b'Vis stengt'
b'DocType: Leave Type',b'Is Leave Without Pay',b'Er permisjon uten Pay'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +261',b'Asset Category is mandatory for Fixed Asset item',b'Asset Kategori er obligatorisk for Fixed Asset element'
b'DocType: Fee Validity',b'Fee Validity',b'Avgift Gyldighet'
b'apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +146',b'No records found in the Payment table',b'Ingen poster ble funnet i Payment tabellen'
b'apps/erpnext/erpnext/education/utils.py +19',b'This {0} conflicts with {1} for {2} {3}',b'Denne {0} konflikter med {1} for {2} {3}'
b'DocType: Student Attendance Tool',b'Students HTML',b'studenter HTML'
b'DocType: POS Profile',b'Apply Discount',b'Bruk rabatt'
b'DocType: GST HSN Code',b'GST HSN Code',b'GST HSN-kode'
b'DocType: Employee External Work History',b'Total Experience',b'Total Experience'
b'apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +70',b'Open Projects',b'\xc3\xa5pne Prosjekter'
b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +295',b'Packing Slip(s) cancelled',b'Pakking Slip (s) kansellert'
b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +36',b'Cash Flow from Investing',b'Kontantstr\xc3\xb8m fra investerings'
b'DocType: Program Course',b'Program Course',b'program Course'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +99',b'Freight and Forwarding Charges',b'Spedisjons- og Kostnader'
b'DocType: Homepage',b'Company Tagline for website homepage',b'Selskapet Undertittel for nettstedet hjemmeside'
b'DocType: Item Group',b'Item Group Name',b'Sak Gruppenavn'
b'apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py +27',b'Taken',b'Tatt'
b'DocType: Student',b'Date of Leaving',b'Dato Leaving'
b'DocType: Pricing Rule',b'For Price List',b'For Prisliste'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +27',b'Executive Search',b'Executive Search'
b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +55',b'Setting defaults',b'Angir standardinnstillinger'
b'apps/erpnext/erpnext/utilities/activation.py +63',b'Create Leads',b'Lag Leads'
b'DocType: Maintenance Schedule',b'Schedules',b'Rutetider'
b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +468',b'POS Profile is required to use Point-of-Sale',b'POS-profilen kreves for \xc3\xa5 bruke Point-of-Sale'
b'DocType: Purchase Invoice Item',b'Net Amount',b'Nettobel\xc3\xb8p'
b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +141',b'{0} {1} has not been submitted so the action cannot be completed',"b'{0} {1} er ikke sendt, s\xc3\xa5 handlingen kan ikke fullf\xc3\xb8res'"
b'DocType: Purchase Order Item Supplied',b'BOM Detail No',b'BOM Detail Nei'
b'DocType: Landed Cost Voucher',b'Additional Charges',b'Ekstra kostnader'
b'DocType: Purchase Invoice',b'Additional Discount Amount (Company Currency)',b'Ekstra rabatt Bel\xc3\xb8p (Selskap Valuta)'
b'DocType: Supplier Scorecard',b'Supplier Scorecard',b'Leverand\xc3\xb8r Scorecard'
b'DocType: Plant Analysis',b'Result Datetime',b'Resultat Datetime'
b'apps/erpnext/erpnext/accounts/doctype/account/account.js +21',b'Please create new account from Chart of Accounts.',b'Opprett ny konto fra kontoplanen.'
,b'Support Hour Distribution',b'Support Time Distribution'
b'DocType: Maintenance Visit',b'Maintenance Visit',b'Vedlikehold Visit'
b'DocType: Student',b'Leaving Certificate Number',b'Leaving Certificate Number'
b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +58',"b'Appointment cancelled, Please review and cancel the invoice {0}'","b'Avtale avbrutt, vennligst kontroller og avbryt fakturaen {0}'"
b'DocType: Sales Invoice Item',b'Available Batch Qty at Warehouse',b'Tilgjengelig Batch Antall p\xc3\xa5 Warehouse'
b'apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +9',b'Update Print Format',b'Oppdater Print Format'
b'DocType: Landed Cost Voucher',b'Landed Cost Help',b'Landed Cost Hjelp'
b'DocType: Purchase Invoice',b'Select Shipping Address',b'Velg leveringsadresse'
b'apps/erpnext/erpnext/config/non_profit.py +28',b'Memebership Details',b'Memebership Detaljer'
b'DocType: Leave Block List',b'Block Holidays on important days.',b'Block Ferie p\xc3\xa5 viktige dager.'
b'apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +220',b'Please input all required Result Value(s)',b'Vennligst skriv inn alle n\xc3\xb8dvendige Resultat Verdi (r)'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js +106',b'Accounts Receivable Summary',b'Kundefordringer Sammendrag'
b'DocType: Employee Loan',b'Monthly Repayment Amount',b'M\xc3\xa5nedlig nedbetaling bel\xc3\xb8pet'
b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html +9',b'Opening Invoices',b'\xc3\x85pning av fakturaer'
b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +195',b'Please set User ID field in an Employee record to set Employee Role',b'Vennligst angi bruker-ID-feltet i en Employee rekord \xc3\xa5 sette Employee Rolle'
b'DocType: UOM',b'UOM Name',b'M\xc3\xa5lenheter Name'
b'DocType: GST HSN Code',b'HSN Code',b'HSN kode'
b'apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +39',b'Contribution Amount',b'Bidrag Bel\xc3\xb8p'
b'DocType: Purchase Invoice',b'Shipping Address',b'Sendingsadresse'
b'DocType: Stock Reconciliation',b'This tool helps you to update or fix the quantity and valuation of stock in the system. It is typically used to synchronise the system values and what actually exists in your warehouses.',b'Dette verkt\xc3\xb8yet hjelper deg til \xc3\xa5 oppdatere eller fikse mengde og verdsetting av aksjer i systemet. Det er vanligvis brukes til \xc3\xa5 synkronisere systemverdier og hva som faktisk eksisterer i ditt varehus.'
b'DocType: Delivery Note',b'In Words will be visible once you save the Delivery Note.',b'I Ord vil v\xc3\xa6re synlig n\xc3\xa5r du lagrer f\xc3\xb8lgeseddel.'
b'DocType: Expense Claim',b'EXP',b'EXP'
b'DocType: Water Analysis',b'Container',b'Container'
b'apps/erpnext/erpnext/education/utils.py +50',b'Student {0} - {1} appears Multiple times in row {2} & {3}',b'Student {0} - {1} vises flere ganger p\xc3\xa5 rad {2} og {3}'
b'DocType: Project',b'Day to Send',b'Dag \xc3\xa5 sende'
b'DocType: Healthcare Settings',b'Manage Sample Collection',b'Administrer pr\xc3\xb8veinnsamling'
b'DocType: Production Plan',b'Ignore Existing Ordered Quantity',b'Ignorer eksisterende bestilt antall'
b'apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +66',b'Please set the series to be used.',b'Vennligst sett serien som skal brukes.'
b'DocType: Patient',b'Tobacco Past Use',b'Tidligere bruk av tobakk'
b'DocType: Sales Invoice Item',b'Brand Name',b'Merkenavn'
b'DocType: Purchase Receipt',b'Transporter Details',b'Transporter Detaljer'
b'apps/erpnext/erpnext/healthcare/doctype/physician/physician.py +55',b'User {0} is already assigned to Physician {1}',b'Bruker {0} er allerede tilordnet Legen {1}'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +2700',b'Default warehouse is required for selected item',b'Standardlager er n\xc3\xb8dvendig til den valgte artikkelen'
b'apps/erpnext/erpnext/utilities/user_progress.py +146',b'Box',b'Eske'
b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1038',b'Possible Supplier',b'mulig Leverand\xc3\xb8r'
b'DocType: Budget',b'Monthly Distribution',b'M\xc3\xa5nedlig Distribution'
b'apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +68',b'Receiver List is empty. Please create Receiver List',b'Mottaker-listen er tom. Opprett Receiver Liste'
b'apps/erpnext/erpnext/public/js/setup_wizard.js +31',b'Healthcare (beta)',b'Helsevesenet (beta)'
b'DocType: Production Plan Sales Order',b'Production Plan Sales Order',b'Produksjonsplan Salgsordre'
b'DocType: Sales Partner',b'Sales Partner Target',b'Sales Partner Target'
b'DocType: Loan Type',b'Maximum Loan Amount',b'Maksimal L\xc3\xa5nebel\xc3\xb8p'
b'DocType: Pricing Rule',b'Pricing Rule',b'Prising Rule'
b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +58',b'Duplicate roll number for student {0}',b'Dupliseringsnummer for student {0}'
b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +58',b'Duplicate roll number for student {0}',b'Dupliseringsnummer for student {0}'
b'DocType: Budget',b'Action if Annual Budget Exceeded',b'Tiltak hvis \xc3\x85rlig budsjett Skredet'
b'apps/erpnext/erpnext/config/learn.py +197',b'Material Request to Purchase Order',b'Materialet Request til innkj\xc3\xb8psordre'
b'DocType: Shopping Cart Settings',b'Payment Success URL',b'Betaling Suksess URL'
b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +81',b'Row # {0}: Returned Item {1} does not exists in {2} {3}',b'Row # {0}: Returned Element {1} ikke eksisterer i {2} {3}'
b'DocType: Purchase Receipt',b'PREC-',b'PREC-'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +16',b'Bank Accounts',b'Bankkontoer'
,b'Bank Reconciliation Statement',b'Bankavstemming Statement'
b'DocType: Consultation',b'Medical Coding',b'Medisinsk koding'
b'DocType: Healthcare Settings',b'Reminder Message',b'P\xc3\xa5minnelsesmelding'
,b'Lead Name',b'Lead Name'
,b'POS',b'POS'
b'DocType: C-Form',b'III',b'III'
b'apps/erpnext/erpnext/config/stock.py +314',b'Opening Stock Balance',b'\xc3\x85pning Stock Balance'
b'apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +58',b'{0} must appear only once',b'{0} m\xc3\xa5 vises bare en gang'
b'apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +59',b'Leaves Allocated Successfully for {0}',b'Etterlater Avsatt Vellykket for {0}'
b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +42',b'No Items to pack',b'Ingenting \xc3\xa5 pakke'
b'DocType: Shipping Rule Condition',b'From Value',b'Fra Verdi'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +606',b'Manufacturing Quantity is mandatory',b'Manufacturing Antall er obligatorisk'
b'DocType: Employee Loan',b'Repayment Method',b'tilbakebetaling Method'
b'DocType: Products Settings',"b'If checked, the Home page will be the default Item Group for the website'","b'Hvis det er merket, vil hjemmesiden v\xc3\xa6re standard Varegruppe for nettstedet'"
b'DocType: Quality Inspection Reading',b'Reading 4',b'Reading 4'
b'apps/erpnext/erpnext/config/hr.py +132',b'Claims for company expense.',b'Krav p\xc3\xa5 bekostning av selskapet.'
b'apps/erpnext/erpnext/utilities/activation.py +118',"b'Students are at the heart of the system, add all your students'","b'Studentene er i hjertet av systemet, legge til alle elevene'"
b'apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +97',b'Row #{0}: Clearance date {1} cannot be before Cheque Date {2}',b'Row # {0}: Clearance date {1} kan ikke v\xc3\xa6re f\xc3\xb8r Cheque Dato {2}'
b'DocType: Asset Maintenance Task',b'Certificate Required',b'Sertifikat kreves'
b'DocType: Company',b'Default Holiday List',b'Standard Holiday List'
b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +196',b'Row {0}: From Time and To Time of {1} is overlapping with {2}',b'Rad {0}: Fra tid og klokkeslett {1} er overlappende med {2}'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +145',b'Stock Liabilities',b'Aksje Gjeld'
b'DocType: Purchase Invoice',b'Supplier Warehouse',b'Leverand\xc3\xb8r Warehouse'
b'DocType: Opportunity',b'Contact Mobile No',b'Kontakt Mobile No'
b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +399',b'Select Company',b'Velg firma'
,b'Material Requests for which Supplier Quotations are not created',b'Materielle Foresp\xc3\xb8rsler som Leverand\xc3\xb8r Sitater ikke er opprettet'
b'DocType: Student Report Generation Tool',b'Print Section',b'Utskriftseksjon'
b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +34',"b""User {0} doesn't have any default POS Profile. Check Default at Row {1} for this User.""",b'Bruker {0} har ingen standard POS-profil. Kontroller standard i rad {1} for denne brukeren.'
b'DocType: Student Group',b'Set 0 for no limit',b'Sett 0 for ingen begrensning'
b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +122',b'The day(s) on which you are applying for leave are holidays. You need not apply for leave.',b'Dagen (e) der du s\xc3\xb8ker om permisjon er helligdager. Du trenger ikke s\xc3\xb8ke om permisjon.'
b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +64',b'Row {idx}: {field} is required to create the Opening {invoice_type} Invoices',b'Row {idx}: {field} er p\xc3\xa5krevd for \xc3\xa5 opprette Fakturaer for \xc3\xa5pning {faktura_type}'
b'DocType: Customer',b'Primary Address and Contact Detail',b'Prim\xc3\xa6radresse og kontaktdetaljer'
b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +20',b'Resend Payment Email',b'Sende Betaling Email'
b'apps/erpnext/erpnext/templates/pages/projects.html +27',b'New task',b'Ny oppgave'
b'DocType: Consultation',b'Appointment',b'Avtale'
b'apps/erpnext/erpnext/utilities/activation.py +74',b'Make Quotation',b'Gj\xc3\xb8r sitat'
b'apps/erpnext/erpnext/config/education.py +230',b'Other Reports',b'andre rapporter'
b'apps/erpnext/erpnext/public/js/setup_wizard.js +39',b'Please select at least one domain.',b'Vennligst velg minst ett domene.'
b'DocType: Dependent Task',b'Dependent Task',b'Avhengig Task'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +444',b'Conversion factor for default Unit of Measure must be 1 in row {0}',b'Omregningsfaktor for standard Enhet m\xc3\xa5 v\xc3\xa6re en i rad {0}'
b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +188',b'Leave of type {0} cannot be longer than {1}',b'Permisjon av typen {0} kan ikke v\xc3\xa6re lengre enn {1}'
b'DocType: Manufacturing Settings',b'Try planning operations for X days in advance.',b'Pr\xc3\xb8v \xc3\xa5 planlegge operasjoner for X dager i forveien.'
b'DocType: HR Settings',b'Stop Birthday Reminders',b'Stop bursdagsp\xc3\xa5minnelser'
b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +235',b'Please set Default Payroll Payable Account in Company {0}',b'Vennligst sette Standard L\xc3\xb8nn betales konto i selskapet {0}'
b'DocType: SMS Center',b'Receiver List',b'Mottaker List'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +1094',b'Search Item',b'S\xc3\xb8k Element'
b'DocType: Payment Schedule',b'Payment Amount',b'Betalings Bel\xc3\xb8p'
b'DocType: Patient Appointment',b'Referring Physician',b'Refererende lege'
b'apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +46',b'Consumed Amount',b'Forbrukes Bel\xc3\xb8p'
b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +100',b'Net Change in Cash',b'Netto endring i kontanter'
b'DocType: Assessment Plan',b'Grading Scale',b'Grading Scale'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +438',b'Unit of Measure {0} has been entered more than once in Conversion Factor Table',b'Enhet {0} har blitt lagt inn mer enn \xc3\xa9n gang i omregningsfaktor tabell'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +639',b'Already completed',b'allerede fullf\xc3\xb8rt'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +33',b'Stock In Hand',b'Lager i h\xc3\xa5nd'
b'apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +64',b'Import Successful!',b'Import Vellykket!'
b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +29',b'Payment Request already exists {0}',b'Betaling Request allerede eksisterer {0}'
b'apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +27',b'Cost of Issued Items',b'Cost of Utstedte Items'
b'DocType: Physician',b'Hospital',b'Sykehus'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +385',b'Quantity must not be more than {0}',b'Antall m\xc3\xa5 ikke v\xc3\xa6re mer enn {0}'
b'apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +117',b'Previous Financial Year is not closed',b'Foreg\xc3\xa5ende regnskaps\xc3\xa5r er ikke stengt'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +46',b'Age (Days)',b'Alder (dager)'
b'DocType: Quotation Item',b'Quotation Item',b'Sitat Element'
b'DocType: Customer',b'Customer POS Id',b'Kundens POS-ID'
b'DocType: Account',b'Account Name',b'Brukernavn'
b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +40',b'From Date cannot be greater than To Date',b'Fra dato ikke kan v\xc3\xa6re st\xc3\xb8rre enn To Date'
b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +198',b'Serial No {0} quantity {1} cannot be a fraction',b'Serial No {0} mengde {1} kan ikke v\xc3\xa6re en br\xc3\xb8kdel'
b'apps/erpnext/erpnext/config/buying.py +43',b'Supplier Type master.',b'Leverand\xc3\xb8r Type mester.'
b'DocType: Purchase Order Item',b'Supplier Part Number',b'Leverand\xc3\xb8r delenummer'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +108',b'Conversion rate cannot be 0 or 1',b'Konverteringsfrekvens kan ikke v\xc3\xa6re 0 eller 1'
b'DocType: Share Balance',b'To No',b'Til nr'
b'DocType: Subscription',b'Reference Document',b'Reference Document'
b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +229',b'{0} {1} is cancelled or stopped',b'{0} {1} avbrytes eller stoppes'
b'DocType: Accounts Settings',b'Credit Controller',b'Credit Controller'
b'DocType: Grant Application',b'Applicant Type',b'S\xc3\xb8ker Type'
b'DocType: Purchase Invoice',b'03-Deficiency in services',b'03-mangel p\xc3\xa5 tjenester'
b'DocType: Delivery Note',b'Vehicle Dispatch Date',b'Vehicle Publiseringsdato'
b'DocType: Healthcare Settings',b'Default Medical Code Standard',b'Standard medisinsk kode Standard'
b'DocType: Purchase Invoice Item',b'HSN/SAC',b'HSN / SAC'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +237',b'Purchase Receipt {0} is not submitted',b'Kvitteringen {0} er ikke innsendt'
b'DocType: Company',b'Default Payable Account',b'Standard Betales konto'
b'apps/erpnext/erpnext/config/website.py +17',"b'Settings for online shopping cart such as shipping rules, price list etc.'","b'Innstillinger for online shopping cart som skipsregler, prisliste etc.'"
b'apps/erpnext/erpnext/controllers/website_list_for_contact.py +113',b'{0}% Billed',b'{0}% Fakturert'
b'apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +18',b'Reserved Qty',b'Reservert Antall'
b'DocType: Party Account',b'Party Account',b'Partiet konto'
b'apps/erpnext/erpnext/config/setup.py +122',b'Human Resources',b'Menneskelige Ressurser'
b'DocType: Lead',b'Upper Income',b'\xc3\x98vre Inntekt'
b'apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +17',b'Reject',b'Avvis'
b'DocType: Journal Entry Account',b'Debit in Company Currency',b'Debet i selskapet Valuta'
b'DocType: BOM Item',b'BOM Item',b'BOM Element'
b'DocType: Appraisal',b'For Employee',b'For Employee'
b'apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.js +49',b'Make Disbursement Entry',b'Gj\xc3\xb8r Utbetaling Entry'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +138',b'Row {0}: Advance against Supplier must be debit',b'Rad {0}: Advance mot Leverand\xc3\xb8ren skal belaste'
b'DocType: Company',b'Default Values',b'Standardverdier'
b'DocType: Membership',b'INR',b'INR'
b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +60',b'{frequency} Digest',b'{Frequency} Digest'
b'DocType: Expense Claim',b'Total Amount Reimbursed',b'Totalbel\xc3\xb8p Refusjon'
b'apps/erpnext/erpnext/hr/doctype/vehicle/vehicle_dashboard.py +5',b'This is based on logs against this Vehicle. See timeline below for details',b'Dette er basert p\xc3\xa5 loggene mot denne bilen. Se tidslinjen nedenfor for detaljer'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +90',b'Against Supplier Invoice {0} dated {1}',b'Mot Leverand\xc3\xb8r Faktura {0} datert {1}'
b'DocType: Customer',b'Default Price List',b'Standard Prisliste'
b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +322',b'Asset Movement record {0} created',b'Asset Movement rekord {0} er opprettet'
b'apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +51',b'You cannot delete Fiscal Year {0}. Fiscal Year {0} is set as default in Global Settings',b'Du kan ikke slette regnskaps\xc3\xa5r {0}. Regnskaps\xc3\xa5ret {0} er satt som standard i Globale innstillinger'
b'apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.py +20',b'A customer with the same name already exists',b'En kunde med samme navn eksisterer allerede'
b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +185',b'This will submit Salary Slips and create accrual Journal Entry. Do you want to proceed?',b'Dette vil sende L\xc3\xb8nnsslipp og opprette periodiseringstabell. Vil du fortsette?'
b'DocType: Purchase Invoice',b'Total Net Weight',b'Total nettovikt'
b'DocType: Purchase Invoice',b'Eligibility For ITC',b'Kvalifisering for ITC'
b'DocType: Journal Entry',b'Entry Type',b'Entry Type'
,b'Customer Credit Balance',b'Customer Credit Balance'
b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +28',b'Net Change in Accounts Payable',b'Netto endring i leverand\xc3\xb8rgjeld'
b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +48',b'EcritureLet',b'EcritureLet'
b'apps/erpnext/erpnext/selling/doctype/customer/customer.py +209',b'Credit limit has been crossed for customer {0} ({1}/{2})',b'Kredittgrensen er krysset for kunden {0} ({1} / {2})'
b'apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +42',"b""Customer required for 'Customerwise Discount'""",b'Kunden n\xc3\xb8dvendig for &#39;Customerwise Discount&#39;'
b'apps/erpnext/erpnext/config/accounts.py +140',b'Update bank payment dates with journals.',b'Oppdatere bankbetalings datoer med tidsskrifter.'
b'apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +21',b'Pricing',b'Priser'
b'DocType: Quotation',b'Term Details',b'Term Detaljer'
b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +30',b'Cannot enroll more than {0} students for this student group.',b'Kan ikke registrere mer enn {0} studentene p\xc3\xa5 denne studentgruppen.'
b'apps/erpnext/erpnext/templates/print_formats/includes/total.html +4',b'Total (Without Tax)',b'Totalt (uten skatt)'
b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +17',b'Lead Count',b'Lead Count'
b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +17',b'Lead Count',b'Lead Count'
b'apps/erpnext/erpnext/assets/doctype/asset_category/asset_category.py +15',b'{0} must be greater than 0',b'{0} m\xc3\xa5 v\xc3\xa6re st\xc3\xb8rre enn 0'
b'apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +30',b'Stock Available',b'P\xc3\xa5 lager'
b'DocType: Manufacturing Settings',b'Capacity Planning For (Days)',b'Kapasitetsplanlegging For (dager)'
b'apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py +10',b'Procurement',b'innkj\xc3\xb8p'
b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +66',b'None of the items have any change in quantity or value.',b'Ingen av elementene har noen endring i mengde eller verdi.'
b'apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +17',b'Mandatory field - Program',b'Obligatorisk felt - Program'
b'DocType: Special Test Template',b'Result Component',b'Resultat Komponent'
b'apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.js +46',b'Warranty Claim',b'Garantikrav'
,b'Lead Details',b'Lead Detaljer'
b'DocType: Volunteer',b'Availability and Skills',b'Tilgjengelighet og ferdigheter'
b'DocType: Salary Slip',b'Loan repayment',b'l\xc3\xa5n tilbakebetaling'
b'DocType: Purchase Invoice',"b""End date of current invoice's period""",b'Sluttdato for gjeldende faktura periode'
b'DocType: Pricing Rule',b'Applicable For',b'Aktuelt For'
b'DocType: Lab Test',b'Technician Name',b'Tekniker Navn'
b'DocType: Accounts Settings',b'Unlink Payment on Cancellation of Invoice',b'Oppheve koblingen Betaling ved kansellering av faktura'
b'apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +16',b'Current Odometer reading entered should be greater than initial Vehicle Odometer {0}',b'N\xc3\xa5v\xc3\xa6rende Kilometerstand inng\xc3\xa5tt b\xc3\xb8r v\xc3\xa6re st\xc3\xb8rre enn f\xc3\xb8rste Vehicle Teller {0}'
b'DocType: Restaurant Reservation',b'No Show',b'Uteblivelse'
b'DocType: Shipping Rule Country',b'Shipping Rule Country',b'Shipping Rule Land'
b'apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +10',b'Leave and Attendance',b'La og oppm\xc3\xb8te'
b'DocType: Maintenance Visit',b'Partially Completed',b'Delvis Fullf\xc3\xb8rt'
b'apps/erpnext/erpnext/healthcare/setup.py +257',b'Moderate Sensitivity',b'Moderat f\xc3\xb8lsomhet'
b'DocType: Leave Type',b'Include holidays within leaves as leaves',b'Inkluder hellig innen blader som l\xc3\xb8v'
b'DocType: Sales Invoice',b'Packed Items',b'Lunsj Items'
b'apps/erpnext/erpnext/config/support.py +27',b'Warranty Claim against Serial No.',b'Garantikrav mot Serial No.'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +197',"b""'Total'""",b'&#39;Total&#39;'
b'DocType: Shopping Cart Settings',b'Enable Shopping Cart',b'Aktiver Handlevogn'
b'DocType: Employee',b'Permanent Address',b'Permanent Adresse'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +260',b'Advance paid against {0} {1} cannot be greater \\\n\t\t\t\t\t\tthan Grand Total {2}',b'Advance betalt mot {0} {1} kan ikke v\xc3\xa6re st\xc3\xb8rre \\ enn Totalsum {2}'
b'DocType: Consultation',b'Medication',b'medisinering'
b'DocType: Production Plan',b'Include Non Stock Items',b'Inkluder ikke-varelager'
b'DocType: Project Update',b'Challenging/Slow',b'Utfordrende / Slow'
b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +147',b'Please select item code',b'Velg elementet kode'
b'DocType: Student Sibling',b'Studying in Same Institute',b'\xc3\x85 studere i samme institutt'
b'DocType: Territory',b'Territory Manager',b'Distriktssjef'
b'DocType: Packed Item',b'To Warehouse (Optional)',b'Til Warehouse (valgfritt)'
b'DocType: GST Settings',b'GST Accounts',b'GST-kontoer'
b'DocType: Payment Entry',b'Paid Amount (Company Currency)',b'Innbetalt bel\xc3\xb8p (Company Valuta)'
b'DocType: Purchase Invoice',b'Additional Discount',b'Ekstra rabatt'
b'DocType: Selling Settings',b'Selling Settings',b'Selge Innstillinger'
b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +83',b'Confirm Action',b'Bekreft handling'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +39',b'Online Auctions',b'Online auksjoner'
b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +100',b'Please specify either Quantity or Valuation Rate or both',b'Vennligst oppgi enten Mengde eller Verdivurdering Rate eller begge deler'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order_dashboard.py +18',b'Fulfillment',b'Oppfyllelse'
b'apps/erpnext/erpnext/templates/generators/item.html +82',b'View in Cart',b'Vis i handlekurven'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +103',b'Marketing Expenses',b'Markedsf\xc3\xb8ringskostnader'
,b'Item Shortage Report',b'Sak Mangel Rapporter'
b'apps/erpnext/erpnext/education/doctype/assessment_criteria/assessment_criteria.py +15',"b""Can't create standard criteria. Please rename the criteria""",b'Kan ikke opprette standard kriterier. Vennligst gi nytt navn til kriteriene'
b'apps/erpnext/erpnext/stock/doctype/item/item.js +311',"b'Weight is mentioned,\\nPlease mention ""Weight UOM"" too'","b'Vekt er nevnt, \\ nVennligst nevne &quot;Weight m\xc3\xa5lenheter&quot; ogs\xc3\xa5'"
b'DocType: Stock Entry Detail',b'Material Request used to make this Stock Entry',b'Materialet Request brukes til \xc3\xa5 gj\xc3\xb8re dette lager Entry'
b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +68',b'Next Depreciation Date is mandatory for new asset',b'Neste Avskrivninger dato er obligatorisk for ny aktiva'
b'DocType: Student Group Creation Tool',b'Separate course based Group for every Batch',b'Separat kursbasert gruppe for hver batch'
b'DocType: Student Group Creation Tool',b'Separate course based Group for every Batch',b'Separat kursbasert gruppe for hver batch'
b'apps/erpnext/erpnext/config/support.py +32',b'Single unit of an Item.',b'Enkelt enhet av et element.'
b'DocType: Fee Category',b'Fee Category',b'Fee Kategori'
b'DocType: Agriculture Task',b'Next Business Day',b'Neste arbeidsdag'
b'DocType: Drug Prescription',b'Dosage by time interval',b'Dosering etter tidsintervall'
b'DocType: Cash Flow Mapper',b'Section Header',b'Seksjonsoverskrift'
,b'Student Fee Collection',b'Student Fee Collection'
b'apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +24',b'Appointment Duration (mins)',b'Avtale Varighet (min)'
b'DocType: Accounts Settings',b'Make Accounting Entry For Every Stock Movement',b'Gj\xc3\xb8r regnskap Entry For Hver Stock Movement'
b'DocType: Leave Allocation',b'Total Leaves Allocated',b'Totalt Leaves Avsatt'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +163',b'Warehouse required at Row No {0}',b'Warehouse kreves ved Row Nei {0}'
b'apps/erpnext/erpnext/public/js/setup_wizard.js +145',b'Please enter valid Financial Year Start and End Dates',b'Fyll inn gyldig Regnskaps\xc3\xa5r start- og sluttdato'
b'DocType: Employee',b'Date Of Retirement',b'Pensjoneringstidspunktet'
b'DocType: Upload Attendance',b'Get Template',b'F\xc3\xa5 Mal'
b'DocType: Material Request',b'Transferred',b'overf\xc3\xb8rt'
b'DocType: Vehicle',b'Doors',b'd\xc3\xb8rer'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/defaults_setup.py +117',b'ERPNext Setup Complete!',b'ERPNext Setup Complete!'
b'DocType: Healthcare Settings',b'Collect Fee for Patient Registration',b'Samle avgift for pasientregistrering'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +678',b'Cannot change Attributes after stock transaction. Make a new Item and transfer stock to the new Item',b'Kan ikke endre attributter etter aksje transaksjon. Lag en ny vare og overf\xc3\xb8r lager til den nye varen'
b'DocType: Course Assessment Criteria',b'Weightage',b'Weightage'
b'DocType: Purchase Invoice',b'Tax Breakup',b'Skatteavbrudd'
b'DocType: Packing Slip',b'PS-',b'PS'
b'DocType: Member',b'Non Profit Member',b'Ikke-profittmedlem'
b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +67',"b""{0} {1}: Cost Center is required for 'Profit and Loss' account {2}. Please set up a default Cost Center for the Company.""",b'{0} {1}: Det kreves kostnadssted for &#39;resultat&#39; konto {2}. Sett opp en standardkostnadssted for selskapet.'
b'DocType: Payment Schedule',b'Payment Term',b'Betalingsperiode'
b'apps/erpnext/erpnext/selling/doctype/customer/customer.py +160',b'A Customer Group exists with same name please change the Customer name or rename the Customer Group',b'En kundegruppe eksisterer med samme navn kan du endre Kundens navn eller endre navn p\xc3\xa5 Kundegruppe'
b'DocType: Land Unit',b'Area',b'Omr\xc3\xa5de'
b'apps/erpnext/erpnext/public/js/templates/contact_list.html +37',b'New Contact',b'Ny kontakt'
b'DocType: Territory',b'Parent Territory',b'Parent Territory'
b'DocType: Purchase Invoice',b'Place of Supply',b'Leveringssted'
b'DocType: Quality Inspection Reading',b'Reading 2',b'Reading 2'
b'DocType: Stock Entry',b'Material Receipt',b'Materialet Kvittering'
b'DocType: Homepage',b'Products',b'Produkter'
b'DocType: Announcement',b'Instructor',b'Instrukt\xc3\xb8r'
b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js +61',b'Select Item (optional)',b'Velg element (valgfritt)'
b'DocType: Fee Schedule Student Group',b'Fee Schedule Student Group',b'Avgift Schedule Student Group'
b'DocType: Student',b'AB+',b'AB +'
b'DocType: Item',"b'If this item has variants, then it cannot be selected in sales orders etc.'","b'Hvis dette elementet har varianter, s\xc3\xa5 det kan ikke velges i salgsordrer etc.'"
b'DocType: Lead',b'Next Contact By',b'Neste Kontakt Av'
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +325',b'Quantity required for Item {0} in row {1}',b'Mengden som kreves for Element {0} i rad {1}'
b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +45',b'Warehouse {0} can not be deleted as quantity exists for Item {1}',b'Warehouse {0} kan ikke slettes som kvantitet finnes for Element {1}'
b'DocType: Quotation',b'Order Type',b'Ordretype'
,b'Item-wise Sales Register',b'Element-messig Sales Register'
b'DocType: Asset',b'Gross Purchase Amount',b'Bruttobel\xc3\xb8pet'
b'apps/erpnext/erpnext/utilities/user_progress.py +39',b'Opening Balances',b'\xc3\x85pningsbalanser'
b'DocType: Asset',b'Depreciation Method',b'avskrivningsmetode'
b'DocType: Purchase Taxes and Charges',b'Is this Tax included in Basic Rate?',b'Er dette inklusiv i Basic Rate?'
b'apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +56',b'Total Target',b'Total Target'
b'DocType: Soil Texture',b'Sand Composition (%)',b'Sandkomposisjon (%)'
b'DocType: Job Applicant',b'Applicant for a Job',b'Kandidat til en jobb'
b'DocType: Production Plan Material Request',b'Production Plan Material Request',b'Produksjonsplan Material Request'
b'DocType: Stock Reconciliation',b'Reconciliation JSON',b'Avstemming JSON'
b'apps/erpnext/erpnext/accounts/report/financial_statements.html +3',b'Too many columns. Export the report and print it using a spreadsheet application.',b'For mange kolonner. Eksportere rapporten og skrive den ut ved hjelp av et regnearkprogram.'
b'DocType: Purchase Invoice Item',b'Batch No',b'Batch No'
b'DocType: Selling Settings',"b""Allow multiple Sales Orders against a Customer's Purchase Order""",b'Tillat flere salgsordrer mot kundens innkj\xc3\xb8psordre'
b'DocType: Student Group Instructor',b'Student Group Instructor',b'Studentgruppeinstrukt\xc3\xb8r'
b'DocType: Grant Application',b'Assessment  Mark (Out of 10)',b'Vurderingsmerke (ut av 10)'
b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +61',b'Guardian2 Mobile No',b'Guardian2 Mobile No'
b'apps/erpnext/erpnext/setup/doctype/company/company.py +218',b'Main',b'Hoved'
b'apps/erpnext/erpnext/stock/doctype/item/item.js +72',b'Variant',b'Variant'
b'DocType: Naming Series',b'Set prefix for numbering series on your transactions',b'Still prefiks for nummerering serien p\xc3\xa5 dine transaksjoner'
b'DocType: Employee Attendance Tool',b'Employees HTML',b'ansatte HTML'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +458',b'Default BOM ({0}) must be active for this item or its template',b'Standard BOM ({0}) m\xc3\xa5 v\xc3\xa6re aktiv for denne varen eller dens mal'
b'DocType: Employee',b'Leave Encashed?',b'Permisjon encashed?'
b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +32',b'Opportunity From field is mandatory',b'Opportunity Fra-feltet er obligatorisk'
b'DocType: Email Digest',b'Annual Expenses',b'\xc3\xa5rlige utgifter'
b'DocType: Item',b'Variants',b'Varianter'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1148',b'Make Purchase Order',b'Gj\xc3\xb8r innkj\xc3\xb8psordre'
b'DocType: SMS Center',b'Send To',b'Send Til'
b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +133',b'There is not enough leave balance for Leave Type {0}',b'Det er ikke nok permisjon balanse for La Type {0}'
b'DocType: Payment Reconciliation Payment',b'Allocated amount',b'Bevilget bel\xc3\xb8p'
b'DocType: Sales Team',b'Contribution to Net Total',b'Bidrag til Net Total'
b'DocType: Sales Invoice Item',"b""Customer's Item Code""",b'Kundens Elementkode'
b'DocType: Stock Reconciliation',b'Stock Reconciliation',b'Stock Avstemming'
b'DocType: Territory',b'Territory Name',b'Territorium Name'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +204',b'Work-in-Progress Warehouse is required before Submit',b'Work-in-progress Warehouse er n\xc3\xb8dvendig f\xc3\xb8r Send'
b'apps/erpnext/erpnext/config/hr.py +40',b'Applicant for a Job.',b'Kandidat til en jobb.'
b'DocType: Purchase Order Item',b'Warehouse and Reference',b'Warehouse og Reference'
b'DocType: Supplier',b'Statutory info and other general information about your Supplier',b'Lovfestet info og annen generell informasjon om din Leverand\xc3\xb8r'
b'DocType: Item',b'Serial Nos and Batches',b'Serienummer og partier'
b'apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py +42',b'Student Group Strength',b'Studentgruppestyrke'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +261',b'Against Journal Entry {0} does not have any unmatched {1} entry',b'Mot Journal Entry {0} har ikke noen enest\xc3\xa5ende {1} oppf\xc3\xb8ring'
b'apps/erpnext/erpnext/config/hr.py +142',b'Appraisals',b'medarbeidersamtaler'
b'apps/erpnext/erpnext/hr/doctype/training_program/training_program_dashboard.py +8',b'Training Events',b'Treningsarrangementer'
b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +205',b'Duplicate Serial No entered for Item {0}',b'Duplisere serie Ingen kom inn for Element {0}'
b'apps/erpnext/erpnext/config/selling.py +179',b'Track Leads by Lead Source.',b'Sporledninger av blykilde.'
b'DocType: Shipping Rule Condition',b'A condition for a Shipping Rule',b'En forutsetning for en Shipping Rule'
b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +167',b'Please enter ',b'Vennligst skriv inn'
b'apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js +43',b'Maintenance Log',b'Vedlikeholdslogg'
b'apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +236',b'Please set filter based on Item or Warehouse',b'Vennligst sette filter basert p\xc3\xa5 varen eller Warehouse'
b'DocType: Packing Slip',b'The net weight of this package. (calculated automatically as sum of net weight of items)',b'Nettovekten av denne pakken. (Automatisk beregnet som summen av nettovekt elementer)'
b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +802',b'Discount amount cannot be greater than 100%',b'Rabattbel\xc3\xb8p kan ikke v\xc3\xa6re st\xc3\xb8rre enn 100%'
b'DocType: Sales Order',b'To Deliver and Bill',b'\xc3\x85 levere og Bill'
b'DocType: Student Group',b'Instructors',b'instrukt\xc3\xb8rer'
b'DocType: GL Entry',b'Credit Amount in Account Currency',b'Credit bel\xc3\xb8p p\xc3\xa5 kontoen Valuta'
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +603',b'BOM {0} must be submitted',b'BOM {0} m\xc3\xa5 sendes'
b'apps/erpnext/erpnext/config/accounts.py +460',b'Share Management',b'Aksjeforvaltning'
b'DocType: Authorization Control',b'Authorization Control',b'Autorisasjon kontroll'
b'apps/erpnext/erpnext/controllers/buying_controller.py +317',b'Row #{0}: Rejected Warehouse is mandatory against rejected Item {1}',b'Row # {0}: Avvist Warehouse er obligatorisk mot avvist Element {1}'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +810',b'Payment',b'Betaling'
b'apps/erpnext/erpnext/controllers/stock_controller.py +92',"b'Warehouse {0} is not linked to any account, please mention the account in  the warehouse record or set default inventory account in company {1}.'","b'Lager {0} er ikke knyttet til noen konto, vennligst oppgi kontoen i lagerregisteret eller sett inn standardbeholdningskonto i selskap {1}.'"
b'apps/erpnext/erpnext/utilities/activation.py +81',b'Manage your orders',b'Administrere dine bestillinger'
b'DocType: Work Order Operation',b'Actual Time and Cost',b'Faktisk leveringstid og pris'
b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +56',b'Material Request of maximum {0} can be made for Item {1} against Sales Order {2}',b'Materialet Request av maksimal {0} kan gj\xc3\xb8res for Element {1} mot Salgsordre {2}'
b'DocType: Crop',b'Crop Spacing',b'Beskj\xc3\xa6ringsavstand'
b'DocType: Course',b'Course Abbreviation',b'Kurs forkortelse'
b'DocType: Student Leave Application',b'Student Leave Application',b'Student La Application'
b'DocType: Item',b'Will also apply for variants',b'Vil ogs\xc3\xa5 gjelde for varianter'
b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +217',"b'Asset cannot be cancelled, as it is already {0}'","b'Asset kan ikke avbestilles, som det allerede er {0}'"
b'apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +29',b'Employee {0} on Half day on {1}',b'Employee {0} p\xc3\xa5 halv dag {1}'
b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +42',b'Total working hours should not be greater than max working hours {0}',b'Samlet arbeidstid m\xc3\xa5 ikke v\xc3\xa6re st\xc3\xb8rre enn maks arbeidstid {0}'
b'apps/erpnext/erpnext/templates/pages/task_info.html +90',b'On',b'P\xc3\xa5'
b'apps/erpnext/erpnext/config/selling.py +62',b'Bundle items at time of sale.',b'Bundle elementer p\xc3\xa5 salgstidspunktet.'
b'DocType: Material Request Plan Item',b'Actual Qty',b'Selve Antall'
b'DocType: Sales Invoice Item',b'References',b'Referanser'
b'DocType: Quality Inspection Reading',b'Reading 10',b'Lese 10'
b'DocType: Item',b'Barcodes',b'strek~~POS=TRUNC'
b'DocType: Hub Category',b'Hub Node',b'Hub Node'
b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +78',b'You have entered duplicate items. Please rectify and try again.',b'Du har skrevet inn like elementer. Vennligst utbedre og pr\xc3\xb8v igjen.'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +129',b'Associate',b'Forbinder'
b'DocType: Asset Movement',b'Asset Movement',b'Asset Movement'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +508',b'Work Order {0} must be submitted',b'Arbeidsordre {0} m\xc3\xa5 sendes'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +2214',b'New Cart',b'New Handlekurv'
b'apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +44',b'Item {0} is not a serialized Item',b'Element {0} er ikke en serie Element'
b'DocType: SMS Center',b'Create Receiver List',b'Lag Receiver List'
b'DocType: Vehicle',b'Wheels',b'hjul'
b'DocType: Packing Slip',b'To Package No.',b'\xc3\x85 pakke No.'
b'DocType: Patient Relation',b'Family',b'Familie'
b'DocType: Production Plan',b'Material Requests',b'material~~POS=TRUNC Foresp\xc3\xb8rsler'
b'DocType: Warranty Claim',b'Issue Date',b'Utgivelsesdato'
b'DocType: Activity Cost',b'Activity Cost',b'Aktivitet Kostnad'
b'DocType: Sales Invoice Timesheet',b'Timesheet Detail',b'Timeregistrering Detalj'
b'DocType: Purchase Receipt Item Supplied',b'Consumed Qty',b'Forbrukes Antall'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +52',b'Telecommunications',b'Telekommunikasjon'
b'apps/erpnext/erpnext/accounts/party.py +263',"b""Billing currency must be equal to either default company's currency or party account currency""",b'Faktureringsvaluta m\xc3\xa5 v\xc3\xa6re lik enten selskapets valuta- eller partikonto-valuta'
b'DocType: Packing Slip',b'Indicates that the package is a part of this delivery (Only Draft)',b'Indikerer at pakken er en del av denne leveransen (Kun Draft)'
b'DocType: Soil Texture',b'Loam',b'leirjord'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +705',b'Row {0}: Due Date cannot be before posting date',b'Row {0}: Forfallsdato kan ikke v\xc3\xa6re f\xc3\xb8r innleggsdato'
b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +36',b'Make Payment Entry',b'Utf\xc3\xb8r betaling Entry'
b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +129',b'Quantity for Item {0} must be less than {1}',b'Kvantum for Element {0} m\xc3\xa5 v\xc3\xa6re mindre enn {1}'
,b'Sales Invoice Trends',b'Salgsfaktura Trender'
b'DocType: Leave Application',b'Apply / Approve Leaves',b'P\xc3\xa5f\xc3\xb8r / Godkjenn L\xc3\xb8v'
b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +3',b'For',b'Til'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +167',"b""Can refer row only if the charge type is 'On Previous Row Amount' or 'Previous Row Total'""",b'Kan referere rad bare hvis belastningen typen er &#39;On Forrige Row bel\xc3\xb8p &quot;eller&quot; Forrige Row Totals'
b'DocType: Sales Order Item',b'Delivery Warehouse',b'Levering Warehouse'
b'apps/erpnext/erpnext/config/accounts.py +241',b'Tree of financial Cost Centers.',b'Tre av finansielle kostnadssteder.'
b'DocType: Serial No',b'Delivery Document No',b'Levering Dokument nr'
b'apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +191',"b""Please set 'Gain/Loss Account on Asset Disposal' in Company {0}""",b'Vennligst sett &#39;Gevinst / tap-konto p\xc3\xa5 Asset Deponering &quot;i selskapet {0}'
b'DocType: Landed Cost Voucher',b'Get Items From Purchase Receipts',b'F\xc3\xa5 elementer fra innkj\xc3\xb8ps Receipts'
b'DocType: Serial No',b'Creation Date',b'Dato opprettet'
b'apps/erpnext/erpnext/stock/doctype/item_price/item_price.py +33',b'Item {0} appears multiple times in Price List {1}',b'Element {0} forekommer flere ganger i Prisliste {1}'
b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +41',"b'Selling must be checked, if Applicable For is selected as {0}'","b'Selling m\xc3\xa5 sjekkes, hvis dette gjelder for er valgt som {0}'"
b'DocType: Production Plan Material Request',b'Material Request Date',b'Materiale Request Dato'
b'DocType: Purchase Order Item',b'Supplier Quotation Item',b'Leverand\xc3\xb8r sitat Element'
b'DocType: Student',b'Student Mobile Number',b'Student Mobilnummer'
b'DocType: Item',b'Has Variants',b'Har Varianter'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +488',"b'Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings'","b'Kan ikke overbillett for element {0} i rad {1} mer enn {2}. For \xc3\xa5 tillate overfakturering, vennligst sett inn Lagerinnstillinger'"
b'apps/erpnext/erpnext/templates/emails/training_event.html +11',b'Update Response',b'Oppdater svar'
b'apps/erpnext/erpnext/public/js/utils.js +232',b'You have already selected items from {0} {1}',b'Du har allerede valgt elementer fra {0} {1}'
b'DocType: Monthly Distribution',b'Name of the Monthly Distribution',b'Navn p\xc3\xa5 Monthly Distribution'
b'apps/erpnext/erpnext/stock/doctype/batch/batch.py +95',b'Batch ID is mandatory',b'Batch-ID er obligatorisk'
b'apps/erpnext/erpnext/stock/doctype/batch/batch.py +95',b'Batch ID is mandatory',b'Batch-ID er obligatorisk'
b'DocType: Sales Person',b'Parent Sales Person',b'Parent Sales Person'
b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +100',b'The seller and the buyer cannot be the same',b'Selgeren og kj\xc3\xb8peren kan ikke v\xc3\xa6re det samme'
b'DocType: Project',b'Collect Progress',b'Samle fremgang'
b'apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +24',b'Select the program first',b'Velg programmet f\xc3\xb8rst'
b'DocType: Patient Appointment',b'Patient Age',b'Pasientalder'
b'apps/erpnext/erpnext/config/learn.py +253',b'Managing Projects',b'Managing Projects'
b'DocType: Supplier',b'Supplier of Goods or Services.',b'Leverand\xc3\xb8r av varer eller tjenester.'
b'DocType: Budget',b'Fiscal Year',b'Regnskaps\xc3\xa5r'
b'DocType: Asset Maintenance Log',b'Planned',b'planlagt'
b'DocType: Healthcare Settings',b'Default receivable accounts to be used if not set in Patient to book Consultation charges.',b'Standardfordelbare kontoer som skal brukes hvis ikke satt inn i pasienten for \xc3\xa5 bestille konsultasjonsgebyrer.'
b'DocType: Vehicle Log',b'Fuel Price',b'Fuel Pris'
b'DocType: Budget',b'Budget',b'Budsjett'
b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +65',b'Set Open',b'Sett inn'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +258',b'Fixed Asset Item must be a non-stock item.',b'Fast Asset varen m\xc3\xa5 v\xc3\xa6re et ikke-lagervare.'
b'apps/erpnext/erpnext/accounts/doctype/budget/budget.py +50',"b""Budget cannot be assigned against {0}, as it's not an Income or Expense account""","b'Budsjettet kan ikke overdras mot {0}, som det er ikke en inntekt eller kostnad konto'"
b'apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.py +51',b'Achieved',b'Oppn\xc3\xa5s'
b'DocType: Student Admission',b'Application Form Route',b'S\xc3\xb8knadsskjema Rute'
b'apps/erpnext/erpnext/selling/page/sales_analytics/sales_analytics.js +66',b'Territory / Customer',b'Territorium / Customer'
b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +44',b'Leave Type {0} cannot be allocated since it is leave without pay',b'La Type {0} kan ikke tildeles siden det er permisjon uten l\xc3\xb8nn'
b'apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +167',b'Row {0}: Allocated amount {1} must be less than or equals to invoice outstanding amount {2}',b'Rad {0}: Nummerert mengden {1} m\xc3\xa5 v\xc3\xa6re mindre enn eller lik fakturere utest\xc3\xa5ende bel\xc3\xb8p {2}'
b'DocType: Sales Invoice',b'In Words will be visible once you save the Sales Invoice.',b'I Ord vil v\xc3\xa6re synlig n\xc3\xa5r du lagrer salgsfaktura.'
b'DocType: Lead',b'Follow Up',b'F\xc3\xb8lge opp'
b'DocType: Item',b'Is Sales Item',b'Er Sales Element'
b'apps/erpnext/erpnext/setup/doctype/item_group/item_group.js +21',b'Item Group Tree',b'Varegruppe treet'
b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +69',b'Item {0} is not setup for Serial Nos. Check Item master',b'Element {0} er ikke oppsett for Serial Nos. Sjekk Element mester'
b'DocType: Maintenance Visit',b'Maintenance Time',b'Vedlikehold Tid'
,b'Amount to Deliver',b'Bel\xc3\xb8p \xc3\xa5 levere'
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +335',b'Same item has been entered multiple times. {0}',b'Samme gjenstand er oppgitt flere ganger. {0}'
b'apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +30',b'The Term Start Date cannot be earlier than the Year Start Date of the Academic Year to which the term is linked (Academic Year {}). Please correct the dates and try again.',"b'Begrepet Startdato kan ikke v\xc3\xa6re tidligere enn \xc3\xa5ret startdato av studie\xc3\xa5ret som begrepet er knyttet (studie\xc3\xa5ret {}). Korriger datoene, og pr\xc3\xb8v igjen.'"
b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +190',b'There were errors.',b'Det var feil.'
b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +166',b'Employee {0} has already applied for {1} between {2} and {3} : ',b'Ansatt {0} har allerede s\xc3\xb8kt om {1} mellom {2} og {3}:'
b'DocType: Guardian',b'Guardian Interests',b'Guardian Interesser'
b'DocType: Naming Series',b'Current Value',b'N\xc3\xa5v\xc3\xa6rende Verdi'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +273',b'Multiple fiscal years exist for the date {0}. Please set company in Fiscal Year',b'Flere regnskaps\xc3\xa5rene finnes for datoen {0}. Vennligst satt selskapet i regnskaps\xc3\xa5ret'
b'DocType: Education Settings',b'Instructor Records to be created by',b'Instrukt\xc3\xb8rposter som skal opprettes av'
b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +229',b'{0} created',b'{0} opprettet'
b'DocType: GST Account',b'GST Account',b'GST-konto'
b'DocType: Delivery Note Item',b'Against Sales Order',b'Mot Salgsordre'
,b'Serial No Status',b'Serial No Status'
b'DocType: Payment Entry Reference',b'Outstanding',b'Utest\xc3\xa5ende'
b'DocType: Supplier',b'Warn POs',b'Advarsel POs'
,b'Daily Timesheet Summary',b'Daglig Timeregistrering Oppsummering'
b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +137',"b'Row {0}: To set {1} periodicity, difference between from and to date \\\n\t\t\t\t\t\tmust be greater than or equal to {2}'","b'Rad {0}: Slik stiller {1} periodisitet, forskjellen mellom fra og til dato \\ m\xc3\xa5 v\xc3\xa6re st\xc3\xb8rre enn eller lik {2}'"
b'apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +6',b'This is based on stock movement. See {0} for details',b'Dette er basert p\xc3\xa5 lagerbevegelse. Se {0} for detaljer'
b'DocType: Pricing Rule',b'Selling',b'Selling'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +392',b'Amount {0} {1} deducted against {2}',b'Mengden {0} {1} trukket mot {2}'
b'DocType: Employee',b'Salary Information',b'L\xc3\xb8nn Informasjon'
b'DocType: Sales Person',b'Name and Employee ID',b'Navn og Employee ID'
b'apps/erpnext/erpnext/accounts/party.py +308',b'Due Date cannot be before Posting Date',b'Due Date kan ikke v\xc3\xa6re f\xc3\xb8r konteringsdato'
b'DocType: Website Item Group',b'Website Item Group',b'Website varegruppe'
b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +463',b'No salary slip found to submit for the above selected criteria OR salary slip already submitted',b'Ingen l\xc3\xb8nnsslipp funnet \xc3\xa5 sende inn for ovennevnte utvalgte kriterier ELLER l\xc3\xb8nnsslipp allerede sendt'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +150',b'Duties and Taxes',b'Skatter og avgifter'
b'DocType: Projects Settings',b'Projects Settings',b'Prosjekter Innstillinger'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +356',b'Please enter Reference date',b'Skriv inn Reference dato'
b'apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +44',b'{0} payment entries can not be filtered by {1}',b'{0} oppf\xc3\xb8ringer betalings kan ikke bli filtrert av {1}'
b'DocType: Item Website Specification',b'Table for Item that will be shown in Web Site',b'Tabell for element som vil bli vist p\xc3\xa5 nettsiden'
b'DocType: Purchase Order Item Supplied',b'Supplied Qty',b'Medf\xc3\xb8lgende Antall'
b'DocType: Purchase Order Item',b'Material Request Item',b'Materialet Request Element'
b'apps/erpnext/erpnext/config/selling.py +75',b'Tree of Item Groups.',b'Tree of varegrupper.'
b'DocType: Production Plan',b'Total Produced Qty',b'Totalt produsert antall'
b'DocType: Payroll Entry',b'Get Employee Details',b'F\xc3\xa5 medarbeiderdetaljer'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +177',b'Cannot refer row number greater than or equal to current row number for this Charge type',b'Kan ikke se rad tall st\xc3\xb8rre enn eller lik gjeldende rad nummer for denne debiteringstype'
b'DocType: Asset',b'Sold',b'selges'
,b'Item-wise Purchase History',b'Element-messig Purchase History'
b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +230',"b""Please click on 'Generate Schedule' to fetch Serial No added for Item {0}""",b'Vennligst klikk p\xc3\xa5 &quot;Generer Schedule &#39;for \xc3\xa5 hente serienummer lagt for Element {0}'
b'DocType: Account',b'Frozen',b'Frozen'
b'DocType: Sales Invoice Payment',b'Base Amount (Company Currency)',b'Grunnbel\xc3\xb8p (Selskap Valuta)'
b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +928',b'Raw Materials',b'R\xc3\xa5stoffer'
b'DocType: Payment Reconciliation Payment',b'Reference Row',b'Referanse Row'
b'DocType: Installation Note',b'Installation Time',b'Installasjon Tid'
b'DocType: Sales Invoice',b'Accounting Details',b'Regnskap Detaljer'
b'apps/erpnext/erpnext/setup/doctype/company/company.js +113',b'Delete all the Transactions for this Company',b'Slett alle transaksjoner for dette selskapet'
b'DocType: Patient',b'O Positive',b'O Positiv'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +68',b'Investments',b'Investeringer'
b'DocType: Issue',b'Resolution Details',b'Oppl\xc3\xb8sning Detaljer'
b'apps/erpnext/erpnext/hr/doctype/leave_type/leave_type.js +3',b'Allocations',b'Avsetninger'
b'DocType: Item Quality Inspection Parameter',b'Acceptance Criteria',b'Akseptkriterier'
b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +159',b'Please enter Material Requests in the above table',b'Fyll inn Material foresp\xc3\xb8rsler i tabellen over'
b'DocType: Item Attribute',b'Attribute Name',b'Attributt navn'
b'DocType: BOM',b'Show In Website',b'Show I Website'
b'DocType: Shopping Cart Settings',b'Show Quantity in Website',b'Vis Antall i Website'
b'DocType: Employee Loan Application',b'Total Payable Amount',b'Totalt betales bel\xc3\xb8pet'
b'DocType: Task',b'Expected Time (in hours)',b'Forventet tid (i timer)'
b'DocType: Item Reorder',b'Check in (group)',b'Sjekk inn (gruppe)'
b'DocType: Soil Texture',b'Silt',b'silt'
,b'Qty to Order',b'Antall \xc3\xa5 bestille'
b'DocType: Period Closing Voucher',"b'The account head under Liability or Equity, in which Profit/Loss will be booked'","b'Kontoen hodet etter forpliktelse eller et egenkapital, der gevinst / tap vil bli bokf\xc3\xb8rt'"
b'apps/erpnext/erpnext/config/projects.py +36',b'Gantt chart of all tasks.',b'Gantt diagram av alle oppgaver.'
b'DocType: Opportunity',b'Mins to First Response',b'Minutter til First Response'
b'DocType: Pricing Rule',b'Margin Type',b'margin Type'
b'apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +15',b'{0} hours',b'{0} timer'
b'DocType: Course',b'Default Grading Scale',b'Standard Grading Scale'
b'DocType: Appraisal',b'For Employee Name',b'For Employee Name'
b'DocType: Holiday List',b'Clear Table',b'Clear Table'
b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +119',b'Available slots',b'Tilgjengelige spor'
b'DocType: C-Form Invoice Detail',b'Invoice No',b'Faktura Nei'
b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +363',b'Make Payment',b'Utf\xc3\xb8re betaling'
b'DocType: Room',b'Room Name',b'Room Name'
b'DocType: Prescription Duration',b'Prescription Duration',b'Reseptbel\xc3\xb8p'
b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +81',"b'Leave cannot be applied/cancelled before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}'","b'La ikke kan brukes / kansellert f\xc3\xb8r {0}, som permisjon balanse har allerede v\xc3\xa6rt carry-sendt i fremtiden permisjon tildeling posten {1}'"
b'DocType: Activity Cost',b'Costing Rate',b'Costing Rate'
b'apps/erpnext/erpnext/config/selling.py +234',b'Customer Addresses And Contacts',b'Kunde Adresser og kontakter'
,b'Campaign Efficiency',b'Kampanjeeffektivitet'
,b'Campaign Efficiency',b'Kampanjeeffektivitet'
b'DocType: Discussion',b'Discussion',b'Diskusjon'
b'DocType: Payment Entry',b'Transaction ID',b'Transaksjons-ID'
b'DocType: Volunteer',b'Anytime',b'N\xc3\xa5r som helst'
b'DocType: Patient',b'Surgical History',b'Kirurgisk historie'
b'DocType: Employee',b'Resignation Letter Date',b'Resignasjon Letter Dato'
b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +39',b'Pricing Rules are further filtered based on quantity.',b'Prising Reglene er videre filtreres basert p\xc3\xa5 kvantitet.'
b'apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +127',b'Not Set',b'Ikke sett'
b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +335',b'Please set the Date Of Joining for employee {0}',b'Vennligst sett datoen for \xc3\xa5 bli med p\xc3\xa5 ansatt {0}'
b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +335',b'Please set the Date Of Joining for employee {0}',b'Vennligst sett datoen for \xc3\xa5 bli med p\xc3\xa5 ansatt {0}'
b'DocType: Task',b'Total Billing Amount (via Time Sheet)',b'Total Billing Bel\xc3\xb8p (via Timeregistrering)'
b'apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +61',b'Repeat Customer Revenue',b'Gjenta kunden Revenue'
b'DocType: Soil Texture',b'Silty Clay Loam',b'Silty Clay Loam'
b'DocType: Chapter',b'Chapter',b'Kapittel'
b'apps/erpnext/erpnext/utilities/user_progress.py +146',b'Pair',b'Par'
b'DocType: Mode of Payment Account',b'Default account will be automatically updated in POS Invoice when this mode is selected.',b'Standardkontoen oppdateres automatisk i POS-faktura n\xc3\xa5r denne modusen er valgt.'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +970',b'Select BOM and Qty for Production',b'Velg BOM og Stk for produksjon'
b'DocType: Asset',b'Depreciation Schedule',b'avskrivninger Schedule'
b'apps/erpnext/erpnext/config/selling.py +124',b'Sales Partner Addresses And Contacts',b'Salgspartneradresser og kontakter'
b'DocType: Bank Reconciliation Detail',b'Against Account',b'Mot konto'
b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +52',b'Half Day Date should be between From Date and To Date',b'Half Day Date b\xc3\xb8r v\xc3\xa6re mellom Fra dato og Til dato'
b'DocType: Maintenance Schedule Detail',b'Actual Date',b'Selve Dato'
b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +139',b'Please set the Default Cost Center in {0} company.',b'Angi standardkostnadssenteret i {0} selskapet.'
b'DocType: Item',b'Has Batch No',b'Har Batch No'
b'apps/erpnext/erpnext/public/js/utils.js +106',b'Annual Billing: {0}',b'\xc3\x85rlig Billing: {0}'
b'apps/erpnext/erpnext/config/accounts.py +200',b'Goods and Services Tax (GST India)',b'Varer og tjenester skatt (GST India)'
b'DocType: Delivery Note',b'Excise Page Number',b'Vesenet Page Number'
b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +227',"b'Company, From Date and To Date is mandatory'","b'Company, Fra dato og Til dato er obligatorisk'"
b'apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +33',b'Get from Consultation',b'F\xc3\xa5 fra konsultasjon'
b'DocType: Asset',b'Purchase Date',b'Kj\xc3\xb8psdato'
b'DocType: Volunteer',b'Volunteer Type',b'Frivillig Type'
b'DocType: Student',b'Personal Details',b'Personlig Informasjon'
b'apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +193',"b""Please set 'Asset Depreciation Cost Center' in Company {0}""",b'Vennligst sett &#39;Asset Avskrivninger kostnadssted &quot;i selskapet {0}'
,b'Maintenance Schedules',b'Vedlikeholdsplaner'
b'DocType: Task',b'Actual End Date (via Time Sheet)',b'Faktisk Sluttdato (via Timeregistrering)'
b'DocType: Soil Texture',b'Soil Type',b'Jordtype'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +387',b'Amount {0} {1} against {2} {3}',b'Mengden {0} {1} mot {2} {3}'
b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +277',b'New Message',b'Ny melding'
,b'Quotation Trends',b'Anf\xc3\xb8rsels Trender'
b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +160',b'Item Group not mentioned in item master for item {0}',b'Varegruppe ikke nevnt i punkt master for elementet {0}'
b'DocType: GoCardless Mandate',b'GoCardless Mandate',b'GoCardless Mandat'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +368',b'Debit To account must be a Receivable account',b'Uttak fra kontoen m\xc3\xa5 v\xc3\xa6re en fordring konto'
b'DocType: Shipping Rule',b'Shipping Amount',b'Fraktbel\xc3\xb8p'
b'DocType: Supplier Scorecard Period',b'Period Score',b'Periodepoeng'
b'apps/erpnext/erpnext/utilities/user_progress.py +66',b'Add Customers',b'Legg til kunder'
b'apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +20',b'Pending Amount',b'Avventer Bel\xc3\xb8p'
b'DocType: Lab Test Template',b'Special',b'Spesiell'
b'DocType: Purchase Order Item Supplied',b'Conversion Factor',b'Omregningsfaktor'
b'DocType: Purchase Order',b'Delivered',b'Levert'
,b'Vehicle Expenses',b'Vehicle Utgifter'
b'DocType: Serial No',b'Invoice Details',b'Fakturadetaljer'
b'DocType: Grant Application',b'Show on Website',b'Vis p\xc3\xa5 nettstedet'
b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +212',b'Expected value after useful life must be greater than or equal to {0}',b'Forventet verdi etter levetid m\xc3\xa5 v\xc3\xa6re st\xc3\xb8rre enn eller lik {0}'
b'apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +29',b'Start on',b'Start p\xc3\xa5'
b'DocType: Hub Category',b'Hub Category',b'Hub kategori'
b'DocType: Purchase Invoice',b'SEZ',b'SEZ'
b'DocType: Purchase Receipt',b'Vehicle Number',b'Vehicle Number'
b'DocType: Employee Loan',b'Loan Amount',b'L\xc3\xa5nebel\xc3\xb8p'
b'DocType: Student Report Generation Tool',b'Add Letterhead',b'Legg til brevpapir'
b'DocType: Program Enrollment',b'Self-Driving Vehicle',b'Selvkj\xc3\xb8rende kj\xc3\xb8ret\xc3\xb8y'
b'DocType: Supplier Scorecard Standing',b'Supplier Scorecard Standing',b'Leverand\xc3\xb8r Scorecard Standing'
b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +443',b'Row {0}: Bill of Materials not found for the Item {1}',b'P {0}: stykk ikke funnet med Element {1}'
b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +98',b'Total allocated leaves {0} cannot be less than already approved leaves {1} for the period',b'Totalt bevilget blader {0} kan ikke v\xc3\xa6re mindre enn allerede godkjente blader {1} for perioden'
b'DocType: Journal Entry',b'Accounts Receivable',b'Kundefordringer'
,b'Supplier-Wise Sales Analytics',b'Leverand\xc3\xb8r-Wise Salgs Analytics'
b'DocType: Purchase Invoice',b'Availed ITC Central Tax',b'Availed ITC Central Tax'
b'DocType: Salary Structure',b'Select employees for current Salary Structure',b'Velg ansatte for n\xc3\xa5v\xc3\xa6rende l\xc3\xb8nn struktur'
b'DocType: Sales Invoice',b'Company Address Name',b'Bedriftsadresse Navn'
b'DocType: Work Order',b'Use Multi-Level BOM',b'Bruk Multi-Level BOM'
b'DocType: Bank Reconciliation',b'Include Reconciled Entries',b'Inkluder forsonet Entries'
b'DocType: Course',"b""Parent Course (Leave blank, if this isn't part of Parent Course)""","b'Foreldrekurs (Forel\xc3\xb8pig, hvis dette ikke er en del av foreldrenes kurs)'"
b'DocType: Course',"b""Parent Course (Leave blank, if this isn't part of Parent Course)""","b'Foreldrekurs (Forel\xc3\xb8pig, hvis dette ikke er en del av foreldrenes kurs)'"
b'DocType: Leave Control Panel',b'Leave blank if considered for all employee types',b'La st\xc3\xa5 tom hvis vurderes for alle typer medarbeider'
b'DocType: Landed Cost Voucher',b'Distribute Charges Based On',b'Distribuere Kostnader Based On'
b'DocType: Projects Settings',b'Timesheets',b'Timelister'
b'DocType: HR Settings',b'HR Settings',b'HR-innstillinger'
b'DocType: Salary Slip',b'net pay info',b'nettol\xc3\xb8nn info'
b'DocType: Lab Test Template',b'This value is updated in the Default Sales Price List.',b'Denne verdien er oppdatert i standard salgsprislisten.'
b'DocType: Email Digest',b'New Expenses',b'nye Utgifter'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +79',b'PDC/LC Amount',b'PDC / LC Bel\xc3\xb8p'
b'DocType: Shareholder',b'Shareholder',b'Aksjon\xc3\xa6r'
b'DocType: Purchase Invoice',b'Additional Discount Amount',b'Ekstra rabatt Bel\xc3\xb8p'
b'DocType: Cash Flow Mapper',b'Position',b'Posisjon'
b'DocType: Patient',b'Patient Details',b'Pasientdetaljer'
b'DocType: Patient',b'B Positive',b'B Positiv'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +596',"b'Row #{0}: Qty must be 1, as item is a fixed asset. Please use separate row for multiple qty.'",b'Row # {0}: Antall m\xc3\xa5 v\xc3\xa6re en som elementet er et anleggsmiddel. Bruk egen rad for flere stk.'
b'DocType: Leave Block List Allow',b'Leave Block List Allow',b'La Block List Tillat'
b'apps/erpnext/erpnext/setup/doctype/company/company.py +317',b'Abbr can not be blank or space',b'Abbr kan ikke v\xc3\xa6re tomt eller plass'
b'DocType: Patient Medical Record',b'Patient Medical Record',b'Patient Medical Record'
b'apps/erpnext/erpnext/accounts/doctype/account/account.js +68',b'Group to Non-Group',b'Gruppe til Non-gruppe'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +50',b'Sports',b'Sport'
b'DocType: Loan Type',b'Loan Name',b'l\xc3\xa5n Name'
b'apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +56',b'Total Actual',b'Total Actual'
b'DocType: Lab Test UOM',b'Test UOM',b'Test UOM'
b'DocType: Student Siblings',b'Student Siblings',b'student S\xc3\xb8sken'
b'apps/erpnext/erpnext/utilities/user_progress.py +146',b'Unit',b'Enhet'
b'apps/erpnext/erpnext/stock/get_item_details.py +138',b'Please specify Company',b'Vennligst oppgi selskapet'
,b'Customer Acquisition and Loyalty',b'Kunden Oppkj\xc3\xb8p og Loyalty'
b'DocType: Asset Maintenance Task',b'Maintenance Task',b'Vedlikeholdsoppgave'
b'apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py +118',b'Please set B2C Limit in GST Settings.',b'Vennligst sett inn B2C Limit i GST-innstillinger.'
b'DocType: Purchase Invoice',b'Warehouse where you are maintaining stock of rejected items',b'Warehouse hvor du opprettholder lager avviste elementer'
b'DocType: Work Order',b'Skip Material Transfer',b'Hopp over materialoverf\xc3\xb8ring'
b'DocType: Work Order',b'Skip Material Transfer',b'Hopp over materialoverf\xc3\xb8ring'
b'apps/erpnext/erpnext/setup/utils.py +109',b'Unable to find exchange rate for {0} to {1} for key date {2}. Please create a Currency Exchange record manually',b'Kan ikke finne valutakurs for {0} til {1} for n\xc3\xb8kkeldato {2}. Vennligst opprett en valutautvekslingsrekord manuelt'
b'DocType: POS Profile',b'Price List',b'Pris Liste'
b'apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +22',b'{0} is now the default Fiscal Year. Please refresh your browser for the change to take effect.',b'{0} er n\xc3\xa5 standard regnskaps\xc3\xa5ret. Vennligst oppdater nettleser for at endringen skal tre i kraft.'
b'apps/erpnext/erpnext/projects/doctype/task/task.js +45',b'Expense Claims',b'Regninger'
b'DocType: Issue',b'Support',b'Support'
,b'BOM Search',b'BOM S\xc3\xb8k'
b'DocType: Project',b'Total Consumed Material Cost  (via Stock Entry)',b'Total forbruket materialkostnad (via lagerinngang)'
b'DocType: Item',"b'Publish ""In Stock"" or ""Not in Stock"" on Hub based on stock available in this warehouse.'",b'Publiser &quot;P\xc3\xa5 lager&quot; eller &quot;Ikke p\xc3\xa5 lager&quot; p\xc3\xa5 Hub basert p\xc3\xa5 lager tilgjengelig i dette varehuset.'
b'DocType: Vehicle',b'Fuel Type',b'drivstoff'
b'apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +27',b'Please specify currency in Company',b'Vennligst oppgi valuta i selskapet'
b'DocType: Workstation',b'Wages per hour',b'L\xc3\xb8nn per time'
b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +47',b'Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3}',b'Stock balanse i Batch {0} vil bli negativ {1} for Element {2} p\xc3\xa5 Warehouse {3}'
b'apps/erpnext/erpnext/templates/emails/reorder_item.html +1',"b""Following Material Requests have been raised automatically based on Item's re-order level""",b'F\xc3\xb8lgende materiale Requests har v\xc3\xa6rt reist automatisk basert p\xc3\xa5 element re-order niv\xc3\xa5'
b'DocType: Email Digest',b'Pending Sales Orders',b'Avventer salgsordrer'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +312',b'Account {0} is invalid. Account Currency must be {1}',b'Konto {0} er ugyldig. Account Valuta m\xc3\xa5 v\xc3\xa6re {1}'
b'DocType: Healthcare Settings',b'Remind Before',b'P\xc3\xa5minn f\xc3\xb8r'
b'apps/erpnext/erpnext/buying/utils.py +34',b'UOM Conversion factor is required in row {0}',b'M\xc3\xa5lenheter Omregningsfaktor er n\xc3\xb8dvendig i rad {0}'
b'DocType: Production Plan Item',b'material_request_item',b'material_request_item'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1087',"b'Row #{0}: Reference Document Type must be one of Sales Order, Sales Invoice or Journal Entry'","b'Row # {0}: Reference Document Type m\xc3\xa5 v\xc3\xa6re en av salgsordre, salgsfaktura eller bilagsregistrering'"
b'DocType: Salary Component',b'Deduction',b'Fradrag'
b'DocType: Item',b'Retain Sample',b'Behold pr\xc3\xb8ve'
b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +115',b'Row {0}: From Time and To Time is mandatory.',b'Rad {0}: Fra tid og Tid er obligatorisk.'
b'DocType: Stock Reconciliation Item',b'Amount Difference',b'bel\xc3\xb8p Difference'
b'apps/erpnext/erpnext/stock/get_item_details.py +356',b'Item Price added for {0} in Price List {1}',b'Varen Pris lagt for {0} i Prisliste {1}'
b'apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js +8',b'Please enter Employee Id of this sales person',b'Skriv inn Employee Id av denne salgs person'
b'DocType: Territory',b'Classification of Customers by region',b'Klassifisering av kunder etter region'
b'apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +71',b'In Production',b'I produksjon'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +65',b'Difference Amount must be zero',b'Forskjellen Bel\xc3\xb8pet m\xc3\xa5 v\xc3\xa6re null'
b'DocType: Project',b'Gross Margin',b'Bruttomargin'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +61',b'Please enter Production Item first',b'Skriv inn Produksjon varen f\xc3\xb8rst'
b'apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +45',b'Calculated Bank Statement balance',b'Beregnet kontoutskrift balanse'
b'DocType: Normal Test Template',b'Normal Test Template',b'Normal testmal'
b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +64',b'disabled user',b'deaktivert bruker'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +919',b'Quotation',b'Sitat'
b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +984',b'Cannot set a received RFQ to No Quote',b'Kan ikke angi en mottatt RFQ til No Quote'
b'DocType: Quotation',b'QTN-',b'QTN-'
b'DocType: Salary Slip',b'Total Deduction',b'Total Fradrag'
b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +18',b'Select an account to print in account currency',b'Velg en konto for \xc3\xa5 skrive ut i kontovaluta'
,b'Production Analytics',b'produksjons~~POS=TRUNC Analytics'
b'apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +6',b'This is based on transactions against this Patient. See timeline below for details',b'Dette er basert p\xc3\xa5 transaksjoner mot denne pasienten. Se tidslinjen nedenfor for detaljer'
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +204',b'Cost Updated',b'Kostnad Oppdatert'
b'DocType: Patient',b'Date of Birth',b'F\xc3\xb8dselsdato'
b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +133',b'Item {0} has already been returned',b'Element {0} er allerede returnert'
b'DocType: Fiscal Year',b'**Fiscal Year** represents a Financial Year. All accounting entries and other major transactions are tracked against **Fiscal Year**.',b'** Regnskaps\xc3\xa5r ** representerer et regnskaps\xc3\xa5r. Alle regnskapspostene og andre store transaksjoner spores mot ** regnskaps\xc3\xa5r **.'
b'DocType: Opportunity',b'Customer / Lead Address',b'Kunde / Lead Adresse'
b'DocType: Supplier Scorecard Period',b'Supplier Scorecard Setup',b'Leverand\xc3\xb8r Scorecard Setup'
b'apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +133',b'Assessment Plan Name',b'Evalueringsplan Navn'
b'DocType: Work Order Operation',b'Work Order Operation',b'Arbeidsordreoperasjon'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +233',b'Warning: Invalid SSL certificate on attachment {0}',b'Advarsel: Ugyldig SSL-sertifikat p\xc3\xa5 vedlegg {0}'
b'apps/erpnext/erpnext/utilities/activation.py +64',"b'Leads help you get business, add all your contacts and more as your leads'","b'Leads hjelpe deg \xc3\xa5 f\xc3\xa5 virksomheten, legge til alle dine kontakter og mer som dine potensielle kunder'"
b'DocType: Work Order Operation',b'Actual Operation Time',b'Selve Operasjon Tid'
b'DocType: Authorization Rule',b'Applicable To (User)',b'Gjelder til (User)'
b'DocType: Purchase Taxes and Charges',b'Deduct',b'Trekke'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +238',b'Job Description',b'Stillingsbeskrivelse'
b'DocType: Student Applicant',b'Applied',b'Tatt i bruk'
b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +874',b'Re-open',b'Re-open'
b'DocType: Sales Invoice Item',b'Qty as per Stock UOM',b'Antall pr Stock m\xc3\xa5lenheter'
b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +59',b'Guardian2 Name',b'Guardian2 Name'
b'DocType: Purchase Invoice',b'02-Post Sale Discount',b'02-post salg rabatt'
b'apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +132',"b'Special Characters except ""-"", ""#"", ""."" and ""/"" not allowed in naming series'","b'Spesialtegn unntatt &quot;-&quot; &quot;.&quot;, &quot;#&quot;, og &quot;/&quot; ikke tillatt i navngi serie'"
b'DocType: Campaign',"b'Keep Track of Sales Campaigns. Keep track of Leads, Quotations, Sales Order etc from Campaigns to gauge Return on Investment.'","b'Hold orden p\xc3\xa5 salgskampanjer. Hold styr p\xc3\xa5 Leads, Sitater, Salgsordre etc fra kampanjer for \xc3\xa5 m\xc3\xa5le avkastning p\xc3\xa5 investeringen.'"
,b'SO Qty',b'SO Antall'
b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +91',b'The field To Shareholder cannot be blank',b'Feltet Til Aksjon\xc3\xa6r kan ikke v\xc3\xa6re tomt'
b'DocType: Guardian',b'Work Address',b'arbeid Adresse'
b'DocType: Appraisal',b'Calculate Total Score',b'Beregn Total Score'
b'DocType: Health Insurance',b'Health Insurance',b'Helseforsikring'
b'DocType: Asset Repair',b'Manufacturing Manager',b'Produksjonssjef'
b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +191',b'Serial No {0} is under warranty upto {1}',b'Serial No {0} er under garanti opptil {1}'
b'DocType: Plant Analysis Criteria',b'Minimum Permissible Value',b'Minste tillatte verdi'
b'apps/erpnext/erpnext/education/doctype/guardian/guardian.py +41',b'User {0} already exists',b'Bruker {0} eksisterer allerede'
b'apps/erpnext/erpnext/hooks.py +109',b'Shipments',b'Forsendelser'
b'DocType: Payment Entry',b'Total Allocated Amount (Company Currency)',b'Totalt tildelte bel\xc3\xb8p (Selskap Valuta)'
b'DocType: Purchase Order Item',b'To be delivered to customer',b'Som skal leveres til kunde'
b'DocType: BOM',b'Scrap Material Cost',b'Skrap Material Cost'
b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +227',b'Serial No {0} does not belong to any Warehouse',b'Serial No {0} tilh\xc3\xb8rer ikke noen Warehouse'
b'DocType: Grant Application',b'Email Notification Sent',b'E-postvarsling sendt'
b'DocType: Purchase Invoice',b'In Words (Company Currency)',b'I Words (Company Valuta)'
b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1018',"b'Item Code, warehouse, quantity are required on row'","b'Varenummer, lager, antall er p\xc3\xa5krevd p\xc3\xa5 rad'"
b'DocType: Pricing Rule',b'Supplier',b'Leverand\xc3\xb8r'
b'apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js +41',b'Show Payment Details',b'Vis betalingsdetaljer'
b'DocType: Consultation',b'Consultation Time',b'Konsultasjonstid'
b'DocType: C-Form',b'Quarter',b'Quarter'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +106',b'Miscellaneous Expenses',b'Diverse utgifter'
b'DocType: Global Defaults',b'Default Company',b'Standard selskapet'
b'apps/erpnext/erpnext/controllers/stock_controller.py +227',b'Expense or Difference account is mandatory for Item {0} as it impacts overall stock value',b'Kostnad eller Difference konto er obligatorisk for Element {0} som det p\xc3\xa5virker samlede b\xc3\xb8rsverdi'
b'DocType: Payment Request',b'PR',b'PR'
b'DocType: Cheque Print Template',b'Bank Name',b'Bank Name'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.py +30',b'-Above',b'-Above'
b'DocType: Employee Loan',b'Employee Loan Account',b'Medarbeider Loan konto'
b'DocType: Leave Application',b'Total Leave Days',b'Totalt La Days'
b'DocType: Email Digest',b'Note: Email will not be sent to disabled users',b'Merk: E-post vil ikke bli sendt til funksjonshemmede brukere'
b'apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +14',b'Number of Interaction',b'Antall interaksjoner'
b'apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +14',b'Number of Interaction',b'Antall interaksjoner'
b'apps/erpnext/erpnext/stock/doctype/item/item.js +105',b'Item Variant Settings',b'Variantinnstillinger'
b'apps/erpnext/erpnext/manufacturing/page/production_analytics/production_analytics.js +37',b'Select Company...',b'Velg Company ...'
b'DocType: Leave Control Panel',b'Leave blank if considered for all departments',b'La st\xc3\xa5 tom hvis vurderes for alle avdelinger'
b'apps/erpnext/erpnext/config/hr.py +228',"b'Types of employment (permanent, contract, intern etc.).'","b'Typer arbeid (fast, kontrakt, l\xc3\xa6rling etc.).'"
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +434',b'{0} is mandatory for Item {1}',b'{0} er obligatorisk for Element {1}'
b'apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js +136',"b'Item {0}: {1} qty produced, '","b'Vare {0}: {1} Antall produsert,'"
b'DocType: Payroll Entry',b'Fortnightly',b'hver fjortende dag'
b'DocType: Currency Exchange',b'From Currency',b'Fra Valuta'
b'DocType: Vital Signs',b'Weight (In Kilogram)',b'Vekt (i kilogram)'
b'DocType: Chapter',b'chapters/chapter_name\nleave blank automatically set after saving chapter.',b'kapitler / kapittelnavn la blankt sett automatisk etter lagring av kapittel.'
b'apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py +202',b'Please set GST Accounts in GST Settings',b'Vennligst sett GST-kontoer i GST-innstillinger'
b'apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js +31',b'Type of Business',b'Type virksomhet'
b'apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +171',"b'Please select Allocated Amount, Invoice Type and Invoice Number in atleast one row'","b'Vennligst velg avsatt bel\xc3\xb8p, fakturatype og fakturanummer i minst \xc3\xa9n rad'"
b'apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +128',b'Cost of New Purchase',b'Kostnad for nye kj\xc3\xb8p'
b'apps/erpnext/erpnext/agriculture/doctype/crop_cycle/crop_cycle.py +35',b'All tasks for the detected diseases were imported',b'Alle oppgaver for de oppdagede sykdommene ble importert'
b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +97',b'Sales Order required for Item {0}',b'Salgsordre kreves for Element {0}'
b'DocType: Grant Application',b'Grant Description',b'Grant Beskrivelse'
b'DocType: Purchase Invoice Item',b'Rate (Company Currency)',b'Rate (Selskap Valuta)'
b'DocType: Student Guardian',b'Others',b'Annet'
b'DocType: Payment Entry',b'Unallocated Amount',b'uallokert Bel\xc3\xb8p'
b'apps/erpnext/erpnext/templates/includes/product_page.js +91',b'Cannot find a matching Item. Please select some other value for {0}.',b'Kan ikke finne en matchende element. Vennligst velg en annen verdi for {0}.'
b'DocType: POS Profile',b'Taxes and Charges',b'Skatter og avgifter'
b'DocType: Item',"b'A Product or a Service that is bought, sold or kept in stock.'","b'Et produkt eller en tjeneste som er kj\xc3\xb8pt, solgt eller holdes p\xc3\xa5 lager.'"
b'apps/erpnext/erpnext/hr/page/team_updates/team_updates.js +44',b'No more updates',b'Ingen flere oppdateringer'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +171',"b""Cannot select charge type as 'On Previous Row Amount' or 'On Previous Row Total' for first row""",b'Kan ikke velge charge type som &#39;On Forrige Row bel\xc3\xb8p &quot;eller&quot; On Forrige Row Totals for f\xc3\xb8rste rad'
b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py +6',b'This covers all scorecards tied to this Setup',b'Dette dekker alle scorecards knyttet til denne oppsettet'
b'apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.py +29',b'Child Item should not be a Product Bundle. Please remove item `{0}` and save',b'Barn Varen b\xc3\xb8r ikke v\xc3\xa6re et produkt Bundle. Vennligst fjern element `{0}` og lagre'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +12',b'Banking',b'Banking'
b'apps/erpnext/erpnext/utilities/activation.py +108',b'Add Timesheets',b'Legg Timelister'
b'DocType: Vehicle Service',b'Service Item',b'tjenesten Element'
b'DocType: Bank Guarantee',b'Bank Guarantee',b'Bankgaranti'
b'DocType: Bank Guarantee',b'Bank Guarantee',b'Bankgaranti'
b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +39',"b""Please click on 'Generate Schedule' to get schedule""",b'Vennligst klikk p\xc3\xa5 &quot;Generer Schedule &#39;for \xc3\xa5 f\xc3\xa5 timeplanen'
b'DocType: Bin',b'Ordered Quantity',b'Bestilte Antall'
b'apps/erpnext/erpnext/public/js/setup_wizard.js +118',"b'e.g. ""Build tools for builders""'",b'f.eks &quot;Bygg verkt\xc3\xb8y for utbyggere&quot;'
b'DocType: Grading Scale',b'Grading Scale Intervals',b'Karakterskalaen Intervaller'
b'apps/erpnext/erpnext/accounts/report/profit_and_loss_statement/profit_and_loss_statement.py +39',b'Profit for the year',b'\xc3\x85rets resultat'
b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +125',b'{0} {1}: Accounting Entry for {2} can only be made in currency: {3}',b'{0} {1}: Regnskap Entry for {2} kan bare gj\xc3\xb8res i valuta: {3}'
b'DocType: Fee Schedule',b'In Process',b'Igang'
b'DocType: Authorization Rule',b'Itemwise Discount',b'Itemwise Rabatt'
b'apps/erpnext/erpnext/config/accounts.py +75',b'Tree of financial accounts.',b'Tre av finansregnskap.'
b'DocType: Cash Flow Mapping',b'Cash Flow Mapping',b'Cash Flow Mapping'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +364',b'{0} against Sales Order {1}',b'{0} mot Salgsordre {1}'
b'DocType: Account',b'Fixed Asset',b'Fast Asset'
b'apps/erpnext/erpnext/config/stock.py +324',b'Serialized Inventory',b'Serialisert Lager'
b'apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +74',b'Email not found in default contact',b'E-post ikke funnet i standardkontakt'
b'DocType: Employee Loan',b'Account Info',b'Kontoinformasjon'
b'DocType: Activity Type',b'Default Billing Rate',b'Standard Billing pris'
b'DocType: Fees',b'Include Payment',b'Inkluder betaling'
b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +77',b'{0} Student Groups created.',b'{0} Studentgrupper opprettet.'
b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +77',b'{0} Student Groups created.',b'{0} Studentgrupper opprettet.'
b'DocType: Sales Invoice',b'Total Billing Amount',b'Total Billing Bel\xc3\xb8p'
b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.py +50',b'Program in the Fee Structure and Student Group {0} are different.',b'Programmet i avgiftsstrukturen og studentgruppen {0} er forskjellig.'
b'DocType: Fee Schedule',b'Receivable Account',b'Fordring konto'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +618',b'Row #{0}: Asset {1} is already {2}',b'Row # {0}: Asset {1} er allerede {2}'
b'DocType: Quotation Item',b'Stock Balance',b'Stock Balance'
b'apps/erpnext/erpnext/config/selling.py +321',b'Sales Order to Payment',b'Salgsordre til betaling'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +123',b'CEO',b'administrerende direkt\xc3\xb8r'
b'DocType: Purchase Invoice',b'With Payment of Tax',b'Med betaling av skatt'
b'DocType: Expense Claim Detail',b'Expense Claim Detail',b'Expense krav Detalj'
b'DocType: Purchase Invoice',b'TRIPLICATE FOR SUPPLIER',b'TRIPLIKAT FOR LEVERAND\xc3\x98R'
b'DocType: Land Unit',b'Is Container',b'Er Container'
b'DocType: Crop Cycle',b'This will be day 1 of the crop cycle',b'Dette blir dag 1 i avlingen syklus'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +871',b'Please select correct account',b'Velg riktig konto'
b'DocType: Purchase Invoice Item',b'Weight UOM',b'Vekt m\xc3\xa5lenheter'
b'apps/erpnext/erpnext/config/accounts.py +466',b'List of available Shareholders with folio numbers',b'Liste over tilgjengelige Aksjon\xc3\xa6rer med folio nummer'
b'DocType: Salary Structure Employee',b'Salary Structure Employee',b'L\xc3\xb8nn Struktur Employee'
b'apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.js +45',b'Show Variant Attributes',b'Vis variantattributter'
b'DocType: Student',b'Blood Group',b'Blodgruppe'
b'DocType: Course',b'Course Name',b'Course Name'
b'DocType: Employee Leave Approver',"b""Users who can approve a specific employee's leave applications""",b'Brukere som kan godkjenne en bestemt ansattes permisjon applikasjoner'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +52',b'Office Equipments',b'Kontor utstyr'
b'DocType: Purchase Invoice Item',b'Qty',b'Antall'
b'DocType: Fiscal Year',b'Companies',b'Selskaper'
b'DocType: Supplier Scorecard',b'Scoring Setup',b'Scoring Setup'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +24',b'Electronics',b'Elektronikk'
b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +326',b'Debit ({0})',b'Debet ({0})'
b'DocType: Stock Settings',b'Raise Material Request when stock reaches re-order level',b'Hev Material Request n\xc3\xa5r aksjen n\xc3\xa5r re-order niv\xc3\xa5'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +98',b'Full-time',b'Fulltid'
b'DocType: Payroll Entry',b'Employees',b'medarbeidere'
b'DocType: Employee',b'Contact Details',b'Kontaktinformasjon'
b'DocType: C-Form',b'Received Date',b'Mottatt dato'
b'DocType: Delivery Note',"b'If you have created a standard template in Sales Taxes and Charges Template, select one and click on the button below.'","b'Hvis du har opprettet en standard mal i salgs skatter og avgifter mal, velger du ett og klikk p\xc3\xa5 knappen under.'"
b'DocType: BOM Scrap Item',b'Basic Amount (Company Currency)',b'Grunnbel\xc3\xb8pet (Selskap Valuta)'
b'DocType: Student',b'Guardians',b'Voktere'
b'apps/erpnext/erpnext/templates/pages/integrations/gocardless_confirmation.html +13',b'Payment Confirmation',b'Betalingsbekreftelse'
b'DocType: Shopping Cart Settings',b'Prices will not be shown if Price List is not set',b'Prisene vil ikke bli vist hvis prislisten er ikke satt'
b'DocType: Stock Entry',b'Total Incoming Value',b'Total Innkommende Verdi'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +362',b'Debit To is required',b'Debet \xc3\x85 kreves'
b'apps/erpnext/erpnext/utilities/activation.py +109',"b'Timesheets help keep track of time, cost and billing for activites done by your team'","b'Timelister bidra til \xc3\xa5 holde styr p\xc3\xa5 tid, kostnader og fakturering for aktiviteter gjort av teamet ditt'"
b'apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +39',b'Purchase Price List',b'Kj\xc3\xb8p Prisliste'
b'apps/erpnext/erpnext/config/buying.py +155',b'Templates of supplier scorecard variables.',b'Maler av leverand\xc3\xb8rens scorecard-variabler.'
b'DocType: Job Offer Term',b'Offer Term',b'Tilbudet Term'
b'DocType: Asset',b'Quality Manager',b'Quality Manager'
b'DocType: Job Applicant',b'Job Opening',b'Job Opening'
b'DocType: Payment Reconciliation',b'Payment Reconciliation',b'Betaling Avstemming'
b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +153',"b""Please select Incharge Person's name""",b'Vennligst velg Incharge persons navn'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +51',b'Technology',b'Teknologi'
b'DocType: Hub Settings',b'Unregister from Hub',b'Avregistrer fra Hub'
b'apps/erpnext/erpnext/public/js/utils.js +108',b'Total Unpaid: {0}',b'Total Ubetalte: {0}'
b'DocType: BOM Website Operation',b'BOM Website Operation',b'BOM Nettstedet Operasjon'
b'DocType: Supplier Scorecard',b'Supplier Score',b'Leverand\xc3\xb8rpoeng'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +213',b'Total Invoiced Amt',b'Total Fakturert Amt'
b'DocType: Supplier',b'Warn RFQs',b'Advarsel RFQs'
b'DocType: BOM',b'Conversion Rate',b'konverterings~~POS=TRUNC'
b'apps/erpnext/erpnext/templates/pages/product_search.html +3',b'Product Search',b'Produkts\xc3\xb8k'
b'DocType: Assessment Plan',b'To Time',b'Til Time'
b'DocType: Authorization Rule',b'Approving Role (above authorized value)',b'Godkjenne Role (ovenfor autorisert verdi)'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +118',b'Credit To account must be a Payable account',b'Kreditt til kontoen m\xc3\xa5 v\xc3\xa6re en Betales konto'
b'apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +43',b'Please select Student Admission which is mandatory for the paid student applicant',"b'Vennligst velg Student Admission, som er obligatorisk for den betalte student s\xc3\xb8keren'"
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +355',b'BOM recursion: {0} cannot be parent or child of {2}',b'BOM rekursjon: {0} kan ikke v\xc3\xa6re forelder eller barn av {2}'
b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +21',b'Please select a Price List to publish pricing',b'Vennligst velg en prisliste for \xc3\xa5 publisere priser'
b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +38',b'Budget List',b'Budsjettliste'
b'DocType: Work Order Operation',b'Completed Qty',b'Fullf\xc3\xb8rt Antall'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +148',"b'For {0}, only debit accounts can be linked against another credit entry'",b'For {0} kan bare belastning kontoer knyttes opp mot en annen kreditt oppf\xc3\xb8ring'
b'apps/erpnext/erpnext/stock/doctype/item_price/item_price.py +27',b'Price List {0} is disabled',b'Prisliste {0} er deaktivert'
b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +127',b'Row {0}: Completed Qty cannot be more than {1} for operation {2}',b'Rad {0}: Fullf\xc3\xb8rt Antall kan ikke v\xc3\xa6re mer enn {1} for drift {2}'
b'DocType: Manufacturing Settings',b'Allow Overtime',b'Tillat Overtid'
b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +148',"b'Serialized Item {0} cannot be updated using Stock Reconciliation, please use Stock Entry'","b'Serialisert element {0} kan ikke oppdateres ved hjelp av Stock Forsoning, vennligst bruk Stock Entry'"
b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +148',"b'Serialized Item {0} cannot be updated using Stock Reconciliation, please use Stock Entry'","b'Serialisert element {0} kan ikke oppdateres ved hjelp av Stock Forsoning, vennligst bruk Stock Entry'"
b'DocType: Training Event Employee',b'Training Event Employee',b'Trening Hendelses Employee'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1031',b'Maximum Samples - {0} can be retained for Batch {1} and Item {2}.',b'Maksimale pr\xc3\xb8ver - {0} kan beholdes for Batch {1} og Item {2}.'
b'apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +7',b'Add Time Slots',b'Legg til tidsluker'
b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +201',b'{0} Serial Numbers required for Item {1}. You have provided {2}.',b'{0} serienumre som kreves for Element {1}. Du har gitt {2}.'
b'DocType: Stock Reconciliation Item',b'Current Valuation Rate',b'N\xc3\xa5v\xc3\xa6rende Verdivurdering Rate'
b'DocType: Training Event',b'Advance',b'Avansere'
b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +6',b'for making recurring again.',b'for \xc3\xa5 gjenta igjen.'
b'apps/erpnext/erpnext/config/erpnext_integrations.py +13',b'GoCardless payment gateway settings',b'GoCardless betalings gateway innstillinger'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +122',b'Exchange Gain/Loss',b'Valutagevinst / tap'
b'DocType: Opportunity',b'Lost Reason',b'Mistet Reason'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +265',b'Row #{0}: Account {1} does not belong to company {2}',b'Rute # {0}: Konto {1} tilh\xc3\xb8rer ikke firma {2}'
b'apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +30',b'Unable to find DocType {0}',b'Kan ikke finne DocType {0}'
b'apps/erpnext/erpnext/public/js/templates/address_list.html +22',b'New Address',b'Ny adresse'
b'DocType: Quality Inspection',b'Sample Size',b'Sample Size'
b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +47',b'Please enter Receipt Document',b'Fyll inn Kvittering Document'
b'apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +369',b'All items have already been invoiced',b'Alle elementene er allerede blitt fakturert'
b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +49',"b""Please specify a valid 'From Case No.'""",b'Vennligst oppgi en gyldig &quot;Fra sak nr &#39;'
b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +24',b'Further cost centers can be made under Groups but entries can be made against non-Groups',b'Ytterligere kostnadsb\xc3\xa6rere kan gj\xc3\xb8res under Grupper men oppf\xc3\xb8ringene kan gj\xc3\xb8res mot ikke-grupper'
b'apps/erpnext/erpnext/config/setup.py +66',b'Users and Permissions',b'Brukere og tillatelser'
b'DocType: Vehicle Log',b'VLOG.',b'Vlog.'
b'DocType: Branch',b'Branch',b'Branch'
b'DocType: Soil Analysis',b'Ca/(K+Ca+Mg)',b'Ca / (K + Ca + Mg)'
b'DocType: Delivery Trip',b'Fulfillment User',b'Fulfillment User'
b'apps/erpnext/erpnext/config/setup.py +61',b'Printing and Branding',b'Trykking og merkevarebygging'
b'DocType: Company',b'Total Monthly Sales',b'Totalt m\xc3\xa5nedlig salg'
b'DocType: Agriculture Analysis Criteria',b'Weather',b'V\xc3\xa6r'
b'DocType: Bin',b'Actual Quantity',b'Selve Antall'
b'DocType: Shipping Rule',b'example: Next Day Shipping',b'Eksempel: Neste Day Shipping'
b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +187',b'Serial No {0} not found',b'Serial No {0} ikke funnet'
b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +291',b'Subscription has been {0}',b'Abonnementet har v\xc3\xa6rt {0}'
b'DocType: Fee Schedule Program',b'Fee Schedule Program',b'Avgift Schedule Program'
b'DocType: Fee Schedule Program',b'Student Batch',b'student Batch'
b'apps/erpnext/erpnext/utilities/activation.py +119',b'Make Student',b'Gj\xc3\xb8r Student'
b'DocType: Supplier Scorecard Scoring Standing',b'Min Grade',b'Min karakter'
b'apps/erpnext/erpnext/projects/doctype/project/project.py +218',b'You have been invited to collaborate on the project: {0}',b'Du har blitt invitert til \xc3\xa5 samarbeide om prosjektet: {0}'
b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +157',b'Physician not available on {0}',b'Legen ikke tilgjengelig p\xc3\xa5 {0}'
b'DocType: Leave Block List Date',b'Block Date',b'Block Dato'
b'DocType: Crop',b'Crop',b'Avling'
b'DocType: Purchase Receipt',b'Supplier Delivery Note',b'Leverand\xc3\xb8rleverans Note'
b'apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +70',b'Apply Now',b'S\xc3\xb8k n\xc3\xa5'
b'apps/erpnext/erpnext/stock/dashboard/item_dashboard_list.html +25',b'Actual Qty {0} / Waiting Qty {1}',b'Faktisk antall {0} / Venter antall {1}'
b'apps/erpnext/erpnext/stock/dashboard/item_dashboard_list.html +25',b'Actual Qty {0} / Waiting Qty {1}',b'Faktisk antall {0} / Venter antall {1}'
b'DocType: Purchase Invoice',b'E-commerce GSTIN',b'E-handel GSTIN'
b'DocType: Sales Order',b'Not Delivered',b'Ikke levert'
,b'Bank Clearance Summary',b'Bank Lagersalg Summary'
b'apps/erpnext/erpnext/config/setup.py +106',"b'Create and manage daily, weekly and monthly email digests.'","b'Opprette og administrere daglige, ukentlige og m\xc3\xa5nedlige e-postford\xc3\xb8yer.'"
b'DocType: Appraisal Goal',b'Appraisal Goal',b'Appraisal Goal'
b'DocType: Stock Reconciliation Item',b'Current Amount',b'Gjeldende Bel\xc3\xb8p'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +58',b'Buildings',b'bygninger'
b'DocType: Fee Schedule',b'Fee Structure',b'Avgiftsstruktur struktur~~POS=HEADCOMP'
b'DocType: Timesheet Detail',b'Costing Amount',b'Costing Bel\xc3\xb8p'
b'DocType: Student Admission Program',b'Application Fee',b'P\xc3\xa5meldingsavgift'
b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +52',b'Submit Salary Slip',b'Send L\xc3\xb8nn Slip'
b'apps/erpnext/erpnext/controllers/selling_controller.py +137',b'Maxiumm discount for Item {0} is {1}%',b'Maxiumm rabatt for Element {0} er {1}%'
b'apps/erpnext/erpnext/stock/doctype/item_price/item_price.js +16',b'Import in Bulk',b'Import i Bulk'
b'DocType: Sales Partner',b'Address & Contacts',b'Adresse og Kontakt'
b'DocType: SMS Log',b'Sender Name',b'Avsender Navn'
b'DocType: Agriculture Analysis Criteria',b'Agriculture Analysis Criteria',b'Landbruk Analyse Kriterier'
b'DocType: POS Profile',b'[Select]',b'[Velg]'
b'DocType: Vital Signs',b'Blood Pressure (diastolic)',b'Blodtrykk (diastolisk)'
b'DocType: SMS Log',b'Sent To',b'Sendt til'
b'DocType: Agriculture Task',b'Holiday Management',b'Holiday Management'
b'DocType: Payment Request',b'Make Sales Invoice',b'Gj\xc3\xb8r Sales Faktura'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +61',b'Softwares',b'programvare'
b'apps/erpnext/erpnext/crm/doctype/lead/lead.py +53',b'Next Contact Date cannot be in the past',b'Neste Kontakt Datoen kan ikke v\xc3\xa6re i fortiden'
b'DocType: Company',b'For Reference Only.',b'For referanse.'
b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +112',b'Physician {0} not available on {1}',b'Lege {0} ikke tilgjengelig p\xc3\xa5 {1}'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +2581',b'Select Batch No',b'Velg batchnummer'
b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +61',b'Invalid {0}: {1}',b'Ugyldig {0}: {1}'
,b'GSTR-1',b'GSTR-en'
b'DocType: Purchase Invoice',b'PINV-RET-',b'PINV-RET-'
b'DocType: Fee Validity',b'Reference Inv',b'Referanse Inv'
b'DocType: Sales Invoice Advance',b'Advance Amount',b'Forskuddsbel\xc3\xb8p'
b'DocType: Manufacturing Settings',b'Capacity Planning',b'Kapasitetsplanlegging'
b'DocType: Supplier Quotation',b'Rounding Adjustment (Company Currency',b'Avrundingsjustering (Bedriftsvaluta'
b'apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +43',"b""'From Date' is required""",b'&quot;Fra dato&quot; er n\xc3\xb8dvendig'
b'DocType: Journal Entry',b'Reference Number',b'Referanse Nummer'
b'DocType: Employee',b'Employment Details',b'Sysselsetting Detaljer'
b'DocType: Employee',b'New Workplace',b'Nye arbeidsplassen'
b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +17',b'Set as Closed',b'Sett som Stengt'
b'apps/erpnext/erpnext/stock/get_item_details.py +127',b'No Item with Barcode {0}',b'Ingen Element med Barcode {0}'
b'DocType: Normal Test Items',b'Require Result Value',b'Krever resultatverdi'
b'DocType: Item',b'Show a slideshow at the top of the page',b'Vis en lysbildeserie p\xc3\xa5 toppen av siden'
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +532',b'Boms',b'Boms'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +162',b'Stores',b'Butikker'
b'DocType: Project Type',b'Projects Manager',b'Prosjekter manager'
b'DocType: Serial No',b'Delivery Time',b'Leveringstid'
b'apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +33',b'Ageing Based On',b'Aldring Based On'
b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +61',b'Appointment cancelled',b'Avtale kansellert'
b'DocType: Item',b'End of Life',b'Slutten av livet'
b'apps/erpnext/erpnext/demo/setup/setup_data.py +331',b'Travel',b'Reise'
b'DocType: Student Report Generation Tool',b'Include All Assessment Group',b'Inkluder alle vurderingsgrupper'
b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +183',b'No active or default Salary Structure found for employee {0} for the given dates',b'Ingen aktive eller standard L\xc3\xb8nn Struktur funnet for arbeidstaker {0} for den gitte datoer'
b'DocType: Leave Block List',b'Allow Users',b'Gi brukere'
b'DocType: Purchase Order',b'Customer Mobile No',b'Kunden Mobile No'
b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +1',b'Recurring',b'Gjentakende'
b'DocType: Cash Flow Mapping Template Details',b'Cash Flow Mapping Template Details',b'Kontantstr\xc3\xb8m kartlegging detaljer'
b'DocType: Cost Center',b'Track separate Income and Expense for product verticals or divisions.',b'Spor separat inntekter og kostnader for produkt vertikaler eller divisjoner.'
b'DocType: Rename Tool',b'Rename Tool',b'Rename Tool'
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +72',b'Update Cost',b'Oppdater Cost'
b'DocType: Item Reorder',b'Item Reorder',b'Sak Omgj\xc3\xb8re'
b'apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +463',b'Show Salary Slip',b'Vis L\xc3\xb8nn Slip'
b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +849',b'Transfer Material',b'Transfer Material'
b'DocType: Fees',b'Send Payment Request',b'Send betalingsforesp\xc3\xb8rsel'
b'DocType: BOM',"b'Specify the operations, operating cost and give a unique Operation no to your operations.'","b'Spesifiser drift, driftskostnadene og gi en unik Operation nei til driften.'"
b'DocType: Water Analysis',b'Origin',b'Opprinnelse'
b'apps/erpnext/erpnext/controllers/status_updater.py +204',b'This document is over limit by {0} {1} for item {4}. Are you making another {3} against the same {2}?',b'Dette dokumentet er over grensen av {0} {1} for elementet {4}. Er du gj\xc3\xb8r en annen {3} mot samme {2}?'
b'apps/erpnext/erpnext/public/js/controllers/transaction.js +1154',b'Please set recurring after saving',b'Vennligst sett gjentakende etter lagring'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +769',b'Select change amount account',b'Velg endring mengde konto'
b'DocType: Purchase Invoice',b'Price List Currency',b'Prisliste Valuta'
b'DocType: Naming Series',b'User must always select',b'Brukeren m\xc3\xa5 alltid velge'
b'DocType: Stock Settings',b'Allow Negative Stock',b'Tillat Negative Stock'
b'DocType: Installation Note',b'Installation Note',b'Installasjon Merk'
b'DocType: Soil Texture',b'Clay',b'Leire'
b'DocType: Topic',b'Topic',b'Emne'
b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +45',b'Cash Flow from Financing',b'Kontantstr\xc3\xb8m fra finansierings'
b'DocType: Budget Account',b'Budget Account',b'budsjett konto'
b'DocType: Quality Inspection',b'Verified By',b'Verified by'
b'apps/erpnext/erpnext/setup/doctype/company/company.py +78',"b""Cannot change company's default currency, because there are existing transactions. Transactions must be cancelled to change the default currency.""","b'Kan ikke endre selskapets standardvaluta, fordi det er eksisterende transaksjoner. Transaksjoner m\xc3\xa5 avbestilles \xc3\xa5 endre valgt valuta.'"
b'DocType: Cash Flow Mapping',b'Is Income Tax Liability',b'Er skatt p\xc3\xa5 inntektsskatt'
b'DocType: Grading Scale Interval',b'Grade Description',b'grade Beskrivelse'
b'DocType: Stock Entry',b'Purchase Receipt No',b'Kvitteringen Nei'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +30',b'Earnest Money',b'Earnest Penger'
b'DocType: Sales Invoice',b' Shipping Bill Number',b'Fraktregningsnummer'
b'apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +34',b'Traceability',b'Sporbarhet'
b'DocType: Asset Maintenance Log',b'Actions performed',b'Handlinger utf\xc3\xb8rt'
b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +51',b'Customer &gt; Customer Group &gt; Territory',b'Kunde&gt; Kundegruppe&gt; Territorium'
b'DocType: Cash Flow Mapper',b'Section Leader',b'Seksjonsleder'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +137',b'Source of Funds (Liabilities)',b'Source of Funds (Gjeld)'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +431',b'Quantity in row {0} ({1}) must be same as manufactured quantity {2}',b'Antall p\xc3\xa5 rad {0} ({1}) m\xc3\xa5 v\xc3\xa6re det samme som produsert mengde {2}'
b'DocType: Supplier Scorecard Scoring Standing',b'Employee',b'Ansatt'
b'DocType: Asset Repair',b'Failure Date',b'Feil dato'
b'DocType: Sample Collection',b'Collected Time',b'Samlet tid'
b'DocType: Company',b'Sales Monthly History',b'Salg M\xc3\xa5nedlig historie'
b'DocType: Asset Maintenance Task',b'Next Due Date',b'neste frist'
b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +214',b'Select Batch',b'Velg Batch'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +244',b'{0} {1} is fully billed',b'{0} {1} er fullt fakturert'
b'apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.js +31',b'Vital Signs',b'Livstegn'
b'DocType: Training Event',b'End Time',b'Sluttid'
b'apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +63',b'Active Salary Structure {0} found for employee {1} for the given dates',b'Aktiv L\xc3\xb8nn Struktur {0} funnet for ansatt {1} for de gitte datoer'
b'DocType: Payment Entry',b'Payment Deductions or Loss',b'Betalings fradrag eller tap'
b'DocType: Soil Analysis',b'Soil Analysis Criterias',b'Jordanalysekriterier'
b'apps/erpnext/erpnext/config/setup.py +42',b'Standard contract terms for Sales or Purchase.',b'Standard kontraktsvilk\xc3\xa5r for salg eller kj\xc3\xb8p.'
b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +112',b'Group by Voucher',b'Grupper etter Voucher'
b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +233',b'Are you sure you want to cancel this appointment?',b'Er du sikker p\xc3\xa5 at du vil avbryte denne avtalen?'
b'DocType: Hotel Room Pricing Package',b'Hotel Room Pricing Package',b'Hotellrom Prispakke'
b'apps/erpnext/erpnext/config/crm.py +6',b'Sales Pipeline',b'salgs~~POS=TRUNC'
b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +201',b'Please set default account in Salary Component {0}',b'Vennligst angi standardkonto i L\xc3\xb8nn Component {0}'
b'apps/erpnext/erpnext/templates/form_grid/material_request_grid.html +7',b'Required On',b'N\xc3\xb8dvendig P\xc3\xa5'
b'DocType: Rename Tool',b'File to Rename',b'Filen til Rename'
b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +200',b'Please select BOM for Item in Row {0}',b'Vennligst velg BOM for Element i Rad {0}'
b'apps/erpnext/erpnext/accounts/doctype/mode_of_payment/mode_of_payment.py +28',b'Account {0} does not match with Company {1} in Mode of Account: {2}',b'Konto {0} stemmer ikke overens med Selskapet {1} i Konto modus: {2}'
b'apps/erpnext/erpnext/controllers/buying_controller.py +464',b'Specified BOM {0} does not exist for Item {1}',b'Spesifisert BOM {0} finnes ikke for Element {1}'
b'apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +301',b'Course: ',b'Kurs:'
b'DocType: Soil Texture',b'Sandy Loam',b'Sandy Loam'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +232',b'Maintenance Schedule {0} must be cancelled before cancelling this Sales Order',b'Vedlikeholdsplan {0} m\xc3\xa5 avbestilles f\xc3\xb8r den avbryter denne salgsordre'
b'DocType: POS Profile',b'Applicable for Users',b'Gjelder for brukere'
b'DocType: Notification Control',b'Expense Claim Approved',b'Expense krav Godkjent'
b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +231',b'No Work Orders created',b'Ingen arbeidsordre opprettet'
b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +321',b'Salary Slip of employee {0} already created for this period',b'L\xc3\xb8nn Slip av ansattes {0} som allerede er opprettet for denne perioden'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +155',b'Pharmaceutical',b'Pharmaceutical'
b'apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26',b'Cost of Purchased Items',b'Kostnad for kj\xc3\xb8pte varer'
b'DocType: Selling Settings',b'Sales Order Required',b'Salgsordre P\xc3\xa5krevd'
b'DocType: Purchase Invoice',b'Credit To',b'Kreditt til'
b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +46',b'PieceDate',b'PieceDate'
b'apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +31',b'Active Leads / Customers',b'Aktive Ledninger / Kunder'
b'DocType: Employee Education',b'Post Graduate',b'Post Graduate'
b'DocType: Maintenance Schedule Detail',b'Maintenance Schedule Detail',b'Vedlikeholdsplan Detalj'
b'DocType: Supplier Scorecard',b'Warn for new Purchase Orders',b'Varsle om nye innkj\xc3\xb8psordrer'
b'DocType: Quality Inspection Reading',b'Reading 9',b'Lese 9'
b'DocType: Supplier',b'Is Frozen',b'Er Frozen'
b'apps/erpnext/erpnext/stock/utils.py +224',b'Group node warehouse is not allowed to select for transactions',b'Gruppe node lageret er ikke lov til \xc3\xa5 velge for transaksjoner'
b'DocType: Buying Settings',b'Buying Settings',b'Kj\xc3\xb8pe Innstillinger'
b'DocType: Stock Entry Detail',b'BOM No. for a Finished Good Item',b'BOM No. for et ferdig God Sak'
b'DocType: Upload Attendance',b'Attendance To Date',b'Oppm\xc3\xb8te To Date'
b'DocType: Request for Quotation Supplier',b'No Quote',b'Ingen sitat'
b'DocType: Warranty Claim',b'Raised By',b'Raised By'
b'DocType: Payment Gateway Account',b'Payment Account',b'Betaling konto'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +909',b'Please specify Company to proceed',b'Vennligst oppgi selskapet \xc3\xa5 fortsette'
b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +27',b'Net Change in Accounts Receivable',b'Netto endring i kundefordringer'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +88',b'Compensatory Off',b'Kompenserende Off'
b'DocType: Job Offer',b'Accepted',b'Akseptert'
b'DocType: Grant Application',b'Organization',b'Organisasjon'
b'DocType: BOM Update Tool',b'BOM Update Tool',b'BOM Update Tool'
b'DocType: SG Creation Tool Course',b'Student Group Name',b'Student Gruppenavn'
b'apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.js +17',b'Show exploded view',b'Vis eksplodert visning'
b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +7',b'Creating Fees',b'Opprette avgifter'
b'apps/erpnext/erpnext/setup/doctype/company/company.js +91',b'Please make sure you really want to delete all the transactions for this company. Your master data will remain as it is. This action cannot be undone.',b'S\xc3\xb8rg for at du virkelig \xc3\xb8nsker \xc3\xa5 slette alle transaksjoner for dette selskapet. Dine stamdata vil forbli som det er. Denne handlingen kan ikke angres.'
b'apps/erpnext/erpnext/templates/pages/product_search.html +21',b'Search Results',b'S\xc3\xb8keresultater'
b'DocType: Room',b'Room Number',b'Romnummer'
b'apps/erpnext/erpnext/utilities/transaction_base.py +107',b'Invalid reference {0} {1}',b'Ugyldig referanse {0} {1}'
b'DocType: Shipping Rule',b'Shipping Rule Label',b'Shipping Rule Etikett'
b'DocType: Journal Entry Account',b'Payroll Entry',b'L\xc3\xb8nninngang'
b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +75',b'View Fees Records',b'Se avgifter'
b'apps/erpnext/erpnext/setup/doctype/company/company.js +35',b'Make Tax Template',b'Lag skatteremne'
b'apps/erpnext/erpnext/public/js/conf.js +28',b'User Forum',b'bruker~~POS=TRUNC'
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +319',b'Raw Materials cannot be blank.',b'R\xc3\xa5vare kan ikke v\xc3\xa6re blank.'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +498',"b'Could not update stock, invoice contains drop shipping item.'","b'Kunne ikke oppdatere lager, inneholder faktura slippe frakt element.'"
b'DocType: Lab Test Sample',b'Lab Test Sample',b'Lab Test pr\xc3\xb8ve'
b'DocType: Item Variant Settings',b'Allow Rename Attribute Value',b'Tillat omd\xc3\xb8pe attributtverdi'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +491',b'Quick Journal Entry',b'Hurtig Journal Entry'
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +200',b'You can not change rate if BOM mentioned agianst any item',b'Du kan ikke endre prisen dersom BOM nevnt agianst ethvert element'
b'DocType: Restaurant',b'Invoice Series Prefix',b'Faktura Serie Prefiks'
b'DocType: Employee',b'Previous Work Experience',b'Tidligere arbeidserfaring'
b'DocType: Stock Entry',b'For Quantity',b'For Antall'
b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +205',b'Please enter Planned Qty for Item {0} at row {1}',b'Skriv inn Planned Antall for Element {0} p\xc3\xa5 rad {1}'
b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +93',b'Google Maps integration is not enabled',b'Integrasjon med Google Maps er ikke aktivert'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +241',b'{0} {1} is not submitted',b'{0} {1} ikke er sendt'
b'DocType: Member',b'Membership Expiry Date',b'Medlemskapets utl\xc3\xb8psdato'
b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +131',b'{0} must be negative in return document',b'{0} m\xc3\xa5 v\xc3\xa6re negativ i retur dokument'
,b'Minutes to First Response for Issues',b'Minutter til First Response for Issues'
b'DocType: Purchase Invoice',b'Terms and Conditions1',b'Vilk\xc3\xa5r og forhold 1'
b'apps/erpnext/erpnext/public/js/setup_wizard.js +109',b'The name of the institute for which you are setting up this system.',b'Navnet p\xc3\xa5 institutt for som du setter opp dette systemet.'
b'DocType: Accounts Settings',"b'Accounting entry frozen up to this date, nobody can do / modify entry except role specified below.'","b'Regnskap oppf\xc3\xb8ring frosset opp til denne datoen, kan ingen gj\xc3\xb8re / endre oppf\xc3\xb8ring unntatt rolle angitt nedenfor.'"
b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +116',b'Please save the document before generating maintenance schedule',b'Vennligst lagre dokumentet f\xc3\xb8r du genererer vedlikeholdsplan'
b'apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.js +30',b'Latest price updated in all BOMs',b'Siste pris oppdatert i alle BOMs'
b'apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +28',b'Project Status',b'Prosjekt Status'
b'DocType: UOM',b'Check this to disallow fractions. (for Nos)',b'Sjekk dette for \xc3\xa5 forby fraksjoner. (For Nos)'
b'DocType: Student Admission Program',b'Naming Series (for Student Applicant)',b'Naming Series (Student s\xc3\xb8keren)'
b'DocType: Delivery Note',b'Transporter Name',b'Transporter Name'
b'DocType: Authorization Rule',b'Authorized Value',b'Autorisert Verdi'
b'DocType: BOM',b'Show Operations',b'Vis Operations'
,b'Minutes to First Response for Opportunity',b'Minutter til First Response for Opportunity'
b'apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68',b'Total Absent',b'Total Frav\xc3\xa6rende'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +862',b'Item or Warehouse for row {0} does not match Material Request',b'Element eller Warehouse for rad {0} samsvarer ikke Material Request'
b'apps/erpnext/erpnext/config/stock.py +191',b'Unit of Measure',b'M\xc3\xa5leenhet'
b'DocType: Fiscal Year',b'Year End Date',b'\xc3\x85r Sluttdato'
b'DocType: Task Depends On',b'Task Depends On',b'Task Avhenger'
b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1026',b'Opportunity',b'Opportunity'
b'DocType: Operation',b'Default Workstation',b'Standard arbeidsstasjon'
b'DocType: Notification Control',b'Expense Claim Approved Message',b'Expense krav Godkjent melding'
b'DocType: Payment Entry',b'Deductions or Loss',b'Fradrag eller tap'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +247',b'{0} {1} is closed',b'{0} {1} er stengt'
b'DocType: Email Digest',b'How frequently?',b'Hvor ofte?'
b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +55',b'Total Collected: {0}',b'Samlet samlet: {0}'
b'DocType: Purchase Receipt',b'Get Current Stock',b'F\xc3\xa5 Current Stock'
b'DocType: Purchase Invoice',b'ineligible',b'ikke kvalifisert'
b'apps/erpnext/erpnext/config/manufacturing.py +46',b'Tree of Bill of Materials',b'Tree of Bill of Materials'
b'DocType: Student',b'Joining Date',b'Bli med dato'
,b'Employees working on a holiday',b'Arbeidstakere som arbeider p\xc3\xa5 ferie'
b'DocType: Share Balance',b'Current State',b'N\xc3\xa5v\xc3\xa6rende situasjon'
b'apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +152',b'Mark Present',b'Mark Present'
b'DocType: Share Transfer',b'From Shareholder',b'Fra Aksjon\xc3\xa6r'
b'DocType: Project',b'% Complete Method',b'% Komplett Method'
b'apps/erpnext/erpnext/healthcare/setup.py +181',b'Drug',b'Legemiddel'
b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +200',b'Maintenance start date can not be before delivery date for Serial No {0}',b'Vedlikehold startdato kan ikke v\xc3\xa6re f\xc3\xb8r leveringsdato for Serial No {0}'
b'DocType: Work Order',b'Actual End Date',b'Selve sluttdato'
b'DocType: Cash Flow Mapping',b'Is Finance Cost Adjustment',b'Er finansieringskostnadsjustering'
b'DocType: BOM',b'Operating Cost (Company Currency)',b'Driftskostnader (Selskap Valuta)'
b'DocType: Purchase Invoice',b'PINV-',b'PINV-'
b'DocType: Authorization Rule',b'Applicable To (Role)',b'Gjelder til (Role)'
b'DocType: BOM Update Tool',b'Replace BOM',b'Erstatt BOM'
b'apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.py +110',b'Code {0} already exist',b'Kode {0} finnes allerede'
b'DocType: Employee Advance',b'Purpose',b'Form\xc3\xa5let'
b'DocType: Company',b'Fixed Asset Depreciation Settings',b'Fast Asset Avskrivninger Innstillinger'
b'DocType: Item',b'Will also apply for variants unless overrridden',b'Vil ogs\xc3\xa5 gjelde for varianter med mindre overrridden'
b'DocType: Purchase Invoice',b'Advances',b'Fremskritt'
b'DocType: Work Order',b'Manufacture against Material Request',b'Produksjon mot Material Request'
b'apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +14',b'Assessment Group: ',b'Bed\xc3\xb8mmelsesgruppe:'
b'DocType: Item Reorder',b'Request for',b'Foresp\xc3\xb8rsel etter'
b'apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +32',b'Approving User cannot be same as user the rule is Applicable To',b'Godkjenne Brukeren kan ikke v\xc3\xa6re det samme som bruker regelen gjelder for'
b'DocType: Stock Entry Detail',b'Basic Rate (as per Stock UOM)',b'Basic Rate (som per Stock m\xc3\xa5lenheter)'
b'DocType: SMS Log',b'No of Requested SMS',b'Ingen av Spurt SMS'
b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +246',b'Leave Without Pay does not match with approved Leave Application records',b'La Uten Pay ikke samsvarer med godkjente La S\xc3\xb8knad poster'
b'DocType: Campaign',b'Campaign-.####',b'Kampanje -. ####'
b'apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +21',b'Next Steps',b'Neste skritt'
b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +796',b'Please supply the specified items at the best possible rates',b'Vennligst oppgi de angitte elementene p\xc3\xa5 de best mulige priser'
b'DocType: Membership',b'USD',b'USD'
b'apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +28',b'Make Invoice',b'Gj\xc3\xb8r Faktura'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +80',b'Remaining Balance',b'Gjenv\xc3\xa6rende balanse'
b'DocType: Selling Settings',b'Auto close Opportunity after 15 days',b'Auto n\xc3\xa6r mulighet etter 15 dager'
b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +86',b'Purchase Orders are not allowed for {0} due to a scorecard standing of {1}.',b'Innkj\xc3\xb8psordrer er ikke tillatt for {0} p\xc3\xa5 grunn av et scorecard som st\xc3\xa5r p\xc3\xa5 {1}.'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +498',b'Barcode {0} is not a valid {1} code',b'Strekkode {0} er ikke en gyldig {1} kode'
b'apps/erpnext/erpnext/public/js/financial_statements.js +83',b'End Year',b'slutt \xc3\x85r'
b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +23',b'Quot/Lead %',b'Quot / Lead%'
b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +23',b'Quot/Lead %',b'Quot / Lead%'
b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +124',b'Contract End Date must be greater than Date of Joining',b'Kontraktssluttdato m\xc3\xa5 v\xc3\xa6re st\xc3\xb8rre enn tidspunktet for inntreden'
b'DocType: Driver',b'Driver',b'Sj\xc3\xa5f\xc3\xb8r'
b'DocType: Vital Signs',b'Nutrition Values',b'Ern\xc3\xa6ringsverdier'
b'DocType: Lab Test Template',b'Is billable',b'Er fakturerbart'
b'DocType: Delivery Note',b'DN-',b'DN-'
b'DocType: Sales Partner',b'A third party distributor / dealer / commission agent / affiliate / reseller who sells the companies products for a commission.',b'En tredjepart distribut\xc3\xb8r / forhandler / kommisjon\xc3\xa6r / agent / forhandler som selger selskaper produkter for en kommisjon.'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +376',b'{0} against Purchase Order {1}',b'{0} mot innkj\xc3\xb8psordre {1}'
b'DocType: Patient',b'Patient Demographics',b'Pasientdemografi'
b'DocType: Task',b'Actual Start Date (via Time Sheet)',b'Faktisk startdato (via Timeregistrering)'
b'apps/erpnext/erpnext/portal/doctype/homepage/homepage.py +15',b'This is an example website auto-generated from ERPNext',b'Dette er et eksempel nettsiden automatisk generert fra ERPNext'
b'apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +43',b'Ageing Range 1',b'Aldring Range 1'
b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +212',b'Total advance amount cannot be greater than total claimed amount',b'Samlet forskuddsbel\xc3\xb8p kan ikke v\xc3\xa6re st\xc3\xb8rre enn totalt bel\xc3\xb8p'
b'DocType: Purchase Taxes and Charges Template',"b'Standard tax template that can be applied to all Purchase Transactions. This template can contain list of tax heads and also other expense heads like ""Shipping"", ""Insurance"", ""Handling"" etc.\n\n#### Note\n\nThe tax rate you define here will be the standard tax rate for all **Items**. If there are **Items** that have different rates, they must be added in the **Item Tax** table in the **Item** master.\n\n#### Description of Columns\n\n1. Calculation Type: \n    - This can be on **Net Total** (that is the sum of basic amount).\n    - **On Previous Row Total / Amount** (for cumulative taxes or charges). If you select this option, the tax will be applied as a percentage of the previous row (in the tax table) amount or total.\n    - **Actual** (as mentioned).\n2. Account Head: The Account ledger under which this tax will be booked\n3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.\n4. Description: Description of the tax (that will be printed in invoices / quotes).\n5. Rate: Tax rate.\n6. Amount: Tax amount.\n7. Total: Cumulative total to this point.\n8. Enter Row: If based on ""Previous Row Total"" you can select the row number which will be taken as a base for this calculation (default is the previous row).\n9. Consider Tax or Charge for: In this section you can specify if the tax / charge is only for valuation (not a part of total) or only for total (does not add value to the item) or for both.\n10. Add or Deduct: Whether you want to add or deduct the tax.'","b'Standard skatt mal som kan brukes p\xc3\xa5 alle kj\xc3\xb8pstransaksjoner. Denne malen kan inneholde liste over skatte hoder og ogs\xc3\xa5 andre utgifter hoder som &quot;Shipping&quot;, &quot;Forsikring&quot;, &quot;H\xc3\xa5ndtering&quot; osv #### Note Skattesatsen du definerer her vil v\xc3\xa6re standard skattesats for alle ** Items * *. Hvis det er ** Elementer ** som har forskjellige priser, m\xc3\xa5 de legges i ** Sak Skatt ** bord i ** Sak ** mester. #### Beskrivelse av kolonner 1. Beregning Type: - Dette kan v\xc3\xa6re p\xc3\xa5 ** Net Total ** (som er summen av grunnbel\xc3\xb8pet). - ** P\xc3\xa5 Forrige Row Total / Bel\xc3\xb8p ** (for kumulative skatter eller avgifter). Hvis du velger dette alternativet, vil skatten bli brukt som en prosentandel av forrige rad (i skattetabellen) eller en total. - ** Faktisk ** (som nevnt). 2. Account Head: Konto hovedbok der denne skatten vil bli bokf\xc3\xb8rt 3. Cost Center: Hvis skatt / avgift er en inntekt (som frakt) eller utgifter det m\xc3\xa5 bestilles mot et kostnadssted. 4. Beskrivelse: Beskrivelse av skatt (som vil bli skrevet ut i fakturaer / sitater). 5. Ranger: skattesats. 6. Bel\xc3\xb8p: Skatt bel\xc3\xb8p. 7. Totalt: Akkumulert total til dette punktet. 8. Angi Row: Dersom basert p\xc3\xa5 &quot;Forrige Row Total&quot; du kan velge radnummeret som vil bli tatt som en base for denne beregningen (standard er den forrige rad). 9. Vurdere Skatte eller Charge for: I denne delen kan du angi om skatt / avgift er kun for verdivurdering (ikke en del av total) eller bare for total (ikke tilf\xc3\xb8re verdi til elementet) eller for begge. 10. legge til eller trekke: Enten du \xc3\xb8nsker \xc3\xa5 legge til eller trekke skatt.'"
b'DocType: Homepage',b'Homepage',b'hjemmeside'
b'apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +68',b'Select Physician...',b'Velg lege ...'
b'DocType: Grant Application',b'Grant Application Details ',b'Gi s\xc3\xb8knadsdetaljer'
b'DocType: Purchase Receipt Item',b'Recd Quantity',b'Recd Antall'
b'apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py +65',b'Fee Records Created - {0}',b'Fee Records Laget - {0}'
b'DocType: Asset Category Account',b'Asset Category Account',b'Asset Kategori konto'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +913',b'Row #{0} (Payment Table): Amount must be positive',b'Row # {0} (Betalingstabell): Bel\xc3\xb8pet m\xc3\xa5 v\xc3\xa6re positivt'
b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +44',b'CompteNum',b'CompteNum'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +137',b'Cannot produce more Item {0} than Sales Order quantity {1}',b'Kan ikke produsere mer Element {0} enn Salgsordre kvantitet {1}'
b'apps/erpnext/erpnext/stock/doctype/item/item.js +391',b'Select Attribute Values',b'Velg Attributtverdier'
b'DocType: Purchase Invoice',b'Reason For Issuing document',b'\xc3\x85rsak til utstedelse av dokument'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +539',b'Stock Entry {0} is not submitted',b'Stock Entry {0} er ikke innsendt'
b'DocType: Payment Reconciliation',b'Bank / Cash Account',b'Bank / minibank konto'
b'apps/erpnext/erpnext/crm/doctype/lead/lead.py +47',b'Next Contact By cannot be same as the Lead Email Address',b'Neste Kontakt By kan ikke v\xc3\xa6re samme som Lead e-postadresse'
b'DocType: Tax Rule',b'Billing City',b'Fakturering By'
b'DocType: Asset',b'Manual',b'H\xc3\xa5ndbok'
b'DocType: Salary Component Account',b'Salary Component Account',b'L\xc3\xb8nn Component konto'
b'DocType: Global Defaults',b'Hide Currency Symbol',b'Skjule Valutasymbol'
b'apps/erpnext/erpnext/config/non_profit.py +58',b'Donor information.',b'Donorinformasjon.'
b'apps/erpnext/erpnext/config/accounts.py +330',"b'e.g. Bank, Cash, Credit Card'","b'f.eks Bank, Cash, Kredittkort'"
b'DocType: Lead Source',b'Source Name',b'Source Name'
b'DocType: Vital Signs',"b'Normal resting blood pressure in an adult is approximately 120 mmHg systolic, and 80 mmHg diastolic, abbreviated ""120/80 mmHg""'","b'Normal hvilende blodtrykk hos en voksen er ca. 120 mmHg systolisk og 80 mmHg diastolisk, forkortet &quot;120/80 mmHg&quot;'"
b'apps/erpnext/erpnext/stock/doctype/batch/batch.py +119',"b'Set items shelf life in days, to set expiry based on manufacturing_date plus self life'","b'Angi gjenstander holdbarhet om dager, for \xc3\xa5 angi utl\xc3\xb8p basert p\xc3\xa5 manufacturing_date pluss selvtid'"
b'DocType: Journal Entry',b'Credit Note',b'Kreditnota'
b'DocType: Projects Settings',b'Ignore Employee Time Overlap',b'Ignorer arbeidstakertidoverlapping'
b'DocType: Warranty Claim',b'Service Address',b'Tjenesten Adresse'
b'DocType: Asset Maintenance Task',b'Calibration',b'kalibrering'
b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +97',b'{0} is a company holiday',b'{0} er en firmas ferie'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +49',b'Furnitures and Fixtures',b'M\xc3\xb8bler og inventar'
b'DocType: Item',b'Manufacture',b'Produksjon'
b'apps/erpnext/erpnext/utilities/user_progress.py +27',b'Setup Company',b'Oppsett Company'
,b'Lab Test Report',b'Lab Test Report'
b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +13',b'Please Delivery Note first',b'Vennligst f\xc3\xb8lgeseddel f\xc3\xb8rst'
b'DocType: Student Applicant',b'Application Date',b'S\xc3\xb8knadsdato'
b'DocType: Salary Detail',b'Amount based on formula',b'Bel\xc3\xb8p basert p\xc3\xa5 formelen'
b'DocType: Purchase Invoice',b'Currency and Price List',b'Valuta og prisliste'
b'DocType: Opportunity',b'Customer / Lead Name',b'Kunde / Lead navn'
b'apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +115',b'Clearance Date not mentioned',b'Klaring Dato ikke nevnt'
b'apps/erpnext/erpnext/config/manufacturing.py +7',b'Production',b'Produksjon'
b'DocType: Guardian',b'Occupation',b'Okkupasjon'
b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +74',b'Row {0}:Start Date must be before End Date',b'Rad {0}: Startdato m\xc3\xa5 v\xc3\xa6re f\xc3\xb8r sluttdato'
b'DocType: Crop',b'Planting Area',b'Planteomr\xc3\xa5de'
b'apps/erpnext/erpnext/controllers/trends.py +19',b'Total(Qty)',b'Total (Stk)'
b'DocType: Installation Note Item',b'Installed Qty',b'Installert antall'
b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +4',b'This could be because of some invalid Email Addresses in the',b'Dette kan skyldes noen ugyldige e-postadresser i'
b'apps/erpnext/erpnext/utilities/user_progress.py +31',b'You added ',b'Du har lagt til'
b'DocType: Purchase Taxes and Charges',b'Parenttype',b'Parenttype'
b'apps/erpnext/erpnext/hr/doctype/training_event/training_event.js +10',b'Training Result',b'trening Resultat'
b'DocType: Purchase Invoice',b'Is Paid',b'er betalt'
b'DocType: Salary Structure',b'Total Earning',b'Total Tjene'
b'DocType: Purchase Receipt',b'Time at which materials were received',b'Tidspunktet for n\xc3\xa5r materialene ble mottatt'
b'DocType: Products Settings',b'Products per Page',b'Produkter per side'
b'DocType: Stock Ledger Entry',b'Outgoing Rate',b'Utg\xc3\xa5ende Rate'
b'apps/erpnext/erpnext/config/hr.py +233',b'Organization branch master.',b'Organisering gren mester.'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +313',b' or ',b'eller'
b'DocType: Sales Order',b'Billing Status',b'Billing Status'
b'apps/erpnext/erpnext/public/js/conf.js +32',b'Report an Issue',b'Melde om et problem'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +120',b'Utility Expenses',b'Utility Utgifter'
b'apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +64',b'90-Above',b'90-Above'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +252',b'Row #{0}: Journal Entry {1} does not have account {2} or already matched against another voucher',b'Row # {0}: Bilagsregistrering {1} har ikke konto {2} eller allerede matchet mot en annen kupong'
b'DocType: Supplier Scorecard Criteria',b'Criteria Weight',b'Kriterier Vekt'
b'DocType: Buying Settings',b'Default Buying Price List',b'Standard Kj\xc3\xb8pe Prisliste'
b'DocType: Payroll Entry',b'Salary Slip Based on Timesheet',b'L\xc3\xb8nn Slip Basert p\xc3\xa5 Timeregistrering'
b'apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +43',b'Buying Rate',b'Kj\xc3\xb8pspris'
b'DocType: Notification Control',b'Sales Order Message',b'Salgsordre Message'
b'apps/erpnext/erpnext/config/setup.py +15',"b'Set Default Values like Company, Currency, Current Fiscal Year, etc.'","b'Sett standardverdier som Company, Valuta, v\xc3\xa6rende regnskaps\xc3\xa5r, etc.'"
b'DocType: Payment Entry',b'Payment Type',b'Betalings Type'
b'apps/erpnext/erpnext/stock/doctype/batch/batch.py +240',b'Please select a Batch for Item {0}. Unable to find a single batch that fulfills this requirement',b'Vennligst velg en batch for element {0}. Kunne ikke finne en enkelt batch som oppfyller dette kravet'
b'apps/erpnext/erpnext/stock/doctype/batch/batch.py +240',b'Please select a Batch for Item {0}. Unable to find a single batch that fulfills this requirement',b'Vennligst velg en batch for element {0}. Kunne ikke finne en enkelt batch som oppfyller dette kravet'
b'DocType: Hub Category',b'Parent Category',b'Foreldrekategori'
b'DocType: Payroll Entry',b'Select Employees',b'Velg Medarbeidere'
b'DocType: Opportunity',b'Potential Sales Deal',b'Potensielle Sales Deal'
b'DocType: Complaint',b'Complaints',b'klager'
b'DocType: Payment Entry',b'Cheque/Reference Date',b'Sjekk / Reference Date'
b'DocType: Purchase Invoice',b'Total Taxes and Charges',b'Totale skatter og avgifter'
b'DocType: Employee',b'Emergency Contact',b'N\xc3\xb8dtelefon'
b'DocType: Bank Reconciliation Detail',b'Payment Entry',b'betaling Entry'
,b'sales-browser',b'salg-browser'
b'apps/erpnext/erpnext/accounts/doctype/account/account.js +79',b'Ledger',b'Ledger'
b'DocType: Patient Medical Record',b'PMR-',b'PMR-'
b'DocType: Drug Prescription',b'Drug Code',b'Legemiddelkode'
b'DocType: Target Detail',b'Target  Amount',b'Target Bel\xc3\xb8p'
b'DocType: POS Profile',b'Print Format for Online',b'Utskriftsformat for Internett'
b'DocType: Shopping Cart Settings',b'Shopping Cart Settings',b'Handlevogn Innstillinger'
b'DocType: Journal Entry',b'Accounting Entries',b'Regnskaps Entries'
b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +17',"b""If selected Pricing Rule is made for 'Rate', it will overwrite Price List. Pricing Rule rate is the final rate, so no further discount should be applied. Hence, in transactions like Sales Order, Purchase Order etc, it will be fetched in 'Rate' field, rather than 'Price List Rate' field.""","b'Hvis valgt prismodell er laget for \xc2\xabRate\xc2\xbb, vil den overskrive Prisliste. Prissetting Regelsats er sluttprisen, s\xc3\xa5 ingen ytterligere rabatt skal brukes. Derfor, i transaksjoner som salgsordre, innkj\xc3\xb8psordre osv., Blir det hentet i feltet &#39;Rate&#39;, i stedet for &#39;Prislistefrekvens&#39;.'"
b'apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +24',b'Duplicate Entry. Please check Authorization Rule {0}',b'Duplisere Entry. Vennligst sjekk Authorization Rule {0}'
b'DocType: Journal Entry Account',b'Reference Due Date',b'Referansedato'
b'DocType: Purchase Order',b'Ref SQ',b'Ref SQ'
b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +55',b'Receipt document must be submitted',b'Kvittering dokumentet m\xc3\xa5 sendes'
b'DocType: Purchase Invoice Item',b'Received Qty',b'Mottatt Antall'
b'DocType: Stock Entry Detail',b'Serial No / Batch',b'Serial No / Batch'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +340',b'Not Paid and Not Delivered',b'Ikke betalt og ikke levert'
b'DocType: Product Bundle',b'Parent Item',b'Parent Element'
b'DocType: Account',b'Account Type',b'Kontotype'
b'DocType: Delivery Note',b'DN-RET-',b'DN-RET-'
b'apps/erpnext/erpnext/templates/pages/projects.html +58',b'No time sheets',b'Ingen timelister'
b'DocType: GoCardless Mandate',b'GoCardless Customer',b'GoCardless kunde'
b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +123',b'Leave Type {0} cannot be carry-forwarded',b'La Type {0} kan ikke b\xc3\xa6re-videre'
b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +215',"b""Maintenance Schedule is not generated for all the items. Please click on 'Generate Schedule'""",b'Vedlikeholdsplan genereres ikke for alle elementene. Vennligst klikk p\xc3\xa5 &quot;Generer Schedule &#39;'
,b'To Produce',b'\xc3\x85 Produsere'
b'apps/erpnext/erpnext/config/hr.py +93',b'Payroll',b'l\xc3\xb8nn'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +196',"b'For row {0} in {1}. To include {2} in Item rate, rows {3} must also be included'","b'For rad {0} i {1}. For \xc3\xa5 inkludere {2} i Element rate, rader {3} m\xc3\xa5 ogs\xc3\xa5 inkluderes'"
b'DocType: Patient Service Unit',b'Parent Service Unit',b'Foreldre Service Unit'
b'apps/erpnext/erpnext/utilities/activation.py +101',b'Make User',b'Gj\xc3\xb8r Bruker'
b'DocType: Packing Slip',b'Identification of the package for the delivery (for print)',b'Identifikasjon av pakken for levering (for print)'
b'DocType: Bin',b'Reserved Quantity',b'Reservert Antall'
b'apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +34',b'Please enter valid email address',b'Vennligst skriv inn gyldig e-postadresse'
b'apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +34',b'Please enter valid email address',b'Vennligst skriv inn gyldig e-postadresse'
b'DocType: Volunteer Skill',b'Volunteer Skill',b'Frivillig ferdighet'
b'DocType: Bank Reconciliation',b'Include POS Transactions',b'Inkluder POS-transaksjoner'
b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +784',b'Please select an item in the cart',b'Vennligst velg et element i handlekurven'
b'DocType: Landed Cost Voucher',b'Purchase Receipt Items',b'Kvitteringen Items'
b'apps/erpnext/erpnext/config/learn.py +21',b'Customizing Forms',b'Tilpasse Forms'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +74',b'Arrear',b'etterskudd'
b'apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +158',b'Depreciation Amount during the period',b'Avskrivningsbel\xc3\xb8pet i perioden'
b'apps/erpnext/erpnext/accounts/doctype/sales_taxes_and_charges_template/sales_taxes_and_charges_template.py +43',b'Disabled template must not be default template',b'Funksjonshemmede malen m\xc3\xa5 ikke v\xc3\xa6re standardmal'
b'apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py +314',b'For row {0}: Enter planned qty',b'For rad {0}: Skriv inn planlagt antall'
b'DocType: Shareholder',b'SH-',b'SH'
b'DocType: Account',b'Income Account',b'Inntekt konto'
b'DocType: Payment Request',"b""Amount in customer's currency""",b'Bel\xc3\xb8p i kundens valuta'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +825',b'Delivery',b'Levering'
b'DocType: Volunteer',b'Weekdays',b'hver~~POS=TRUNC'
b'DocType: Stock Reconciliation Item',b'Current Qty',b'N\xc3\xa5v\xc3\xa6rende Antall'
b'DocType: Restaurant Menu',b'Restaurant Menu',b'Restaurantmeny'
b'apps/erpnext/erpnext/templates/generators/item_group.html +36',b'Prev',b'prev'
b'DocType: Appraisal Goal',b'Key Responsibility Area',b'Key Ansvar Omr\xc3\xa5de'
b'apps/erpnext/erpnext/utilities/activation.py +127',"b'Student Batches help you track attendance, assessments and fees for students'","b'Student batcher hjelpe deg med \xc3\xa5 spore oppm\xc3\xb8te, vurderinger og avgifter for studenter'"
b'DocType: Payment Entry',b'Total Allocated Amount',b'Totalt tildelte bel\xc3\xb8p'
b'apps/erpnext/erpnext/setup/doctype/company/company.py +151',b'Set default inventory account for perpetual inventory',b'Angi standard beholdningskonto for evigvarende beholdning'
b'DocType: Item Reorder',b'Material Request Type',b'Materialet Request Type'
b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +252',b'Accural Journal Entry for salaries from {0} to {1}',b'Accural dagboken til l\xc3\xb8nninger fra {0} i {1}'
b'apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.js +17',b'Send Grant Review Email',b'Send Grant Review Email'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +848',"b'LocalStorage is full, did not save'","b'Localstorage er full, ikke redde'"
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +100',b'Row {0}: UOM Conversion Factor is mandatory',b'Rad {0}: m\xc3\xa5lenheter omregningsfaktor er obligatorisk'
b'apps/erpnext/erpnext/utilities/user_progress.py +235',b'Room Capacity',b'Romkapasitet'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +95',b'Ref',b'Ref'
b'DocType: Lab Test',b'LP-',b'LP-'
b'DocType: Healthcare Settings',b'Registration Fee',b'Registreringsavgift'
b'DocType: Budget',b'Cost Center',b'Kostnadssted'
b'apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +45',b'Voucher #',b'Kupong #'
b'DocType: Notification Control',b'Purchase Order Message',b'Innkj\xc3\xb8psordre Message'
b'DocType: Tax Rule',b'Shipping Country',b'Shipping Land'
b'DocType: Selling Settings',"b""Hide Customer's Tax Id from Sales Transactions""",b'Skjule Kundens Tax ID fra salgstransaksjoner'
b'DocType: Upload Attendance',b'Upload HTML',b'Last opp HTML'
b'DocType: Employee',b'Relieving Date',b'Lindrende Dato'
b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +14',"b'Pricing Rule is made to overwrite Price List / define discount percentage, based on some criteria.'","b'Prising Rule er laget for \xc3\xa5 overskrive Prisliste / definere rabattprosenten, basert p\xc3\xa5 noen kriterier.'"
b'DocType: Serial No',b'Warehouse can only be changed via Stock Entry / Delivery Note / Purchase Receipt',b'Lageret kan bare endres via Stock Entry / f\xc3\xb8lgeseddel / Kj\xc3\xb8pskvittering'
b'DocType: Employee Education',b'Class / Percentage',b'Klasse / Prosent'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +134',b'Head of Marketing and Sales',b'Head of Marketing and Sales'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +72',b'Income Tax',b'Inntektsskatt'
b'apps/erpnext/erpnext/config/selling.py +174',b'Track Leads by Industry Type.',b'Spor Leads etter bransje Type.'
b'apps/erpnext/erpnext/utilities/user_progress.py +101',b'Go to Letterheads',b'G\xc3\xa5 til Letterheads'
b'DocType: Item Supplier',b'Item Supplier',b'Sak Leverand\xc3\xb8r'
b'apps/erpnext/erpnext/public/js/controllers/transaction.js +1255',b'Please enter Item Code to get batch no',b'Skriv inn Element kode for \xc3\xa5 f\xc3\xa5 batch no'
b'apps/erpnext/erpnext/selling/doctype/quotation/quotation.js +880',b'Please select a value for {0} quotation_to {1}',b'Velg en verdi for {0} quotation_to {1}'
b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +419',b'No Items selected for transfer',b'Ingen elementer valgt for overf\xc3\xb8ring'
b'apps/erpnext/erpnext/config/selling.py +46',b'All Addresses.',b'Alle adresser.'
b'DocType: Company',b'Stock Settings',b'Aksje Innstillinger'
b'apps/erpnext/erpnext/accounts/doctype/account/account.py +183',"b'Merging is only possible if following properties are same in both records. Is Group, Root Type, Company'","b'Sammensl\xc3\xa5ing er bare mulig hvis f\xc3\xb8lgende egenskaper er samme i begge postene. Er Group, Root Type, Company'"
b'DocType: Vehicle',b'Electric',b'Elektrisk'
b'DocType: Task',b'% Progress',b'% Progress'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +123',b'Gain/Loss on Asset Disposal',b'Gevinst / Tap p\xc3\xa5 Asset Avhending'
b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +117',b'Account number for account {0} is not available.<br> Please setup your Chart of Accounts correctly.',b'Kontonummer for konto {0} er ikke tilgjengelig. <br> Vennligst konfigurer kontoregnskapet ditt riktig.'
b'DocType: Task',b'Depends on Tasks',b'Avhenger Oppgaver'
b'apps/erpnext/erpnext/config/selling.py +36',b'Manage Customer Group Tree.',b'Administrere kunde Gruppe treet.'
b'DocType: Shopping Cart Settings',b'Attachments can be shown without enabling the shopping cart',b'Vedlegg kan vises uten \xc3\xa5 tillate handlekurven'
b'DocType: Normal Test Items',b'Result Value',b'Resultat Verdi'
b'DocType: Hotel Room',b'Hotels',b'hoteller'
b'DocType: Supplier Quotation',b'SQTN-',b'SQTN-'
b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +22',b'New Cost Center Name',b'New kostnadssted Navn'
b'DocType: Leave Control Panel',b'Leave Control Panel',b'La Kontrollpanel'
b'DocType: Project',b'Task Completion',b'Task Fullf\xc3\xb8ring'
b'apps/erpnext/erpnext/templates/includes/product_page.js +22',b'Not in Stock',b'Ikke p\xc3\xa5 lager'
b'DocType: Volunteer',b'Volunteer Skills',b'Frivillig Ferdigheter'
b'DocType: Appraisal',b'HR User',b'HR User'
b'DocType: Purchase Invoice',b'Taxes and Charges Deducted',b'Skatter og avgifter fratrukket'
b'apps/erpnext/erpnext/hooks.py +142',b'Issues',b'Problemer'
b'apps/erpnext/erpnext/controllers/status_updater.py +12',b'Status must be one of {0}',b'Status m\xc3\xa5 v\xc3\xa6re en av {0}'
b'apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +64',b'Reminder to update GSTIN Sent',b'P\xc3\xa5minnelse om \xc3\xa5 oppdatere GSTIN Sendt'
b'DocType: Sales Invoice',b'Debit To',b'Debet \xc3\x85'
b'DocType: Restaurant Menu Item',b'Restaurant Menu Item',b'Restaurant menyelement'
b'DocType: Delivery Note',b'Required only for sample item.',b'Kreves bare for pr\xc3\xb8ve element.'
b'DocType: Stock Ledger Entry',b'Actual Qty After Transaction',b'Selve Antall Etter Transaksjons'
,b'Pending SO Items For Purchase Request',b'Avventer SO varer for kj\xc3\xb8p Request'
b'apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +35',b'Student Admissions',b'student Opptak'
b'apps/erpnext/erpnext/accounts/party.py +388',b'{0} {1} is disabled',b'{0} {1} er deaktivert'
b'DocType: Supplier',b'Billing Currency',b'Faktureringsvaluta'
b'DocType: Sales Invoice',b'SINV-RET-',b'SINV-RET-'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +200',b'Extra Large',b'Extra large'
b'DocType: Crop',b'Scientific Name',b'Vitenskapelig navn'
b'apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68',b'Total Leaves',b'Totalt Leaves'
b'DocType: Customer',"b'Reselect, if the chosen contact is edited after save'",b'Velg hvis den valgte kontakten redigeres etter lagre'
b'DocType: Consultation',b'In print',b'I papirutgave'
,b'Profit and Loss Statement',b'Resultatregnskap'
b'DocType: Bank Reconciliation Detail',b'Cheque Number',b'Sjekk Antall'
,b'Sales Browser',b'Salg Browser'
b'DocType: Journal Entry',b'Total Credit',b'Total Credit'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +542',b'Warning: Another {0} # {1} exists against stock entry {2}',b'Advarsel: Another {0} # {1} finnes mot aksje oppf\xc3\xb8ring {2}'
b'apps/erpnext/erpnext/utilities/user_progress_utils.py +66',b'Local',b'Lokal'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +26',b'Loans and Advances (Assets)',b'Utl\xc3\xa5n (Eiendeler)'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +12',b'Debtors',b'Skyldnere'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +199',b'Large',b'Stor'
b'DocType: Homepage Featured Product',b'Homepage Featured Product',b'Hjemmeside Aktuelle produkter'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +248',b'All Assessment Groups',b'Alle Assessment grupper'
b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js +15',b'New Warehouse Name',b'New Warehouse navn'
b'apps/erpnext/erpnext/accounts/report/financial_statements.py +259',b'Total {0} ({1})',b'Totalt {0} ({1})'
b'DocType: C-Form Invoice Detail',b'Territory',b'Territorium'
b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +151',b'Please mention no of visits required',b'Vennligst oppgi ingen av bes\xc3\xb8k som kreves'
b'DocType: Stock Settings',b'Default Valuation Method',b'Standard verdsettelsesmetode'
b'apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +26',b'Fee',b'Avgift'
b'apps/erpnext/erpnext/setup/doctype/company/company.js +154',b'Update in progress. It might take a while.',b'Oppdatering p\xc3\xa5g\xc3\xa5r. Det kan ta en stund.'
b'DocType: Production Plan Item',b'Produced Qty',b'Produsert antall'
b'DocType: Vehicle Log',b'Fuel Qty',b'drivstoff Antall'
b'DocType: Stock Entry',b'Target Warehouse Name',b'M\xc3\xa5llagernavn'
b'DocType: Work Order Operation',b'Planned Start Time',b'Planlagt Starttid'
b'DocType: Course',b'Assessment',b'Assessment'
b'DocType: Payment Entry Reference',b'Allocated',b'Avsatt'
b'apps/erpnext/erpnext/config/accounts.py +267',b'Close Balance Sheet and book Profit or Loss.',b'Lukk Balanse og bok resultatet.'
b'DocType: Student Applicant',b'Application Status',b's\xc3\xb8knad Status'
b'DocType: Sensitivity Test Items',b'Sensitivity Test Items',b'Sensitivitetstestelementer'
b'DocType: Project Update',b'Project Update',b'Prosjektoppdatering'
b'DocType: Fees',b'Fees',b'avgifter'
b'DocType: Currency Exchange',b'Specify Exchange Rate to convert one currency into another',b'Spesifiser Exchange Rate \xc3\xa5 konvertere en valuta til en annen'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +159',b'Quotation {0} is cancelled',b'Sitat {0} er kansellert'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +119',b'Total Outstanding Amount',b'Totalt utest\xc3\xa5ende bel\xc3\xb8p'
b'DocType: Sales Partner',b'Targets',b'Targets'
b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].js +54',b'Please register the SIREN number in the company information file',b'Vennligst registrer SIREN-nummeret i bedriftsinformasjonsfilen'
b'DocType: Price List',b'Price List Master',b'Prisliste Master'
b'DocType: GST Account',b'CESS Account',b'CESS-konto'
b'DocType: Sales Person',b'All Sales Transactions can be tagged against multiple **Sales Persons** so that you can set and monitor targets.',b'Alle salgstransaksjoner kan v\xc3\xa6re merket mot flere ** Salgs Personer ** slik at du kan stille inn og overv\xc3\xa5ke m\xc3\xa5l.'
,b'S.O. No.',b'SO No.'
b'apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +241',b'Please create Customer from Lead {0}',b'Opprett Customer fra Lead {0}'
b'apps/erpnext/erpnext/healthcare/page/medical_record/patient_select.html +3',b'Select Patient',b'Velg Pasient'
b'DocType: Price List',b'Applicable for Countries',b'Gjelder for Land'
b'DocType: Supplier Scorecard Scoring Variable',b'Parameter Name',b'Parameternavn'
b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +52',b'Student Group Name is mandatory in row {0}',b'Student Gruppenavn er obligatorisk i rad {0}'
b'DocType: Homepage',b'Products to be shown on website homepage',b'Produkter som skal vises p\xc3\xa5 nettstedet hjemmeside'
b'apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.js +13',b'This is a root customer group and cannot be edited.',"b'Dette er en rot kundegruppe, og kan ikke redigeres.'"
b'DocType: Student',b'AB-',b'AB-'
b'DocType: POS Profile',b'Ignore Pricing Rule',b'Ignorer Pricing Rule'
b'DocType: Employee Education',b'Graduate',b'Utdannet'
b'DocType: Leave Block List',b'Block Days',b'Block Days'
b'apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +83',"b'Shipping Address does not have country, which is required for this Shipping Rule'","b'Fraktadresse har ikke land, som kreves for denne leveringsregelen'"
b'DocType: Journal Entry',b'Excise Entry',b'Vesenet Entry'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +65',"b""Warning: Sales Order {0} already exists against Customer's Purchase Order {1}""",b'Advarsel: Salgsordre {0} finnes allerede mot kundens innkj\xc3\xb8psordre {1}'
b'DocType: Terms and Conditions',"b'Standard Terms and Conditions that can be added to Sales and Purchases.\n\nExamples:\n\n1. Validity of the offer.\n1. Payment Terms (In Advance, On Credit, part advance etc).\n1. What is extra (or payable by the Customer).\n1. Safety / usage warning.\n1. Warranty if any.\n1. Returns Policy.\n1. Terms of shipping, if applicable.\n1. Ways of addressing disputes, indemnity, liability, etc.\n1. Address and Contact of your Company.'","b'Standardvilk\xc3\xa5rene som kan legges til salg og kj\xc3\xb8p. Eksempler: 1. Gyldighet av tilbudet. 1. Betalingsvilk\xc3\xa5r (p\xc3\xa5 forh\xc3\xa5nd, p\xc3\xa5 kreditt, del forh\xc3\xa5nd etc). 1. Hva er ekstra (eller skal betales av kunden). 1. Sikkerhet / bruk advarsel. 1. Garanti om noen. 1. Returrett. 1. Vilk\xc3\xa5r for frakt, hvis aktuelt. 1. M\xc3\xa5ter adressering tvister, erstatning, ansvar, etc. 1. Adresse og kontakt med din bedrift.'"
b'DocType: Issue',b'Issue Type',b'Utgave type'
b'DocType: Attendance',b'Leave Type',b'La Type'
b'DocType: Purchase Invoice',b'Supplier Invoice Details',b'Leverand\xc3\xb8r Fakturadetaljer'
b'DocType: Agriculture Task',b'Ignore holidays',b'Ignorer ferier'
b'apps/erpnext/erpnext/controllers/stock_controller.py +233',"b""Expense / Difference account ({0}) must be a 'Profit or Loss' account""",b'Expense / Difference konto ({0}) m\xc3\xa5 v\xc3\xa6re en &quot;resultatet&quot; konto'
b'DocType: Project',b'Copied From',b'Kopiert fra'
b'DocType: Project',b'Copied From',b'Kopiert fra'
b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +340',b'Invoice already created for all billing hours',b'Faktura som allerede er opprettet for alle faktureringstimer'
b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +96',b'Name error: {0}',b'Navn feil: {0}'
b'DocType: Cash Flow Mapping',b'Is Finance Cost',b'Er finansieringskostnad'
b'apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +18',b'Attendance for employee {0} is already marked',b'Oppm\xc3\xb8te for arbeidstaker {0} er allerede merket'
b'DocType: Packing Slip',b'If more than one package of the same type (for print)',b'Hvis mer enn en pakke av samme type (for print)'
b'apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +27',b'Please set default customer in Restaurant Settings',b'Vennligst sett standardkunden i Restaurantinnstillinger'
,b'Salary Register',b'l\xc3\xb8nn Register'
b'DocType: Warehouse',b'Parent Warehouse',b'Parent Warehouse'
b'DocType: C-Form Invoice Detail',b'Net Total',b'Net Total'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +546',b'Default BOM not found for Item {0} and Project {1}',b'Standard BOM ikke funnet for element {0} og prosjekt {1}'
b'apps/erpnext/erpnext/config/hr.py +168',b'Define various loan types',b'Definere ulike typer l\xc3\xa5n'
b'DocType: Bin',b'FCFS Rate',b'FCFS Rate'
b'DocType: Opening Invoice Creation Tool Item',b'Outstanding Amount',b'Utest\xc3\xa5ende Bel\xc3\xb8p'
b'apps/erpnext/erpnext/templates/generators/bom.html +71',b'Time(in mins)',b'Tid (i minutter)'
b'DocType: Project Task',b'Working',b'Arbeids'
b'DocType: Stock Ledger Entry',b'Stock Queue (FIFO)',b'Stock Queue (FIFO)'
b'apps/erpnext/erpnext/public/js/setup_wizard.js +127',b'Financial Year',b'Regnskaps\xc3\xa5r'
b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +46',b'{0} does not belong to Company {1}',b'{0} ikke tilh\xc3\xb8rer selskapet {1}'
b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard_period/supplier_scorecard_period.py +66',b'Could not solve criteria score function for {0}. Make sure the formula is valid.',b'Kunne ikke l\xc3\xb8se kriterier score funksjon for {0}. Pass p\xc3\xa5 at formelen er gyldig.'
b'apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +122',b'Cost as on',b'Koste s\xc3\xa5 p\xc3\xa5'
b'DocType: Healthcare Settings',b'Out Patient Settings',b'Ut pasientinnstillinger'
b'DocType: Account',b'Round Off',b'Avrunde'
b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +259',b'Quantity must be positive',b'Mengden m\xc3\xa5 v\xc3\xa6re positiv'
b'DocType: Material Request Plan Item',b'Requested Qty',b'Spurt Antall'
b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +96',b'The fields From Shareholder and To Shareholder cannot be blank',b'Feltene fra Aksjon\xc3\xa6r og Til Aksjon\xc3\xa6r kan ikke v\xc3\xa6re tomme'
b'DocType: Tax Rule',b'Use for Shopping Cart',b'Brukes til handlekurv'
b'apps/erpnext/erpnext/controllers/item_variant.py +101',b'Value {0} for Attribute {1} does not exist in the list of valid Item Attribute Values for Item {2}',b'Verdi {0} for Egenskap {1} finnes ikke i listen over gyldige elementattributtet Verdier for Element {2}'
b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +79',b'Select Serial Numbers',b'Velg serienummer'
b'DocType: BOM Item',b'Scrap %',b'Skrap%'
b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +46',"b'Charges will be distributed proportionately based on item qty or amount, as per your selection'","b'Kostnader vil bli fordelt forholdsmessig basert p\xc3\xa5 element stk eller bel\xc3\xb8p, som per ditt valg'"
b'DocType: Maintenance Visit',b'Purposes',b'Form\xc3\xa5l'
b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +112',b'Atleast one item should be entered with negative quantity in return document',b'Atleast ett element b\xc3\xb8r legges inn med negativt antall i retur dokument'
b'apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +71',"b'Operation {0} longer than any available working hours in workstation {1}, break down the operation into multiple operations'","b'Operation {0} lenger enn noen tilgjengelige arbeidstimer i arbeidsstasjonen {1}, bryte ned driften i flere operasjoner'"
b'DocType: Membership',b'Membership Status',b'Medlemskapsstatus'
,b'Requested',b'Spurt'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +93',b'No Remarks',b'Nei Anmerkninger'
b'DocType: Asset',b'In Maintenance',b'Ved vedlikehold'
b'DocType: Purchase Invoice',b'Overdue',b'Forfalt'
b'DocType: Account',b'Stock Received But Not Billed',"b'Stock mottatt, men ikke fakturert'"
b'apps/erpnext/erpnext/accounts/doctype/account/account.py +84',b'Root Account must be a group',b'Root-kontoen m\xc3\xa5 v\xc3\xa6re en gruppe'
b'DocType: Drug Prescription',b'Drug Prescription',b'Drug Prescription'
b'DocType: Fees',b'FEE.',b'AVGIFT.'
b'DocType: Employee Loan',b'Repaid/Closed',b'Tilbakebetalt / Stengt'
b'DocType: Item',b'Total Projected Qty',b'Samlet forventet Antall'
b'DocType: Monthly Distribution',b'Distribution Name',b'Distribusjon Name'
b'apps/erpnext/erpnext/stock/stock_ledger.py +477',"b'Valuation rate not found for the Item {0}, which is required to do accounting entries for {1} {2}. If the item is transacting as a zero valuation rate item in the {1}, please mention that in the {1} Item table. Otherwise, please create an incoming stock transaction for the item or mention valuation rate in the Item record, and then try submiting/cancelling this entry'","b'Verdsettelsesraten ikke funnet for elementet {0}, som er n\xc3\xb8dvendig for \xc3\xa5 gj\xc3\xb8re regnskapsposter for {1} {2}. Hvis varen er transaksjon som nullverdieringsgrad i {1}, m\xc3\xa5 du nevne det i {1} elementtabellen. Ellers kan du opprette en inntektsaksjonstransaksjon for varen eller nevne verdsettelsesraten i vareoppf\xc3\xb8ringen, og pr\xc3\xb8v deretter \xc3\xa5 sende inn / avbryte denne oppf\xc3\xb8ringen'"
b'DocType: Course',b'Course Code',b'Kurskode'
b'apps/erpnext/erpnext/controllers/stock_controller.py +337',b'Quality Inspection required for Item {0}',b'Quality Inspection n\xc3\xb8dvendig for Element {0}'
b'DocType: POS Settings',b'Use POS in Offline Mode',b'Bruk POS i frakoblet modus'
b'DocType: Supplier Scorecard',b'Supplier Variables',b'Leverand\xc3\xb8rvariabler'
b'DocType: Quotation',"b""Rate at which customer's currency is converted to company's base currency""",b'Hastigheten som kundens valuta er konvertert til selskapets hovedvaluta'
b'DocType: Purchase Invoice Item',b'Net Rate (Company Currency)',b'Netto Rate (Selskap Valuta)'
b'DocType: Salary Detail',b'Condition and Formula Help',b'Tilstand og Formula Hjelp'
b'apps/erpnext/erpnext/config/selling.py +105',b'Manage Territory Tree.',b'Administrer Territory treet.'
b'DocType: Patient Service Unit',b'Patient Service Unit',b'Pasient Service Unit'
b'DocType: Journal Entry Account',b'Sales Invoice',b'Salg Faktura'
b'DocType: Journal Entry Account',b'Party Balance',b'Fest Balance'
b'DocType: Cash Flow Mapper',b'Section Subtotal',b'Seksjon Subtotal'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +498',b'Please select Apply Discount On',b'Vennligst velg Bruk rabatt p\xc3\xa5'
b'DocType: Stock Settings',b'Sample Retention Warehouse',b'Pr\xc3\xb8vebehandlingslager'
b'DocType: Company',b'Default Receivable Account',b'Standard fordringer konto'
b'DocType: Physician Schedule',b'Physician Schedule',b'Legerplan'
b'DocType: Purchase Invoice',b'Deemed Export',b'Gjeldende eksport'
b'DocType: Stock Entry',b'Material Transfer for Manufacture',b'Material Transfer for Produksjon'
b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +20',b'Discount Percentage can be applied either against a Price List or for all Price List.',b'Rabattprosenten kan brukes enten mot en prisliste eller for alle Prisliste.'
b'DocType: Subscription',b'Half-yearly',b'Halv\xc3\xa5rs'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +407',b'Accounting Entry for Stock',b'Regnskap Entry for Stock'
b'DocType: Lab Test',b'LabTest Approver',b'LabTest Approver'
b'apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py +61',b'You have already assessed for the assessment criteria {}.',b'Du har allerede vurdert for vurderingskriteriene {}.'
b'DocType: Vehicle Service',b'Engine Oil',b'Motorolje'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1005',b'Work Orders Created: {0}',b'Arbeidsordre opprettet: {0}'
b'DocType: Sales Invoice',b'Sales Team1',b'Salg TEAM1'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +547',b'Item {0} does not exist',b'Element {0} finnes ikke'
b'DocType: Sales Invoice',b'Customer Address',b'Kunde Adresse'
b'DocType: Employee Loan',b'Loan Details',b'l\xc3\xa5n Detaljer'
b'DocType: Company',b'Default Inventory Account',b'Standard lagerkonto'
b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +192',b'The folio numbers are not matching',b'Folio tallene stemmer ikke overens'
b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +124',b'Row {0}: Completed Qty must be greater than zero.',b'Rad {0}: Fullf\xc3\xb8rt Antall m\xc3\xa5 v\xc3\xa6re st\xc3\xb8rre enn null.'
b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +262',b'Payment Request for {0}',b'Betalingsforesp\xc3\xb8rsel om {0}'
b'DocType: Item Barcode',b'Barcode Type',b'Strekkode Type'
b'DocType: Antibiotic',b'Antibiotic Name',b'Antibiotisk navn'
b'DocType: Purchase Invoice',b'Apply Additional Discount On',b'P\xc3\xa5f\xc3\xb8r Ytterligere rabatt p\xc3\xa5'
b'apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +66',b'Select Type...',b'Velg type ...'
b'DocType: Crop Cycle',b'A link to all the Land Units in which the Crop is growing',b'En kobling til alle arealene der gr\xc3\xb8ften vokser'
b'DocType: Account',b'Root Type',b'Root Type'
b'DocType: Item',b'FIFO',b'FIFO'
b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +136',b'Row # {0}: Cannot return more than {1} for Item {2}',b'Row # {0}: Kan ikke returnere mer enn {1} for Element {2}'
b'DocType: Item Group',b'Show this slideshow at the top of the page',b'Vis lysbildefremvisning p\xc3\xa5 toppen av siden'
b'DocType: BOM',b'Item UOM',b'Sak m\xc3\xa5lenheter'
b'DocType: Sales Taxes and Charges',b'Tax Amount After Discount Amount (Company Currency)',b'Skattebel\xc3\xb8p Etter Rabattbel\xc3\xb8p (Company Valuta)'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +177',b'Target warehouse is mandatory for row {0}',b'Target lageret er obligatorisk for rad {0}'
b'DocType: Cheque Print Template',b'Primary Settings',b'prim\xc3\xa6re Innstillinger'
b'DocType: Purchase Invoice',b'Select Supplier Address',b'Velg Leverand\xc3\xb8r Adresse'
b'apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +397',b'Add Employees',b'Legg Medarbeidere'
b'DocType: Purchase Invoice Item',b'Quality Inspection',b'Quality Inspection'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +196',b'Extra Small',b'Extra Small'
b'DocType: Company',b'Standard Template',b'standard Template'
b'DocType: Training Event',b'Theory',b'Teori'
b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +806',b'Warning: Material Requested Qty is less than Minimum Order Qty',b'Advarsel: Material Requested Antall er mindre enn Minimum Antall'
b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +211',b'Account {0} is frozen',b'Konto {0} er frosset'
b'DocType: Company',b'Legal Entity / Subsidiary with a separate Chart of Accounts belonging to the Organization.',b'Legal Entity / Datterselskap med en egen konto tilh\xc3\xb8righet til organisasjonen.'
b'DocType: Payment Request',b'Mute Email',b'Demp Email'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +29',"b'Food, Beverage & Tobacco'","b'Mat, drikke og tobakk'"
b'DocType: Account',b'Account Number',b'Kontonummer'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +752',b'Can only make payment against unbilled {0}',b'Kan bare gj\xc3\xb8re betaling mot fakturert {0}'
b'apps/erpnext/erpnext/controllers/selling_controller.py +102',b'Commission rate cannot be greater than 100',b'Kommisjon kan ikke v\xc3\xa6re st\xc3\xb8rre enn 100'
b'DocType: Volunteer',b'Volunteer',b'Frivillig'
b'DocType: Stock Entry',b'Subcontract',b'Underentrepriser'
b'apps/erpnext/erpnext/public/js/utils/party.js +166',b'Please enter {0} first',b'Fyll inn {0} f\xc3\xb8rst'
b'apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py +104',b'No replies from',b'Ingen svar fra'
b'DocType: Work Order Operation',b'Actual End Time',b'Faktisk Sluttid'
b'DocType: Item',b'Manufacturer Part Number',b'Produsentens varenummer'
b'DocType: Work Order Operation',b'Estimated Time and Cost',b'Estimert leveringstid og pris'
b'DocType: Bin',b'Bin',b'Bin'
b'DocType: Crop',b'Crop Name',b'Beskj\xc3\xa6re navn'
b'DocType: SMS Log',b'No of Sent SMS',b'Ingen av Sendte SMS'
b'DocType: Antibiotic',b'Healthcare Administrator',b'Helseadministrator'
b'apps/erpnext/erpnext/utilities/user_progress.py +47',b'Set a Target',b'Angi et m\xc3\xa5l'
b'DocType: Dosage Strength',b'Dosage Strength',b'Doseringsstyrke'
b'DocType: Account',b'Expense Account',b'Expense konto'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +49',b'Software',b'Programvare'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +203',b'Colour',b'Farge'
b'DocType: Assessment Plan Criteria',b'Assessment Plan Criteria',b'Assessment Plan Kriterier'
b'apps/erpnext/erpnext/stock/doctype/batch/batch.py +118',b'Expiry date is mandatory for selected item',b'Utl\xc3\xb8psdato er obligatorisk for valgt element'
b'DocType: Supplier Scorecard Scoring Standing',b'Prevent Purchase Orders',b'Forhindre innkj\xc3\xb8psordrer'
b'apps/erpnext/erpnext/healthcare/setup.py +258',b'Susceptible',b'utsatt'
b'DocType: Patient Appointment',b'Scheduled',b'Planlagt'
b'apps/erpnext/erpnext/config/buying.py +18',b'Request for quotation.',b'Foresp\xc3\xb8rsel om kostnadsoverslag.'
b'apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.js +13',"b'Please select Item where ""Is Stock Item"" is ""No"" and ""Is Sales Item"" is ""Yes"" and there is no other Product Bundle'","b'Vennligst velg Element der &quot;Er Stock Item&quot; er &quot;Nei&quot; og &quot;Er Sales Item&quot; er &quot;Ja&quot;, og det er ingen andre Product Bundle'"
b'apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.js +148',b'Select Customer',b'Velg kunde'
b'DocType: Student Log',b'Academic',b'akademisk'
b'DocType: Patient',b'Personal and Social History',b'Personlig og sosial historie'
b'apps/erpnext/erpnext/education/doctype/guardian/guardian.py +51',b'User {0} created',b'Bruker {0} opprettet'
b'DocType: Fee Schedule',b'Fee Breakup for each student',b'Fee Breakup for hver student'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +541',b'Total advance ({0}) against Order {1} cannot be greater than the Grand Total ({2})',b'Total forh\xc3\xa5nd ({0}) mot Bestill {1} kan ikke v\xc3\xa6re st\xc3\xb8rre enn totalsummen ({2})'
b'DocType: Sales Partner',b'Select Monthly Distribution to unevenly distribute targets across months.',b'Velg M\xc3\xa5nedlig Distribusjon til ujevnt fordele m\xc3\xa5lene gjennom m\xc3\xa5neder.'
b'apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +78',b'Change Code',b'Endre kode'
b'DocType: Purchase Invoice Item',b'Valuation Rate',b'Verdivurdering Rate'
b'DocType: Stock Reconciliation',b'SR/',b'SR /'
b'DocType: Vehicle',b'Diesel',b'diesel'
b'apps/erpnext/erpnext/stock/get_item_details.py +388',b'Price List Currency not selected',b'Prisliste Valuta ikke valgt'
b'DocType: Purchase Invoice',b'Availed ITC Cess',b'Benyttet ITC Cess'
,b'Student Monthly Attendance Sheet',b'Student M\xc3\xa5nedlig Oppm\xc3\xb8te Sheet'
b'apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +96',b'Shipping rule only applicable for Selling',b'Fraktregel gjelder kun for salg'
b'apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +30',b'Project Start Date',b'Prosjekt startdato'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +23',b'Until',b'Inntil'
b'DocType: Rename Tool',b'Rename Log',b'Rename Logg'
b'apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py +27',b'Student Group or Course Schedule is mandatory',b'Studentgruppe eller kursplan er obligatorisk'
b'apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py +27',b'Student Group or Course Schedule is mandatory',b'Studentgruppe eller kursplan er obligatorisk'
b'DocType: HR Settings',b'Maintain Billing Hours and Working Hours Same on Timesheet',b'Opprettholde Fakturerings timer og arbeidstid samme p\xc3\xa5 Timeregistrering'
b'DocType: Maintenance Visit Purpose',b'Against Document No',b'Mot Dokument nr'
b'DocType: BOM',b'Scrap',b'skrap'
b'apps/erpnext/erpnext/utilities/user_progress.py +217',b'Go to Instructors',b'G\xc3\xa5 til Instrukt\xc3\xb8rer'
b'apps/erpnext/erpnext/config/selling.py +110',b'Manage Sales Partners.',b'Administrer Salgs Partners.'
b'DocType: Quality Inspection',b'Inspection Type',b'Inspeksjon Type'
b'DocType: Fee Validity',b'Visited yet',b'Bes\xc3\xb8kt enn\xc3\xa5'
b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +134',b'Warehouses with existing transaction can not be converted to group.',b'N\xc3\xa6ringslokaler med eksisterende transaksjon kan ikke konverteres til gruppen.'
b'DocType: Assessment Result Tool',b'Result HTML',b'resultat HTML'
b'apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +35',b'Expires On',b'G\xc3\xa5r ut p\xc3\xa5 dato den'
b'apps/erpnext/erpnext/utilities/activation.py +117',b'Add Students',b'Legg Studenter'
b'apps/erpnext/erpnext/public/js/utils.js +270',b'Please select {0}',b'Vennligst velg {0}'
b'DocType: C-Form',b'C-Form No',b'C-Form Nei'
b'DocType: BOM',b'Exploded_items',b'Exploded_items'
b'apps/erpnext/erpnext/utilities/user_progress.py +139',b'List your products or services that you buy or sell.',b'Oppgi produktene eller tjenestene du kj\xc3\xb8per eller selger.'
b'DocType: Water Analysis',b'Storage Temperature',b'Lager temperatur'
b'DocType: Employee Attendance Tool',b'Unmarked Attendance',b'Umerket Oppm\xc3\xb8te'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +137',b'Researcher',b'Forsker'
b'DocType: Program Enrollment Tool Student',b'Program Enrollment Tool Student',b'Program P\xc3\xa5melding Tool Student'
b'apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.py +16',b'Start date should be less than end date for task {0}',b'Startdato b\xc3\xb8r v\xc3\xa6re mindre enn sluttdato for oppgaven {0}'
b'apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py +25',b'Name or Email is mandatory',b'Navn eller E-post er obligatorisk'
b'DocType: Member',b'MEM-',b'med-'
b'DocType: Instructor',b'Instructor Log',b'Instrukt\xc3\xb8rlogg'
b'DocType: Purchase Order Item',b'Returned Qty',b'Returnerte Stk'
b'DocType: Student',b'Exit',b'Utgang'
b'apps/erpnext/erpnext/accounts/doctype/account/account.py +156',b'Root Type is mandatory',b'Root Type er obligatorisk'
b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +29',b'Failed to install presets',b'Kunne ikke installere forh\xc3\xa5ndsinnstillinger'
b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +44',"b'{0} currently has a {1} Supplier Scorecard standing, and RFQs to this supplier should be issued with caution.'","b'{0} har for \xc3\xb8yeblikket en {1} leverand\xc3\xb8r scorecard, og RFQs til denne leverand\xc3\xb8ren skal utstedes med forsiktighet.'"
b'DocType: Chapter',b'Non Profit Manager',b'Non Profit Manager'
b'DocType: BOM',b'Total Cost(Company Currency)',b'Totalkostnad (Selskap Valuta)'
b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +315',b'Serial No {0} created',b'Serial No {0} opprettet'
b'DocType: Homepage',b'Company Description for website homepage',b'Selskapet beskrivelse for nettstedet hjemmeside'
b'DocType: Item Customer Detail',"b'For the convenience of customers, these codes can be used in print formats like Invoices and Delivery Notes'","b'For det lettere for kunder, kan disse kodene brukes i trykte formater som regningene og leveringssedlene'"
b'apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py +18',b'Suplier Name',b'suplier Name'
b'apps/erpnext/erpnext/accounts/report/financial_statements.py +174',b'Could not retrieve information for {0}.',b'Kunne ikke hente informasjon for {0}.'
b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +134',b'Opening Entry Journal',b'\xc3\x85pningsoppf\xc3\xb8ring Journal'
b'DocType: Sales Invoice',b'Time Sheet List',b'Timeregistrering List'
b'DocType: Employee',b'You can enter any date manually',b'Du kan legge inn noen dato manuelt'
b'DocType: Healthcare Settings',b'Result Printed',b'Resultat Trykt'
b'DocType: Asset Category Account',b'Depreciation Expense Account',b'Avskrivninger konto'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +233',b'Probationary Period',b'Pr\xc3\xb8vetid'
b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js +32',b'View {0}',b'Se {0}'
b'DocType: Customer Group',b'Only leaf nodes are allowed in transaction',b'Bare bladnoder er tillatt i transaksjonen'
b'DocType: Project',b'Total Costing Amount (via Timesheets)',b'Totalt kostende bel\xc3\xb8p (via tidsskrifter)'
b'DocType: Employee Advance',b'Expense Approver',b'Expense Godkjenner'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +136',b'Row {0}: Advance against Customer must be credit',b'Rad {0}: Advance mot Kunden m\xc3\xa5 v\xc3\xa6re kreditt'
b'DocType: Project',b'Hourly',b'Hver time'
b'apps/erpnext/erpnext/accounts/doctype/account/account.js +89',b'Non-Group to Group',b'Non-gruppe til gruppe'
b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +58',b'Batch is mandatory in row {0}',b'Batch er obligatorisk i rad {0}'
b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +58',b'Batch is mandatory in row {0}',b'Batch er obligatorisk i rad {0}'
b'DocType: Purchase Receipt Item Supplied',b'Purchase Receipt Item Supplied',b'Kvitteringen Sak Leveres'
b'apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py +24',b'To Datetime',b'Til Datetime'
b'apps/erpnext/erpnext/config/selling.py +302',b'Logs for maintaining sms delivery status',b'Logger for \xc3\xa5 opprettholde sms leveringsstatus'
b'DocType: Accounts Settings',b'Make Payment via Journal Entry',b'Utf\xc3\xb8r betaling via bilagsregistrering'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +223',b'Printed On',b'Trykt p\xc3\xa5'
b'DocType: Item',b'Inspection Required before Delivery',b'Inspeksjon P\xc3\xa5krevd f\xc3\xb8r Levering'
b'DocType: Item',b'Inspection Required before Purchase',b'Inspeksjon P\xc3\xa5krevd f\xc3\xb8r kj\xc3\xb8p'
b'apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +93',b'Pending Activities',b'Ventende Aktiviteter'
b'DocType: Patient Appointment',b'Reminded',b'minnet'
b'DocType: Patient',b'PID-',b'PID-'
b'DocType: Chapter Member',b'Chapter Member',b'Kapittelmedlem'
b'DocType: Material Request Plan Item',b'Minimum Order Quantity',b'Minimum antall'
b'apps/erpnext/erpnext/public/js/setup_wizard.js +106',b'Your Organization',b'Din organisasjon'
b'DocType: Fee Component',b'Fees Category',b'avgifter Kategori'
b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +134',b'Please enter relieving date.',b'Skriv inn lindrende dato.'
b'apps/erpnext/erpnext/controllers/trends.py +149',b'Amt',b'Amt'
b'DocType: Supplier Scorecard',b'Notify Employee',b'Informer medarbeider'
b'DocType: Opportunity',b'Enter name of campaign if source of enquiry is campaign',b'Skriv inn navnet p\xc3\xa5 kampanjen hvis kilden til henvendelsen er kampanje'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +38',b'Newspaper Publishers',b'Avis Publishers'
b'apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +30',b'Select Fiscal Year',b'Velg regnskaps\xc3\xa5r'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +115',b'Expected Delivery Date should be after Sales Order Date',b'Forventet leveringsdato b\xc3\xb8r v\xc3\xa6re etter salgsordre'
b'apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +42',b'Reorder Level',b'Omgj\xc3\xb8re niv\xc3\xa5'
b'DocType: Company',b'Chart Of Accounts Template',b'Konto Mal'
b'DocType: Attendance',b'Attendance Date',b'Oppm\xc3\xb8te Dato'
b'apps/erpnext/erpnext/stock/get_item_details.py +352',b'Item Price updated for {0} in Price List {1}',b'Sak Pris oppdateres for {0} i prislisten {1}'
b'DocType: Salary Structure',b'Salary breakup based on Earning and Deduction.',b'L\xc3\xb8nn breakup basert p\xc3\xa5 opptjening og fradrag.'
b'apps/erpnext/erpnext/accounts/doctype/account/account.py +128',b'Account with child nodes cannot be converted to ledger',b'Konto med barnet noder kan ikke konverteres til Ledger'
b'DocType: Purchase Invoice Item',b'Accepted Warehouse',b'Akseptert Warehouse'
b'DocType: Bank Reconciliation Detail',b'Posting Date',b'Publiseringsdato'
b'DocType: Item',b'Valuation Method',b'Verdsettelsesmetode'
b'apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +203',b'Mark Half Day',b'Mark Half Day'
b'DocType: Sales Invoice',b'Sales Team',b'Sales Team'
b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +87',b'Duplicate entry',b'Duplicate entry'
b'DocType: Program Enrollment Tool',b'Get Students',b'F\xc3\xa5 Studenter'
b'DocType: Serial No',b'Under Warranty',b'Under Garanti'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +516',b'[Error]',b'[Error]'
b'DocType: Sales Order',b'In Words will be visible once you save the Sales Order.',b'I Ord vil v\xc3\xa6re synlig n\xc3\xa5r du lagrer kundeordre.'
,b'Employee Birthday',b'Ansatt Bursdag'
b'apps/erpnext/erpnext/assets/doctype/asset_repair/asset_repair.py +14',b'Please select Completion Date for Completed Repair',b'Vennligst velg Fullf\xc3\xb8ringsdato for fullf\xc3\xb8rt reparasjon'
b'DocType: Student Batch Attendance Tool',b'Student Batch Attendance Tool',b'Student Batch Oppm\xc3\xb8te Tool'
b'apps/erpnext/erpnext/controllers/status_updater.py +213',b'Limit Crossed',b'Limit Krysset'
b'apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.js +22',b'Scheduled Upto',b'Planlagt Upto'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +55',b'Venture Capital',b'Venture Capital'
b'apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +40',"b""An academic term with this 'Academic Year' {0} and 'Term Name' {1} already exists. Please modify these entries and try again.""",b'Et semester med denne &#39;Academic Year&#39; {0} og &quot;Term Name {1} finnes allerede. Vennligst endre disse oppf\xc3\xb8ringene og pr\xc3\xb8v igjen.'
b'DocType: UOM',b'Must be Whole Number',b'M\xc3\xa5 v\xc3\xa6re hele tall'
b'DocType: Leave Control Panel',b'New Leaves Allocated (In Days)',b'Nye L\xc3\xb8v Tildelte (i dager)'
b'DocType: Purchase Invoice',b'Invoice Copy',b'Faktura kopi'
b'apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +49',b'Serial No {0} does not exist',b'Serial No {0} finnes ikke'
b'DocType: Sales Invoice Item',b'Customer Warehouse (Optional)',b'Customer Warehouse (valgfritt)'
b'DocType: Pricing Rule',b'Discount Percentage',b'Rabatt Prosent'
b'apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +51',b'Reserved for sub contracting',b'Reservert for underentreprise'
b'DocType: Payment Reconciliation Invoice',b'Invoice Number',b'Fakturanummer'
b'DocType: Shopping Cart Settings',b'Orders',b'Bestillinger'
b'DocType: Employee Leave Approver',b'Leave Approver',b'La Godkjenner'
b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +285',b'Please select a batch',b'Vennligst velg en batch'
b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +42',b'JournalLib',b'JournalLib'
b'DocType: Assessment Group',b'Assessment Group Name',b'Assessment Gruppenavn'
b'DocType: Manufacturing Settings',b'Material Transferred for Manufacture',b'Materialet Overf\xc3\xb8rt for Produksjon'
b'DocType: Landed Cost Item',b'Receipt Document Type',b'Kvittering dokumenttype'
b'DocType: Daily Work Summary Settings',b'Select Companies',b'Velg selskaper'
b'DocType: Antibiotic',b'Healthcare',b'Helsetjenester'
b'DocType: Target Detail',b'Target Detail',b'Target Detalj'
b'apps/erpnext/erpnext/stock/doctype/item/item.js +65',b'Single Variant',b'Enkelt variant'
b'apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +24',b'All Jobs',b'alle jobber'
b'DocType: Sales Order',b'% of materials billed against this Sales Order',b'% Av materialer fakturert mot denne kundeordre'
b'DocType: Program Enrollment',b'Mode of Transportation',b'Transportform'
b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +49',b'Period Closing Entry',b'Periode Closing Entry'
b'apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +72',b'Select Department...',b'Velg avdeling ...'
b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +38',b'Cost Center with existing transactions can not be converted to group',b'Kostnadssted med eksisterende transaksjoner kan ikke konverteres til gruppen'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +374',b'Amount {0} {1} {2} {3}',b'Mengden {0} {1} {2} {3}'
b'DocType: Account',b'Depreciation',b'Avskrivninger'
b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +102',b'The number of shares and the share numbers are inconsistent',b'Antall aksjer og aksjenumrene er inkonsekvente'
b'apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +49',b'Supplier(s)',b'Leverand\xc3\xb8r (er)'
b'DocType: Employee Attendance Tool',b'Employee Attendance Tool',b'Employee Oppm\xc3\xb8te Tool'
b'DocType: Guardian Student',b'Guardian Student',b'Guardian Student'
b'DocType: Supplier',b'Credit Limit',b'Kredittgrense'
b'apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +70',b'Avg. Selling Price List Rate',b'Nr. Selge prisliste rate'
b'DocType: Salary Component',b'Salary Component',b'l\xc3\xb8nn Component'
b'apps/erpnext/erpnext/accounts/utils.py +495',b'Payment Entries {0} are un-linked',b'Betalings Innlegg {0} er un-linked'
b'DocType: GL Entry',b'Voucher No',b'Kupong Ingen'
,b'Lead Owner Efficiency',b'Leder Eier Effektivitet'
,b'Lead Owner Efficiency',b'Leder Eier Effektivitet'
b'DocType: Leave Allocation',b'Leave Allocation',b'La Allocation'
b'DocType: Payment Request',b'Recipient Message And Payment Details',b'Mottakers Message og betalingsinformasjon'
b'DocType: Training Event',b'Trainer Email',b'trener E-post'
b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +550',b'Material Requests {0} created',b'Materielle Foresp\xc3\xb8rsler {0} er opprettet'
b'DocType: Restaurant Reservation',b'No of People',b'Ingen av mennesker'
b'apps/erpnext/erpnext/config/selling.py +164',b'Template of terms or contract.',b'Mal av begreper eller kontrakt.'
b'DocType: Purchase Invoice',b'Address and Contact',b'Adresse og Kontakt'
b'DocType: Cheque Print Template',b'Is Account Payable',b'Er konto Betales'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +276',b'Stock cannot be updated against Purchase Receipt {0}',b'Stock kan ikke oppdateres mot Kj\xc3\xb8pskvittering {0}'
b'DocType: Support Settings',b'Auto close Issue after 7 days',b'Auto n\xc3\xa6r Issue etter 7 dager'
b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +71',"b'Leave cannot be allocated before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}'","b'Permisjon kan ikke tildeles f\xc3\xb8r {0}, som permisjon balanse har allerede v\xc3\xa6rt carry-sendt i fremtiden permisjon tildeling posten {1}'"
b'apps/erpnext/erpnext/accounts/party.py +317',b'Note: Due / Reference Date exceeds allowed customer credit days by {0} day(s)',b'Merk: P\xc3\xa5 grunn / Reference Date stiger tillatt kunde kreditt dager med {0} dag (er)'
b'apps/erpnext/erpnext/education/doctype/program/program.js +8',b'Student Applicant',b'student S\xc3\xb8ker'
b'DocType: Purchase Invoice',b'ORIGINAL FOR RECIPIENT',b'ORIGINAL FOR RECIPIENT'
b'DocType: Asset Category Account',b'Accumulated Depreciation Account',b'Akkumulerte avskrivninger konto'
b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +11',b'This email is autogenerated',b'Denne e-posten er autogenerert'
b'DocType: Stock Settings',b'Freeze Stock Entries',b'Freeze Stock Entries'
b'DocType: Program Enrollment',b'Boarding Student',b'Studerende Student'
b'DocType: Asset',b'Expected Value After Useful Life',b'Forventet verdi Etter Levetid'
b'DocType: Item',b'Reorder level based on Warehouse',b'Omgj\xc3\xb8re niv\xc3\xa5 basert p\xc3\xa5 Warehouse'
b'DocType: Activity Cost',b'Billing Rate',b'Billing Rate'
,b'Qty to Deliver',b'Antall \xc3\xa5 levere'
,b'Stock Analytics',b'Aksje Analytics'
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +523',b'Operations cannot be left blank',b'Operasjoner kan ikke v\xc3\xa6re tomt'
b'DocType: Maintenance Visit Purpose',b'Against Document Detail No',b'Mot Document Detail Nei'
b'apps/erpnext/erpnext/regional/__init__.py +11',b'Deletion is not permitted for country {0}',b'Sletting er ikke tillatt for land {0}'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +110',b'Party Type is mandatory',b'Partiet Type er obligatorisk'
b'DocType: Quality Inspection',b'Outgoing',b'Utg\xc3\xa5ende'
b'DocType: Material Request',b'Requested For',b'Spurt For'
b'DocType: Quotation Item',b'Against Doctype',b'Mot Doctype'
b'apps/erpnext/erpnext/controllers/buying_controller.py +404',b'{0} {1} is cancelled or closed',b'{0} {1} er kansellert eller lukket'
b'DocType: Asset',b'Calculate Depreciation',b'Beregn Avskrivninger'
b'DocType: Delivery Note',b'Track this Delivery Note against any Project',b'Spor dette f\xc3\xb8lgeseddel mot ethvert prosjekt'
b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +35',b'Net Cash from Investing',b'Netto kontantstr\xc3\xb8m fra investerings'
b'DocType: Work Order',b'Work-in-Progress Warehouse',b'Work-in-progress Warehouse'
b'apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +111',b'Asset {0} must be submitted',b'Asset {0} m\xc3\xa5 fremlegges'
b'DocType: Fee Schedule Program',b'Total Students',b'Totalt studenter'
b'apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py +56',b'Attendance Record {0} exists against Student {1}',b'Oppm\xc3\xb8te Record {0} finnes mot Student {1}'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +354',b'Reference #{0} dated {1}',b'Reference # {0} datert {1}'
b'apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +164',b'Depreciation Eliminated due to disposal of assets',b'Avskrivninger Sl\xc3\xa5tt p\xc3\xa5 grunn av salg av eiendeler'
b'DocType: Member',b'Member',b'Medlem'
b'apps/erpnext/erpnext/templates/includes/cart/cart_address.html +15',b'Manage Addresses',b'Administrer Adresser'
b'DocType: Work Order Item',b'Work Order Item',b'Arbeid Bestillingselement'
b'DocType: Pricing Rule',b'Item Code',b'Sak Kode'
b'DocType: Serial No',b'Warranty / AMC Details',b'Garanti / AMC Detaljer'
b'apps/erpnext/erpnext/education/doctype/student_group/student_group.js +116',b'Select students manually for the Activity based Group',b'Velg studenter manuelt for aktivitetsbasert gruppe'
b'DocType: Journal Entry',b'User Remark',b'Bruker Remark'
b'DocType: Lead',b'Market Segment',b'Markedssegment'
b'DocType: Agriculture Analysis Criteria',b'Agriculture Manager',b'Landbruksansvarlig'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +966',b'Paid Amount cannot be greater than total negative outstanding amount {0}',b'Betalt Bel\xc3\xb8pet kan ikke v\xc3\xa6re st\xc3\xb8rre enn total negativ utest\xc3\xa5ende bel\xc3\xb8p {0}'
b'DocType: Supplier Scorecard Period',b'Variables',b'variabler'
b'DocType: Employee Internal Work History',b'Employee Internal Work History',b'Ansatt Intern Work History'
b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +249',b'Closing (Dr)',b'Lukking (Dr)'
b'DocType: Cheque Print Template',b'Cheque Size',b'sjekk Size'
b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +232',b'Serial No {0} not in stock',b'Serial No {0} ikke p\xc3\xa5 lager'
b'apps/erpnext/erpnext/config/selling.py +169',b'Tax template for selling transactions.',b'Skatt mal for \xc3\xa5 selge transaksjoner.'
b'DocType: Sales Invoice',b'Write Off Outstanding Amount',b'Skriv Av utest\xc3\xa5ende bel\xc3\xb8p'
b'apps/erpnext/erpnext/hr/doctype/expense_claim_type/expense_claim_type.py +27',b'Account {0} does not match with Company {1}',b'Konto {0} stemmer ikke overens med selskapets {1}'
b'DocType: Education Settings',b'Current Academic Year',b'N\xc3\xa5v\xc3\xa6rende akademisk \xc3\xa5r'
b'DocType: Education Settings',b'Current Academic Year',b'N\xc3\xa5v\xc3\xa6rende akademisk \xc3\xa5r'
b'DocType: Stock Settings',b'Default Stock UOM',b'Standard Stock m\xc3\xa5lenheter'
b'DocType: Asset',b'Number of Depreciations Booked',b'Antall Avskrivninger bestilt'
b'apps/erpnext/erpnext/public/js/pos/pos.html +71',b'Qty Total',b'Antall totalt'
b'apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +32',b'Against Employee Loan: {0}',b'Mot Ansattes l\xc3\xa5n: {0}'
b'DocType: Landed Cost Item',b'Receipt Document',b'kvittering Document'
b'DocType: Employee Education',b'School/University',b'Skole / universitet'
b'DocType: Payment Request',b'Reference Details',b'Referanse Detaljer'
b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +56',b'Expected Value After Useful Life must be less than Gross Purchase Amount',b'Forventet verdi Etter Nyttig Livet m\xc3\xa5 v\xc3\xa6re mindre enn Bruttobel\xc3\xb8pet'
b'DocType: Sales Invoice Item',b'Available Qty at Warehouse',b'Tilgjengelig Antall p\xc3\xa5 Warehouse'
b'apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +20',b'Billed Amount',b'Fakturert bel\xc3\xb8p'
b'DocType: Share Transfer',b'(including)',b'(gjelder ogs\xc3\xa5)'
b'DocType: Asset',b'Double Declining Balance',b'Dobbel degressiv'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +180',b'Closed order cannot be cancelled. Unclose to cancel.',b'Stengt for kan ikke avbestilles. Unclose \xc3\xa5 avbryte.'
b'DocType: Student Guardian',b'Father',b'Far'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +627',"b""'Update Stock' cannot be checked for fixed asset sale""",b'&#39;Oppdater Stock &quot;kan ikke kontrolleres for driftsmiddel salg'
b'DocType: Bank Reconciliation',b'Bank Reconciliation',b'Bankavstemming'
b'DocType: Attendance',b'On Leave',b'P\xc3\xa5 ferie'
b'apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +7',b'Get Updates',b'F\xc3\xa5 oppdateringer'
b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +96',b'{0} {1}: Account {2} does not belong to Company {3}',b'{0} {1}: Account {2} ikke tilh\xc3\xb8rer selskapet {3}'
b'apps/erpnext/erpnext/stock/doctype/item/item.js +397',b'Select at least one value from each of the attributes.',b'Velg minst \xc3\xa9n verdi fra hver av attributter.'
b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +166',b'Material Request {0} is cancelled or stopped',b'Materialet Request {0} blir kansellert eller stoppet'
b'apps/erpnext/erpnext/config/hr.py +314',b'Leave Management',b'La Ledelse'
b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +118',b'Group by Account',b'Grupper etter Account'
b'apps/erpnext/erpnext/education/doctype/instructor/instructor.py +21',b'Please select Employee',b'Vennligst velg Medarbeider'
b'DocType: Sales Order',b'Fully Delivered',b'Fullt Leveres'
b'DocType: Lead',b'Lower Income',b'Lavere inntekt'
b'DocType: Restaurant Order Entry',b'Current Order',b'N\xc3\xa5v\xc3\xa6rende ordre'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +196',b'Source and target warehouse cannot be same for row {0}',b'Kilden og m\xc3\xa5let lageret kan ikke v\xc3\xa6re det samme for rad {0}'
b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +243',"b'Difference Account must be a Asset/Liability type account, since this Stock Reconciliation is an Opening Entry'","b'Forskjellen konto m\xc3\xa5 v\xc3\xa6re en eiendel / forpliktelse type konto, siden dette Stock Forsoning er en \xc3\xa5pning Entry'"
b'apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +107',b'Disbursed Amount cannot be greater than Loan Amount {0}',b'Utbetalt Mengde kan ikke v\xc3\xa6re st\xc3\xb8rre enn l\xc3\xa5ne bel\xc3\xb8pet {0}'
b'apps/erpnext/erpnext/utilities/user_progress.py +176',b'Go to Programs',b'G\xc3\xa5 til Programmer'
b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +205',b'Row {0}# Allocated amount {1} cannot be greater than unclaimed amount {2}',b'Row {0} # Tilordnet mengde {1} kan ikke v\xc3\xa6re st\xc3\xb8rre enn uanmeldt bel\xc3\xb8p {2}'
b'apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +89',b'Purchase Order number required for Item {0}',b'Innkj\xc3\xb8psordrenummeret som kreves for Element {0}'
b'apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +18',"b""'From Date' must be after 'To Date'""",b'&quot;Fra dato&quot; m\xc3\xa5 v\xc3\xa6re etter &#39;To Date&#39;'
b'apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +39',b'Cannot change status as student {0} is linked with student application {1}',b'Kan ikke endre status som student {0} er knyttet til studentens s\xc3\xb8knad {1}'
b'DocType: Asset',b'Fully Depreciated',b'fullt avskrevet'
b'DocType: Item Barcode',b'UPC-A',b'UPC-A'
,b'Stock Projected Qty',b'Lager Antall projiserte'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +444',b'Customer {0} does not belong to project {1}',b'Kunden {0} ikke h\xc3\xb8rer til prosjektet {1}'
b'DocType: Employee Attendance Tool',b'Marked Attendance HTML',b'Merket Oppm\xc3\xb8te HTML'
b'apps/erpnext/erpnext/utilities/activation.py +73',"b'Quotations are proposals, bids you have sent to your customers'","b'Sitater er forslag, bud du har sendt til dine kunder'"
b'DocType: Sales Invoice',"b""Customer's Purchase Order""",b'Kundens innkj\xc3\xb8psordre'
b'DocType: Consultation',b'Patient',b'Pasient'
b'apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +47',b'Bypass credit check at Sales Order ',b'Bypass kreditt sjekk p\xc3\xa5 salgsordre'
b'DocType: Land Unit',b'Check if it is a hydroponic unit',b'Sjekk om det er en hydroponisk enhet'
b'apps/erpnext/erpnext/config/stock.py +109',b'Serial No and Batch',b'Serial No og Batch'
b'DocType: Warranty Claim',b'From Company',b'Fra Company'
b'apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py +52',b'Sum of Scores of Assessment Criteria needs to be {0}.',b'Summen av Resultater av vurderingskriterier m\xc3\xa5 v\xc3\xa6re {0}.'
b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +77',b'Please set Number of Depreciations Booked',b'Vennligst sett Antall Avskrivninger bestilt'
b'DocType: Supplier Scorecard Period',b'Calculations',b'beregninger'
b'apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +86',b'Value or Qty',b'Verdi eller Stk'
b'DocType: Payment Terms Template',b'Payment Terms',b'Betalingsbetingelser'
b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +449',b'Productions Orders cannot be raised for:',b'Productions Bestillinger kan ikke heves for:'
b'apps/erpnext/erpnext/utilities/user_progress.py +147',b'Minute',b'Minutt'
b'DocType: Purchase Invoice',b'Purchase Taxes and Charges',b'Kj\xc3\xb8pe skatter og avgifter'
b'DocType: Chapter',b'Meetup Embed HTML',b'Meetup Embed HTML'
b'apps/erpnext/erpnext/utilities/user_progress.py +121',b'Go to Suppliers',b'G\xc3\xa5 til Leverand\xc3\xb8rer'
,b'Qty to Receive',b'Antall \xc3\xa5 motta'
b'DocType: Leave Block List',b'Leave Block List Allowed',b'La Block List tillatt'
b'DocType: Grading Scale Interval',b'Grading Scale Interval',b'Grading Scale Intervall'
b'apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +49',b'Expense Claim for Vehicle Log {0}',b'Expense krav for Vehicle Logg {0}'
b'DocType: Sales Invoice Item',b'Discount (%) on Price List Rate with Margin',b'Rabatt (%) p\xc3\xa5 prisliste med margin'
b'apps/erpnext/erpnext/patches/v7_0/create_warehouse_nestedset.py +59',b'All Warehouses',b'alle N\xc3\xa6ringslokaler'
b'DocType: Sales Partner',b'Retailer',b'Forhandler'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +115',b'Credit To account must be a Balance Sheet account',b'Kreditt til kontoen m\xc3\xa5 v\xc3\xa6re en balansekonto'
b'apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +118',b'All Supplier Types',b'Alle Leverand\xc3\xb8r Typer'
b'DocType: Donor',b'Donor',b'donor'
b'DocType: Global Defaults',b'Disable In Words',b'Deaktiver I Ord'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +60',b'Item Code is mandatory because Item is not automatically numbered',b'Elementkode er obligatorisk fordi varen ikke blir automatisk nummerert'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +98',b'Quotation {0} not of type {1}',b'Sitat {0} ikke av typen {1}'
b'DocType: Maintenance Schedule Item',b'Maintenance Schedule Item',b'Vedlikeholdsplan Sak'
b'DocType: Sales Order',b'%  Delivered',b'% Leveres'
b'apps/erpnext/erpnext/education/doctype/fees/fees.js +105',b'Please set the Email ID for the Student to send the Payment Request',b'Vennligst still inn e-post-IDen for studenten for \xc3\xa5 sende betalingsanmodningen'
b'DocType: Patient',b'Medical History',b'Medisinsk historie'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +157',b'Bank Overdraft Account',b'Kassekreditt konto'
b'DocType: Patient',b'Patient ID',b'Pasient ID'
b'DocType: Physician Schedule',b'Schedule Name',b'Planleggingsnavn'
b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js +48',b'Make Salary Slip',b'Gj\xc3\xb8r L\xc3\xb8nn Slip'
b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +840',b'Add All Suppliers',b'Legg til alle leverand\xc3\xb8rer'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +94',b'Row #{0}: Allocated Amount cannot be greater than outstanding amount.',b'Rad # {0}: Tilordnet bel\xc3\xb8p kan ikke v\xc3\xa6re st\xc3\xb8rre enn utest\xc3\xa5ende bel\xc3\xb8p.'
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +75',b'Browse BOM',b'Bla BOM'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +155',b'Secured Loans',b'Sikret l\xc3\xa5n'
b'DocType: Purchase Invoice',b'Edit Posting Date and Time',b'Rediger konteringsdato og klokkeslett'
b'apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +101',b'Please set Depreciation related Accounts in Asset Category {0} or Company {1}',b'Vennligst sett Avskrivninger relatert kontoer i Asset Kategori {0} eller selskapet {1}'
b'DocType: Lab Test Groups',b'Normal Range',b'Normal rekkevidde'
b'DocType: Academic Term',b'Academic Year',b'Studie\xc3\xa5r'
b'apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +72',b'Available Selling',b'Tilgjengelig salg'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +169',b'Opening Balance Equity',b'\xc3\x85pningsbalanse Equity'
b'DocType: Lead',b'CRM',b'CRM'
b'DocType: Purchase Invoice',b'N',b'N'
b'apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +175',b'Remaining',b'Gjenv\xc3\xa6rende v\xc3\xa6rende~~POS=HEADCOMP'
b'DocType: Appraisal',b'Appraisal',b'Appraisal'
b'DocType: Purchase Invoice',b'GST Details',b'GST-detaljer'
b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +156',b'Email sent to supplier {0}',b'E-post sendt til leverand\xc3\xb8ren {0}'
b'DocType: Item',b'Default Sales Unit of Measure',b'Standard salgsmengde av m\xc3\xa5l'
b'apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +9',b'Academic Year: ',b'Studie\xc3\xa5r:'
b'DocType: Opportunity',b'OPTY-',b'OPTY-'
b'apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py +19',b'Date is repeated',b'Dato gjentas'
b'apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +27',b'Authorized Signatory',b'Autorisert signatur'
b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +64',b'Create Fees',b'Opprett gebyrer'
b'DocType: Project',b'Total Purchase Cost (via Purchase Invoice)',b'Total anskaffelseskost (via fakturaen)'
b'DocType: Training Event',b'Start Time',b'Starttid'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +400',b'Select Quantity',b'Velg Antall'
b'DocType: Customs Tariff Number',b'Customs Tariff Number',b'Tolltariffen nummer'
b'DocType: Patient Appointment',b'Patient Appointment',b'Pasientavtale'
b'apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +34',b'Approving Role cannot be same as role the rule is Applicable To',b'Godkjenne Role kan ikke v\xc3\xa6re det samme som rollen regelen gjelder for'
b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +64',b'Unsubscribe from this Email Digest',b'Melde deg ut av denne e-post Digest'
b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +830',b'Get Suppliers By',b'F\xc3\xa5 leverand\xc3\xb8rer av'
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +173',b'{0} not found for Item {1}',b'{0} ikke funnet for element {1}'
b'apps/erpnext/erpnext/utilities/user_progress.py +197',b'Go to Courses',b'G\xc3\xa5 til kurs'
b'DocType: Accounts Settings',b'Show Inclusive Tax In Print',b'Vis inklusiv skatt i utskrift'
b'apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +17',"b'Bank Account, From Date and To Date are Mandatory'","b'Bankkonto, fra dato og til dato er obligatorisk'"
b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +28',b'Message Sent',b'Melding Sendt'
b'apps/erpnext/erpnext/accounts/doctype/account/account.py +98',b'Account with child nodes cannot be set as ledger',b'Konto med barnet noder kan ikke settes som hovedbok'
b'DocType: C-Form',b'II',b'II'
b'DocType: Sales Invoice',"b""Rate at which Price list currency is converted to customer's base currency""",b'Hastigheten som Prisliste valuta er konvertert til kundens basisvaluta'
b'DocType: Purchase Invoice Item',b'Net Amount (Company Currency)',b'Nettobel\xc3\xb8p (Company Valuta)'
b'DocType: Physician',b'Physician Schedules',b'Legeplaner'
b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +215',b'Total advance amount cannot be greater than total sanctioned amount',b'Samlet forskuddbel\xc3\xb8p kan ikke v\xc3\xa6re st\xc3\xb8rre enn total sanksjonert bel\xc3\xb8p'
b'DocType: Salary Slip',b'Hour Rate',b'Time Rate'
b'DocType: Stock Settings',b'Item Naming By',b'Sak Naming Av'
b'apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +46',b'Another Period Closing Entry {0} has been made after {1}',b'En annen periode Closing Entry {0} har blitt gjort etter {1}'
b'DocType: Work Order',b'Material Transferred for Manufacturing',b'Materialet Overf\xc3\xb8rt for Manufacturing'
b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +41',b'Account {0} does not exists',b'Konto {0} ikke eksisterer'
b'DocType: Project',b'Project Type',b'Prosjekttype'
b'apps/erpnext/erpnext/projects/doctype/task/task.py +153',b'Child Task exists for this Task. You can not delete this Task.',b'Barneoppgave eksisterer for denne oppgaven. Du kan ikke slette denne oppgaven.'
b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +48',b'DateLet',b'DateLet'
b'apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +16',b'Either target qty or target amount is mandatory.',b'Enten m\xc3\xa5let stk eller m\xc3\xa5l bel\xc3\xb8pet er obligatorisk.'
b'apps/erpnext/erpnext/config/projects.py +56',b'Cost of various activities',b'Kostnad for ulike aktiviteter'
b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +60',"b'Setting Events to {0}, since the Employee attached to the below Sales Persons does not have a User ID{1}'","b'Innstilling Hendelser til {0}, siden den ansatte knyttet til under selgerne ikke har en bruker-ID {1}'"
b'DocType: Timesheet',b'Billing Details',b'Fakturadetaljer'
b'apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +163',b'Source and target warehouse must be different',b'Kilde og m\xc3\xa5l lageret m\xc3\xa5 v\xc3\xa6re annerledes'
b'apps/erpnext/erpnext/erpnext_integrations/doctype/gocardless_settings/gocardless_settings.py +140',b'Payment Failed. Please check your GoCardless Account for more details',b'Betalingen feilet. Vennligst sjekk din GoCardless-konto for mer informasjon'
b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +101',b'Not allowed to update stock transactions older than {0}',b'Ikke lov til \xc3\xa5 oppdatere lagertransaksjoner eldre enn {0}'
b'DocType: BOM',b'Inspection Required',b'Inspeksjon p\xc3\xa5krevd'
b'DocType: Purchase Invoice Item',b'PR Detail',b'PR Detalj'
b'DocType: Driving License Category',b'Class',b'Klasse'
b'DocType: Sales Order',b'Fully Billed',b'Fullt Fakturert'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +426',b'Work Order cannot be raised against a Item Template',b'Arbeidsordre kan ikke heves opp mot en varemaling'
b'apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +101',b'Shipping rule only applicable for Buying',b'Fraktregel gjelder kun for kj\xc3\xb8p'
b'DocType: Vital Signs',b'BMI',b'BMI'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +20',b'Cash In Hand',b'Kontanter'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +137',b'Delivery warehouse required for stock item {0}',b'Levering lager n\xc3\xb8dvendig for lagervare {0}'
b'DocType: Packing Slip',b'The gross weight of the package. Usually net weight + packaging material weight. (for print)',b'Totalvekten av pakken. Vanligvis nettovekt + emballasjematerialet vekt. (For utskrift)'
b'DocType: Assessment Plan',b'Program',b'Program'
b'DocType: Accounts Settings',b'Users with this role are allowed to set frozen accounts and create / modify accounting entries against frozen accounts',b'Brukere med denne rollen har lov til \xc3\xa5 sette frosne kontoer og lage / endre regnskapspostene mot frosne kontoer'
b'DocType: Serial No',b'Is Cancelled',b'Er Avlyst'
b'DocType: Student Group',b'Group Based On',b'Gruppe basert p\xc3\xa5'
b'DocType: Student Group',b'Group Based On',b'Gruppe basert p\xc3\xa5'
b'DocType: Journal Entry',b'Bill Date',b'Bill Dato'
b'DocType: Healthcare Settings',b'Laboratory SMS Alerts',b'Laboratory SMS Alerts'
b'apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +20',"b'Service Item,Type,frequency and expense amount are required'","b'Tjenesten varen, type, frekvens og utgiftene bel\xc3\xb8p kreves'"
b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +45',"b'Even if there are multiple Pricing Rules with highest priority, then following internal priorities are applied:'","b'Selv om det er flere Prising regler med h\xc3\xb8yest prioritet, deretter f\xc3\xb8lgende interne prioriteringer til grunn:'"
b'DocType: Plant Analysis Criteria',b'Plant Analysis Criteria',b'Plantanalyse Kriterier'
b'DocType: Cheque Print Template',b'Cheque Height',b'sjekk H\xc3\xb8yde'
b'DocType: Supplier',b'Supplier Details',b'Leverand\xc3\xb8r Detaljer'
b'DocType: Setup Progress',b'Setup Progress',b'Oppsett Progress'
b'DocType: Hub Settings',b'Publish Items to Hub',b'Publiser varer i Hub'
b'apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +35',b'From value must be less than to value in row {0}',b'Fra verdien m\xc3\xa5 v\xc3\xa6re mindre enn til verdien i rad {0}'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +182',b'Wire Transfer',b'Wire Transfer'
b'apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +92',b'Check all',b'Sjekk alt'
,b'Issued Items Against Work Order',b'Utstedte varer mot arbeidsordre'
b'DocType: Vehicle Log',b'Invoice Ref',b'faktura~~POS=TRUNC Ref'
b'DocType: Company',b'Default Income Account',b'Standard Inntekt konto'
b'apps/erpnext/erpnext/selling/page/sales_analytics/sales_analytics.js +32',b'Customer Group / Customer',b'Kunden Group / Kunde'
b'apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +37',b'Unclosed Fiscal Years Profit / Loss (Credit)',b'Unclosed regnskaps\xc3\xa5rene Profit / Loss (Credit)'
b'DocType: Sales Invoice',b'Time Sheets',b'timelister'
b'DocType: Lab Test Template',b'Change In Item',b'Endre i element'
b'DocType: Payment Gateway Account',b'Default Payment Request Message',b'Standard betalingsforesp\xc3\xb8rsel Message'
b'DocType: Item Group',b'Check this if you want to show in website',b'Sjekk dette hvis du vil vise p\xc3\xa5 nettstedet'
b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +338',b'Balance ({0})',b'Balanse ({0})'
b'apps/erpnext/erpnext/config/accounts.py +134',b'Banking and Payments',b'Bank og Betalinger'
,b'Welcome to ERPNext',b'Velkommen til ERPNext'
b'apps/erpnext/erpnext/config/learn.py +102',b'Lead to Quotation',b'F\xc3\xb8re til prisanslag'
b'apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +34',b'Email Reminders will be sent to all parties with email contacts',b'E-mail p\xc3\xa5minnelser vil bli sendt til alle parter med e-postkontakter'
b'DocType: Project',b'Twice Daily',b'To ganger daglig'
b'DocType: Patient',b'A Negative',b'En negativ'
b'apps/erpnext/erpnext/templates/includes/product_list.js +45',b'Nothing more to show.',b'Ingenting mer \xc3\xa5 vise.'
b'DocType: Lead',b'From Customer',b'Fra Customer'
b'apps/erpnext/erpnext/demo/setup/setup_data.py +327',b'Calls',b'Samtaler'
b'apps/erpnext/erpnext/utilities/user_progress.py +143',b'A Product',b'Et produkt'
b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +207',b'Batches',b'batcher'
b'apps/erpnext/erpnext/education/doctype/fee_structure/fee_structure.js +34',b'Make Fee Schedule',b'Lag avgiftsplan'
b'DocType: Purchase Order Item Supplied',b'Stock UOM',b'Stock m\xc3\xa5lenheter'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +233',b'Purchase Order {0} is not submitted',b'Purchase Order {0} ikke er sendt'
b'DocType: Vital Signs',b'Normal reference range for an adult is 16\xe2\x80\x9320 breaths/minute (RCP 2012)',b'Normalt referanseomr\xc3\xa5de for en voksen er 16-20 puste / minutt (RCP 2012)'
b'DocType: Customs Tariff Number',b'Tariff Number',b'tariff Antall'
b'DocType: Work Order Item',b'Available Qty at WIP Warehouse',b'Tilgjengelig antall p\xc3\xa5 WIP Warehouse'
b'apps/erpnext/erpnext/stock/doctype/item/item.js +39',b'Projected',b'Prosjekterte'
b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +222',b'Serial No {0} does not belong to Warehouse {1}',b'Serial No {0} tilh\xc3\xb8rer ikke Warehouse {1}'
b'apps/erpnext/erpnext/controllers/status_updater.py +177',b'Note: System will not check over-delivery and over-booking for Item {0} as quantity or amount is 0',b'Merk: Systemet vil ikke sjekke over-levering og over-booking for Element {0} som mengde eller bel\xc3\xb8pet er 0'
b'DocType: Notification Control',b'Quotation Message',b'Sitat Message'
b'DocType: Employee Loan',b'Employee Loan Application',b'Medarbeider l\xc3\xa5nes\xc3\xb8knad'
b'DocType: Issue',b'Opening Date',b'\xc3\x85pningsdato'
b'apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +86',b'Please save the patient first',b'Vennligst lagre pasienten f\xc3\xb8rst'
b'apps/erpnext/erpnext/education/api.py +80',b'Attendance has been marked successfully.',b'Oppm\xc3\xb8te er merket med hell.'
b'DocType: Program Enrollment',b'Public Transport',b'Offentlig transport'
b'DocType: Soil Texture',b'Silt Composition (%)',b'Siltkomposisjon (%)'
b'DocType: Journal Entry',b'Remark',b'Bemerkning'
b'DocType: Healthcare Settings',b'Avoid Confirmation',b'Unng\xc3\xa5 bekreftelse'
b'DocType: Purchase Receipt Item',b'Rate and Amount',b'Rate og Bel\xc3\xb8p'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +176',b'Account Type for {0} must be {1}',b'Kontotype for {0} m\xc3\xa5 v\xc3\xa6re {1}'
b'DocType: Healthcare Settings',b'Default income accounts to be used if not set in Physician to book Consultation charges.',b'Standard inntektsregnskap som skal brukes dersom ikke settes i Lege for \xc3\xa5 bestille Konsultasjonsgebyrer.'
b'apps/erpnext/erpnext/config/hr.py +55',b'Leaves and Holiday',b'Blader og Holiday'
b'DocType: Education Settings',b'Current Academic Term',b'N\xc3\xa5v\xc3\xa6rende faglig term'
b'DocType: Education Settings',b'Current Academic Term',b'N\xc3\xa5v\xc3\xa6rende faglig term'
b'DocType: Sales Order',b'Not Billed',b'Ikke Fakturert'
b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +76',b'Both Warehouse must belong to same Company',b'B\xc3\xa5de Warehouse m\xc3\xa5 tilh\xc3\xb8re samme selskapet'
b'apps/erpnext/erpnext/public/js/templates/contact_list.html +34',b'No contacts added yet.',b'Ingen kontakter er lagt til enn\xc3\xa5.'
b'DocType: Purchase Invoice Item',b'Landed Cost Voucher Amount',b'Landed Cost Voucher Bel\xc3\xb8p'
,b'Item Balance (Simple)',b'Varebalanse (Enkel)'
b'apps/erpnext/erpnext/config/accounts.py +17',b'Bills raised by Suppliers.',b'Regninger oppdratt av leverand\xc3\xb8rer.'
b'DocType: POS Profile',b'Write Off Account',b'Skriv Off konto'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +215',b'Debit Note Amt',b'Debet notat Amt'
b'apps/erpnext/erpnext/templates/print_formats/includes/taxes.html +5',b'Discount Amount',b'Rabattbel\xc3\xb8p'
b'DocType: Purchase Invoice',b'Return Against Purchase Invoice',b'Tilbake mot fakturaen'
b'DocType: Item',b'Warranty Period (in days)',b'Garantiperioden (i dager)'
b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +61',b'Failed to set defaults',b'Kunne ikke angi standardinnstillinger'
b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +56',b'Relation with Guardian1',b'Relasjon med Guardian1'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +786',b'Please select BOM against item {0}',b'Vennligst velg BOM mot element {0}'
b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +18',b'Make Invoices',b'Lag fakturaer'
b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +23',b'Net Cash from Operations',b'Netto kontantstr\xc3\xb8m fra driften'
b'apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +26',b'Item 4',b'Sak 4'
b'DocType: Student Admission',b'Admission End Date',b'Opptak Sluttdato'
b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py +30',b'Sub-contracting',b'Underleverand\xc3\xb8rer'
b'DocType: Journal Entry Account',b'Journal Entry Account',b'Journal Entry konto'
b'apps/erpnext/erpnext/education/doctype/academic_year/academic_year.js +3',b'Student Group',b'student Gruppe'
b'DocType: Shopping Cart Settings',b'Quotation Series',b'Sitat Series'
b'apps/erpnext/erpnext/setup/doctype/item_group/item_group.py +57',"b'An item exists with same name ({0}), please change the item group name or rename the item'","b'Et element eksisterer med samme navn ({0}), m\xc3\xa5 du endre navn varegruppen eller endre navn p\xc3\xa5 elementet'"
b'DocType: Soil Analysis Criteria',b'Soil Analysis Criteria',b'Jordanalyse Kriterier'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +2041',b'Please select customer',b'Velg kunde'
b'DocType: C-Form',b'I',b'Jeg'
b'DocType: Company',b'Asset Depreciation Cost Center',b'Asset Avskrivninger kostnadssted'
b'DocType: Production Plan Sales Order',b'Sales Order Date',b'Salgsordre Dato'
b'DocType: Sales Invoice Item',b'Delivered Qty',b'Leveres Antall'
b'DocType: Assessment Plan',b'Assessment Plan',b'Assessment Plan'
b'apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +90',b'Customer {0} is created.',b'Kunden {0} er opprettet.'
b'DocType: Stock Settings',b'Limit Percent',b'grense Prosent'
b'apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +82',b' Currently no stock available in any warehouse',b'Forel\xc3\xb8pig ingen lager tilgjengelig i varehus'
,b'Payment Period Based On Invoice Date',b'Betaling perioden basert p\xc3\xa5 Fakturadato'
b'DocType: Sample Collection',b'No. of print',b'Antall utskrifter'
b'DocType: Hotel Room Reservation Item',b'Hotel Room Reservation Item',b'Hotel Room Reservation Item'
b'apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +58',b'Missing Currency Exchange Rates for {0}',b'Mangler valutakurser for {0}'
b'DocType: Health Insurance',b'Health Insurance Name',b'Helseforsikringsnavn'
b'DocType: Assessment Plan',b'Examiner',b'Examiner'
b'DocType: Student',b'Siblings',b's\xc3\xb8sken'
b'DocType: Journal Entry',b'Stock Entry',b'Stock Entry'
b'DocType: Payment Entry',b'Payment References',b'Betalings Referanser'
b'DocType: C-Form',b'C-FORM-',b'C-form-'
b'DocType: Vehicle',b'Insurance Details',b'forsikring Detaljer'
b'DocType: Account',b'Payable',b'Betales'
b'DocType: Share Balance',b'Share Type',b'Del Type'
b'apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +113',b'Please enter Repayment Periods',b'Fyll inn nedbetalingstid'
b'apps/erpnext/erpnext/shopping_cart/cart.py +378',b'Debtors ({0})',b'Skyldnere ({0})'
b'DocType: Pricing Rule',b'Margin',b'Margin'
b'apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +57',b'New Customers',b'Nye kunder'
b'apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +74',b'Gross Profit %',b'Bruttofortjeneste%'
b'DocType: Appraisal Goal',b'Weightage (%)',b'Weightage (%)'
b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +503',b'Change POS Profile',b'Endre POS-profil'
b'DocType: Bank Reconciliation Detail',b'Clearance Date',b'Klaring Dato'
b'apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +7',b'Assessment Report',b'Vurderingsrapport'
b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +59',b'Gross Purchase Amount is mandatory',b'Bruttobel\xc3\xb8pet er obligatorisk'
b'apps/erpnext/erpnext/setup/doctype/company/company.js +95',b'Company name not same',b'Firmanavn ikke det samme'
b'DocType: Lead',b'Address Desc',b'Adresse Desc'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +113',b'Party is mandatory',b'Party er obligatorisk'
b'DocType: Journal Entry',b'JV-',b'JV-'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +712',b'Rows with duplicate due dates in other rows were found: {list}',b'Rader med dupliserte forfallsdatoer i andre rader ble funnet: {list}'
b'DocType: Topic',b'Topic Name',b'emne Name'
b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +37',b'Atleast one of the Selling or Buying must be selected',b'Minst \xc3\xa9n av de selge eller kj\xc3\xb8pe m\xc3\xa5 velges'
b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +290',b'Select an employee to get the employee advance.',b'Velg en ansatt for \xc3\xa5 f\xc3\xa5 ansatt p\xc3\xa5 forh\xc3\xa5nd.'
b'apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +56',b'Please select a valid Date',b'Vennligst velg en gyldig dato'
b'apps/erpnext/erpnext/public/js/setup_wizard.js +36',b'Select the nature of your business.',b'Velg form\xc3\xa5let med virksomheten.'
b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +24',b'Please setup Employee Naming System in Human Resource &gt; HR Settings',b'Vennligst oppsett Medarbeiders navngivningssystem i menneskelig ressurs&gt; HR-innstillinger'
b'DocType: Lab Test Template',"b'Single for results which require only a single input, result UOM and normal value \n<br>\nCompound for results which require multiple input fields with corresponding event names, result UOMs and normal values\n<br>\nDescriptive for tests which have multiple result components and corresponding result entry fields. \n<br>\nGrouped for test templates which are a group of other test templates.\n<br>\nNo Result for tests with no results. Also, no Lab Test is created. e.g.. Sub Tests for Grouped results.'","b'Enkelt for resultater som krever bare ett enkelt inngang, resultat UOM og normal verdi <br> Sammensatt for resultater som krever flere inntastingsfelter med tilsvarende hendelsesnavn, resulterer UOM og normale verdier <br> Beskrivende for tester som har flere resultatkomponenter og tilh\xc3\xb8rende resultatoppf\xc3\xb8ringsfelter. <br> Gruppert for testmaler som er en gruppe andre testmaler. <br> Ingen resultat for tester uten resultater. Ogs\xc3\xa5, ingen Lab Test er opprettet. f.eks. Delpr\xc3\xb8ver for grupperte resultater.'"
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +86',b'Row #{0}: Duplicate entry in References {1} {2}',b'Row # {0}: Dupliseringsoppf\xc3\xb8ring i Referanser {1} {2}'
b'apps/erpnext/erpnext/config/manufacturing.py +57',b'Where manufacturing operations are carried.',b'Hvor fabrikasjonsvirksomhet gjennomf\xc3\xb8res.'
b'apps/erpnext/erpnext/education/doctype/instructor/instructor.js +18',b'As Examiner',b'Som eksaminator'
b'DocType: Appointment Type',b'Default Duration',b'Standard varighet'
b'DocType: Asset Movement',b'Source Warehouse',b'Kilde Warehouse'
b'DocType: Installation Note',b'Installation Date',b'Installasjonsdato'
b'apps/erpnext/erpnext/accounts/doctype/shareholder/shareholder.js +30',b'Share Ledger',b'Del Ledger'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +606',b'Row #{0}: Asset {1} does not belong to company {2}',b'Row # {0}: Asset {1} ikke tilh\xc3\xb8rer selskapet {2}'
b'apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +206',b'Sales Invoice {0} created',b'Salgsfaktura {0} opprettet'
b'DocType: Employee',b'Confirmation Date',b'Bekreftelse Dato'
b'DocType: C-Form',b'Total Invoiced Amount',b'Total Fakturert bel\xc3\xb8p'
b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +50',b'Min Qty can not be greater than Max Qty',b'Min Antall kan ikke v\xc3\xa6re st\xc3\xb8rre enn Max Antall'
b'DocType: Soil Texture',b'Silty Clay',b'Silty Clay'
b'DocType: Account',b'Accumulated Depreciation',b'akkumulerte avskrivninger'
b'DocType: Supplier Scorecard Scoring Standing',b'Standing Name',b'St\xc3\xa5ende navn'
b'DocType: Stock Entry',b'Customer or Supplier Details',b'Kunde eller leverand\xc3\xb8r Detaljer'
b'DocType: Employee Loan Application',b'Required by Date',b'Kreves av Dato'
b'DocType: Lead',b'Lead Owner',b'Lead Eier'
b'DocType: Production Plan',b'Sales Orders Detail',b'Salgsordre detalj'
b'DocType: Bin',b'Requested Quantity',b'Requested Antall'
b'DocType: Patient',b'Marital Status',b'Sivilstatus'
b'DocType: Stock Settings',b'Auto Material Request',b'Auto Materiell Request'
b'DocType: Delivery Note Item',b'Available Batch Qty at From Warehouse',b'Tilgjengelig Batch Antall p\xc3\xa5 From Warehouse'
b'DocType: Customer',b'CUST-',b'CUST-'
b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +50',b'Idevise',b'Idevise'
b'DocType: Salary Slip',b'Gross Pay - Total Deduction - Loan Repayment',b'Brutto l\xc3\xb8nn - Totalt Fradrag - Loan Nedbetaling'
b'apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +29',b'Current BOM and New BOM can not be same',b'N\xc3\xa5v\xc3\xa6rende BOM og New BOM kan ikke v\xc3\xa6re det samme'
b'apps/erpnext/erpnext/hr/report/salary_register/salary_register.py +47',b'Salary Slip ID',b'L\xc3\xb8nn Slip ID'
b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +118',b'Date Of Retirement must be greater than Date of Joining',b'Pensjoneringstidspunktet m\xc3\xa5 v\xc3\xa6re st\xc3\xb8rre enn tidspunktet for inntreden'
b'apps/erpnext/erpnext/stock/doctype/item/item.js +68',b'Multiple Variants',b'Flere variasjoner'
b'DocType: Sales Invoice',b'Against Income Account',b'Mot Inntekt konto'
b'apps/erpnext/erpnext/controllers/website_list_for_contact.py +117',b'{0}% Delivered',b'{0}% Leveres'
b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +107',b'Item {0}: Ordered qty {1} cannot be less than minimum order qty {2} (defined in Item).',b'Element {0}: Bestilte qty {1} kan ikke v\xc3\xa6re mindre enn minimum ordreantall {2} (definert i punkt).'
b'DocType: Monthly Distribution Percentage',b'Monthly Distribution Percentage',b'M\xc3\xa5nedlig Distribution Prosent'
b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +49',b'Please login as another user.',b'Vennligst logg inn som en annen bruker.'
b'DocType: Daily Work Summary Group User',b'Daily Work Summary Group User',b'Daglig arbeidsoppsummeringsgruppebruker'
b'DocType: Territory',b'Territory Targets',b'Terri Targets'
b'DocType: Soil Analysis',b'Ca/Mg',b'Ca / Mg'
b'DocType: Delivery Note',b'Transporter Info',b'Transporter Info'
b'apps/erpnext/erpnext/accounts/utils.py +502',b'Please set default {0} in Company {1}',b'Vennligst sett standard {0} i selskapet {1}'
b'DocType: Cheque Print Template',b'Starting position from top edge',b'Startposisjon fra \xc3\xb8verste kant'
b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +33',b'Same supplier has been entered multiple times',b'Samme leverand\xc3\xb8r er angitt flere ganger'
b'apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.py +152',b'Gross Profit / Loss',b'Brutto gevinst / tap'
,b'Warehouse wise Item Balance Age and Value',b'Lagerbetraktet Varebalanse Alder og verdi'
b'DocType: Purchase Order Item Supplied',b'Purchase Order Item Supplied',b'Innkj\xc3\xb8psordre Sak Leveres'
b'apps/erpnext/erpnext/public/js/setup_wizard.js +94',b'Company Name cannot be Company',b'Firmanavn kan ikke v\xc3\xa6re selskap'
b'apps/erpnext/erpnext/config/setup.py +27',b'Letter Heads for print templates.',b'Brevark for utskriftsmaler.'
b'apps/erpnext/erpnext/config/setup.py +32',b'Titles for print templates e.g. Proforma Invoice.',b'Titler for utskriftsmaler f.eks Proforma Faktura.'
b'DocType: Program Enrollment',b'Walking',b'walking'
b'DocType: Student Guardian',b'Student Guardian',b'student Guardian'
b'DocType: Member',b'Member Name',b'Medlemsnavn'
b'DocType: Stock Settings',b'Use Naming Series',b'Bruk Naming Series'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +218',b'Valuation type charges can not marked as Inclusive',b'Verdsettelse typen kostnader kan ikke merket som Inclusive'
b'DocType: POS Profile',b'Update Stock',b'Oppdater Stock'
b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +10',b'in the subscription',b'i abonnementet'
b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +100',b'Different UOM for items will lead to incorrect (Total) Net Weight value. Make sure that Net Weight of each item is in the same UOM.',b'Ulik m\xc3\xa5lenheter for elementer vil f\xc3\xb8re til feil (Total) Netto vekt verdi. S\xc3\xb8rg for at nettovekt av hvert element er i samme m\xc3\xa5lenheter.'
b'DocType: Membership',b'Payment Details',b'Betalingsinformasjon'
b'apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +39',b'BOM Rate',b'BOM Rate'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +225',"b'Stopped Work Order cannot be cancelled, Unstop it first to cancel'","b'Stoppet arbeidsordre kan ikke kanselleres, Unstop det f\xc3\xb8rst for \xc3\xa5 avbryte'"
b'DocType: Asset',b'Journal Entry for Scrap',b'Bilagsregistrering for Scrap'
b'apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +83',b'Please pull items from Delivery Note',b'Kan trekke elementer fra f\xc3\xb8lgeseddel'
b'apps/erpnext/erpnext/accounts/utils.py +472',b'Journal Entries {0} are un-linked',b'Journal Entries {0} er un-linked'
b'apps/erpnext/erpnext/config/crm.py +92',"b'Record of all communications of type email, phone, chat, visit, etc.'","b'Registrering av all kommunikasjon av typen e-post, telefon, chat, bes\xc3\xb8k, etc.'"
b'DocType: Supplier Scorecard Scoring Standing',b'Supplier Scorecard Scoring Standing',b'Leverand\xc3\xb8r Scorecard Scoring Standing'
b'DocType: Manufacturer',b'Manufacturers used in Items',b'Produsenter som brukes i Items'
b'apps/erpnext/erpnext/accounts/general_ledger.py +170',b'Please mention Round Off Cost Center in Company',b'Vennligst oppgi Round Off Cost Center i selskapet'
b'DocType: Purchase Invoice',b'Terms',b'Vilk\xc3\xa5r'
b'apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +10',b'Select Days',b'Velg dager'
b'DocType: Academic Term',b'Term Name',b'Term Navn'
b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +332',b'Credit ({0})',b'Kreditt ({0})'
b'DocType: Buying Settings',b'Purchase Order Required',b'Innkj\xc3\xb8psordre P\xc3\xa5krevd'
,b'Item-wise Sales History',b'Element-messig Sales History'
b'DocType: Expense Claim',b'Total Sanctioned Amount',b'Total vedtatte bel\xc3\xb8p'
b'DocType: Land Unit',b'Land Unit',b'Land Unit'
,b'Purchase Analytics',b'Kj\xc3\xb8ps Analytics'
b'DocType: Sales Invoice Item',b'Delivery Note Item',b'Levering Note Element'
b'DocType: Asset Maintenance Log',b'Task',b'Task'
b'DocType: Purchase Taxes and Charges',b'Reference Row #',b'Referanse Row #'
b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +76',b'Batch number is mandatory for Item {0}',b'Batchnummer er obligatorisk for Element {0}'
b'apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.js +13',b'This is a root sales person and cannot be edited.',b'Dette er en grunnlegg salg person og kan ikke redigeres.'
b'DocType: Salary Detail',"b""If selected, the value specified or calculated in this component will not contribute to the earnings or deductions. However, it's value can be referenced by other components that can be added or deducted. ""","b'Hvis valgt, vil verdien som er spesifisert eller beregnet i denne komponenten, ikke bidra til inntektene eller fradragene. Men det er verdien som kan refereres av andre komponenter som kan legges til eller trekkes fra.'"
b'DocType: Salary Detail',"b""If selected, the value specified or calculated in this component will not contribute to the earnings or deductions. However, it's value can be referenced by other components that can be added or deducted. ""","b'Hvis valgt, vil verdien som er spesifisert eller beregnet i denne komponenten, ikke bidra til inntektene eller fradragene. Men det er verdien som kan refereres av andre komponenter som kan legges til eller trekkes fra.'"
b'DocType: Asset Settings',b'Number of Days in Fiscal Year',b'Antall dager i regnskaps\xc3\xa5ret'
,b'Stock Ledger',b'Stock Ledger'
b'apps/erpnext/erpnext/templates/includes/cart/cart_items.html +29',b'Rate: {0}',b'Valuta: {0}'
b'DocType: Company',b'Exchange Gain / Loss Account',b'Valutagevinst / tap-konto'
b'apps/erpnext/erpnext/config/hr.py +7',b'Employee and Attendance',b'Medarbeider og oppm\xc3\xb8te'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +93',b'Purpose must be one of {0}',b'Hensikten m\xc3\xa5 v\xc3\xa6re en av {0}'
b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +100',b'Fill the form and save it',b'Fyll ut skjemaet og lagre det'
b'apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +26',b'Community Forum',b'Community Forum'
b'apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +52',b'Actual qty in stock',b'Faktisk antall p\xc3\xa5 lager'
b'apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +52',b'Actual qty in stock',b'Faktisk antall p\xc3\xa5 lager'
b'DocType: Homepage',"b'URL for ""All Products""'",b'URL for &quot;Alle produkter&quot;'
b'DocType: Leave Application',b'Leave Balance Before Application',b'La Balance F\xc3\xb8r Application'
b'apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +46',b'Send SMS',b'Send SMS'
b'DocType: Supplier Scorecard Criteria',b'Max Score',b'Max score'
b'DocType: Cheque Print Template',b'Width of amount in word',b'Bredde p\xc3\xa5 bel\xc3\xb8pet i ord'
b'DocType: Company',b'Default Letter Head',b'Standard Brevhode'
b'DocType: Purchase Order',b'Get Items from Open Material Requests',b'F\xc3\xa5 Elementer fra \xc3\x85pen Material Foresp\xc3\xb8rsler'
b'DocType: Hotel Room Amenity',b'Billable',b'Fakturerbare'
b'DocType: Lab Test Template',b'Standard Selling Rate',b'Standard salgskurs'
b'DocType: Account',b'Rate at which this tax is applied',b'Hastigheten som denne skatten er brukt'
b'DocType: Cash Flow Mapper',b'Section Name',b'Seksjonsnavn'
b'apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +77',b'Reorder Qty',b'Omgj\xc3\xb8re Antall'
b'apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +28',b'Current Job Openings',b'N\xc3\xa5v\xc3\xa6rende jobb \xc3\x85pninger'
b'DocType: Company',b'Stock Adjustment Account',b'Stock Adjustment konto'
b'apps/erpnext/erpnext/public/js/payment/pos_payment.html +17',b'Write Off',b'Skriv Off'
b'DocType: Patient Service Unit',b'Allow Overlap',b'Tillat overlapping'
b'DocType: Timesheet Detail',b'Operation ID',b'Operation ID'
b'DocType: Employee',"b'System User (login) ID. If set, it will become default for all HR forms.'","b'Systemet bruker (innlogging) ID. Hvis satt, vil det bli standard for alle HR-skjemaer.'"
b'apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +16',b'{0}: From {1}',b'{0}: Fra {1}'
b'DocType: Task',b'depends_on',b'kommer an p\xc3\xa5'
b'apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +60',b'Queued for updating latest price in all Bill of Materials. It may take a few minutes.',b'I k\xc3\xb8 for \xc3\xa5 oppdatere siste pris i alle Materialebevis. Det kan ta noen minutter.'
b'apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +26',"b""Name of new Account. Note: Please don't create accounts for Customers and Suppliers""",b'Navn p\xc3\xa5 ny konto. Merk: Vennligst ikke opprette kontoer for kunder og leverand\xc3\xb8rer'
b'apps/erpnext/erpnext/config/setup.py +37',b'Country wise default Address Templates',b'Country klok standardadresse Maler'
b'DocType: Water Analysis',b'Appearance',b'Utseende'
b'apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +70',b'Avg. Buying Price List Rate',b'Nr. Kj\xc3\xb8pe prisliste rate'
b'DocType: Sales Order Item',b'Supplier delivers to Customer',b'Leverand\xc3\xb8r leverer til kunden'
b'apps/erpnext/erpnext/config/non_profit.py +23',b'Member information.',b'Medlemsinformasjon.'
b'apps/erpnext/erpnext/utilities/bot.py +34',b'[{0}](#Form/Item/{0}) is out of stock',b'[{0}] (# Form / post / {0}) er utsolgt'
b'apps/erpnext/erpnext/assets/doctype/asset/asset.js +58',b'Asset Maintenance',b'Asset Maintenance'
,b'Sales Payment Summary',b'Salgsbetalingssammendrag'
b'DocType: Restaurant',b'Restaurant',b'Restaurant'
b'apps/erpnext/erpnext/accounts/party.py +320',b'Due / Reference Date cannot be after {0}',b'Due / Reference Datoen kan ikke v\xc3\xa6re etter {0}'
b'apps/erpnext/erpnext/config/setup.py +51',b'Data Import and Export',b'Data import og eksport'
b'DocType: Patient',b'Account Details',b'kontodetaljer'
b'DocType: Crop',b'Materials Required',b'Materialer som kreves'
b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +76',b'No students Found',b'Ingen studenter Funnet'
b'DocType: Medical Department',b'Medical Department',b'Medisinsk avdeling'
b'DocType: Supplier Scorecard Scoring Criteria',b'Supplier Scorecard Scoring Criteria',b'Leverand\xc3\xb8r Scorecard Scoring Criteria'
b'apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +55',b'Invoice Posting Date',b'Faktura Publiseringsdato'
b'apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +25',b'Sell',b'Selge'
b'DocType: Purchase Invoice',b'Rounded Total',b'Avrundet Total'
b'DocType: Product Bundle',b'List items that form the package.',b'Listeelementer som danner pakken.'
b'apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.py +39',b'Not permitted. Please disable the Test Template',b'Ikke tillatt. Vennligst deaktiver testmalen'
b'apps/erpnext/erpnext/accounts/doctype/monthly_distribution/monthly_distribution.py +26',b'Percentage Allocation should be equal to 100%',b'Prosentvis Tildeling skal v\xc3\xa6re lik 100%'
b'DocType: Crop Cycle',b'Linked Land Unit',b'Tilknyttet landsenhet'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +584',b'Please select Posting Date before selecting Party',b'Vennligst velg Publiseringsdato f\xc3\xb8r du velger Partiet'
b'DocType: Program Enrollment',b'School House',b'school House'
b'DocType: Serial No',b'Out of AMC',b'Ut av AMC'
b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +82',b'Number of Depreciations Booked cannot be greater than Total Number of Depreciations',b'Antall Avskrivninger reservert kan ikke v\xc3\xa6re st\xc3\xb8rre enn Totalt antall Avskrivninger'
b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +47',b'Make Maintenance Visit',b'Gj\xc3\xb8r Vedlikehold Visit'
b'apps/erpnext/erpnext/selling/doctype/customer/customer.py +215',b'Please contact to the user who have Sales Master Manager {0} role',b'Ta kontakt for brukeren som har salgs Master manager {0} rolle'
b'DocType: Company',b'Default Cash Account',b'Standard Cash konto'
b'apps/erpnext/erpnext/config/accounts.py +62',b'Company (not Customer or Supplier) master.',b'Company (ikke kunde eller leverand\xc3\xb8r) mester.'
b'apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +6',b'This is based on the attendance of this Student',b'Dette er basert p\xc3\xa5 tilstedev\xc3\xa6relse av denne Student'
b'apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +178',b'No Students in',b'Ingen studenter i'
b'apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +179',b'Add more items or open full form',b'Legg til flere elementer eller \xc3\xa5pne full form'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +212',b'Delivery Notes {0} must be cancelled before cancelling this Sales Order',b'Levering Merknader {0} m\xc3\xa5 avbestilles f\xc3\xb8r den avbryter denne salgsordre'
b'apps/erpnext/erpnext/utilities/user_progress.py +259',b'Go to Users',b'G\xc3\xa5 til Brukere'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +85',b'Paid amount + Write Off Amount can not be greater than Grand Total',b'Innbetalt bel\xc3\xb8p + avskrive Bel\xc3\xb8pet kan ikke v\xc3\xa6re st\xc3\xb8rre enn Totalsum'
b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +78',b'{0} is not a valid Batch Number for Item {1}',b'{0} er ikke en gyldig batchnummer for varen {1}'
b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +130',b'Note: There is not enough leave balance for Leave Type {0}',b'Merk: Det er ikke nok permisjon balanse for La Type {0}'
b'apps/erpnext/erpnext/regional/india/utils.py +16',b'Invalid GSTIN or Enter NA for Unregistered',b'Ugyldig GSTIN eller Skriv inn NA for Uregistrert'
b'DocType: Training Event',b'Seminar',b'Seminar'
b'DocType: Program Enrollment Fee',b'Program Enrollment Fee',b'Program innmeldingsavgift'
b'DocType: Item',b'Supplier Items',b'Leverand\xc3\xb8r Items'
b'DocType: Opportunity',b'Opportunity Type',b'Opportunity Type'
b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +16',b'New Company',b'Nytt firma'
b'apps/erpnext/erpnext/setup/doctype/company/delete_company_transactions.py +17',b'Transactions can only be deleted by the creator of the Company',b'Transaksjoner kan bare slettes av skaperen av selskapet'
b'apps/erpnext/erpnext/accounts/general_ledger.py +21',b'Incorrect number of General Ledger Entries found. You might have selected a wrong Account in the transaction.',b'Feil antall hovedbok Entries funnet. Du kan ha valgt feil konto i transaksjonen.'
b'DocType: Employee',b'Prefered Contact Email',b'Foretrukket Kontakt E-post'
b'DocType: Cheque Print Template',b'Cheque Width',b'sjekk Bredde'
b'DocType: Selling Settings',b'Validate Selling Price for Item against Purchase Rate or Valuation Rate',b'Validere salgspris for varen mot Purchase Rate Verdivurdering Ranger'
b'DocType: Fee Schedule',b'Fee Schedule',b'Prisliste'
b'DocType: Hub Settings',b'Publish Availability',b'Publiser Tilgjengelighet'
b'DocType: Company',b'Create Chart Of Accounts Based On',b'Opprett kontoplan basert p\xc3\xa5'
b'apps/erpnext/erpnext/projects/doctype/task/task.js +91',b'Cannot convert it to non-group. Child Tasks exist.',b'Kan ikke konvertere det til ikke-gruppe. Barnoppgaver eksisterer.'
b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +112',b'Date of Birth cannot be greater than today.',b'F\xc3\xb8dselsdato kan ikke v\xc3\xa6re st\xc3\xb8rre enn i dag.'
,b'Stock Ageing',b'Stock Ageing'
b'apps/erpnext/erpnext/education/doctype/student/student.py +40',b'Student {0} exist against student applicant {1}',b'Student {0} eksistere mot student S\xc3\xb8keren {1}'
b'DocType: Purchase Invoice',b'Rounding Adjustment (Company Currency)',b'Avrundingsjustering (Bedriftsvaluta)'
b'apps/erpnext/erpnext/projects/doctype/task/task.js +39',b'Timesheet',b'Tids skjema'
b'apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +243',b'Batch: ',b'Parti:'
b'DocType: Volunteer',b'Afternoon',b'Ettermiddag'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +258',"b""{0} '{1}' is disabled""",b'{0} {1} er deaktivert'
b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +13',b'Set as Open',b'Sett som \xc3\x85pen'
b'DocType: Cheque Print Template',b'Scanned Cheque',b'skannede Cheque'
b'DocType: Notification Control',b'Send automatic emails to Contacts on Submitting transactions.',b'Send automatisk e-poster til Kontakter p\xc3\xa5 Sende transaksjoner.'
b'DocType: Timesheet',b'Total Billable Amount',b'Total Fakturerbart Bel\xc3\xb8p'
b'DocType: Customer',b'Credit Limit and Payment Terms',b'Kredittgrense og betalingsbetingelser'
b'apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +20',b'Item 3',b'Sak 3'
b'apps/erpnext/erpnext/restaurant/doctype/restaurant/restaurant.js +6',b'Order Entry',b'Bestillingsinngang'
b'DocType: Purchase Order',b'Customer Contact Email',b'Kundekontakt E-post'
b'DocType: Warranty Claim',b'Item and Warranty Details',b'Element og Garanti Detaljer'
b'DocType: Chapter',b'Chapter Members',b'Kapittelmedlemmer'
b'DocType: Sales Team',b'Contribution (%)',b'Bidrag (%)'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +102',"b""Note: Payment Entry will not be created since 'Cash or Bank Account' was not specified""",b'Merk: Betaling Entry vil ikke bli laget siden &quot;Cash eller bankkontoen ble ikke spesifisert'
b'apps/erpnext/erpnext/projects/doctype/project/project.py +70',b'Project {0} already exists',b'Prosjektet {0} eksisterer allerede'
b'DocType: Medical Department',b'Nursing User',b'Sykepleier Bruker'
b'DocType: Plant Analysis',b'Plant Analysis Criterias',b'Plant Analyse Kriterier'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +239',b'Responsibilities',b'Ansvarsomr\xc3\xa5der'
b'apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +125',b'Validity period of this quotation has ended.',b'Gyldighetsperioden for dette sitatet er avsluttet.'
b'DocType: Expense Claim Account',b'Expense Claim Account',b'Expense krav konto'
b'DocType: Accounts Settings',b'Allow Stale Exchange Rates',b'Tillat uaktuelle valutakurser'
b'DocType: Sales Person',b'Sales Person Name',b'Sales Person Name'
b'apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +54',b'Please enter atleast 1 invoice in the table',b'Skriv inn atleast en faktura i tabellen'
b'apps/erpnext/erpnext/utilities/user_progress.py +247',b'Add Users',b'Legg til brukere'
b'DocType: POS Item Group',b'Item Group',b'Varegruppe'
b'apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +16',b'Student Group: ',b'Studentgruppe:'
b'DocType: Item',b'Safety Stock',b'Safety Stock'
b'DocType: Healthcare Settings',b'Healthcare Settings',b'Helseinstitusjoner'
b'apps/erpnext/erpnext/projects/doctype/task/task.py +54',b'Progress % for a task cannot be more than 100.',b'Progress% for en oppgave kan ikke v\xc3\xa6re mer enn 100.'
b'DocType: Stock Reconciliation Item',b'Before reconciliation',b'F\xc3\xb8r avstemming'
b'apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py +12',b'To {0}',b'Til {0}'
b'DocType: Purchase Invoice',b'Taxes and Charges Added (Company Currency)',b'Skatter og avgifter legges (Company Valuta)'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +476',b'Item Tax Row {0} must have account of type Tax or Income or Expense or Chargeable',b'Sak Skatte Rad {0} m\xc3\xa5 ha konto for type skatt eller inntekt eller kostnad eller Charge'
b'DocType: Sales Order',b'Partly Billed',b'Delvis Fakturert'
b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +43',b'Item {0} must be a Fixed Asset Item',b'Element {0} m\xc3\xa5 v\xc3\xa6re et driftsmiddel element'
b'apps/erpnext/erpnext/stock/doctype/item/item.js +372',b'Make Variants',b'Lag variasjoner'
b'DocType: Item',b'Default BOM',b'Standard BOM'
b'DocType: Project',b'Total Billed Amount (via Sales Invoices)',b'Sum fakturert bel\xc3\xb8p (via salgsfakturaer)'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +118',b'Debit Note Amount',b'Debet Note Bel\xc3\xb8p'
b'DocType: Project Update',b'Not Updated',b'Ikke oppdatert'
b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +106',"b'There are inconsistencies between the rate, no of shares and the amount calculated'","b'Det er uoverensstemmelser mellom rente, antall aksjer og beregnet bel\xc3\xb8p'"
b'apps/erpnext/erpnext/setup/doctype/company/company.js +89',b'Please re-type company name to confirm',b'Vennligst re-type firmanavn for \xc3\xa5 bekrefte'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +216',b'Total Outstanding Amt',b'Total Outstanding Amt'
b'DocType: Journal Entry',b'Printing Settings',b'Utskriftsinnstillinger'
b'DocType: Employee Advance',b'Advance Account',b'Forh\xc3\xa5ndskonto'
b'DocType: Job Offer',b'Job Offer Terms',b'Jobbtilbudsbetingelser'
b'DocType: Sales Invoice',b'Include Payment (POS)',b'Inkluder Payment (POS)'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +292',b'Total Debit must be equal to Total Credit. The difference is {0}',b'Total debet m\xc3\xa5 v\xc3\xa6re lik samlet kreditt. Forskjellen er {0}'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +11',b'Automotive',b'Automotive'
b'DocType: Vehicle',b'Insurance Company',b'Forsikringsselskap'
b'DocType: Asset Category Account',b'Fixed Asset Account',b'Fast Asset konto'
b'apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +414',b'Variable',b'variabel'
b'apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.js +47',b'From Delivery Note',b'Fra f\xc3\xb8lgeseddel'
b'DocType: Chapter',b'Members',b'medlemmer'
b'DocType: Student',b'Student Email Address',b'Student e-postadresse'
b'DocType: Item',b'Hub Warehouse',b'Hub lager'
b'DocType: Assessment Plan',b'From Time',b'Fra Time'
b'DocType: Hotel Settings',b'Hotel Settings',b'Hotellinnstillinger'
b'apps/erpnext/erpnext/public/js/pos/pos_bill_item.html +12',b'In Stock: ',b'P\xc3\xa5 lager:'
b'DocType: Notification Control',b'Custom Message',b'Standard melding'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +33',b'Investment Banking',b'Investment Banking'
b'DocType: Purchase Invoice',b'input',b'inngang'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +79',b'Cash or Bank Account is mandatory for making payment entry',b'Kontanter eller bankkontoen er obligatorisk for \xc3\xa5 gj\xc3\xb8re betaling oppf\xc3\xb8ring'
b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +54',b'Student Address',b'Studentadresse'
b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +54',b'Student Address',b'Studentadresse'
b'DocType: Purchase Invoice',b'Price List Exchange Rate',b'Prisliste Exchange Rate'
b'apps/erpnext/erpnext/accounts/doctype/account/account.py +251',b'Account Number {0} already used in account {1}',b'Kontonummer {0} som allerede er brukt i konto {1}'
b'DocType: GoCardless Mandate',b'Mandate',b'mandat'
b'DocType: POS Profile',b'POS Profile Name',b'POS profilnavn'
b'DocType: Hotel Room Reservation',b'Booked',b'bestilt'
b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +45',b'CompAuxLib',b'CompAuxLib'
b'DocType: Purchase Invoice Item',b'Rate',b'Rate'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +104',b'Intern',b'Intern'
b'DocType: Delivery Stop',b'Address Name',b'Adressenavn'
b'DocType: Stock Entry',b'From BOM',b'Fra BOM'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +639',b'Splitting {0} units of {1}',b'Splitting {0} enheter av {1}'
b'DocType: Assessment Code',b'Assessment Code',b'Assessment Kode'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +73',b'Basic',b'Grunnleggende'
b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +94',b'Stock transactions before {0} are frozen',b'Lagertransaksjoner f\xc3\xb8r {0} er frosset'
b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +219',"b""Please click on 'Generate Schedule'""",b'Vennligst klikk p\xc3\xa5 &quot;Generer Schedule &#39;'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +122',b'Reference No is mandatory if you entered Reference Date',b'Referansenummer er obligatorisk hvis du skrev Reference Date'
b'DocType: Bank Reconciliation Detail',b'Payment Document',b'betaling Document'
b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py +37',b'Error evaluating the criteria formula',b'Feil ved vurdering av kriterieformelen'
b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +115',b'Date of Joining must be greater than Date of Birth',b'Dato Bli m\xc3\xa5 v\xc3\xa6re st\xc3\xb8rre enn f\xc3\xb8dselsdato'
b'DocType: Salary Slip',b'Salary Structure',b'L\xc3\xb8nn Struktur'
b'DocType: Account',b'Bank',b'Bank'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +9',b'Airline',b'Flyselskap'
b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +853',b'Issue Material',b'Issue Material'
b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +3',b'An error occured while creating recurring',b'Det oppstod en feil under oppretting'
b'DocType: Material Request Item',b'For Warehouse',b'For Warehouse'
b'DocType: Employee',b'Offer Date',b'Tilbudet Dato'
b'apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +33',b'Quotations',b'Sitater'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +735',b'You are in offline mode. You will not be able to reload until you have network.',b'Du er i frakoblet modus. Du vil ikke v\xc3\xa6re i stand til \xc3\xa5 laste f\xc3\xb8r du har nettverk.'
b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +47',b'No Student Groups created.',b'Ingen studentgrupper opprettet.'
b'DocType: Purchase Invoice Item',b'Serial No',b'Serial No'
b'apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +119',b'Monthly Repayment Amount cannot be greater than Loan Amount',b'M\xc3\xa5nedlig nedbetaling bel\xc3\xb8pet kan ikke v\xc3\xa6re st\xc3\xb8rre enn L\xc3\xa5nebel\xc3\xb8p'
b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +143',b'Please enter Maintaince Details first',b'Skriv inn maintaince detaljer F\xc3\xb8rste'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +56',b'Row #{0}: Expected Delivery Date cannot be before Purchase Order Date',b'Rute # {0}: Forventet leveringsdato kan ikke v\xc3\xa6re f\xc3\xb8r innkj\xc3\xb8psordrenes dato'
b'DocType: Purchase Invoice',b'Print Language',b'Print Spr\xc3\xa5k'
b'DocType: Salary Slip',b'Total Working Hours',b'Samlet arbeidstid'
b'DocType: Sales Invoice',b'Customer PO Details',b'Kunde PO Detaljer'
b'DocType: Subscription',b'Next Schedule Date',b'Neste planleggingsdato'
b'DocType: Stock Entry',b'Including items for sub assemblies',b'Inkludert elementer for sub samlinger'
b'DocType: Opening Invoice Creation Tool Item',b'Temporary Opening Account',b'Midlertidig \xc3\xa5pningskonto'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +1964',b'Enter value must be positive',b'Oppgi verdien skal v\xc3\xa6re positiv'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/pos.py +446',b'All Territories',b'Alle Territories'
b'apps/erpnext/erpnext/projects/doctype/task/task_tree.js +49',b'Add Multiple Tasks',b'Legg til flere oppgaver'
b'DocType: Purchase Invoice',b'Items',b'Elementer'
b'apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py +34',b'Student is already enrolled.',b'Student er allerede registrert.'
b'DocType: Fiscal Year',b'Year Name',b'\xc3\x85r Navn'
b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +241',b'There are more holidays than working days this month.',b'Det er mer ferie enn virkedager denne m\xc3\xa5neden.'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +78',b'PDC/LC Ref',b'PDC / LC Ref'
b'DocType: Product Bundle Item',b'Product Bundle Item',b'Produktet Bundle Element'
b'DocType: Sales Partner',b'Sales Partner Name',b'Sales Partner Name'
b'apps/erpnext/erpnext/hooks.py +136',b'Request for Quotations',b'Foresp\xc3\xb8rsel om Sitater'
b'DocType: Payment Reconciliation',b'Maximum Invoice Amount',b'Maksimal Fakturert bel\xc3\xb8p'
b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +50',b'Montantdevise',b'Montantdevise'
b'apps/erpnext/erpnext/healthcare/setup.py +210',b'Haematology',b'hematologi'
b'DocType: Normal Test Items',b'Normal Test Items',b'Normale testelementer'
b'DocType: Student Language',b'Student Language',b'student Spr\xc3\xa5k'
b'apps/erpnext/erpnext/config/selling.py +23',b'Customers',b'kunder'
b'DocType: Cash Flow Mapping',b'Is Working Capital',b'Er arbeidskapital'
b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +24',b'Order/Quot %',b'Ordre / Quot%'
b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +24',b'Order/Quot %',b'Ordre / Quot%'
b'apps/erpnext/erpnext/config/healthcare.py +25',b'Record Patient Vitals',b'Opptak Pasient Vitals'
b'DocType: Fee Schedule',b'Institution',b'institusjon'
b'DocType: Asset',b'Partially Depreciated',b'delvis Avskrives'
b'DocType: Issue',b'Opening Time',b'\xc3\x85pning Tid'
b'apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +89',b'From and To dates required',b'Fra og Til dato kreves'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +46',b'Securities & Commodity Exchanges',b'Verdipapirer og r\xc3\xa5vareb\xc3\xb8rser'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +689',"b""Default Unit of Measure for Variant '{0}' must be same as in Template '{1}'""",b'Standard Enhet for Variant {0} m\xc3\xa5 v\xc3\xa6re samme som i malen {1}'
b'DocType: Shipping Rule',b'Calculate Based On',b'Beregn basert p\xc3\xa5'
b'DocType: Delivery Note Item',b'From Warehouse',b'Fra Warehouse'
b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +59',b'No employees for the mentioned criteria',b'Ingen ansatte for de nevnte kriteriene'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +955',b'No Items with Bill of Materials to Manufacture',b'Ingen elementer med Bill of Materials til Manufacture'
b'DocType: Hotel Settings',b'Default Customer',b'Standardkund'
b'DocType: Assessment Plan',b'Supervisor Name',b'Supervisor Name'
b'DocType: Healthcare Settings',b'Do not confirm if appointment is created for the same day',b'Bekreft ikke om avtalen er opprettet for samme dag'
b'DocType: Program Enrollment Course',b'Program Enrollment Course',b'Programopptakskurs'
b'DocType: Program Enrollment Course',b'Program Enrollment Course',b'Programopptakskurs'
b'DocType: Purchase Taxes and Charges',b'Valuation and Total',b'Verdivurdering og Total'
b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py +11',b'Scorecards',b'm\xc3\xa5lstyring'
b'DocType: Tax Rule',b'Shipping City',b'Shipping by'
b'DocType: Notification Control',b'Customize the Notification',b'Tilpass varslings'
b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +24',b'Cash Flow from Operations',b'Kontantstr\xc3\xb8m fra driften'
b'DocType: Purchase Invoice',b'Shipping Rule',b'Shipping Rule'
b'DocType: Patient Relation',b'Spouse',b'Ektefelle'
b'DocType: Lab Test Groups',b'Add Test',b'Legg til test'
b'DocType: Manufacturer',b'Limited to 12 characters',b'Begrenset til 12 tegn'
b'DocType: Journal Entry',b'Print Heading',b'Print Overskrift'
b'apps/erpnext/erpnext/config/stock.py +146',b'Delivery Trip service tours to customers.',b'Leveringsturtjenesten til kunder.'
b'apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +57',b'Total cannot be zero',b'Totalt kan ikke v\xc3\xa6re null'
b'apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +16',"b""'Days Since Last Order' must be greater than or equal to zero""",b'&#39;Dager siden siste Bestill &quot;m\xc3\xa5 v\xc3\xa6re st\xc3\xb8rre enn eller lik null'
b'DocType: Plant Analysis Criteria',b'Maximum Permissible Value',b'Maksimal tillatelig verdi'
b'DocType: Journal Entry Account',b'Employee Advance',b'Ansattes fremskritt'
b'DocType: Payroll Entry',b'Payroll Frequency',b'l\xc3\xb8nn Frequency'
b'DocType: Lab Test Template',b'Sensitivity',b'F\xc3\xb8lsomhet'
b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +941',b'Raw Material',b'R\xc3\xa5materiale'
b'DocType: Leave Application',b'Follow via Email',b'F\xc3\xb8lg via e-post'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +55',b'Plants and Machineries',b'Planter og Machineries'
b'DocType: Purchase Taxes and Charges',b'Tax Amount After Discount Amount',b'Skattebel\xc3\xb8p Etter Rabattbel\xc3\xb8p'
b'DocType: Daily Work Summary Settings',b'Daily Work Summary Settings',b'Daglige arbeid Oppsummering Innstillinger'
b'apps/erpnext/erpnext/controllers/buying_controller.py +447',b'Please enter Reqd by Date',b'Vennligst skriv inn reqd etter dato'
b'DocType: Payment Entry',b'Internal Transfer',b'Internal Transfer'
b'DocType: Asset Maintenance',b'Maintenance Tasks',b'Vedlikeholdsoppgaver'
b'apps/erpnext/erpnext/setup/doctype/territory/territory.py +19',b'Either target qty or target amount is mandatory',b'Enten m\xc3\xa5let stk eller m\xc3\xa5l bel\xc3\xb8pet er obligatorisk'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +366',b'Please select Posting Date first',b'Vennligst velg Publiseringsdato f\xc3\xb8rst'
b'apps/erpnext/erpnext/public/js/account_tree_grid.js +209',b'Opening Date should be before Closing Date',b'\xc3\x85pningsdato b\xc3\xb8r v\xc3\xa6re f\xc3\xb8r p\xc3\xa5meldingsfristens utl\xc3\xb8p'
b'DocType: Leave Control Panel',b'Carry Forward',b'Fremf\xc3\xb8ring'
b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +30',b'Cost Center with existing transactions can not be converted to ledger',b'Kostnadssted med eksisterende transaksjoner kan ikke konverteres til Ledger'
b'DocType: Department',b'Days for which Holidays are blocked for this department.',b'Dager som Holidays er blokkert for denne avdelingen.'
b'DocType: GoCardless Mandate',b'ERPNext Integrations',b'ERPNext Integrasjoner'
b'DocType: Crop Cycle',b'Detected Disease',b'Oppdaget sykdom'
,b'Produced',b'Produsert'
b'DocType: Item',b'Item Code for Suppliers',b'Sak Kode for leverand\xc3\xb8rer'
b'DocType: Issue',b'Raised By (Email)',b'Raised By (e-post)'
b'DocType: Training Event',b'Trainer Name',b'trener Name'
b'DocType: Mode of Payment',b'General',b'Generelt'
b'apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +28',b'Last Communication',b'Siste kommunikasjon'
b'apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +28',b'Last Communication',b'Siste kommunikasjon'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +372',"b""Cannot deduct when category is for 'Valuation' or 'Valuation and Total'""",b'Kan ikke trekke n\xc3\xa5r kategorien er for verdsetting &quot;eller&quot; Verdsettelse og Totals'
b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +234',b'Serial Nos Required for Serialized Item {0}',b'Serial Nos N\xc3\xb8dvendig for Serialisert Element {0}'
b'apps/erpnext/erpnext/config/accounts.py +144',b'Match Payments with Invoices',b'Match Betalinger med Fakturaer'
b'DocType: Journal Entry',b'Bank Entry',b'Bank Entry'
b'DocType: Authorization Rule',b'Applicable To (Designation)',b'Gjelder til (Betegnelse)'
,b'Profitability Analysis',b'l\xc3\xb8nnsomhets~~POS=TRUNC'
b'DocType: Fees',b'Student Email',b'Student e-post'
b'DocType: Supplier',b'Prevent POs',b'Forhindre PO&#39;er'
b'DocType: Patient',"b'Allergies, Medical and Surgical History'","b'Allergier, medisinsk og kirurgisk historie'"
b'apps/erpnext/erpnext/templates/generators/item.html +77',b'Add to Cart',b'Legg til i handlevogn'
b'apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.js +28',b'Group By',b'Grupper etter'
b'DocType: Guardian',b'Interests',b'Interesser'
b'apps/erpnext/erpnext/config/accounts.py +298',b'Enable / disable currencies.',b'Aktivere / deaktivere valutaer.'
b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +105',b'Dr {0} on Half day Leave on {1}',b'Dr {0} p\xc3\xa5 halv dag permisjon p\xc3\xa5 {1}'
b'DocType: Production Plan',b'Get Material Request',b'F\xc3\xa5 Material Request'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +111',b'Postal Expenses',b'Post Utgifter'
b'apps/erpnext/erpnext/controllers/trends.py +19',b'Total(Amt)',b'Total (Amt)'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +26',b'Entertainment & Leisure',b'Entertainment &amp; Leisure'
,b'Item Variant Details',b'Varevarianter Detaljer'
b'DocType: Quality Inspection',b'Item Serial No',b'Sak Serial No'
b'apps/erpnext/erpnext/utilities/activation.py +135',b'Create Employee Records',b'Lag Medarbeider Records'
b'apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68',b'Total Present',b'Total Present'
b'apps/erpnext/erpnext/config/accounts.py +105',b'Accounting Statements',b'regnskaps~~POS=TRUNC Uttalelser'
b'DocType: Drug Prescription',b'Hour',b'Time'
b'DocType: Restaurant Order Entry',b'Last Sales Invoice',b'Siste salgsfaktura'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +788',b'Please select Qty against item {0}',b'Vennligst velg antall til elementet {0}'
b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +29',b'New Serial No cannot have Warehouse. Warehouse must be set by Stock Entry or Purchase Receipt',b'New Serial No kan ikke ha Warehouse. Warehouse m\xc3\xa5 settes av Stock Entry eller Kj\xc3\xb8pskvittering'
b'DocType: Lead',b'Lead Type',b'Lead Type'
b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +114',b'You are not authorized to approve leaves on Block Dates',b'Du er ikke autorisert til \xc3\xa5 godkjenne blader p\xc3\xa5 Block Datoer'
b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +394',b'All these items have already been invoiced',b'Alle disse elementene er allerede blitt fakturert'
b'DocType: Company',b'Monthly Sales Target',b'M\xc3\xa5nedlig salgsm\xc3\xa5l'
b'apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py +37',b'Can be approved by {0}',b'Kan godkjennes av {0}'
b'DocType: Hotel Room',b'Hotel Room Type',b'Hotellromtype'
b'DocType: Item',b'Default Material Request Type',b'Standard Material Request Type'
b'DocType: Supplier Scorecard',b'Evaluation Period',b'Evalueringsperiode'
b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_list.js +13',b'Unknown',b'Ukjent'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +954',b'Work Order not created',b'Arbeidsordre er ikke opprettet'
b'DocType: Shipping Rule',b'Shipping Rule Conditions',b'Frakt Regel betingelser'
b'DocType: Purchase Invoice',b'Export Type',b'Eksporttype'
b'DocType: Salary Slip Loan',b'Salary Slip Loan',b'L\xc3\xb8nnsslippl\xc3\xa5n'
b'DocType: BOM Update Tool',b'The new BOM after replacement',b'Den nye BOM etter utskiftning'
,b'Point of Sale',b'Utsalgssted'
b'DocType: Payment Entry',b'Received Amount',b'mottatt bel\xc3\xb8p'
b'DocType: Patient',b'Widow',b'Enke'
b'DocType: GST Settings',b'GSTIN Email Sent On',b'GSTIN Email Sent On'
b'DocType: Program Enrollment',b'Pick/Drop by Guardian',b'Pick / Drop av Guardian'
b'DocType: Crop',b'Planting UOM',b'Planting UOM'
b'DocType: Account',b'Tax',b'Skatte'
b'apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py +45',b'Not Marked',b'ikke Merket'
b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html +1',b'Opening Invoices Summary',b'\xc3\x85pning av fakturaoversikt'
b'DocType: Education Settings',b'Education Manager',b'Utdannelsesleder'
b'DocType: Crop Cycle',b'The minimum length between each plant in the field for optimum growth',b'Minimale lengde mellom hver plante i feltet for optimal vekst'
b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +152',"b'Batched Item {0} cannot be updated using Stock Reconciliation, instead use Stock Entry'","b'Batched Item {0} kan ikke oppdateres ved hjelp av Stock Forsoning, bruk i stedet Lagerinngang'"
b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +152',"b'Batched Item {0} cannot be updated using Stock Reconciliation, instead use Stock Entry'","b'Batched Item {0} kan ikke oppdateres ved hjelp av Stock Forsoning, bruk i stedet Lagerinngang'"
b'DocType: Quality Inspection',b'Report Date',b'Rapporter Date'
b'DocType: Student',b'Middle Name',b'Mellomnavn'
b'DocType: C-Form',b'Invoices',b'Fakturaer'
b'DocType: Water Analysis',b'Type of Sample',b'Type pr\xc3\xb8ve'
b'DocType: Batch',b'Source Document Name',b'Kilde dokumentnavn'
b'DocType: Batch',b'Source Document Name',b'Kilde dokumentnavn'
b'DocType: Production Plan',b'Get Raw Materials For Production',b'F\xc3\xa5 r\xc3\xa5materialer til produksjon'
b'DocType: Job Opening',b'Job Title',b'Jobbtittel'
b'apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py +84',"b'{0} indicates that {1} will not provide a quotation, but all items \\\n\t\t\t\t\thave been quoted. Updating the RFQ quote status.'","b'{0} indikerer at {1} ikke vil gi et tilbud, men alle elementer \\ er blitt sitert. Oppdaterer RFQ sitatstatus.'"
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1026',b'Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.',b'Maksimale pr\xc3\xb8ver - {0} har allerede blitt beholdt for Batch {1} og Item {2} i Batch {3}.'
b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +125',b'Please Set Supplier Type in Buying Settings.',b'Vennligst sett Leverand\xc3\xb8r Type i Kj\xc3\xb8psinnstillinger.'
b'DocType: Manufacturing Settings',b'Update BOM Cost Automatically',b'Oppdater BOM Kostnad automatisk'
b'DocType: Lab Test',b'Test Name',b'Testnavn'
b'apps/erpnext/erpnext/utilities/activation.py +99',b'Create Users',b'Lag brukere'
b'apps/erpnext/erpnext/utilities/user_progress.py +147',b'Gram',b'Gram'
b'DocType: Supplier Scorecard',b'Per Month',b'Per m\xc3\xa5ned'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +433',b'Quantity to Manufacture must be greater than 0.',b'Antall \xc3\xa5 Manufacture m\xc3\xa5 v\xc3\xa6re st\xc3\xb8rre enn 0.'
b'DocType: Asset Settings',b'Calculate Prorated Depreciation Schedule Based on Fiscal Year',b'Beregn Prorated Depreciation Schedule Basert p\xc3\xa5 Skatte\xc3\xa5r'
b'apps/erpnext/erpnext/config/maintenance.py +17',b'Visit report for maintenance call.',b'Bes\xc3\xb8k rapport for vedlikehold samtale.'
b'DocType: Stock Entry',b'Update Rate and Availability',b'Oppdateringsfrekvens og tilgjengelighet'
b'DocType: Stock Settings',b'Percentage you are allowed to receive or deliver more against the quantity ordered. For example: If you have ordered 100 units. and your Allowance is 10% then you are allowed to receive 110 units.',b'Prosentvis du har lov til \xc3\xa5 motta eller levere mer mot antall bestilte produkter. For eksempel: Hvis du har bestilt 100 enheter. og din Fradrag er 10% s\xc3\xa5 du har lov til \xc3\xa5 motta 110 enheter.'
b'DocType: POS Customer Group',b'Customer Group',b'Kundegruppe'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +217',b'Row #{0}: Operation {1} is not completed for {2} qty of finished goods in Work Order # {3}. Please update operation status via Time Logs',b'Rute # {0}: Drift {1} er ikke fullf\xc3\xb8rt for {2} Antall ferdige varer i Arbeidsordre # {3}. Oppdater operasjonsstatus via Time Logs'
b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +128',b'New Batch ID (Optional)',b'Ny batch-ID (valgfritt)'
b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +128',b'New Batch ID (Optional)',b'Ny batch-ID (valgfritt)'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +201',b'Expense account is mandatory for item {0}',b'Utgiftskonto er obligatorisk for elementet {0}'
b'DocType: BOM',b'Website Description',b'Website Beskrivelse'
b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +47',b'Net Change in Equity',b'Netto endring i egenkapital'
b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +220',b'Please cancel Purchase Invoice {0} first',b'Vennligst avbryte fakturaen {0} f\xc3\xb8rst'
b'apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py +43',"b'Email Address must be unique, already exists for {0}'","b'E-post adresse m\xc3\xa5 v\xc3\xa6re unikt, allerede eksisterer for {0}'"
b'DocType: Serial No',b'AMC Expiry Date',b'AMC Utl\xc3\xb8psdato'
b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +880',b'Receipt',b'Kvittering'
,b'Sales Register',b'Salg Register'
b'DocType: Daily Work Summary Group',b'Send Emails At',b'Send e-post til'
b'DocType: Quotation',b'Quotation Lost Reason',b'Sitat av Lost Reason'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +381',b'Transaction reference no {0} dated {1}',b'Transaksjonsreferanse ikke {0} datert {1}'
b'apps/erpnext/erpnext/setup/doctype/supplier_type/supplier_type.js +5',b'There is nothing to edit.',b'Det er ingenting \xc3\xa5 redigere.'
b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +116',b'Summary for this month and pending activities',b'Oppsummering for denne m\xc3\xa5neden og ventende aktiviteter'
b'apps/erpnext/erpnext/utilities/user_progress.py +248',"b'Add users to your organization, other than yourself.'","b'Legg til brukere i organisasjonen din, bortsett fra deg selv.'"
b'DocType: Customer Group',b'Customer Group Name',b'Kundegruppenavn'
b'apps/erpnext/erpnext/public/js/pos/pos.html +109',b'No Customers yet!',b'Ingen kunder enn\xc3\xa5!'
b'apps/erpnext/erpnext/public/js/financial_statements.js +56',b'Cash Flow Statement',b'Kontantstr\xc3\xb8moppstilling'
b'apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py +473',b'No material request created',b'Ingen materiell foresp\xc3\xb8rsel opprettet'
b'apps/erpnext/erpnext/hr/doctype/employee_loan_application/employee_loan_application.py +23',b'Loan Amount cannot exceed Maximum Loan Amount of {0}',b'L\xc3\xa5nebel\xc3\xb8p kan ikke overstige maksimalt l\xc3\xa5nebel\xc3\xb8p p\xc3\xa5 {0}'
b'apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py +22',b'License',b'Tillatelse'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +491',b'Please remove this Invoice {0} from C-Form {1}',b'Vennligst fjern denne Faktura {0} fra C-Form {1}'
b'DocType: Leave Control Panel',"b""Please select Carry Forward if you also want to include previous fiscal year's balance leaves to this fiscal year""",b'Vennligst velg b\xc3\xa6re frem hvis du ogs\xc3\xa5 vil ha med forrige regnskaps\xc3\xa5r balanse later til dette regnskaps\xc3\xa5ret'
b'DocType: GL Entry',b'Against Voucher Type',b'Mot Voucher Type'
b'DocType: Physician',b'Phone (R)',b'Telefon (R)'
b'apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +56',b'Time slots added',b'Tidsluker lagt til'
b'DocType: Item',b'Attributes',b'Egenskaper'
b'apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +31',b'Enable Template',b'Aktiver mal'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +226',b'Please enter Write Off Account',b'Skriv inn avskrive konto'
b'apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +71',b'Last Order Date',b'Siste Order Date'
b'DocType: Patient',b'B Negative',b'B Negativ'
b'apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +25',b'Maintenance Status has to be Cancelled or Completed to Submit',b'Vedlikeholdsstatus m\xc3\xa5 avbrytes eller fullf\xc3\xb8res for \xc3\xa5 sende inn'
b'DocType: Hotel Room',b'Hotel Room',b'Hotellrom'
b'apps/erpnext/erpnext/accounts/doctype/budget/budget.py +47',b'Account {0} does not belongs to company {1}',b'Konto {0} ikke tilh\xc3\xb8rer selskapet {1}'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +884',b'Serial Numbers in row {0} does not match with Delivery Note',b'Serienumre i rad {0} stemmer ikke overens med leveringsnotat'
b'DocType: Student',b'Guardian Details',b'Guardian Detaljer'
b'DocType: C-Form',b'C-Form',b'C-Form'
b'apps/erpnext/erpnext/config/hr.py +18',b'Mark Attendance for multiple employees',b'Mark Oppm\xc3\xb8te for flere ansatte'
b'DocType: Agriculture Task',b'Start Day',b'Start dag'
b'DocType: Vehicle',b'Chassis No',b'chassis Nei'
b'DocType: Payment Request',b'Initiated',b'Initiert'
b'DocType: Production Plan Item',b'Planned Start Date',b'Planlagt startdato'
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +618',b'Please select a BOM',b'Vennligst velg en BOM'
b'DocType: Purchase Invoice',b'Availed ITC Integrated Tax',b'Benyttet ITC Integrated Tax'
b'DocType: Serial No',b'Creation Document Type',b'Creation dokumenttype'
b'DocType: Project Task',b'View Timesheet',b'Se tidsskema'
b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +54',b'End date must be greater than start date',b'Sluttdato m\xc3\xa5 v\xc3\xa6re st\xc3\xb8rre enn startdato'
b'DocType: Leave Type',b'Is Encash',b'Er encash'
b'DocType: Leave Allocation',b'New Leaves Allocated',b'Nye Leaves Avsatt'
b'apps/erpnext/erpnext/controllers/trends.py +269',b'Project-wise data is not available for Quotation',b'Prosjekt-messig data er ikke tilgjengelig for prisanslag'
b'apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +30',b'End on',b'Slutt p\xc3\xa5'
b'DocType: Project',b'Expected End Date',b'Forventet sluttdato'
b'DocType: Budget Account',b'Budget Amount',b'budsjett~~POS=TRUNC'
b'DocType: Donor',b'Donor Name',b'Donornavn'
b'DocType: Appraisal Template',b'Appraisal Template Title',b'Appraisal Mal Tittel'
b'apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +39',"b""From Date {0} for Employee {1} cannot be before employee's joining Date {2}""",b'Fra Dato {0} for Employee {1} kan ikke v\xc3\xa6re f\xc3\xb8r arbeidstakers begynte Dato {2}'
b'apps/erpnext/erpnext/utilities/user_progress_utils.py +29',b'Commercial',b'Commercial'
b'DocType: Patient',b'Alcohol Current Use',b'Alkoholstr\xc3\xb8mbruk'
b'DocType: Student Admission Program',b'Student Admission Program',b'Studentopptaksprogram'
b'DocType: Payment Entry',b'Account Paid To',b'Konto Betalt for \xc3\xa5'
b'apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.py +24',b'Parent Item {0} must not be a Stock Item',b'Parent Element {0} m\xc3\xa5 ikke v\xc3\xa6re en lagervare'
b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +466',b'Could not submit any Salary Slip <br>\\\n\t\t\tPossible reasons: <br>\\\n\t\t\t1. Net pay is less than 0. <br>\\\n\t\t\t2. Company Email Address specified in employee master is not valid. <br>',"b'Kunne ikke sende inn L\xc3\xb8nnsslipp <br> \\ Mulige \xc3\xa5rsaker: <br> \\ 1. Netto l\xc3\xb8nn er mindre enn 0. <br> \\ 2. Firmaets e-postadresse som er oppgitt i ansattmesteren, er ikke gyldig. <br>'"
b'apps/erpnext/erpnext/config/selling.py +57',b'All Products or Services.',b'Alle produkter eller tjenester.'
b'DocType: Expense Claim',b'More Details',b'Mer informasjon'
b'DocType: Supplier Quotation',b'Supplier Address',b'Leverand\xc3\xb8r Adresse'
b'apps/erpnext/erpnext/accounts/doctype/budget/budget.py +128',b'{0} Budget for Account {1} against {2} {3} is {4}. It will exceed by {5}',b'{0} budsjettet for kontoen {1} mot {2} {3} er {4}. Det vil overstige ved {5}'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +695',"b""Row {0}# Account must be of type 'Fixed Asset'""",b'Rad {0} # konto m\xc3\xa5 v\xc3\xa6re av typen &quot;Fixed Asset &#39;'
b'apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37',b'Out Qty',b'Ut Antall'
b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +6',b'and unchcked Disabled in the',b'og unchcked Disabled in the'
b'apps/erpnext/erpnext/buying/doctype/supplier/supplier.py +41',b'Series is mandatory',b'Serien er obligatorisk'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +28',b'Financial Services',b'Finansielle Tjenester'
b'DocType: Student Sibling',b'Student ID',b'Student ID'
b'apps/erpnext/erpnext/config/projects.py +51',b'Types of activities for Time Logs',b'Typer aktiviteter for Tid Logger'
b'DocType: Opening Invoice Creation Tool',b'Sales',b'Salgs'
b'DocType: Stock Entry Detail',b'Basic Amount',b'Grunnbel\xc3\xb8p'
b'DocType: Training Event',b'Exam',b'Eksamen'
b'DocType: Complaint',b'Complaint',b'Klage'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +462',b'Warehouse required for stock Item {0}',b'Warehouse n\xc3\xb8dvendig for lager Element {0}'
b'DocType: Leave Allocation',b'Unused leaves',b'Ubrukte blader'
b'DocType: Patient',b'Alcohol Past Use',b'Alkohol Tidligere Bruk'
b'DocType: Fertilizer Content',b'Fertilizer Content',b'Gj\xc3\xb8dselinnhold'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +187',b'Cr',b'Cr'
b'DocType: Project Update',b'Problematic/Stuck',b'Problematisk / Stuck'
b'DocType: Tax Rule',b'Billing State',b'Billing State'
b'DocType: Share Transfer',b'Transfer',b'Transfer'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +252',b'Work Order {0} must be cancelled before cancelling this Sales Order',b'Arbeidsordre {0} m\xc3\xa5 avbestilles f\xc3\xb8r du kansellerer denne salgsordren'
b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +917',b'Fetch exploded BOM (including sub-assemblies)',b'Hente eksploderte BOM (inkludert underenheter)'
b'DocType: Authorization Rule',b'Applicable To (Employee)',b'Gjelder til (Employee)'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +137',b'Due Date is mandatory',b'Due Date er obligatorisk'
b'apps/erpnext/erpnext/controllers/item_variant.py +82',b'Increment for Attribute {0} cannot be 0',b'\xc3\x98kning for Egenskap {0} kan ikke v\xc3\xa6re 0'
b'apps/erpnext/erpnext/hotels/report/hotel_room_occupancy/hotel_room_occupancy.py +19',b'Rooms Booked',b'Rom bestilles'
b'apps/erpnext/erpnext/crm/doctype/lead/lead.py +57',b'Ends On date cannot be before Next Contact Date.',b'Slutter p\xc3\xa5 dato kan ikke v\xc3\xa6re f\xc3\xb8r neste kontakt dato.'
b'DocType: Journal Entry',b'Pay To / Recd From',b'Betal Til / recd From'
b'DocType: Naming Series',b'Setup Series',b'Oppsett Series'
b'DocType: Payment Reconciliation',b'To Invoice Date',b'\xc3\x85 Fakturadato'
b'DocType: Shareholder',b'Contact HTML',b'Kontakt HTML'
b'apps/erpnext/erpnext/healthcare/doctype/healthcare_settings/healthcare_settings.py +19',b'Registration fee can not be Zero',b'Registreringsavgift kan ikke v\xc3\xa6re null'
b'DocType: Disease',b'Treatment Period',b'Behandlingsperiode'
b'apps/erpnext/erpnext/education/api.py +338',b'Result already Submitted',b'Resultat allerede sendt'
b'apps/erpnext/erpnext/controllers/buying_controller.py +169',b'Reserved Warehouse is mandatory for Item {0} in Raw Materials supplied',b'Reservert lager er obligatorisk for vare {0} i r\xc3\xa5varer som leveres'
,b'Inactive Customers',b'inaktive kunder'
b'DocType: Student Admission Program',b'Maximum Age',b'Maksimal alder'
b'apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +28',b'Please wait 3 days before resending the reminder.',b'Vennligst vent 3 dager f\xc3\xb8r du sender p\xc3\xa5minnelsen p\xc3\xa5 nytt.'
b'DocType: Landed Cost Voucher',b'LCV',b'LCV'
b'DocType: Landed Cost Voucher',b'Purchase Receipts',b'Kj\xc3\xb8ps Kvitteringer'
b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +29',b'How Pricing Rule is applied?',b'Hvordan Pricing Rule er brukt?'
b'DocType: Stock Entry',b'Delivery Note No',b'Levering Note Nei'
b'DocType: Cheque Print Template',b'Message to show',b'Melding for visning'
b'apps/erpnext/erpnext/public/js/setup_wizard.js +28',b'Retail',b'Retail'
b'DocType: Student Attendance',b'Absent',b'Frav\xc3\xa6rende'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +591',b'Product Bundle',b'Produktet Bundle'
b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +38',b'Unable to find score starting at {0}. You need to have standing scores covering 0 to 100',b'Kan ikke finne poeng som starter ved {0}. Du m\xc3\xa5 ha st\xc3\xa5ende poeng som dekker 0 til 100'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +212',b'Row {0}: Invalid reference {1}',b'Rad {0}: Ugyldig referanse {1}'
b'DocType: Purchase Taxes and Charges Template',b'Purchase Taxes and Charges Template',b'Kj\xc3\xb8pe skatter og avgifter Mal'
b'DocType: Timesheet',b'TS-',b'TS-'
b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +61',b'{0} {1}: Either debit or credit amount is required for {2}',b'{0} {1}: Enten debet- eller kredittbel\xc3\xb8pet er n\xc3\xb8dvendig for {2}'
b'DocType: GL Entry',b'Remarks',b'Bemerkninger'
b'DocType: Hotel Room Amenity',b'Hotel Room Amenity',b'Hotel Romfasiliteter'
b'DocType: Payment Entry',b'Account Paid From',b'Konto betalt fra'
b'DocType: Purchase Order Item Supplied',b'Raw Material Item Code',b'Raw Material Elementkode'
b'DocType: Task',b'Parent Task',b'Foreldreoppgave'
b'DocType: Journal Entry',b'Write Off Based On',b'Skriv Off basert p\xc3\xa5'
b'apps/erpnext/erpnext/utilities/activation.py +65',b'Make Lead',b'Gj\xc3\xb8r Lead'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +112',b'Print and Stationery',b'Skriv ut og Saker'
b'DocType: Stock Settings',b'Show Barcode Field',b'Vis strekkodefelt'
b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +809',b'Send Supplier Emails',b'Send Leverand\xc3\xb8r e-post'
b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +96',"b'Salary already processed for period between {0} and {1}, Leave application period cannot be between this date range.'","b'L\xc3\xb8nn allerede behandlet for perioden mellom {0} og {1}, La s\xc3\xb8knadsperioden kan ikke v\xc3\xa6re mellom denne datoperioden.'"
b'DocType: Chapter Member',b'Leave Reason',b'Legg igjen grunn'
b'DocType: Guardian Interest',b'Guardian Interest',b'Guardian Rente'
b'DocType: Volunteer',b'Availability',b'Tilgjengelighet'
b'apps/erpnext/erpnext/config/accounts.py +319',b'Setup default values for POS Invoices',b'Oppsett standardverdier for POS-fakturaer'
b'apps/erpnext/erpnext/config/hr.py +182',b'Training',b'Oppl\xc3\xa6ring'
b'DocType: Project',b'Time to send',b'Tid til \xc3\xa5 sende'
b'DocType: Timesheet',b'Employee Detail',b'Medarbeider Detalj'
b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +58',b'Guardian1 Email ID',b'Guardian1 Email ID'
b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +58',b'Guardian1 Email ID',b'Guardian1 Email ID'
b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +68',"b""Next Date's day and Repeat on Day of Month must be equal""",b'Neste Date dag og gjenta p\xc3\xa5 dag i m\xc3\xa5neden m\xc3\xa5 v\xc3\xa6re lik'
b'DocType: Lab Prescription',b'Test Code',b'Testkode'
b'apps/erpnext/erpnext/config/website.py +11',b'Settings for website homepage',b'Innstillinger for nettstedet hjemmeside'
b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +40',b'RFQs are not allowed for {0} due to a scorecard standing of {1}',b'RFQ er ikke tillatt for {0} p\xc3\xa5 grunn av et resultatkort som st\xc3\xa5r for {1}'
b'DocType: Job Offer',b'Awaiting Response',b'Venter p\xc3\xa5 svar'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +60',b'Above',b'Fremfor'
b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1466',b'Total Amount {0}',b'Totalt bel\xc3\xb8p {0}'
b'apps/erpnext/erpnext/controllers/item_variant.py +306',b'Invalid attribute {0} {1}',b'Ugyldig egenskap {0} {1}'
b'DocType: Supplier',b'Mention if non-standard payable account',b'Nevn hvis ikke-standard betalingskonto'
b'apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.py +25',"b""Please select the assessment group other than 'All Assessment Groups'""",b'Vennligst velg vurderingsgruppen annet enn &#39;Alle vurderingsgrupper&#39;'
b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +67',b'Row {0}: Cost center is required for an item {1}',b'Row {0}: Kostnadsstedet kreves for et element {1}'
b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +43',b'EcritureDate',b'EcritureDate'
b'DocType: Training Event Employee',b'Optional',b'Valgfri'
b'DocType: Salary Slip',b'Earning & Deduction',b'Tjene &amp; Fradrag'
b'DocType: Agriculture Analysis Criteria',b'Water Analysis',b'Vannanalyse'
b'DocType: Chapter',b'Region',b'Region'
b'apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +38',b'Optional. This setting will be used to filter in various transactions.',b'Valgfritt. Denne innstillingen vil bli brukt for \xc3\xa5 filtrere i forskjellige transaksjoner.'
b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +110',b'Negative Valuation Rate is not allowed',b'Negative Verdivurdering Rate er ikke tillatt'
b'DocType: Holiday List',b'Weekly Off',b'Ukentlig Off'
b'apps/erpnext/erpnext/agriculture/doctype/crop_cycle/crop_cycle.js +7',b'Reload Linked Analysis',b'Last inn sammenkoblet analyse'
b'DocType: Fiscal Year',"b'For e.g. 2012, 2012-13'","b'For eksempel 2012, 2012-13'"
b'apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +96',b'Provisional Profit / Loss (Credit)',b'Forel\xc3\xb8pig Profit / Loss (Credit)'
b'DocType: Sales Invoice',b'Return Against Sales Invoice',b'Tilbake Mot Salg Faktura'
b'apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +32',b'Item 5',b'Sak 5'
b'DocType: Serial No',b'Creation Time',b'Creation Tid'
b'apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +62',b'Total Revenue',b'Totale Inntekter'
b'DocType: Patient',b'Other Risk Factors',b'Andre risikofaktorer'
b'DocType: Sales Invoice',b'Product Bundle Help',b'Produktet Bundle Hjelp'
,b'Monthly Attendance Sheet',b'M\xc3\xa5nedlig Oppm\xc3\xb8te Sheet'
b'apps/erpnext/erpnext/hr/report/employee_advance_summary/employee_advance_summary.py +15',b'No record found',b'Ingen rekord funnet'
b'apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +140',b'Cost of Scrapped Asset',b'Kostnad for kasserte Asset'
b'apps/erpnext/erpnext/controllers/stock_controller.py +236',b'{0} {1}: Cost Center is mandatory for Item {2}',b'{0} {1}: Kostnadssted er obligatorisk for Element {2}'
b'DocType: Vehicle',b'Policy No',b'Regler Nei'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +686',b'Get Items from Product Bundle',b'F\xc3\xa5 Elementer fra Produkt Bundle'
b'DocType: Asset',b'Straight Line',b'Rett linje'
b'DocType: Project User',b'Project User',b'prosjekt Bruker'
b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +72',b'Split',b'Dele'
b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +72',b'Split',b'Dele'
b'DocType: GL Entry',b'Is Advance',b'Er Advance'
b'apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +21',b'Attendance From Date and Attendance To Date is mandatory',b'Oppm\xc3\xb8te Fra Dato og oppm\xc3\xb8te To Date er obligatorisk'
b'apps/erpnext/erpnext/controllers/buying_controller.py +156',"b""Please enter 'Is Subcontracted' as Yes or No""",b'Skriv inn &#39;Er underleverand\xc3\xb8r&#39; som Ja eller Nei'
b'DocType: Item',b'Default Purchase Unit of Measure',b'Standard innkj\xc3\xb8psenhet for m\xc3\xa5l'
b'apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +29',b'Last Communication Date',b'Siste kommunikasjonsdato'
b'apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +29',b'Last Communication Date',b'Siste kommunikasjonsdato'
b'DocType: Sales Team',b'Contact No.',b'Kontaktnummer.'
b'DocType: Bank Reconciliation',b'Payment Entries',b'Betalings Entries'
b'DocType: Land Unit',b'Land Unit Details',b'Land Enhet Detaljer'
b'DocType: Land Unit',b'Latitude',b'Breddegrad'
b'DocType: Work Order',b'Scrap Warehouse',b'skrap Warehouse'
b'DocType: Work Order',b'Check if material transfer entry is not required',b'Sjekk om materialoverf\xc3\xb8ring ikke er n\xc3\xb8dvendig'
b'DocType: Work Order',b'Check if material transfer entry is not required',b'Sjekk om materialoverf\xc3\xb8ring ikke er n\xc3\xb8dvendig'
b'DocType: Program Enrollment Tool',b'Get Students From',b'F\xc3\xa5 studenter fra'
b'apps/erpnext/erpnext/config/learn.py +263',b'Publish Items on Website',b'Publiser Elementer p\xc3\xa5 nettstedet'
b'apps/erpnext/erpnext/utilities/activation.py +126',b'Group your students in batches',b'Gruppe elevene i grupper'
b'DocType: Authorization Rule',b'Authorization Rule',b'Autorisasjon Rule'
b'DocType: POS Profile',b'Offline POS Section',b'Frakoblet POS-seksjon'
b'DocType: Sales Invoice',b'Terms and Conditions Details',b'Vilk\xc3\xa5r og betingelser Detaljer'
b'apps/erpnext/erpnext/templates/generators/item.html +100',b'Specifications',b'Spesifikasjoner'
b'DocType: Sales Taxes and Charges Template',b'Sales Taxes and Charges Template',b'Salgs skatter og avgifter Mal'
b'apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +68',b'Total (Credit)',b'Total (Credit)'
b'DocType: Repayment Schedule',b'Payment Date',b'Betalingsdato'
b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +122',b'New Batch Qty',b'Ny batch Antall'
b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +122',b'New Batch Qty',b'Ny batch Antall'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +10',b'Apparel & Accessories',b'Kl\xc3\xa6r og tilbeh\xc3\xb8r'
b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard_period/supplier_scorecard_period.py +91',b'Could not solve weighted score function. Make sure the formula is valid.',b'Kunne ikke l\xc3\xb8se vektet poengsumfunksjon. Pass p\xc3\xa5 at formelen er gyldig.'
b'apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +67',b'Number of Order',b'Antall Bestill'
b'DocType: Item Group',b'HTML / Banner that will show on the top of product list.',b'HTML / Banner som vil vises p\xc3\xa5 toppen av listen over produkter.'
b'DocType: Shipping Rule',b'Specify conditions to calculate shipping amount',b'Spesifiser forhold til \xc3\xa5 beregne frakt bel\xc3\xb8p'
b'DocType: Program Enrollment',"b""Institute's Bus""",b'Instituttets buss'
b'DocType: Accounts Settings',b'Role Allowed to Set Frozen Accounts & Edit Frozen Entries',b'Rolle lov til \xc3\xa5 sette Frosne Kontoer og Rediger Frosne Entries'
b'DocType: Supplier Scorecard Scoring Variable',b'Path',b'Sti'
b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +28',b'Cannot convert Cost Center to ledger as it has child nodes',b'Kan ikke konvertere kostnadssted til hovedbok som den har barnet noder'
b'DocType: Production Plan',b'Total Planned Qty',b'Totalt planlagt antall'
b'apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +68',b'Opening Value',b'\xc3\xa5pning Verdi'
b'DocType: Salary Detail',b'Formula',b'Formel'
b'apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +47',b'Serial #',b'Serial #'
b'DocType: Lab Test Template',b'Lab Test Template',b'Lab Test Template'
b'apps/erpnext/erpnext/setup/doctype/company/company.py +181',b'Sales Account',b'Salgskonto'
b'DocType: Purchase Invoice Item',b'Total Weight',b'Total vekt'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +94',b'Commission on Sales',b'Provisjon p\xc3\xa5 salg'
b'DocType: Job Offer Term',b'Value / Description',b'Verdi / beskrivelse'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +630',"b'Row #{0}: Asset {1} cannot be submitted, it is already {2}'","b'Row # {0}: Asset {1} kan ikke sendes inn, er det allerede {2}'"
b'DocType: Tax Rule',b'Billing Country',b'Fakturering Land'
b'DocType: Purchase Order Item',b'Expected Delivery Date',b'Forventet Leveringsdato'
b'DocType: Restaurant Order Entry',b'Restaurant Order Entry',b'Restaurant Bestillingsinngang'
b'apps/erpnext/erpnext/accounts/general_ledger.py +134',b'Debit and Credit not equal for {0} #{1}. Difference is {2}.',b'Debet- og kredittkort ikke lik for {0} # {1}. Forskjellen er {2}.'
b'DocType: Asset Maintenance Task',b'Assign To Name',b'Tilordne til navn'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +98',b'Entertainment Expenses',b'Underholdning Utgifter'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +98',b'Make Material Request',b'Gj\xc3\xb8r Material Request'
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html +20',b'Open Item {0}',b'\xc3\x85pen Element {0}'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +222',b'Sales Invoice {0} must be cancelled before cancelling this Sales Order',b'Salg Faktura {0} m\xc3\xa5 slettes f\xc3\xb8r den sletter denne salgsordre'
b'DocType: Consultation',b'Age',b'Alder'
b'DocType: Sales Invoice Timesheet',b'Billing Amount',b'Faktureringsbel\xc3\xb8p'
b'DocType: Cash Flow Mapping',b'Select Maximum Of 1',b'Velg Maksimum 1'
b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +84',b'Invalid quantity specified for item {0}. Quantity should be greater than 0.',b'Ugyldig kvantum spesifisert for elementet {0}. Antall m\xc3\xa5 v\xc3\xa6re st\xc3\xb8rre enn 0.'
b'DocType: Company',b'Default Employee Advance Account',b'Standard ansattskonto'
b'apps/erpnext/erpnext/config/hr.py +60',b'Applications for leave.',b'S\xc3\xb8knader om permisjon.'
b'apps/erpnext/erpnext/accounts/doctype/account/account.py +164',b'Account with existing transaction can not be deleted',b'Konto med eksisterende transaksjon kan ikke slettes'
b'DocType: Vehicle',b'Last Carbon Check',b'Siste Carbon Sjekk'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +102',b'Legal Expenses',b'Rettshjelp'
b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +140',b'Please select quantity on row ',b'Vennligst velg antall p\xc3\xa5 rad'
b'apps/erpnext/erpnext/config/accounts.py +277',b'Make Opening Sales and Purchase Invoices',b'Lag \xc3\xa5pne salgs- og kj\xc3\xb8psfakturaer'
b'DocType: Purchase Invoice',b'Posting Time',b'Postering Tid'
b'DocType: Timesheet',b'% Amount Billed',b'% Mengde Fakturert'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +118',b'Telephone Expenses',b'Telefon Utgifter'
b'DocType: Sales Partner',b'Logo',b'Logo'
b'DocType: Naming Series',b'Check this if you want to force the user to select a series before saving. There will be no default if you check this.',b'Sjekk dette hvis du vil tvinge brukeren til \xc3\xa5 velge en serie f\xc3\xb8r du lagrer. Det blir ingen standard hvis du sjekke dette.'
b'apps/erpnext/erpnext/stock/get_item_details.py +131',b'No Item with Serial No {0}',b'Ingen Element med Serial No {0}'
b'DocType: Email Digest',b'Open Notifications',b'\xc3\x85pne P\xc3\xa5minnelser'
b'DocType: Payment Entry',b'Difference Amount (Company Currency)',b'Forskjell Bel\xc3\xb8p (Selskap Valuta)'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +79',b'Direct Expenses',b'Direkte kostnader'
b'apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +60',b'New Customer Revenue',b'Ny kunde Revenue'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +119',b'Travel Expenses',b'Reiseutgifter'
b'DocType: Maintenance Visit',b'Breakdown',b'Sammenbrudd'
b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +50',b'Add custom field Subscription in the doctype {0}',b'Legg til egendefinert felt Abonnement i doktypen {0}'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +820',b'Account: {0} with currency: {1} can not be selected',b'Konto: {0} med valuta: {1} kan ikke velges'
b'DocType: Purchase Receipt Item',b'Sample Quantity',b'Pr\xc3\xb8vekvantitet'
b'DocType: Manufacturing Settings',"b'Update BOM cost automatically via Scheduler, based on latest valuation rate / price list rate / last purchase rate of raw materials.'","b'Oppdater BOM kostnad automatisk via Scheduler, basert p\xc3\xa5 siste verdivurdering / prisliste rate / siste kj\xc3\xb8pshastighet av r\xc3\xa5varer.'"
b'DocType: Bank Reconciliation Detail',b'Cheque Date',b'Sjekk Dato'
b'apps/erpnext/erpnext/accounts/doctype/account/account.py +50',b'Account {0}: Parent account {1} does not belong to company: {2}',b'Konto {0}: Parent konto {1} ikke tilh\xc3\xb8rer selskapet: {2}'
b'apps/erpnext/erpnext/setup/doctype/company/company.js +106',b'Successfully deleted all transactions related to this company!',b'Slettet alle transaksjoner knyttet til dette selskapet!'
b'apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +27',b'As on Date',b'Som p\xc3\xa5 dato'
b'DocType: Appraisal',b'HR',b'HR'
b'DocType: Program Enrollment',b'Enrollment Date',b'p\xc3\xa5melding Dato'
b'DocType: Healthcare Settings',b'Out Patient SMS Alerts',b'Ut Patient SMS Alerts'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +100',b'Probation',b'Pr\xc3\xb8vetid'
b'apps/erpnext/erpnext/config/hr.py +115',b'Salary Components',b'l\xc3\xb8nn Components'
b'DocType: Program Enrollment Tool',b'New Academic Year',b'Nytt studie\xc3\xa5r'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +811',b'Return / Credit Note',b'Retur / kreditnota'
b'DocType: Stock Settings',b'Auto insert Price List rate if missing',b'Auto innsats Prisliste rente hvis mangler'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +117',b'Total Paid Amount',b'Totalt innbetalt bel\xc3\xb8p'
b'DocType: GST Settings',b'B2C Limit',b'B2C Limit'
b'DocType: Work Order Item',b'Transferred Qty',b'Overf\xc3\xb8rt Antall'
b'apps/erpnext/erpnext/config/learn.py +11',b'Navigating',b'Navigere'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +188',b'Planning',b'Planlegging'
b'DocType: Share Balance',b'Issued',b'Utstedt'
b'apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +14',b'Student Activity',b'Studentaktivitet'
b'apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +80',b'Supplier Id',b'Leverand\xc3\xb8r Id'
b'DocType: Payment Request',b'Payment Gateway Details',b'Betaling Gateway Detaljer'
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +276',b'Quantity should be greater than 0',b'Mengden skal v\xc3\xa6re st\xc3\xb8rre enn 0'
b'DocType: Journal Entry',b'Cash Entry',b'Cash Entry'
b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js +17',"b""Child nodes can be only created under 'Group' type nodes""",b'Ordnede noder kan bare opprettes under &#39;Gruppe&#39; type noder'
b'DocType: Leave Application',b'Half Day Date',b'Half Day Date'
b'DocType: Academic Year',b'Academic Year Name',b'Akademisk \xc3\x85r Navn'
b'DocType: Sales Partner',b'Contact Desc',b'Kontakt Desc'
b'apps/erpnext/erpnext/config/hr.py +65',"b'Type of leaves like casual, sick etc.'","b'Type blader som casual, syke etc.'"
b'DocType: Email Digest',b'Send regular summary reports via Email.',b'Send vanlige oppsummeringsrapporter via e-post.'
b'DocType: Payment Entry',b'PE-',b'PE'
b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +282',b'Please set default account in Expense Claim Type {0}',b'Vennligst angi standardkonto i Expense krav Type {0}'
b'DocType: Assessment Result',b'Student Name',b'Student navn'
b'DocType: Brand',b'Item Manager',b'Sak manager'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +143',b'Payroll Payable',b'l\xc3\xb8nn Betales'
b'DocType: Buying Settings',b'Default Supplier Type',b'Standard Leverand\xc3\xb8r Type'
b'DocType: Plant Analysis',b'Collection Datetime',b'Samling Datetime'
b'DocType: Work Order',b'Total Operating Cost',b'Total driftskostnader'
b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +171',b'Note: Item {0} entered multiple times',b'Merk: Element {0} inng\xc3\xa5tt flere ganger'
b'apps/erpnext/erpnext/config/selling.py +41',b'All Contacts.',b'Alle kontakter.'
b'apps/erpnext/erpnext/public/js/setup_wizard.js +71',b'Company Abbreviation',b'Firma Forkortelse'
b'apps/erpnext/erpnext/healthcare/doctype/physician/physician.py +47',b'User {0} does not exist',b'Bruker {0} finnes ikke'
b'DocType: Payment Term',b'Day(s) after invoice date',b'Dag (er) etter faktura dato'
b'DocType: Payment Schedule',b'Payment Schedule',b'Nedbetalingsplan'
b'DocType: Subscription',b'SUB-',b'UNDER-'
b'DocType: Item Attribute Value',b'Abbreviation',b'Forkortelse'
b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +195',b'Payment Entry already exists',b'Betaling Entry finnes allerede'
b'apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py +36',b'Not authroized since {0} exceeds limits',b'Ikke authroized siden {0} overskrider grensene'
b'apps/erpnext/erpnext/config/hr.py +110',b'Salary template master.',b'L\xc3\xb8nn mal mester.'
b'apps/erpnext/erpnext/healthcare/setup.py +241',b'Pathology',b'Patologi'
b'DocType: Restaurant Order Entry',b'Restaurant Table',b'Restaurantbord'
b'DocType: Hotel Room',b'Hotel Manager',b'Hotell sjef'
b'DocType: Leave Type',b'Max Days Leave Allowed',b'Max Dager La tillatt'
b'apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +63',b'Set Tax Rule for shopping cart',b'Still skatteregel for shopping cart'
b'DocType: Purchase Invoice',b'Taxes and Charges Added',b'Skatter og avgifter legges'
,b'Sales Funnel',b'Sales trakt'
b'apps/erpnext/erpnext/setup/doctype/company/company.py +49',b'Abbreviation is mandatory',b'Forkortelsen er obligatorisk'
b'DocType: Project',b'Task Progress',b'Task Progress'
b'apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html +7',b'Cart',b'Kurven'
,b'Qty to Transfer',b'Antall overf\xc3\xb8re'
b'apps/erpnext/erpnext/config/selling.py +13',b'Quotes to Leads or Customers.',b'Sitater for \xc3\xa5 Leads eller kunder.'
b'DocType: Stock Settings',b'Role Allowed to edit frozen stock',b'Rolle tillatt \xc3\xa5 redigere frossen lager'
,b'Territory Target Variance Item Group-Wise',b'Territorium Target Avviks varegruppe-Wise'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +143',b'All Customer Groups',b'Alle kundegrupper'
b'apps/erpnext/erpnext/accounts/doctype/budget/budget.py +114',b'Accumulated Monthly',b'akkumulert pr m\xc3\xa5ned'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +781',b'{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2}.',b'{0} er obligatorisk. Kanskje Valutaveksling posten ikke er skapt for {1} til {2}.'
b'apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +44',b'Tax Template is mandatory.',b'Skatt Mal er obligatorisk.'
b'apps/erpnext/erpnext/accounts/doctype/account/account.py +44',b'Account {0}: Parent account {1} does not exist',b'Konto {0}: Parent konto {1} finnes ikke'
b'DocType: Purchase Invoice Item',b'Price List Rate (Company Currency)',b'Prisliste Rate (Selskap Valuta)'
b'DocType: Products Settings',b'Products Settings',b'Produkter Innstillinger'
,b'Item Price Stock',b'Varen Pris Lager'
b'DocType: Lab Prescription',b'Test Created',b'Test laget'
b'DocType: Healthcare Settings',b'Custom Signature in Print',b'Tilpasset signatur i utskrift'
b'DocType: Account',b'Temporary',b'Midlertidig'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +107',b'Customer LPO No.',b'Kunde LPO nr.'
b'DocType: Program',b'Courses',b'kurs'
b'DocType: Monthly Distribution Percentage',b'Percentage Allocation',b'Prosentvis Allocation'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +128',b'Secretary',b'Sekret\xc3\xa6r'
b'DocType: Global Defaults',"b""If disable, 'In Words' field will not be visible in any transaction""","b'Hvis deaktivere, &#39;I Ord-feltet ikke vil v\xc3\xa6re synlig i enhver transaksjon'"
b'DocType: Serial No',b'Distinct unit of an Item',b'Distinkt enhet av et element'
b'DocType: Supplier Scorecard Criteria',b'Criteria Name',b'Kriterium Navn'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1295',b'Please set Company',b'Vennligst sett selskap'
b'DocType: Pricing Rule',b'Buying',b'Kj\xc3\xb8pe'
b'apps/erpnext/erpnext/config/agriculture.py +24',b'Diseases & Fertilizers',b'Sykdommer og gj\xc3\xb8dsel'
b'DocType: HR Settings',b'Employee Records to be created by',b'Medarbeider Records \xc3\xa5 v\xc3\xa6re skapt av'
b'DocType: Patient',b'AB Negative',b'AB Negativ'
b'DocType: Sample Collection',b'SMPL-',b'SMPL-'
b'DocType: POS Profile',b'Apply Discount On',b'P\xc3\xa5f\xc3\xb8r rabatt p\xc3\xa5'
b'DocType: Member',b'Membership Type',b'Medlemskapstype'
,b'Reqd By Date',b'Reqd etter dato'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +140',b'Creditors',b'Kreditorer'
b'DocType: Assessment Plan',b'Assessment Name',b'Assessment Name'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js +94',b'Show PDC in Print',b'Vis PDC i Print'
b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +97',b'Row # {0}: Serial No is mandatory',b'Row # {0}: Serial No er obligatorisk'
b'DocType: Purchase Taxes and Charges',b'Item Wise Tax Detail',b'Sak Wise Skatt Detalj'
b'apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.js +13',b'Job Offer',b'Jobbtilbud'
b'apps/erpnext/erpnext/public/js/setup_wizard.js +71',b'Institute Abbreviation',b'Institute forkortelse'
,b'Item-wise Price List Rate',b'Element-messig Prisliste Ranger'
b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1082',b'Supplier Quotation',b'Leverand\xc3\xb8r sitat'
b'DocType: Quotation',b'In Words will be visible once you save the Quotation.',b'I Ord vil v\xc3\xa6re synlig n\xc3\xa5r du lagrer Tilbud.'
b'apps/erpnext/erpnext/utilities/transaction_base.py +164',b'Quantity ({0}) cannot be a fraction in row {1}',b'Antall ({0}) kan ikke v\xc3\xa6re en br\xc3\xb8kdel i rad {1}'
b'apps/erpnext/erpnext/utilities/transaction_base.py +164',b'Quantity ({0}) cannot be a fraction in row {1}',b'Antall ({0}) kan ikke v\xc3\xa6re en br\xc3\xb8kdel i rad {1}'
b'DocType: Consultation',b'C-',b'C-'
b'DocType: Attendance',b'ATT-',b'ATT-'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +492',b'Barcode {0} already used in Item {1}',b'Barcode {0} allerede brukt i Element {1}'
b'apps/erpnext/erpnext/config/selling.py +86',b'Rules for adding shipping costs.',b'Regler for \xc3\xa5 legge til fraktkostnader.'
b'DocType: Hotel Room',b'Extra Bed Capacity',b'Ekstra seng kapasitet'
b'DocType: Item',b'Opening Stock',b'\xc3\xa5pning Stock'
b'apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +20',b'Customer is required',b'Kunden m\xc3\xa5'
b'DocType: Lab Test',b'Result Date',b'Resultatdato'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +77',b'PDC/LC Date',b'PDC / LC-dato'
b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +20',b'{0} is mandatory for Return',b'{0} er obligatorisk for Return'
b'DocType: Purchase Order',b'To Receive',b'\xc3\x85 Motta'
b'apps/erpnext/erpnext/utilities/user_progress.py +252',b'user@example.com',b'user@example.com'
b'DocType: Asset',b'Asset Owner',b'Asset Eier'
b'DocType: Employee',b'Personal Email',b'Personlig e-post'
b'apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +57',b'Total Variance',b'Total Variance'
b'DocType: Accounts Settings',"b'If enabled, the system will post accounting entries for inventory automatically.'","b'Hvis aktivert, vil systemet starte regnskapspostene for inventar automatisk.'"
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +15',b'Brokerage',b'Brokerage'
b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +195',b'Attendance for employee {0} is already marked for this day',b'Oppm\xc3\xb8te for arbeidstaker {0} er allerede markert for denne dagen'
b'DocType: Work Order Operation',"b""in Minutes\nUpdated via 'Time Log'""",b'Minutter Oppdatert via &#39;Time Logg&#39;'
b'DocType: Customer',b'From Lead',b'Fra Lead'
b'apps/erpnext/erpnext/config/manufacturing.py +13',b'Orders released for production.',b'Bestillinger frigitt for produksjon.'
b'apps/erpnext/erpnext/public/js/account_tree_grid.js +65',b'Select Fiscal Year...',b'Velg regnskaps\xc3\xa5r ...'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +567',b'POS Profile required to make POS Entry',b'POS Profile n\xc3\xb8dvendig \xc3\xa5 foreta POS Entry'
b'DocType: Program Enrollment Tool',b'Enroll Students',b'Meld Studenter'
b'DocType: Lab Test',b'Approved Date',b'Godkjent dato'
b'apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py +21',b'Standard Selling',b'Standard Selling'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +165',b'Atleast one warehouse is mandatory',b'Minst \xc3\xa9n lageret er obligatorisk'
b'DocType: Serial No',b'Out of Warranty',b'Ut av Garanti'
b'DocType: BOM Update Tool',b'Replace',b'Erstatt'
b'apps/erpnext/erpnext/templates/includes/product_list.js +42',b'No products found.',b'Ingen produkter funnet.'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +360',b'{0} against Sales Invoice {1}',b'{0} mot Sales Faktura {1}'
b'DocType: Antibiotic',b'Laboratory User',b'Laboratoriebruker'
b'DocType: Sales Invoice',b'SINV-',b'SINV-'
b'DocType: Request for Quotation Item',b'Project Name',b'Prosjektnavn'
b'DocType: Customer',b'Mention if non-standard receivable account',b'Nevn hvis ikke-standard fordring konto'
b'DocType: Journal Entry Account',b'If Income or Expense',b'Dersom inntekt eller kostnad'
b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +288',b'Select interest income account in employee loan {0}',b'Velg renteinntekter konto i ansatt l\xc3\xa5n {0}'
b'DocType: Work Order',b'Required Items',b'n\xc3\xb8dvendige elementer'
b'DocType: Stock Ledger Entry',b'Stock Value Difference',b'Stock Verdi Difference'
b'apps/erpnext/erpnext/config/learn.py +229',b'Human Resource',b'Menneskelig Resurs'
b'DocType: Payment Reconciliation Payment',b'Payment Reconciliation Payment',b'Betaling Avstemming Betaling'
b'DocType: Disease',b'Treatment Task',b'Behandlingsoppgave'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +38',b'Tax Assets',b'Skattefordel'
b'DocType: BOM Item',b'BOM No',b'BOM Nei'
b'DocType: Instructor',b'INS/',b'INS /'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +160',b'Journal Entry {0} does not have account {1} or already matched against other voucher',b'Journal Entry {0} ikke har konto {1} eller allerede matchet mot andre verdikupong'
b'DocType: Item',b'Moving Average',b'Glidende gjennomsnitt'
b'DocType: BOM Update Tool',b'The BOM which will be replaced',b'BOM som vil bli erstattet'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +46',b'Electronic Equipments',b'elektronisk utstyr'
b'DocType: Asset',b'Maintenance Required',b'Vedlikehold kreves'
b'DocType: Account',b'Debit',b'Debet'
b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +49',b'Leaves must be allocated in multiples of 0.5',"b'Bladene skal avsettes i multipler av 0,5'"
b'DocType: Work Order',b'Operation Cost',b'Operation Cost'
b'apps/erpnext/erpnext/config/hr.py +29',b'Upload attendance from a .csv file',b'Last opp oppm\xc3\xb8te fra en CSV-fil'
b'apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +45',b'Outstanding Amt',b'Enest\xc3\xa5ende Amt'
b'DocType: Sales Person',b'Set targets Item Group-wise for this Sales Person.',b'Sette m\xc3\xa5l varegruppe-messig for Sales Person.'
b'DocType: Stock Settings',b'Freeze Stocks Older Than [Days]',b'Freeze Aksjer Eldre enn [dager]'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +600',b'Row #{0}: Asset is mandatory for fixed asset purchase/sale',b'Row # {0}: Asset er obligatorisk for anleggsmiddel kj\xc3\xb8p / salg'
b'DocType: Asset Maintenance Team',b'Maintenance Team Name',b'Vedlikehold Lagnavn'
b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +42',"b'If two or more Pricing Rules are found based on the above conditions, Priority is applied. Priority is a number between 0 to 20 while default value is zero (blank). Higher number means it will take precedence if there are multiple Pricing Rules with same conditions.'","b'Hvis to eller flere Prising Reglene er funnet basert p\xc3\xa5 de ovennevnte forhold, er Priority brukt. Prioritet er et tall mellom 0 og 20, mens standardverdi er null (blank). H\xc3\xb8yere tall betyr at det vil ha forrang dersom det er flere Prising regler med samme betingelser.'"
b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +197',"b""Customer is mandatory if 'Opportunity From' is selected as Customer""",b'Kunden er obligatorisk dersom &#39;Mulighet Fra&#39; er valgt som kunde'
b'apps/erpnext/erpnext/controllers/trends.py +36',b'Fiscal Year: {0} does not exists',b'Fiscal Year: {0} ikke eksisterer'
b'DocType: Currency Exchange',b'To Currency',b'\xc3\x85 Valuta'
b'DocType: Leave Block List',b'Allow the following users to approve Leave Applications for block days.',b'Tillat f\xc3\xb8lgende brukere \xc3\xa5 godkjenne La Applications for blokk dager.'
b'apps/erpnext/erpnext/config/hr.py +137',b'Types of Expense Claim.',b'Typer av Expense krav.'
b'apps/erpnext/erpnext/controllers/selling_controller.py +148',b'Selling rate for item {0} is lower than its {1}. Selling rate should be atleast {2}',b'Selgingsfrekvensen for elementet {0} er lavere enn dens {1}. Salgsprisen b\xc3\xb8r v\xc3\xa6re minst {2}'
b'DocType: Item',b'Taxes',b'Skatter'
b'DocType: Purchase Invoice',b'capital goods',b'kapitalvarer'
b'DocType: Purchase Invoice Item',b'Weight Per Unit',b'Vekt pr. Enhet'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +344',b'Paid and Not Delivered',b'Betalt og ikke levert'
b'DocType: Project',b'Default Cost Center',b'Standard kostnadssted'
b'DocType: Bank Guarantee',b'End Date',b'Sluttdato'
b'apps/erpnext/erpnext/config/stock.py +7',b'Stock Transactions',b'aksje~~POS=TRUNC'
b'DocType: Budget',b'Budget Accounts',b'Budsjett Regnskap'
b'DocType: Employee',b'Internal Work History',b'Intern Work History'
b'DocType: Depreciation Schedule',b'Accumulated Depreciation Amount',b'Akkumulerte avskrivninger bel\xc3\xb8p'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +42',b'Private Equity',b'Private Equity'
b'DocType: Supplier Scorecard Variable',b'Supplier Scorecard Variable',b'Leverand\xc3\xb8r Scorecard Variable'
b'DocType: Employee Loan',b'Fully Disbursed',b'fullt utbetalt'
b'DocType: Employee Advance',b'Due Advance Amount',b'Forfallsbel\xc3\xb8p'
b'DocType: Maintenance Visit',b'Customer Feedback',b'Customer Feedback'
b'DocType: Account',b'Expense',b'Expense'
b'apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.js +54',b'Score cannot be greater than Maximum Score',b'Score kan ikke v\xc3\xa6re st\xc3\xb8rre enn Maksimal poengsum'
b'apps/erpnext/erpnext/utilities/user_progress.py +129',b'Customers and Suppliers',b'Kunder og leverand\xc3\xb8rer'
b'DocType: Item Attribute',b'From Range',b'Fra Range'
b'DocType: BOM',b'Set rate of sub-assembly item based on BOM',b'Angi hastighet p\xc3\xa5 underenhetens element basert p\xc3\xa5 BOM'
b'DocType: Hotel Room Reservation',b'Invoiced',b'fakturert'
b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +98',b'Syntax error in formula or condition: {0}',b'Syntaksfeil i formelen eller tilstand: {0}'
b'DocType: Daily Work Summary Settings Company',b'Daily Work Summary Settings Company',b'Daglig arbeid Oppsummering Innstillinger selskapet'
b'apps/erpnext/erpnext/stock/utils.py +125',b'Item {0} ignored since it is not a stock item',b'Element {0} ignorert siden det ikke er en lagervare'
b'DocType: Appraisal',b'APRSL',b'APRSL'
b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +23',"b'To not apply Pricing Rule in a particular transaction, all applicable Pricing Rules should be disabled.'","b'Hvis du ikke vil bruke Prissetting regel i en bestemt transaksjon, b\xc3\xb8r alle gjeldende reglene for prissetting deaktiveres.'"
b'DocType: Payment Term',b'Day(s) after the end of the invoice month',b'Dag (er) etter slutten av faktura m\xc3\xa5neden'
b'DocType: Assessment Group',b'Parent Assessment Group',b'Parent Assessment Group'
b'apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +27',b'Jobs',b'Jobs'
,b'Sales Order Trends',b'Salgsordre Trender'
b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +51',"b""The 'From Package No.' field must neither be empty nor it's value less than 1.""",b'Fra pakke nr. feltet m\xc3\xa5 verken v\xc3\xa6re tomt eller det er mindre enn 1.'
b'DocType: Employee',b'Held On',b'Avholdt'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order_calendar.js +36',b'Production Item',b'Produksjon Element'
,b'Employee Information',b'Informasjon ansatt'
b'DocType: Stock Entry Detail',b'Additional Cost',b'Tilleggs Cost'
b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +48',"b'Can not filter based on Voucher No, if grouped by Voucher'","b'Kan ikke filtrere basert p\xc3\xa5 Voucher Nei, hvis gruppert etter Voucher'"
b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +918',b'Make Supplier Quotation',b'Gj\xc3\xb8r Leverand\xc3\xb8r sitat'
b'DocType: Quality Inspection',b'Incoming',b'Innkommende'
b'apps/erpnext/erpnext/setup/doctype/company/company.js +70',b'Default tax templates for sales and purchase are created.',b'Standard skattemaler for salg og kj\xc3\xb8p opprettes.'
b'apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.py +57',b'Assessment Result record {0} already exists.',b'Vurderingsresultatrekord {0} eksisterer allerede.'
b'DocType: BOM',b'Materials Required (Exploded)',b'Materialer som er n\xc3\xb8dvendige (Exploded)'
b'apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py +60',"b""Please set Company filter blank if Group By is 'Company'""",b'Vennligst sett Company filter blank hvis Group By er &#39;Company&#39;'
b'apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +66',b'Posting Date cannot be future date',b'Publiseringsdato kan ikke v\xc3\xa6re fremtidig dato'
b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +102',b'Row # {0}: Serial No {1} does not match with {2} {3}',b'Row # {0}: Serial No {1} samsvarer ikke med {2} {3}'
b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +10',b'for generating the recurring',b'for \xc3\xa5 generere de tilbakevendende'
b'DocType: Stock Entry',b'Target Warehouse Address',b'M\xc3\xa5llageradresse'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +86',b'Casual Leave',b'Casual La'
b'DocType: Agriculture Task',b'End Day',b'Endedag'
b'DocType: Batch',b'Batch ID',b'Batch ID'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +380',b'Note: {0}',b'Merk: {0}'
,b'Delivery Note Trends',b'Levering Note Trender'
b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +112',"b""This Week's Summary""",b'Denne ukens oppsummering'
b'apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py +22',b'In Stock Qty',b'P\xc3\xa5 lager Antall'
b'DocType: Delivery Trip',b'Calculate Estimated Arrival Times',b'Beregn ansl\xc3\xa5tte ankomsttider'
b'apps/erpnext/erpnext/accounts/general_ledger.py +113',b'Account: {0} can only be updated via Stock Transactions',b'Konto: {0} kan bare oppdateres via lagertransaksjoner'
b'DocType: Student Group Creation Tool',b'Get Courses',b'F\xc3\xa5 Kurs'
b'DocType: GL Entry',b'Party',b'Selskap'
b'DocType: Healthcare Settings',b'Patient Name',b'Pasientnavn'
b'DocType: Variant Field',b'Variant Field',b'Variantfelt'
b'DocType: Sales Order',b'Delivery Date',b'Leveringsdato'
b'DocType: Opportunity',b'Opportunity Date',b'Opportunity Dato'
b'DocType: Employee',b'Health Insurance Provider',b'Helseforsikringsselskap'
b'DocType: Purchase Receipt',b'Return Against Purchase Receipt',b'Tilbake Against Kj\xc3\xb8pskvittering'
b'DocType: Water Analysis',b'Person Responsible',b'Ansvarlig person'
b'DocType: Request for Quotation Item',b'Request for Quotation Item',b'Foresp\xc3\xb8rsel om prisanslag Element'
b'DocType: Purchase Order',b'To Bill',b'Til Bill'
b'DocType: Material Request',b'% Ordered',b'% Bestilt'
b'DocType: Education Settings',"b'For Course based Student Group, the Course will be validated for every Student from the enrolled Courses in Program Enrollment.'",b'For kursbasert studentgruppe vil kurset bli validert for hver student fra de innmeldte kursene i programopptaket.'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +103',b'Piecework',b'Akkord'
b'apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +70',b'Avg. Buying Rate',b'Avg. Kj\xc3\xb8pe Rate'
b'DocType: Share Balance',b'From No',b'Fra nr'
b'DocType: Task',b'Actual Time (in Hours)',b'Virkelig tid (i timer)'
b'DocType: Employee',b'History In Company',b'Historie I selskapet'
b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +270',b'New Message from {sender}',b'Ny melding fra {avsender}'
b'DocType: Customer',b'Customer Primary Address',b'Kunde hovedadresse'
b'apps/erpnext/erpnext/config/learn.py +107',b'Newsletters',b'Nyhetsbrev'
b'DocType: Drug Prescription',b'Description/Strength',b'Beskrivelse / styrke'
b'DocType: Share Balance',b'Is Company',b'Er selskapet'
b'DocType: Stock Ledger Entry',b'Stock Ledger Entry',b'Stock Ledger Entry'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +83',b'Same item has been entered multiple times',b'Samme element er angitt flere ganger'
b'DocType: Department',b'Leave Block List',b'La Block List'
b'DocType: Purchase Invoice',b'Tax ID',b'Skatt ID'
b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +192',b'Item {0} is not setup for Serial Nos. Column must be blank',b'Element {0} er ikke oppsett for Serial Nos. Kolonne m\xc3\xa5 v\xc3\xa6re tomt'
b'DocType: Accounts Settings',b'Accounts Settings',b'Regnskap Innstillinger'
b'apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +11',b'Approve',b'Vedta'
b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +69',"b'Malformatted address for {0}, please fix to continue.'","b'Malformatted adresse for {0}, v\xc3\xa6r s\xc3\xa5 snill \xc3\xa5 fikse for \xc3\xa5 fortsette.'"
b'apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +28',"b'Number of new Account, it will be included in the account name as a prefix'","b'Antall ny konto, den vil bli inkludert i kontonavnet som prefiks'"
b'DocType: Maintenance Team Member',b'Team Member',b'Teammedlem'
b'apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js +151',b'No Result to submit',b'Ingen resultat \xc3\xa5 sende inn'
b'DocType: Customer',b'Sales Partner and Commission',b'Sales Partner og Kommisjonen'
b'DocType: Employee Loan',b'Rate of Interest (%) / Year',b'Rente (%) / \xc3\x85r'
,b'Project Quantity',b'prosjekt Antall'
b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +79',"b""Total {0} for all items is zero, may be you should change 'Distribute Charges Based On'""","b'Totalt {0} for alle elementer er null, kan v\xc3\xa6re du b\xc3\xb8r endre &#39;Fordel Avgifter basert p\xc3\xa5&#39;'"
b'DocType: Opportunity',b'To Discuss',b'\xc3\x85 Diskutere'
b'apps/erpnext/erpnext/stock/stock_ledger.py +377',b'{0} units of {1} needed in {2} to complete this transaction.',b'{0} enheter av {1} trengs i {2} for \xc3\xa5 fullf\xc3\xb8re denne transaksjonen.'
b'DocType: Loan Type',b'Rate of Interest (%) Yearly',b'Rente (%) \xc3\x85rlig'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +71',b'Temporary Accounts',b'Midlertidige kontoer'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +207',b'Black',b'Svart'
b'DocType: BOM Explosion Item',b'BOM Explosion Item',b'BOM Explosion Element'
b'DocType: Shareholder',b'Contact List',b'Kontaktliste'
b'DocType: Account',b'Auditor',b'Revisor'
b'DocType: Project',b'Frequency To Collect Progress',b'Frekvens for \xc3\xa5 samle fremgang'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +132',b'{0} items produced',b'{0} elementer produsert'
b'apps/erpnext/erpnext/utilities/user_progress.py +58',b'Learn More',b'L\xc3\xa6re mer'
b'DocType: Cheque Print Template',b'Distance from top edge',b'Avstand fra \xc3\xb8vre kant'
b'apps/erpnext/erpnext/stock/get_item_details.py +367',b'Price List {0} is disabled or does not exist',b'Prisliste {0} er deaktivert eller eksisterer ikke'
b'DocType: Purchase Invoice',b'Return',b'Return'
b'DocType: Pricing Rule',b'Disable',b'Deaktiver'
b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +180',b'Mode of payment is required to make a payment',b'Modus for betaling er n\xc3\xb8dvendig \xc3\xa5 foreta en betaling'
b'DocType: Project Task',b'Pending Review',b'Avventer omtale'
b'apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +14',"b'Edit in full page for more options like assets, serial nos, batches etc.'","b'Rediger p\xc3\xa5 full side for flere alternativer som eiendeler, serienummer, batcher etc.'"
b'apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +10',b'Appointments and Consultations',b'Utnevnelser og konsultasjoner'
b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +41',b'{0} - {1} is not enrolled in the Batch {2}',b'{0} - {1} er ikke p\xc3\xa5meldt i batch {2}'
b'apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +113',"b'Asset {0} cannot be scrapped, as it is already {1}'","b'Asset {0} kan ikke bli vraket, som det er allerede {1}'"
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +77',b'Cheques Required',b'Sjekker p\xc3\xa5krevd'
b'DocType: Task',b'Total Expense Claim (via Expense Claim)',b'Total Expense krav (via Expense krav)'
b'apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +177',b'Mark Absent',b'Mark Frav\xc3\xa6rende'
b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +40',b'Failed to setup company',b'Kunne ikke opprette selskapet'
b'DocType: Asset Repair',b'Asset Repair',b'Asset Repair'
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +143',b'Row {0}: Currency of the BOM #{1} should be equal to the selected currency {2}',b'Rad {0}: valuta BOM # {1} b\xc3\xb8r v\xc3\xa6re lik den valgte valutaen {2}'
b'DocType: Journal Entry Account',b'Exchange Rate',b'Vekslingskurs'
b'DocType: Patient',b'Additional information regarding the patient',b'Ytterligere informasjon om pasienten'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +585',b'Sales Order {0} is not submitted',b'Salgsordre {0} er ikke innsendt'
b'DocType: Homepage',b'Tag Line',b'tag Linje'
b'DocType: Fee Component',b'Fee Component',b'Fee Component'
b'apps/erpnext/erpnext/config/hr.py +204',b'Fleet Management',b'Fl\xc3\xa5testyring'
b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1080',b'Add items from',b'Legg elementer fra'
b'apps/erpnext/erpnext/config/agriculture.py +7',b'Crops & Lands',b'Crops &amp; Lands'
b'DocType: Cheque Print Template',b'Regular',b'Regelmessig'
b'DocType: Fertilizer',b'Density (if liquid)',b'Tetthet (hvis flytende)'
b'apps/erpnext/erpnext/education/doctype/course/course.py +20',b'Total Weightage of all Assessment Criteria must be 100%',b'Totalt weightage av alle vurderingskriteriene m\xc3\xa5 v\xc3\xa6re 100%'
b'DocType: Purchase Order Item',b'Last Purchase Rate',b'Siste Purchase Rate'
b'DocType: Account',b'Asset',b'Asset'
b'DocType: Project Task',b'Task ID',b'Task ID'
b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +84',b'Stock cannot exist for Item {0} since has variants',b'Stock kan ikke eksistere for Element {0} siden har varianter'
b'DocType: Lab Test',b'Mobile',b'Mobil'
,b'Sales Person-wise Transaction Summary',b'Transaksjons Oppsummering Sales Person-messig'
b'DocType: Training Event',b'Contact Number',b'Kontakt nummer'
b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +73',b'Warehouse {0} does not exist',b'Warehouse {0} finnes ikke'
b'DocType: Monthly Distribution',b'Monthly Distribution Percentages',b'M\xc3\xa5nedlig Distribusjonsprosent'
b'apps/erpnext/erpnext/stock/doctype/batch/batch.py +110',b'The selected item cannot have Batch',b'Den valgte elementet kan ikke ha Batch'
b'DocType: Delivery Note',b'% of materials delivered against this Delivery Note',b'% Av materialer leveres mot denne f\xc3\xb8lgeseddel'
b'DocType: Asset Maintenance Log',b'Has Certificate',b'Har sertifikat'
b'DocType: Project',b'Customer Details',b'Kunde Detaljer'
b'DocType: Asset',b'Check if Asset requires Preventive Maintenance or Calibration',b'Sjekk om Asset krever forebyggende vedlikehold eller kalibrering'
b'apps/erpnext/erpnext/public/js/setup_wizard.js +87',b'Company Abbreviation cannot have more than 5 characters',b'Selskapets forkortelse kan ikke inneholde mer enn 5 tegn'
b'DocType: Employee',b'Reports to',b'Rapporter til'
,b'Unpaid Expense Claim',b'Ubetalte Expense krav'
b'DocType: Payment Entry',b'Paid Amount',b'Innbetalt bel\xc3\xb8p'
b'apps/erpnext/erpnext/utilities/user_progress.py +158',b'Explore Sales Cycle',b'Utforsk salgssyklusen'
b'DocType: Assessment Plan',b'Supervisor',b'Supervisor'
b'apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +869',b'Retention Stock Entry',b'Beholdningsinngang'
,b'Available Stock for Packing Items',b'Tilgjengelig p\xc3\xa5 lager for pakk gjenstander'
b'DocType: Item Variant',b'Item Variant',b'Sak Variant'
,b'Work Order Stock Report',b'Arbeide ordre lagerrapport'
b'DocType: Assessment Result Tool',b'Assessment Result Tool',b'Assessment Resultat Tool'
b'apps/erpnext/erpnext/education/doctype/instructor/instructor.js +24',b'As Supervisor',b'Som veileder'
b'DocType: BOM Scrap Item',b'BOM Scrap Item',b'BOM Scrap Element'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +895',b'Submitted orders can not be deleted',b'Innsendte bestillinger kan ikke slettes'
b'apps/erpnext/erpnext/accounts/doctype/account/account.py +114',"b""Account balance already in Debit, you are not allowed to set 'Balance Must Be' as 'Credit'""","b'Saldo allerede i debet, har du ikke lov til \xc3\xa5 sette &quot;Balance m\xc3\xa5 v\xc3\xa6re &#39;som&#39; Credit &#39;'"
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +118',b'Quality Management',b'Kvalitetsstyring'
b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +41',b'Item {0} has been disabled',b'Element {0} har blitt deaktivert'
b'DocType: Project',b'Total Billable Amount (via Timesheets)',b'Totalt fakturerbart bel\xc3\xb8p (via tidsskrifter)'
b'DocType: Agriculture Task',b'Previous Business Day',b'Tidligere arbeidsdag'
b'DocType: Employee Loan',b'Repay Fixed Amount per Period',b'Smelle fast bel\xc3\xb8p per periode'
b'DocType: Employee',b'Health Insurance No',b'Helseforsikring nr'
b'apps/erpnext/erpnext/buying/utils.py +47',b'Please enter quantity for Item {0}',b'Skriv inn antall for Element {0}'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +215',b'Credit Note Amt',b'Kreditt notat Amt'
b'DocType: Employee External Work History',b'Employee External Work History',b'Ansatt Ekstern Work History'
b'DocType: Opening Invoice Creation Tool',b'Purchase',b'Kj\xc3\xb8p'
b'apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37',b'Balance Qty',b'Balanse Antall'
b'apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +20',b'Goals cannot be empty',b'M\xc3\xa5l kan ikke v\xc3\xa6re tomt'
b'apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.js +15',b'Enrolling students',b'Registrering av studenter'
b'DocType: Item Group',b'Parent Item Group',b'Parent varegruppe'
b'DocType: Appointment Type',b'Appointment Type',b'Avtale Type'
b'apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +21',b'{0} for {1}',b'{0} for {1}'
b'DocType: Healthcare Settings',b'Valid number of days',b'Gyldig antall dager'
b'apps/erpnext/erpnext/setup/doctype/company/company.js +39',b'Cost Centers',b'Kostnadssteder'
b'DocType: Land Unit',b'Linked Plant Analysis',b'Linked Plant Analysis'
b'DocType: Purchase Receipt',"b""Rate at which supplier's currency is converted to company's base currency""",b'Hastigheten som leverand\xc3\xb8rens valuta er konvertert til selskapets hovedvaluta'
b'apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +36',b'Row #{0}: Timings conflicts with row {1}',b'Row # {0}: timings konflikter med rad {1}'
b'DocType: Purchase Invoice Item',b'Allow Zero Valuation Rate',b'Tillat null verdivurdering'
b'DocType: Training Event Employee',b'Invited',b'invitert'
b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +178',b'Multiple active Salary Structures found for employee {0} for the given dates',b'Flere aktive L\xc3\xb8nn Structures funnet for arbeidstaker {0} for den gitte datoer'
b'apps/erpnext/erpnext/config/accounts.py +308',b'Setup Gateway accounts.',b'Oppsett Gateway kontoer.'
b'DocType: Employee',b'Employment Type',b'Type stilling'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +42',b'Fixed Assets',b'Anleggsmidler'
b'DocType: Payment Entry',b'Set Exchange Gain / Loss',b'Sett valutagevinst / tap'
,b'GST Purchase Register',b'GST Innkj\xc3\xb8psregister'
,b'Cash Flow',b'Cash Flow'
b'apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +25',b'Combined invoice portion must equal 100%',b'Kombinert fakturaport m\xc3\xa5 v\xc3\xa6re 100%'
b'DocType: Item Group',b'Default Expense Account',b'Standard kostnadskonto'
b'DocType: GST Account',b'CGST Account',b'CGST-konto'
b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +53',b'Student Email ID',b'Student Email ID'
b'DocType: Employee',b'Notice (days)',b'Varsel (dager)'
b'DocType: Tax Rule',b'Sales Tax Template',b'Merverdiavgift Mal'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +2510',b'Select items to save the invoice',b'Velg elementer for \xc3\xa5 lagre fakturaen'
b'DocType: Employee',b'Encashment Date',b'Encashment Dato'
b'DocType: Training Event',b'Internet',b'Internett'
b'DocType: Special Test Template',b'Special Test Template',b'Spesiell testmal'
b'DocType: Account',b'Stock Adjustment',b'Stock Adjustment'
b'apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +34',b'Default Activity Cost exists for Activity Type - {0}',b'Standard Aktivitet Kostnad finnes for Aktivitetstype - {0}'
b'DocType: Work Order',b'Planned Operating Cost',b'Planlagt driftskostnader'
b'DocType: Academic Term',b'Term Start Date',b'Term Startdato'
b'apps/erpnext/erpnext/config/accounts.py +471',b'List of all share transactions',b'Liste over alle aksje transaksjoner'
b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +18',b'Opp Count',b'Opptelling'
b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +244',b'Please find attached {0} #{1}',b'Vedlagt {0} # {1}'
b'apps/erpnext/erpnext/accounts/report/share_balance/share_balance.py +52',b'Average Rate',b'Gjennomsnittlig rente'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +728',b'Total Payment Amount in Payment Schedule must be equal to Grand / Rounded Total',b'Totalt betalingsbel\xc3\xb8p i betalingsplan m\xc3\xa5 v\xc3\xa6re lik Grand / Rounded Total'
b'apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +34',b'Bank Statement balance as per General Ledger',b'Kontoutskrift balanse pr hovedbok'
b'DocType: Job Applicant',b'Applicant Name',b'S\xc3\xb8kerens navn'
b'DocType: Authorization Rule',b'Customer / Item Name',b'Kunde / Navn'
b'DocType: Buying Settings',"b'If enabled, last purchase details of items will not be fetched from previous purchase order or purchase receipt'","b'Hvis aktivert, vil siste kj\xc3\xb8psdetaljer for elementer ikke bli hentet fra tidligere innkj\xc3\xb8psordre eller kj\xc3\xb8pskvittering'"
b'DocType: Product Bundle',"b'Aggregate group of **Items** into another **Item**. This is useful if you are bundling a certain **Items** into a package and you maintain stock of the packed **Items** and not the aggregate **Item**. \n\nThe package **Item** will have ""Is Stock Item"" as ""No"" and ""Is Sales Item"" as ""Yes"".\n\nFor Example: If you are selling Laptops and Backpacks separately and have a special price if the customer buys both, then the Laptop + Backpack will be a new Product Bundle Item.\n\nNote: BOM = Bill of Materials'","b'Samlet gruppe ** Elementer ** i en annen ** Sak **. Dette er nyttig hvis du er bunting en viss ** Elementer ** inn i en pakke, og du opprettholde bestanden av de pakkede ** Elementer ** og ikke samlet ** Sak **. Pakken ** Sak ** vil ha &quot;Er Stock Item&quot; som &quot;Nei&quot; og &quot;Er Sales Item&quot; som &quot;Ja&quot;. For eksempel: Hvis du selger b\xc3\xa6rbare datamaskiner og ryggsekker separat og har en spesiell pris hvis kunden kj\xc3\xb8per begge, s\xc3\xa5 Laptop + Backpack vil v\xc3\xa6re et nytt produkt Bundle varen. Merk: BOM = Bill of Materials'"
b'apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +42',b'Serial No is mandatory for Item {0}',b'Serial No er obligatorisk for Element {0}'
b'DocType: Item Variant Attribute',b'Attribute',b'Attributt'
b'apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +43',b'Please specify from/to range',b'Vennligst oppgi fra / til spenner'
b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +28',b'Opening {0} Invoice created',b'\xc3\x85pning {0} Faktura opprettet'
b'DocType: Serial No',b'Under AMC',b'Under AMC'
b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +55',b'Item valuation rate is recalculated considering landed cost voucher amount',b'Sak verdivurdering rente beregnes p\xc3\xa5 nytt vurderer inntakskost kupong bel\xc3\xb8p'
b'apps/erpnext/erpnext/config/selling.py +153',b'Default settings for selling transactions.',b'Standardinnstillingene for salg transaksjoner.'
b'DocType: Guardian',b'Guardian Of ',b'Guardian Av'
b'DocType: Grading Scale Interval',b'Threshold',b'Terskel'
b'DocType: BOM Update Tool',b'Current BOM',b'N\xc3\xa5v\xc3\xa6rende BOM'
b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html +32',b'Balance (Dr - Cr)',b'Balanse (Dr - Cr)'
b'apps/erpnext/erpnext/public/js/utils.js +55',b'Add Serial No',b'Legg Serial No'
b'DocType: Work Order Item',b'Available Qty at Source Warehouse',b'Tilgjengelig antall p\xc3\xa5 Source Warehouse'
b'apps/erpnext/erpnext/config/support.py +22',b'Warranty',b'Garanti'
b'DocType: Purchase Invoice',b'Debit Note Issued',b'Debitnota Utstedt'
b'DocType: Work Order',b'Warehouses',b'N\xc3\xa6ringslokaler'
b'apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +18',b'{0} asset cannot be transferred',b'{0} eiendelen kan ikke overf\xc3\xb8res'
b'DocType: Hotel Room Pricing',b'Hotel Room Pricing',b'Hotellrompriser'
b'apps/erpnext/erpnext/stock/doctype/item/item.js +80',b'This Item is a Variant of {0} (Template).',b'Denne varen er en variant av {0} (mal).'
b'DocType: Workstation',b'per hour',b'per time'
b'apps/erpnext/erpnext/config/buying.py +7',b'Purchasing',b'innkj\xc3\xb8p'
b'DocType: Announcement',b'Announcement',b'Kunngj\xc3\xb8ring'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +84',b'Customer LPO',b'Kunde LPO'
b'DocType: Education Settings',"b'For Batch based Student Group, the Student Batch will be validated for every Student from the Program Enrollment.'","b'For Batch-baserte Studentgruppen, vil studentenes batch bli validert for hver student fra programopptaket.'"
b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +50',b'Warehouse can not be deleted as stock ledger entry exists for this warehouse.',b'Warehouse kan ikke slettes som finnes lager hovedbok oppf\xc3\xb8ring for dette lageret.'
b'apps/erpnext/erpnext/public/js/setup_wizard.js +25',b'Distribution',b'Distribusjon'
b'DocType: Expense Claim Advance',b'Expense Claim Advance',b'Kostnadskrav Advance'
b'DocType: Lab Test',b'Report Preference',b'Rapportpreferanse'
b'apps/erpnext/erpnext/config/non_profit.py +43',b'Volunteer information.',b'Frivillig informasjon.'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +133',b'Project Manager',b'Prosjektleder'
,b'Quoted Item Comparison',b'Sitert Element Sammenligning'
b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +34',b'Overlap in scoring between {0} and {1}',b'Overlappe i scoring mellom {0} og {1}'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +114',b'Dispatch',b'Dispatch'
b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +74',b'Max discount allowed for item: {0} is {1}%',b'Maks rabatt tillatt for element: {0} er {1}%'
b'apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +176',b'Net Asset value as on',b'Net Asset verdi som p\xc3\xa5'
b'DocType: Crop',b'Produce',b'Produsere'
b'DocType: Hotel Settings',b'Default Taxes and Charges',b'Standard Skatter og avgifter'
b'DocType: Account',b'Receivable',b'Fordring'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +308',b'Row #{0}: Not allowed to change Supplier as Purchase Order already exists',b'Row # {0}: Ikke lov til \xc3\xa5 endre Leverand\xc3\xb8r som innkj\xc3\xb8psordre allerede eksisterer'
b'DocType: Accounts Settings',b'Role that is allowed to submit transactions that exceed credit limits set.',b'Rollen som f\xc3\xa5r lov til \xc3\xa5 sende transaksjoner som overstiger kredittgrenser fastsatt.'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +989',b'Select Items to Manufacture',b'Velg delbetaling Produksjon'
b'DocType: Delivery Stop',b'Delivery Stop',b'Leveringsstopp'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +963',"b'Master data syncing, it might take some time'","b'Master data synkronisering, kan det ta litt tid'"
b'DocType: Item',b'Material Issue',b'Material Issue'
b'DocType: Employee Education',b'Qualification',b'Kvalifisering'
b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +42',b'View Salary Slips',b'Se L\xc3\xb8nnsslipp'
b'DocType: Item Price',b'Item Price',b'Sak Pris'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +48',b'Soap & Detergent',b'S\xc3\xa5pe og vaskemiddel'
b'DocType: BOM',b'Show Items',b'Vis Items'
b'apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.py +30',b'From Time cannot be greater than To Time.',b'Fra tid kan ikke v\xc3\xa6re st\xc3\xb8rre enn til annen.'
b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +92',b'Do you want to notify all the customers by email?',b'Vil du varsle alle kundene via e-post?'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +36',b'Motion Picture & Video',b'Motion Picture &amp; Video'
b'apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js +5',b'Ordered',b'Bestilt'
b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js +51',b'Resume',b'Gjenoppta'
b'DocType: Salary Detail',b'Component',b'Komponent'
b'DocType: Assessment Criteria',b'Assessment Criteria Group',b'Vurderingskriterier Gruppe'
b'DocType: Healthcare Settings',b'Patient Name By',b'Pasientnavn Av'
b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +72',b'Opening Accumulated Depreciation must be less than equal to {0}',b'\xc3\x85pning akkumulerte avskrivninger m\xc3\xa5 v\xc3\xa6re mindre enn eller lik {0}'
b'DocType: Warehouse',b'Warehouse Name',b'Warehouse Name'
b'DocType: Naming Series',b'Select Transaction',b'Velg Transaksjons'
b'apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +30',b'Please enter Approving Role or Approving User',b'Skriv inn Godkjenne Rolle eller Godkjenne User'
b'DocType: Journal Entry',b'Write Off Entry',b'Skriv Off Entry'
b'DocType: BOM',b'Rate Of Materials Based On',b'Valuta materialer basert p\xc3\xa5'
b'apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +21',b'Support Analtyics',b'St\xc3\xb8tte Analtyics'
b'apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +102',b'Uncheck all',b'Fjern haken ved alle'
b'DocType: POS Profile',b'Terms and Conditions',b'Vilk\xc3\xa5r og betingelser'
b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +49',b'To Date should be within the Fiscal Year. Assuming To Date = {0}',b'To Date b\xc3\xb8r v\xc3\xa6re innenfor regnskaps\xc3\xa5ret. Antar To Date = {0}'
b'DocType: Employee',"b'Here you can maintain height, weight, allergies, medical concerns etc'","b'Her kan du opprettholde h\xc3\xb8yde, vekt, allergier, medisinske bekymringer etc'"
b'DocType: Leave Block List',b'Applies to Company',b'Gjelder Selskapet'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +231',b'Cannot cancel because submitted Stock Entry {0} exists',b'Kan ikke avbryte fordi innsendt Stock Entry {0} finnes'
b'DocType: Employee Loan',b'Disbursement Date',b'Innbetalingsdato'
b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +80',"b""'Recipients' not specified""",b'&#39;Mottakere&#39; ikke spesifisert'
b'DocType: BOM Update Tool',b'Update latest price in all BOMs',b'Oppdater siste pris i alle BOMs'
b'apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.js +23',b'Medical Record',b'Pasientjournal'
b'DocType: Vehicle',b'Vehicle',b'Kj\xc3\xb8ret\xc3\xb8y'
b'DocType: Purchase Invoice',b'In Words',b'I Words'
b'apps/erpnext/erpnext/hr/doctype/training_result/training_result.py +15',b'{0} must be submitted',b'{0} m\xc3\xa5 sendes'
b'DocType: POS Profile',b'Item Groups',b'varegruppene'
b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +221',"b""Today is {0}'s birthday!""",b'I dag er {0} s bursdag!'
b'DocType: Sales Order Item',b'For Production',b'For Production'
b'DocType: Payment Request',b'payment_url',b'payment_url'
b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +186',b'Please add a Temporary Opening account in Chart of Accounts',b'Vennligst legg til en midlertidig \xc3\xa5pningskonto i kontoplan'
b'DocType: Customer',b'Customer Primary Contact',b'Kundens prim\xc3\xa6re kontakt'
b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +154',b'Period Closing Journal',b'Periode avsluttende journal'
b'DocType: Project Task',b'View Task',b'Vis Task'
b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +22',b'Opp/Lead %',b'Opp / Lead%'
b'DocType: Material Request',b'MREQ-',b'MREQ-'
b'DocType: Payment Schedule',b'Invoice Portion',b'Fakturaandel'
,b'Asset Depreciations and Balances',b'Asset Avskrivninger og Balanserer'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +370',b'Amount {0} {1} transferred from {2} to {3}',b'Mengden {0} {1} overf\xc3\xb8rt fra {2} til {3}'
b'DocType: Sales Invoice',b'Get Advances Received',b'F\xc3\xa5 Fremskritt mottatt'
b'DocType: Email Digest',b'Add/Remove Recipients',b'Legg til / fjern Mottakere'
b'apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.js +19',"b""To set this Fiscal Year as Default, click on 'Set as Default'""","b'For \xc3\xa5 sette dette regnskaps\xc3\xa5ret som standard, klikk p\xc3\xa5 &quot;Angi som standard &#39;'"
b'DocType: Production Plan',b'Include Subcontracted Items',b'Inkluder underleverte varer'
b'apps/erpnext/erpnext/projects/doctype/project/project.py +220',b'Join',b'Bli med'
b'apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +21',b'Shortage Qty',b'Mangel Antall'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +672',b'Cannot change Variant properties after stock transction. You will have to make a new Item to do this.',b'Kan ikke endre Variantegenskaper etter lageroverf\xc3\xb8ring. Du m\xc3\xa5 lage en ny gjenstand for \xc3\xa5 gj\xc3\xb8re dette.'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +714',b'Item variant {0} exists with same attributes',b'Sak variant {0} finnes med samme attributtene'
b'DocType: Employee Loan',b'Repay from Salary',b'Smelle fra L\xc3\xb8nn'
b'DocType: Leave Application',b'LAP/',b'RUNDE/'
b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +360',b'Requesting payment against {0} {1} for amount {2}',b'Ber om betaling mot {0} {1} for mengden {2}'
b'DocType: Salary Slip',b'Salary Slip',b'L\xc3\xb8nn Slip'
b'DocType: Lead',b'Lost Quotation',b'mistet sitat'
b'apps/erpnext/erpnext/utilities/user_progress.py +221',b'Student Batches',b'Studentbatcher'
b'DocType: Pricing Rule',b'Margin Rate or Amount',b'Margin Rate Bel\xc3\xb8p'
b'apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +48',"b""'To Date' is required""",b'&#39;To Date&#39; er p\xc3\xa5krevd'
b'DocType: Packing Slip',"b'Generate packing slips for packages to be delivered. Used to notify package number, package contents and its weight.'","b'Generere pakksedler for pakker som skal leveres. Brukes til \xc3\xa5 varsle pakke nummer, innholdet i pakken og vekten.'"
b'DocType: Sales Invoice Item',b'Sales Order Item',b'Salgsordre Element'
b'DocType: Salary Slip',b'Payment Days',b'Betalings Days'
b'DocType: Stock Settings',b'Convert Item Description to Clean HTML',b'Konverter elementbeskrivelse for \xc3\xa5 rydde HTML'
b'DocType: Patient',b'Dormant',b'Sovende'
b'DocType: Salary Slip',b'Total Interest Amount',b'Totalt rentebel\xc3\xb8p'
b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +124',b'Warehouses with child nodes cannot be converted to ledger',b'N\xc3\xa6ringslokaler med barn noder kan ikke konverteres til Ledger'
b'DocType: BOM',b'Manage cost of operations',b'Administrer driftskostnader'
b'DocType: Accounts Settings',b'Stale Days',b'Foreldede dager'
b'DocType: Notification Control',"b'When any of the checked transactions are ""Submitted"", an email pop-up automatically opened to send an email to the associated ""Contact"" in that transaction, with the transaction as an attachment. The user may or may not send the email.'","b'N\xc3\xa5r noen av de merkede transaksjonene &quot;Skrevet&quot;, en e-pop-up automatisk \xc3\xa5pnet for \xc3\xa5 sende en e-post til den tilh\xc3\xb8rende &quot;Kontakt&quot; i at transaksjonen med transaksjonen som et vedlegg. Brukeren kan eller ikke kan sende e-posten.'"
b'apps/erpnext/erpnext/config/setup.py +14',b'Global Settings',b'Globale innstillinger'
b'DocType: Crop',b'Row Spacing UOM',b'Row Spacing UOM'
b'DocType: Assessment Result Detail',b'Assessment Result Detail',b'Assessment Resultat Detalj'
b'DocType: Employee Education',b'Employee Education',b'Ansatt Utdanning'
b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +53',b'Duplicate item group found in the item group table',b'Duplicate varegruppe funnet i varegruppen bordet'
b'DocType: Land Unit',b'Parent Land Unit',b'Moderselskap'
b'apps/erpnext/erpnext/public/js/controllers/transaction.js +1113',b'It is needed to fetch Item Details.',b'Det er n\xc3\xb8dvendig \xc3\xa5 hente Element detaljer.'
b'DocType: Fertilizer',b'Fertilizer Name',b'Navn p\xc3\xa5 gj\xc3\xb8dsel'
b'DocType: Salary Slip',b'Net Pay',b'Netto L\xc3\xb8nn'
b'DocType: Cash Flow Mapping Accounts',b'Account',b'Konto'
b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +217',b'Serial No {0} has already been received',b'Serial No {0} er allerede mottatt'
,b'Requested Items To Be Transferred',b'Ettersp\xc3\xb8r elementene som skal overf\xc3\xb8res'
b'DocType: Expense Claim',b'Vehicle Log',b'Vehicle Log'
b'DocType: Vital Signs',b'Presence of a fever (temp &gt; 38.5 \xc2\xb0C/101.3 \xc2\xb0F or sustained temp &gt; 38 \xc2\xb0C/100.4 \xc2\xb0F)',"b'Tilstedev\xc3\xa6relse av feber (temp&gt; 38,5 \xc2\xb0 C eller vedvarende temp&gt; 38 \xc2\xb0 C / 100,4 \xc2\xb0 F)'"
b'DocType: Customer',b'Sales Team Details',b'Salgsteam Detaljer'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +1352',b'Delete permanently?',b'Slett permanent?'
b'DocType: Expense Claim',b'Total Claimed Amount',b'Total Hevdet Bel\xc3\xb8p'
b'apps/erpnext/erpnext/config/crm.py +17',b'Potential opportunities for selling.',b'Potensielle muligheter for \xc3\xa5 selge.'
b'DocType: Shareholder',b'Folio no.',b'Folio nr.'
b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +246',b'Invalid {0}',b'Ugyldig {0}'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +90',b'Sick Leave',b'Sykefrav\xc3\xa6r'
b'DocType: Email Digest',b'Email Digest',b'E-post Digest'
b'DocType: Delivery Note',b'Billing Address Name',b'Billing Address Navn'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +22',b'Department Stores',b'Varehus'
,b'Item Delivery Date',b'Leveringsdato for vare'
b'DocType: Production Plan',b'Material Requested',b'Materiale som kreves'
b'DocType: Warehouse',b'PIN',b'PIN'
b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +116',"b""Error '{0}' occured. Arguments {1}.""",b'Feil &#39;{0}&#39; oppstod. Argumenter {1}.'
b'DocType: Bin',b'Reserved Qty for sub contract',b'Reservert antall for kontrakt'
b'DocType: Patient Service Unit',b'Patinet Service Unit',b'Patinet Service Unit'
b'DocType: Sales Invoice',b'Base Change Amount (Company Currency)',b'Base Endre Bel\xc3\xb8p (Selskap Valuta)'
b'apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +304',b'No accounting entries for the following warehouses',b'Ingen regnskapspostene for f\xc3\xb8lgende varehus'
b'apps/erpnext/erpnext/projects/doctype/project/project.js +95',b'Save the document first.',b'Lagre dokumentet f\xc3\xb8rst.'
b'apps/erpnext/erpnext/shopping_cart/cart.py +74',b'Only {0} in stock for item {1}',b'Kun {0} p\xc3\xa5 lager for varen {1}'
b'DocType: Account',b'Chargeable',b'Avgift'
b'DocType: Company',b'Change Abbreviation',b'Endre Forkortelse'
b'apps/erpnext/erpnext/templates/pages/integrations/gocardless_checkout.py +66',b'Pay {0} {1}',b'Betal {0} {1}'
b'DocType: Expense Claim Detail',b'Expense Date',b'Expense Dato'
b'DocType: Item',b'Max Discount (%)',b'Max Rabatt (%)'
b'apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +30',b'Credit Days cannot be a negative number',b'Kredittdager kan ikke v\xc3\xa6re et negativt nummer'
b'apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +70',b'Last Order Amount',b'Siste ordrebel\xc3\xb8p'
b'DocType: Cash Flow Mapper',b'e.g Adjustments for:',b'f.eks. justeringer for:'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +275',"b' {0} Retain Sample is based on batch, please check Has Batch No to retain sample of item'","b'{0} Behold pr\xc3\xb8ve er basert p\xc3\xa5 batch, vennligst sjekk Har batch nr for \xc3\xa5 beholde pr\xc3\xb8ve av element'"
b'DocType: Task',b'Is Milestone',b'Er Milestone'
b'DocType: Delivery Stop',b'Email Sent To',b'E-post sendt \xc3\x85'
b'DocType: Budget',b'Warn',b'Advare'
b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +81',b'Are you sure you want to unregister?',b'Er du sikker p\xc3\xa5 at du vil avregistrere?'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +797',b'All items have already been transferred for this Work Order.',b'Alle elementer er allerede overf\xc3\xb8rt for denne arbeidsordren.'
b'DocType: Appraisal',"b'Any other remarks, noteworthy effort that should go in the records.'","b'Eventuelle andre bemerkninger, bemerkelsesverdig innsats som b\xc3\xb8r g\xc3\xa5 i postene.'"
b'DocType: Asset Maintenance',b'Manufacturing User',b'Manufacturing User'
b'DocType: Purchase Invoice',b'Raw Materials Supplied',b'R\xc3\xa5vare Leveres'
b'DocType: C-Form',b'Series',b'Series'
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +282',b'Currency of the price list {0} must be {1} or {2}',b'Valuta p\xc3\xa5 prislisten {0} m\xc3\xa5 v\xc3\xa6re {1} eller {2}'
b'DocType: Appraisal',b'Appraisal Template',b'Appraisal Mal'
b'DocType: Soil Texture',b'Ternary Plot',b'Ternary Plot'
b'DocType: Item Group',b'Item Classification',b'Sak Klassifisering'
b'DocType: Driver',b'License Number',b'Lisensnummer'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +131',b'Business Development Manager',b'Business Development Manager'
b'DocType: Maintenance Visit Purpose',b'Maintenance Visit Purpose',b'Vedlikehold Bes\xc3\xb8k Form\xc3\xa5l'
b'apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +19',b'Invoice Patient Registration',b'Faktura Pasientregistrering'
b'DocType: Crop',b'Period',b'Periode'
b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.js +27',b'General Ledger',b'General Ledger'
b'apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +33',b'Employee {0} on Leave on {1}',b'Employee {0} p\xc3\xa5 La den {1}'
b'apps/erpnext/erpnext/selling/doctype/campaign/campaign.js +10',b'View Leads',b'Vis Leads'
b'DocType: Program Enrollment Tool',b'New Program',b'nytt program'
b'DocType: Item Attribute Value',b'Attribute Value',b'Attributtverdi'
,b'Itemwise Recommended Reorder Level',b'Itemwise Anbefalt Omgj\xc3\xb8re niv\xc3\xa5'
b'DocType: Salary Detail',b'Salary Detail',b'l\xc3\xb8nn Detalj'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1070',b'Please select {0} first',b'Vennligst velg {0} f\xc3\xb8rst'
b'DocType: Appointment Type',b'Physician',b'lege'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +872',b'Batch {0} of Item {1} has expired.',b'Batch {0} av Element {1} er utl\xc3\xb8pt.'
b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment_dashboard.py +11',b'Consultations',b'konsultasjoner'
b'DocType: Sales Invoice',b'Commission',b'Kommisjon'
b'apps/erpnext/erpnext/config/manufacturing.py +27',b'Time Sheet for manufacturing.',b'Timeregistrering for produksjon.'
b'apps/erpnext/erpnext/templates/pages/cart.html +37',b'Subtotal',b'delsum'
b'apps/erpnext/erpnext/config/erpnext_integrations.py +18',b'GoCardless SEPA Mandate',b'GoCardless SEPA Mandat'
b'DocType: Physician',b'Charges',b'kostnader'
b'DocType: Production Plan',b'Get Items For Work Order',b'F\xc3\xa5 varer for arbeidsordre'
b'DocType: Salary Detail',b'Default Amount',b'Standard Bel\xc3\xb8p'
b'DocType: Lab Test Template',b'Descriptive',b'beskrivende'
b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +95',b'Warehouse not found in the system',b'Warehouse ikke funnet i systemet'
b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +115',"b""This Month's Summary""",b'Denne m\xc3\xa5neden Oppsummering'
b'DocType: Quality Inspection Reading',b'Quality Inspection Reading',b'Quality Inspection Reading'
b'apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +25',b'`Freeze Stocks Older Than` should be smaller than %d days.',b'`Freeze Aksjer Eldre Than` b\xc3\xb8r v\xc3\xa6re mindre enn% d dager.'
b'DocType: Tax Rule',b'Purchase Tax Template',b'Kj\xc3\xb8pe Tax Mal'
b'apps/erpnext/erpnext/utilities/user_progress.py +48',"b""Set a sales goal you'd like to achieve for your company.""",b'Sett et salgsm\xc3\xa5l du vil oppn\xc3\xa5 for din bedrift.'
,b'Project wise Stock Tracking',b'Prosjektet klok Stock Tracking'
b'DocType: GST HSN Code',b'Regional',b'Regional'
b'apps/erpnext/erpnext/config/healthcare.py +40',b'Laboratory',b'Laboratorium'
b'DocType: Stock Entry Detail',b'Actual Qty (at source/target)',b'Faktiske antall (ved kilden / target)'
b'DocType: Item Customer Detail',b'Ref Code',b'Ref Kode'
b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +75',b'Customer Group is Required in POS Profile',b'Kundegruppe er p\xc3\xa5krevd i POS-profil'
b'apps/erpnext/erpnext/config/hr.py +12',b'Employee records.',b'Medarbeider poster.'
b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +98',b'Please set Next Depreciation Date',b'Vennligst sett Neste Avskrivninger Dato'
b'DocType: HR Settings',b'Payroll Settings',b'L\xc3\xb8nn Innstillinger'
b'apps/erpnext/erpnext/config/accounts.py +146',b'Match non-linked Invoices and Payments.',b'Matche ikke bundet fakturaer og betalinger.'
b'DocType: POS Settings',b'POS Settings',b'POS-innstillinger'
b'apps/erpnext/erpnext/templates/pages/cart.html +16',b'Place Order',b'Legg inn bestilling'
b'DocType: Email Digest',b'New Purchase Orders',b'Nye innkj\xc3\xb8psordrer'
b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +24',b'Root cannot have a parent cost center',b'Root kan ikke ha en forelder kostnadssted'
b'apps/erpnext/erpnext/public/js/stock_analytics.js +54',b'Select Brand...',b'Velg merke ...'
b'apps/erpnext/erpnext/public/js/setup_wizard.js +32',b'Non Profit (beta)',b'Ikke-profitt (beta)'
b'apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +18',b'Training Events/Results',b'Treningsarrangementer / resultater'
b'apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +152',b'Accumulated Depreciation as on',b'Akkumulerte avskrivninger som p\xc3\xa5'
b'DocType: Sales Invoice',b'C-Form Applicable',b'C-Form Gjelder'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +438',b'Operation Time must be greater than 0 for Operation {0}',b'Operation Tid m\xc3\xa5 v\xc3\xa6re st\xc3\xb8rre enn 0 for operasjon {0}'
b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +107',b'Warehouse is mandatory',b'Warehouse er obligatorisk'
b'DocType: Shareholder',b'Address and Contacts',b'Adresse og Kontakt'
b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +67',b'Failed to create website',b'Kunne ikke opprette nettside'
b'DocType: Soil Analysis',b'Mg/K',b'Mg / K'
b'DocType: UOM Conversion Detail',b'UOM Conversion Detail',b'M\xc3\xa5lenheter Conversion Detalj'
b'apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +924',b'Retention Stock Entry already created or Sample Quantity not provided',b'Retention Stock Entry allerede opprettet eller Sample Quantity ikke oppgitt'
b'DocType: Program',b'Program Abbreviation',b'program forkortelse'
b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +52',b'Charges are updated in Purchase Receipt against each item',b'Kostnader er oppdatert i Purchase Mottak mot hvert element'
b'DocType: Warranty Claim',b'Resolved By',b'L\xc3\xb8st Av'
b'DocType: Bank Guarantee',b'Start Date',b'Startdato'
b'apps/erpnext/erpnext/config/hr.py +75',b'Allocate leaves for a period.',b'Bevilge blader for en periode.'
b'apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +42',b'Cheques and Deposits incorrectly cleared',b'Sjekker og Innskudd feil ryddet'
b'apps/erpnext/erpnext/accounts/doctype/account/account.py +46',b'Account {0}: You can not assign itself as parent account',b'Konto {0}: Du kan ikke tildele seg selv som forelder konto'
b'DocType: Purchase Invoice Item',b'Price List Rate',b'Prisliste Rate'
b'apps/erpnext/erpnext/utilities/activation.py +72',b'Create customer quotes',b'Opprett kunde sitater'
b'DocType: Item',"b'Show ""In Stock"" or ""Not in Stock"" based on stock available in this warehouse.'",b'Vis &quot;p\xc3\xa5 lager&quot; eller &quot;Not in Stock&quot; basert p\xc3\xa5 lager tilgjengelig i dette lageret.'
b'apps/erpnext/erpnext/config/manufacturing.py +38',b'Bill of Materials (BOM)',b'Bill of Materials (BOM)'
b'DocType: Item',b'Average time taken by the supplier to deliver',b'Gjennomsnittlig tid tatt av leverand\xc3\xb8ren til \xc3\xa5 levere'
b'DocType: Sample Collection',b'Collected By',b'Samlet inn'
b'apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.js +35',b'Assessment Result',b'Assessment Resultat'
b'DocType: Hotel Room Package',b'Hotel Room Package',b'Hotellromspakke'
b'apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +13',b'Hours',b'Timer'
b'DocType: Project',b'Expected Start Date',b'Tiltredelse'
b'DocType: Purchase Invoice',b'04-Correction in Invoice',b'04-korreksjon i faktura'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +963',b'Work Order already created for all items with BOM',b'Arbeidsordre som allerede er opprettet for alle elementer med BOM'
b'apps/erpnext/erpnext/stock/doctype/item/item.js +60',b'Variant Details Report',b'Variant Detaljer Report'
b'DocType: Setup Progress Action',b'Setup Progress Action',b'Oppsett Progress Action'
b'apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +36',b'Buying Price List',b'Kj\xc3\xb8pe prisliste'
b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +49',b'Remove item if charges is not applicable to that item',b'Fjern artikkel om avgifter er ikke aktuelt til dette elementet'
b'apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +21',b'Please select Maintenance Status as Completed or remove Completion Date',"b'Vennligst velg Vedlikeholdsstatus som Fullf\xc3\xb8rt, eller fjern sluttdato'"
b'DocType: Supplier',b'Default Payment Terms Template',b'Standard betalingsbetingelser mal'
b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +34',b'Transaction currency must be same as Payment Gateway currency',b'Transaksjons valuta m\xc3\xa5 v\xc3\xa6re samme som Payment Gateway valuta'
b'DocType: Payment Entry',b'Receive',b'Motta'
b'apps/erpnext/erpnext/templates/pages/rfq.html +75',b'Quotations: ',b'sitater:'
b'DocType: Maintenance Visit',b'Fully Completed',b'Fullt Fullf\xc3\xb8rt'
b'apps/erpnext/erpnext/projects/doctype/project/project_list.js +6',b'{0}% Complete',b'{0}% Komplett'
b'DocType: Employee',b'Educational Qualification',b'Pedagogiske Kvalifikasjoner'
b'DocType: Workstation',b'Operating Costs',b'Driftskostnader'
b'DocType: Budget',b'Action if Accumulated Monthly Budget Exceeded',b'Tiltak hvis Sn\xc3\xb8 M\xc3\xa5nedlig budsjett Skredet'
b'DocType: Subscription',b'Submit on creation',b'Send inn p\xc3\xa5 skapelse'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +483',b'Currency for {0} must be {1}',b'Valuta for {0} m\xc3\xa5 v\xc3\xa6re {1}'
b'DocType: Asset',b'Disposal Date',b'Deponering Dato'
b'DocType: Daily Work Summary Settings',"b'Emails will be sent to all Active Employees of the company at the given hour, if they do not have holiday. Summary of responses will be sent at midnight.'","b'E-post vil bli sendt til alle aktive ansatte i selskapet ved den gitte timen, hvis de ikke har ferie. Oppsummering av svarene vil bli sendt ved midnatt.'"
b'DocType: Employee Leave Approver',b'Employee Leave Approver',b'Ansatt La Godkjenner'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +510',b'Row {0}: An Reorder entry already exists for this warehouse {1}',b'Rad {0}: En Omgj\xc3\xb8re oppf\xc3\xb8ring finnes allerede for dette lageret {1}'
b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +99',"b'Cannot declare as lost, because Quotation has been made.'","b'Kan ikke erkl\xc3\xa6re som tapt, fordi tilbudet er gjort.'"
b'apps/erpnext/erpnext/hr/doctype/training_event/training_event.js +16',b'Training Feedback',b'trening Tilbakemelding'
b'DocType: Supplier Scorecard Criteria',b'Supplier Scorecard Criteria',b'Leverand\xc3\xb8r Scorecard Kriterier'
b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +149',b'Please select Start Date and End Date for Item {0}',b'Vennligst velg startdato og sluttdato for Element {0}'
b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +55',b'Course is mandatory in row {0}',b'Kurset er obligatorisk i rad {0}'
b'apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.js +16',b'To date cannot be before from date',b'Til dags dato kan ikke v\xc3\xa6re f\xc3\xb8r fra dato'
b'DocType: Supplier Quotation Item',b'Prevdoc DocType',b'Prevdoc DOCTYPE'
b'DocType: Cash Flow Mapper',b'Section Footer',b'Seksjon Footer'
b'apps/erpnext/erpnext/stock/doctype/item/item.js +304',b'Add / Edit Prices',b'Legg til / Rediger priser'
b'DocType: Batch',b'Parent Batch',b'Parent Batch'
b'DocType: Cheque Print Template',b'Cheque Print Template',b'Sjekk ut Mal'
b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +36',b'Chart of Cost Centers',b'Plan Kostnadssteder'
b'DocType: Lab Test Template',b'Sample Collection',b'Eksempel Innsamling'
,b'Requested Items To Be Ordered',b'Ettersp\xc3\xb8r Elementer bestilles'
b'apps/erpnext/erpnext/public/js/hub/hub_page.js +137',b'My Orders',b'Mine bestillinger'
b'DocType: Price List',b'Price List Name',b'Prisliste Name'
b'DocType: BOM',b'Manufacturing',b'Manufacturing'
,b'Ordered Items To Be Delivered',b'Bestilte varer som skal leveres'
b'DocType: Account',b'Income',b'Inntekt'
b'DocType: Industry Type',b'Industry Type',b'Industry Type'
b'apps/erpnext/erpnext/templates/includes/cart.js +150',b'Something went wrong!',b'Noe gikk galt!'
b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +105',b'Warning: Leave application contains following block dates',b'Advarsel: La programmet inneholder f\xc3\xb8lgende blokk datoer'
b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +275',b'Sales Invoice {0} has already been submitted',b'Salg Faktura {0} er allerede innsendt'
b'DocType: Supplier Scorecard Scoring Criteria',b'Score',b'Score'
b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +25',b'Fiscal Year {0} does not exist',b'Regnskaps\xc3\xa5ret {0} finnes ikke'
b'DocType: Asset Maintenance Log',b'Completion Date',b'Ferdigstillelse Dato'
b'DocType: Purchase Invoice Item',b'Amount (Company Currency)',b'Bel\xc3\xb8p (Selskap Valuta)'
b'DocType: Agriculture Analysis Criteria',b'Agriculture User',b'Landbruker Bruker'
b'apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +38',b'Valid till date cannot be before transaction date',b'Gyldig til dato kan ikke v\xc3\xa6re f\xc3\xb8r transaksjonsdato'
b'apps/erpnext/erpnext/stock/stock_ledger.py +381',b'{0} units of {1} needed in {2} on {3} {4} for {5} to complete this transaction.',b'{0} enheter av {1} trengs i {2} p\xc3\xa5 {3} {4} for {5} for \xc3\xa5 fullf\xc3\xb8re denne transaksjonen.'
b'DocType: Fee Schedule',b'Student Category',b'student Kategori'
b'DocType: Announcement',b'Student',b'Student'
b'apps/erpnext/erpnext/config/hr.py +238',b'Organization unit (department) master.',b'Organisasjonsenhet (departement) mester.'
b'DocType: Shipping Rule',b'Shipping Rule Type',b'Forsendelsestype'
b'apps/erpnext/erpnext/utilities/user_progress.py +239',b'Go to Rooms',b'G\xc3\xa5 til rom'
b'apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +75',b'Please enter message before sending',b'Skriv inn meldingen f\xc3\xb8r du sender'
b'DocType: Purchase Invoice',b'DUPLICATE FOR SUPPLIER',b'DUPLIKATE FOR LEVERAND\xc3\x98R'
b'DocType: Email Digest',b'Pending Quotations',b'Avventer Sitater'
b'apps/erpnext/erpnext/config/accounts.py +318',b'Point-of-Sale Profile',b'Point-of-Sale Profile'
b'apps/erpnext/erpnext/agriculture/doctype/soil_texture/soil_texture.py +25',b'{0} should be a value between 0 and 100',b'{0} skal v\xc3\xa6re en verdi mellom 0 og 100'
b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +94',b'Next Depreciation Date cannot be before Available-for-use Date',b'Neste avskrivningsdato kan ikke v\xc3\xa6re f\xc3\xb8r Tilgjengelig-til-bruk-dato'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +156',b'Unsecured Loans',b'Usikret l\xc3\xa5n'
b'DocType: Cost Center',b'Cost Center Name',b'Kostnadssteds Name'
b'DocType: Student',b'B+',b'B +'
b'DocType: HR Settings',b'Max working hours against Timesheet',b'Max arbeidstid mot Timeregistrering'
b'DocType: Maintenance Schedule Detail',b'Scheduled Date',b'Planlagt dato'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +214',b'Total Paid Amt',b'Sum innskutt Amt'
b'DocType: SMS Center',b'Messages greater than 160 characters will be split into multiple messages',b'Meldinger som er st\xc3\xb8rre enn 160 tegn vil bli delt inn i flere meldinger'
b'DocType: Purchase Receipt Item',b'Received and Accepted',b'Mottatt og akseptert'
b'DocType: Hub Settings',b'Company and Seller Profile',b'Bedrift og selgerprofil'
,b'GST Itemised Sales Register',b'GST Artized Sales Register'
b'DocType: Soil Texture',b'Silt Loam',b'Silt Loam'
,b'Serial No Service Contract Expiry',b'Serial No Service kontraktsutl\xc3\xb8p'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +299',b'You cannot credit and debit same account at the same time',b'Du kan ikke kreditt- og debet samme konto samtidig'
b'DocType: Vital Signs',"b""Adults' pulse rate is anywhere between 50 and 80 beats per minute.""",b'Voksnes pulsrate er hvor som helst mellom 50 og 80 slag per minutt.'
b'DocType: Naming Series',b'Help HTML',b'Hjelp HTML'
b'DocType: Student Group Creation Tool',b'Student Group Creation Tool',b'Student Gruppe Creation Tool'
b'DocType: Item',b'Variant Based On',b'Variant basert p\xc3\xa5'
b'apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +53',b'Total weightage assigned should be 100%. It is {0}',b'Total weightage tilordnet skal v\xc3\xa6re 100%. Det er {0}'
b'apps/erpnext/erpnext/utilities/user_progress.py +109',b'Your Suppliers',b'Dine Leverand\xc3\xb8rer'
b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +6',b'Please correct the',b'Vennligst korrig\xc3\xa9r'
b'apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +80',b'Cannot set as Lost as Sales Order is made.',b'Kan ikke settes som tapt som Salgsordre er gjort.'
b'DocType: Request for Quotation Item',b'Supplier Part No',b'Leverand\xc3\xb8r varenummer'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +382',"b""Cannot deduct when category is for 'Valuation' or 'Vaulation and Total'""",b'Kan ikke trekke n\xc3\xa5r kategorien er for verdsetting &#39;eller&#39; Vaulation og Total &#39;'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +377',b'Received From',b'Mottatt fra'
b'DocType: Lead',b'Converted',b'Omregnet'
b'DocType: Item',b'Has Serial No',b'Har Serial No'
b'DocType: Employee',b'Date of Issue',b'Utstedelsesdato'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +222',"b""As per the Buying Settings if Purchase Reciept Required == 'YES', then for creating Purchase Invoice, user need to create Purchase Receipt first for item {0}""","b'I henhold til kj\xc3\xb8psinnstillingene hvis kj\xc3\xb8p tilbakekj\xc3\xb8pt er n\xc3\xb8dvendig == &#39;JA&#39; og deretter for \xc3\xa5 opprette kj\xc3\xb8pfaktura, m\xc3\xa5 brukeren opprette kj\xc3\xb8psmottak f\xc3\xb8rst for element {0}'"
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +167',b'Row #{0}: Set Supplier for item {1}',b'Row # {0}: Sett Leverand\xc3\xb8r for elementet {1}'
b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +121',b'Row {0}: Hours value must be greater than zero.',b'Rad {0}: Timer verdien m\xc3\xa5 v\xc3\xa6re st\xc3\xb8rre enn null.'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +195',b'Website Image {0} attached to Item {1} cannot be found',b'Website Bilde {0} festet til Element {1} kan ikke finnes'
b'DocType: Issue',b'Content Type',b'Innholdstype'
b'DocType: Asset',b'Assets',b'Eiendeler'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +17',b'Computer',b'Datamaskin'
b'DocType: Item',b'List this Item in multiple groups on the website.',b'Liste denne vare i flere grupper p\xc3\xa5 nettstedet.'
b'DocType: Payment Term',b'Due Date Based On',b'Forfallsdato basert p\xc3\xa5'
b'apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +82',b'Please set default customer group and territory in Selling Settings',b'Vennligst angi standard kundegruppe og territorium i salgsinnstillinger'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +214',b'{0} {1} does not exist',b'{0} {1} finnes ikke'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +323',b'Please check Multi Currency option to allow accounts with other currency',b'Vennligst sjekk Multi Valuta alternativet for \xc3\xa5 tillate kontoer med andre valuta'
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +88',b'Item: {0} does not exist in the system',b'Sak: {0} finnes ikke i systemet'
b'apps/erpnext/erpnext/accounts/doctype/account/account.py +106',b'You are not authorized to set Frozen value',b'Du er ikke autorisert til \xc3\xa5 sette Frozen verdi'
b'DocType: Payment Reconciliation',b'Get Unreconciled Entries',b'F\xc3\xa5 avstemte Entries'
b'DocType: Payment Reconciliation',b'From Invoice Date',b'Fra Fakturadato'
b'DocType: Healthcare Settings',b'Laboratory Settings',b'Laboratorieinnstillinger'
b'DocType: Patient Appointment',b'Service Unit',b'Servicenhet'
b'apps/erpnext/erpnext/buying/report/quoted_item_comparison/quoted_item_comparison.js +97',b'Successfully Set Supplier',b'Vellykket sett leverand\xc3\xb8r'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +75',b'Leave Encashment',b'La Encashment'
b'apps/erpnext/erpnext/public/js/setup_wizard.js +114',b'What does it do?',b'Hva gj\xc3\xb8r det?'
b'DocType: Crop',b'Byproducts',b'biprodukter'
b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +84',b'To Warehouse',b'Til Warehouse'
b'apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +26',b'All Student Admissions',b'Alle Student Opptak'
,b'Average Commission Rate',b'Gjennomsnittlig kommisjon'
b'DocType: Share Balance',b'No of Shares',b'Antall aksjer'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +448',"b""'Has Serial No' can not be 'Yes' for non-stock item""",b'\xc2\xabHar Serial No &#39;kan ikke v\xc3\xa6re&#39; Ja &#39;for ikke-lagervare'
b'apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +59',b'Select Status',b'Velg Status'
b'apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +41',b'Attendance can not be marked for future dates',b'Oppm\xc3\xb8te kan ikke merkes for fremtidige datoer'
b'DocType: Pricing Rule',b'Pricing Rule Help',b'Prising Rule Hjelp'
b'DocType: School House',b'House Name',b'Husnavn'
b'DocType: Fee Schedule',b'Total Amount per Student',b'Totalt bel\xc3\xb8p per student'
b'DocType: Purchase Taxes and Charges',b'Account Head',b'Account Leder'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +153',b'Electrical',b'Elektrisk'
b'apps/erpnext/erpnext/utilities/activation.py +100',b'Add the rest of your organization as your users. You can also add invite Customers to your portal by adding them from Contacts',b'Tilsett resten av organisasjonen som brukerne. Du kan ogs\xc3\xa5 legge invitere kunder til portalen ved \xc3\xa5 legge dem fra Kontakter'
b'DocType: Stock Entry',b'Total Value Difference (Out - In)',b'Total verdi Difference (ut -)'
b'DocType: Grant Application',b'Requested Amount',b'\xc3\x98nsket bel\xc3\xb8p'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +348',b'Row {0}: Exchange Rate is mandatory',b'Rad {0}: Exchange Rate er obligatorisk'
b'apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +27',b'User ID not set for Employee {0}',b'Bruker-ID ikke satt for Employee {0}'
b'DocType: Vehicle',b'Vehicle Value',b'Vehicle Verdi'
b'DocType: Crop Cycle',b'Detected Diseases',b'Detekterte sykdommer'
b'DocType: Stock Entry',b'Default Source Warehouse',b'Standardkilde Warehouse'
b'DocType: Item',b'Customer Code',b'Kunden Kode'
b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +220',b'Birthday Reminder for {0}',b'Bursdag P\xc3\xa5minnelse for {0}'
b'DocType: Asset Maintenance Task',b'Last Completion Date',b'Siste sluttdato'
b'apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +72',b'Days Since Last Order',b'Dager siden siste Bestill'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +365',b'Debit To account must be a Balance Sheet account',b'Uttak fra kontoen m\xc3\xa5 v\xc3\xa6re en balansekonto'
b'DocType: Buying Settings',b'Naming Series',b'Navngi Series'
b'DocType: GoCardless Settings',b'GoCardless Settings',b'GoCardless Innstillinger'
b'DocType: Leave Block List',b'Leave Block List Name',b'La Block List Name'
b'apps/erpnext/erpnext/hr/doctype/vehicle/vehicle.py +14',b'Insurance Start date should be less than Insurance End date',b'Forsikring Startdatoen m\xc3\xa5 v\xc3\xa6re mindre enn Forsikring Sluttdato'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +32',b'Stock Assets',b'Aksje Eiendeler'
b'DocType: Restaurant',b'Active Menu',b'Aktiv meny'
b'DocType: Target Detail',b'Target Qty',b'Target Antall'
b'DocType: Shopping Cart Settings',b'Checkout Settings',b'Kasse Innstillinger'
b'DocType: Student Attendance',b'Present',b'Present'
b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +37',b'Delivery Note {0} must not be submitted',b'Levering Note {0} m\xc3\xa5 ikke sendes inn'
b'DocType: Notification Control',b'Sales Invoice Message',b'Salgsfaktura Message'
b'apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +27',b'Closing Account {0} must be of type Liability / Equity',b'Lukke konto {0} m\xc3\xa5 v\xc3\xa6re av typen Ansvar / Egenkapital'
b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +325',b'Salary Slip of employee {0} already created for time sheet {1}',b'L\xc3\xb8nn Slip av ansattes {0} allerede opprettet for timeregistrering {1}'
b'DocType: Vehicle Log',b'Odometer',b'Kilometerteller'
b'DocType: Production Plan Item',b'Ordered Qty',b'Bestilte Antall'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +744',b'Item {0} is disabled',b'Element {0} er deaktivert'
b'DocType: Stock Settings',b'Stock Frozen Upto',b'Stock Frozen Opp'
b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +930',b'BOM does not contain any stock item',b'BOM inneholder ikke lagervare'
b'DocType: Chapter',b'Chapter Head',b'Kapittelhode'
b'DocType: Payment Term',b'Month(s) after the end of the invoice month',b'M\xc3\xa5ned (e) etter slutten av faktura m\xc3\xa5neden'
b'apps/erpnext/erpnext/config/projects.py +24',b'Project activity / task.',b'Prosjektet aktivitet / oppgave.'
b'DocType: Vehicle Log',b'Refuelling Details',b'Fylle drivstoff Detaljer'
b'apps/erpnext/erpnext/config/hr.py +104',b'Generate Salary Slips',b'Generere l\xc3\xb8nnsslipper'
b'apps/erpnext/erpnext/agriculture/doctype/water_analysis/water_analysis.py +25',b'Lab result datetime cannot be before testing datetime',b'Lab-resultat datetime kan ikke v\xc3\xa6re f\xc3\xb8r testing av datetime'
b'DocType: POS Profile',b'Allow user to edit Discount',b'Tillat brukeren \xc3\xa5 redigere rabatt'
b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +55',b'Get customers from',b'F\xc3\xa5 kunder fra'
b'DocType: Purchase Invoice Item',b'Include Exploded Items',b'Inkluder eksploderte elementer'
b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +45',"b'Buying must be checked, if Applicable For is selected as {0}'","b'Kj\xc3\xb8per m\xc3\xa5 sjekkes, hvis dette gjelder for er valgt som {0}'"
b'apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +40',b'Discount must be less than 100',b'Rabatt m\xc3\xa5 v\xc3\xa6re mindre enn 100'
b'DocType: Shipping Rule',b'Restrict to Countries',b'Begrens til land'
b'DocType: Purchase Invoice',b'Write Off Amount (Company Currency)',b'Skriv Off Bel\xc3\xb8p (Selskap Valuta)'
b'DocType: Sales Invoice Timesheet',b'Billing Hours',b'fakturerings~~POS=TRUNC Timer'
b'DocType: Project',b'Total Sales Amount (via Sales Order)',b'Total salgsbel\xc3\xb8p (via salgsordre)'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +548',b'Default BOM for {0} not found',b'Standard BOM for {0} ikke funnet'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +514',b'Row #{0}: Please set reorder quantity',b'Row # {0}: Vennligst sett omgj\xc3\xb8ring kvantitet'
b'apps/erpnext/erpnext/public/js/pos/pos.html +20',b'Tap items to add them here',b'Trykk p\xc3\xa5 elementer for \xc3\xa5 legge dem til her'
b'DocType: Fees',b'Program Enrollment',b'program P\xc3\xa5melding'
b'DocType: Share Transfer',b'To Folio No',b'Til Folio nr'
b'DocType: Landed Cost Voucher',b'Landed Cost Voucher',b'Landed Cost Voucher'
b'apps/erpnext/erpnext/public/js/queries.js +39',b'Please set {0}',b'Vennligst sett {0}'
b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +37',b'{0} - {1} is inactive student',b'{0} - {1} er inaktiv student'
b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +37',b'{0} - {1} is inactive student',b'{0} - {1} er inaktiv student'
b'DocType: Employee',b'Health Details',b'Helse Detaljer'
b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +24',b'To create a Payment Request reference document is required',b'For \xc3\xa5 opprette en betalingsforesp\xc3\xb8rsel kreves referansedokument'
b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +24',b'To create a Payment Request reference document is required',b'For \xc3\xa5 opprette en betalingsforesp\xc3\xb8rsel kreves referansedokument'
b'DocType: Soil Texture',b'Sandy Clay',b'Sandy Clay'
b'DocType: Grant Application',b'Assessment  Manager',b'Vurderingsleder'
b'DocType: Payment Entry',b'Allocate Payment Amount',b'Fordele Betalingsbel\xc3\xb8p'
b'DocType: Employee External Work History',b'Salary',b'L\xc3\xb8nn'
b'DocType: Serial No',b'Delivery Document Type',b'Levering dokumenttype'
b'DocType: Sales Order',b'Partly Delivered',b'Delvis Leveres'
b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +48',b'Item Code &gt; Item Group &gt; Brand',b'Varenummer&gt; Varegruppe&gt; Varemerke'
b'DocType: Item Variant Settings',b'Do not update variants on save',b'Ikke oppdater varianter p\xc3\xa5 lagre'
b'DocType: Email Digest',b'Receivables',b'Fordringer'
b'DocType: Lead Source',b'Lead Source',b'Lead Source'
b'DocType: Customer',b'Additional information regarding the customer.',b'Ytterligere informasjon om kunden.'
b'DocType: Quality Inspection Reading',b'Reading 5',b'Reading 5'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +236',"b'{0} {1} is associated with {2}, but Party Account is {3}'","b'{0} {1} er knyttet til {2}, men partikonto er {3}'"
b'apps/erpnext/erpnext/healthcare/doctype/sample_collection/sample_collection.js +7',b'View Lab Tests',b'Se labtester'
b'DocType: Purchase Invoice',b'Y',b'Y'
b'DocType: Maintenance Visit',b'Maintenance Date',b'Vedlikehold Dato'
b'DocType: Purchase Invoice Item',b'Rejected Serial No',b'Avvist Serial No'
b'apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +82',b'Year start date or end date is overlapping with {0}. To avoid please set company',b'\xc3\x85r startdato eller sluttdato er overlappende med {0}. For \xc3\xa5 unng\xc3\xa5 vennligst sett selskap'
b'apps/erpnext/erpnext/selling/doctype/customer/customer.py +122',b'Please mention the Lead Name in Lead {0}',b'Vennligst nevne Lead Name in Lead {0}'
b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +156',b'Start date should be less than end date for Item {0}',b'Startdato skal v\xc3\xa6re mindre enn sluttdato for Element {0}'
b'DocType: Item',"b'Example: ABCD.#####\nIf series is set and Serial No is not mentioned in transactions, then automatic serial number will be created based on this series. If you always want to explicitly mention Serial Nos for this item. leave this blank.'","b'Eksempel:. ABCD ##### Hvis serien er satt og serienummer er ikke nevnt i transaksjoner, og deretter automatisk serienummer vil bli opprettet basert p\xc3\xa5 denne serien. Hvis du alltid vil eksplisitt nevne Serial Nos for dette elementet. la dette st\xc3\xa5 tomt.'"
b'DocType: Upload Attendance',b'Upload Attendance',b'Last opp Oppm\xc3\xb8te'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +579',b'BOM and Manufacturing Quantity are required',b'BOM og Industri Antall kreves'
b'apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +50',b'Ageing Range 2',b'Aldring Range 2'
b'DocType: SG Creation Tool Course',b'Max Strength',b'Max Strength'
b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +28',b'Installing presets',b'Installere forh\xc3\xa5ndsinnstillinger'
b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +85',b'No Delivery Note selected for Customer {}',b'Ingen leveringsnotering valgt for kunden {}'
b'apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +25',b'BOM replaced',b'BOM erstattet'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1052',b'Select Items based on Delivery Date',b'Velg elementer basert p\xc3\xa5 leveringsdato'
b'DocType: Grant Application',b'Has any past Grant Record',b'Har noen tidligere Grant Record'
,b'Sales Analytics',b'Salgs Analytics'
b'apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +127',b'Available {0}',b'Tilgjengelig {0}'
,b'Prospects Engaged But Not Converted',"b'Utsikter engasjert, men ikke konvertert'"
,b'Prospects Engaged But Not Converted',"b'Utsikter engasjert, men ikke konvertert'"
b'DocType: Manufacturing Settings',b'Manufacturing Settings',b'Produksjons Innstillinger'
b'apps/erpnext/erpnext/config/setup.py +56',b'Setting up Email',b'Sette opp e-post'
b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +57',b'Guardian1 Mobile No',b'Guardian1 Mobile No'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +106',b'Please enter default currency in Company Master',b'Skriv inn standardvaluta i selskapet Master'
b'DocType: Stock Entry Detail',b'Stock Entry Detail',b'Stock Entry Detail'
b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +109',b'Daily Reminders',b'Daglige p\xc3\xa5minnelser'
b'DocType: Products Settings',b'Home Page is Products',b'Hjemme side er produkter'
,b'Asset Depreciation Ledger',b'Asset Avskrivninger Ledger'
b'apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +91',b'Tax Rule Conflicts with {0}',b'Skatteregel Konflikter med {0}'
b'apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +25',b'New Account Name',b'New Account Name'
b'DocType: Purchase Invoice Item',b'Raw Materials Supplied Cost',b'R\xc3\xa5vare Leveres Cost'
b'DocType: Selling Settings',b'Settings for Selling Module',b'Innstillinger for \xc3\xa5 selge Module'
b'DocType: Hotel Room Reservation',b'Hotel Room Reservation',b'Hotellrombestilling'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +115',b'Customer Service',b'Kundeservice'
b'DocType: BOM',b'Thumbnail',b'Thumbnail'
b'DocType: Item Customer Detail',b'Item Customer Detail',b'Sak Customer Detalj'
b'apps/erpnext/erpnext/config/hr.py +50',b'Offer candidate a Job.',b'Tilbudet kandidat en jobb.'
b'DocType: Notification Control',b'Prompt for Email on Submission of',b'Sp\xc3\xb8r for E-post om innsending av'
b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +88',b'Total allocated leaves are more than days in the period',b'Totalt tildelte bladene er mer enn dager i perioden'
b'DocType: Land Unit',b'Linked Soil Analysis',b'Koblet jordanalyse'
b'DocType: Pricing Rule',b'Percentage',b'Prosentdel'
b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +70',b'Item {0} must be a stock Item',b'Elementet {0} m\xc3\xa5 v\xc3\xa6re en lagervare'
b'DocType: Manufacturing Settings',b'Default Work In Progress Warehouse',b'Standard Work In Progress Warehouse'
b'apps/erpnext/erpnext/config/accounts.py +288',b'Default settings for accounting transactions.',b'Standardinnstillingene for regnskapsmessige transaksjoner.'
b'DocType: Maintenance Visit',b'MV',b'MV'
b'DocType: Restaurant',b'Default Tax Template',b'Standardskattemall'
b'apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +66',b'{0} Students have been enrolled',b'{0} Studentene har blitt registrert'
b'DocType: Fees',b'Student Details',b'Studentdetaljer'
b'DocType: Purchase Invoice Item',b'Stock Qty',b'Varenummer'
b'DocType: Employee Loan',b'Repayment Period in Months',b'Nedbetalingstid i m\xc3\xa5neder'
b'apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +26',b'Error: Not a valid id?',b'Feil: Ikke en gyldig id?'
b'DocType: Naming Series',b'Update Series Number',b'Update-serien Nummer'
b'DocType: Account',b'Equity',b'Egenkapital'
b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +78',"b""{0} {1}: 'Profit and Loss' type account {2} not allowed in Opening Entry""",b'{0} {1}: &#39;Resultat&#39; type konto {2} ikke tillatt i \xc3\x85pning Entry'
b'DocType: Sales Order',b'Printing Details',b'Utskrift Detaljer'
b'DocType: Task',b'Closing Date',b'Avslutningsdato'
b'DocType: Sales Order Item',b'Produced Quantity',b'Produsert Antall'
b'DocType: Timesheet',b'Work Detail',b'Arbeidsdetalj'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +126',b'Engineer',b'Ingeni\xc3\xb8r'
b'DocType: Journal Entry',b'Total Amount Currency',b'Totalbel\xc3\xb8p Valuta'
b'apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +38',b'Search Sub Assemblies',b'S\xc3\xb8k Sub Assemblies'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +171',b'Item Code required at Row No {0}',b'Elementkode kreves ved Row Nei {0}'
b'DocType: GST Account',b'SGST Account',b'SGST-konto'
b'apps/erpnext/erpnext/utilities/user_progress.py +154',b'Go to Items',b'G\xc3\xa5 til elementer'
b'DocType: Sales Partner',b'Partner Type',b'Partner Type'
b'DocType: Purchase Taxes and Charges',b'Actual',b'Faktiske'
b'DocType: Restaurant Menu',b'Restaurant Manager',b'Restaurantsjef'
b'DocType: Authorization Rule',b'Customerwise Discount',b'Customerwise Rabatt'
b'apps/erpnext/erpnext/config/projects.py +46',b'Timesheet for tasks.',b'Timeregistrering for oppgaver.'
b'DocType: Purchase Invoice',b'Against Expense Account',b'Mot regning'
b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +282',b'Installation Note {0} has already been submitted',b'Installasjon Merk {0} har allerede blitt sendt'
b'DocType: Bank Reconciliation',b'Get Payment Entries',b'F\xc3\xa5 Betalings Entries'
b'DocType: Quotation Item',b'Against Docname',b'Mot Docname'
b'DocType: SMS Center',b'All Employee (Active)',b'All Employee (Active)'
b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +9',b'View Now',b'Vis n\xc3\xa5'
b'DocType: BOM',b'Raw Material Cost',b'Raw Material Cost'
b'DocType: Item Reorder',b'Re-Order Level',b'Re-Order niv\xc3\xa5'
b'apps/erpnext/erpnext/projects/doctype/project/project.js +54',b'Gantt Chart',b'Gantt'
b'DocType: Crop Cycle',b'Cycle Type',b'Syklus type'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +99',b'Part-time',b'Deltid'
b'DocType: Employee',b'Applicable Holiday List',b'Gjelder Holiday List'
b'DocType: Employee',b'Cheque',b'Cheque'
b'DocType: Training Event',b'Employee Emails',b'Medarbeider e-post'
b'apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +60',b'Series Updated',b'Serien Oppdatert'
b'apps/erpnext/erpnext/accounts/doctype/account/account.py +159',b'Report Type is mandatory',b'Rapporter Type er obligatorisk'
b'DocType: Item',b'Serial Number Series',b'Serienummer Series'
b'apps/erpnext/erpnext/buying/utils.py +68',b'Warehouse is mandatory for stock Item {0} in row {1}',b'Warehouse er obligatorisk for lager Element {0} i rad {1}'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +45',b'Retail & Wholesale',b'Retail &amp; Wholesale'
b'DocType: Issue',b'First Responded On',b'F\xc3\xb8rst Svarte P\xc3\xa5'
b'DocType: Website Item Group',b'Cross Listing of Item in multiple groups',b'Cross Notering av varen i flere grupper'
b'apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +90',b'Fiscal Year Start Date and Fiscal Year End Date are already set in Fiscal Year {0}',b'Regnskaps\xc3\xa5r Startdato og regnskaps\xc3\xa5r sluttdato er allerede satt i regnskaps\xc3\xa5ret {0}'
b'DocType: Projects Settings',b'Ignore User Time Overlap',b'Ignorer brukstidens overlapping'
b'apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +113',b'Clearance Date updated',b'Lagersalg oppdatert'
b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +146',b'Split Batch',b'Split Batch'
b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +146',b'Split Batch',b'Split Batch'
b'DocType: Stock Settings',b'Batch Identification',b'Batchidentifikasjon'
b'apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +132',b'Successfully Reconciled',b'Vellykket Forsonet'
b'DocType: Request for Quotation Supplier',b'Download PDF',b'Last ned PDF'
b'DocType: Work Order',b'Planned End Date',b'Planlagt sluttdato'
b'DocType: Shareholder',b'Hidden list maintaining the list of contacts linked to Shareholder',b'Skjult liste opprettholder listen over kontakter knyttet til Aksjon\xc3\xa6r'
b'apps/erpnext/erpnext/config/non_profit.py +63',b'Donor Type information.',b'Donor Type informasjon.'
b'DocType: Request for Quotation',b'Supplier Detail',b'Leverand\xc3\xb8r Detalj'
b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +100',b'Error in formula or condition: {0}',b'Feil i formel eller betingelse: {0}'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +99',b'Invoiced Amount',b'Fakturert bel\xc3\xb8p'
b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +47',b'Criteria weights must add up to 100%',b'Kriterievekter m\xc3\xa5 legge opp til 100%'
b'apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.js +7',b'Attendance',b'Oppm\xc3\xb8te'
b'apps/erpnext/erpnext/public/js/pos/pos.html +115',b'Stock Items',b'lager~~POS=TRUNC'
b'DocType: BOM',b'Materials',b'Materialer'
b'DocType: Leave Block List',"b'If not checked, the list will have to be added to each Department where it has to be applied.'","b'Hvis ikke sjekket, vil listen m\xc3\xa5 legges til hver avdeling hvor det m\xc3\xa5 brukes.'"
b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +111',b'Creating {0}',b'Opprette {0}'
b'apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +28',b'Source and Target Warehouse cannot be same',b'Kilde og Target Warehouse kan ikke v\xc3\xa6re det samme'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +586',b'Posting date and posting time is mandatory',b'Konteringsdato og legger tid er obligatorisk'
b'apps/erpnext/erpnext/config/buying.py +76',b'Tax template for buying transactions.',b'Skatt mal for \xc3\xa5 kj\xc3\xb8pe transaksjoner.'
,b'Item Prices',b'Varepriser'
b'DocType: Purchase Order',b'In Words will be visible once you save the Purchase Order.',b'I Ord vil v\xc3\xa6re synlig n\xc3\xa5r du lagrer innkj\xc3\xb8psordre.'
b'DocType: Period Closing Voucher',b'Period Closing Voucher',b'Periode Closing Voucher'
b'DocType: Consultation',b'Review Details',b'Gjennomg\xc3\xa5 detaljer'
b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +185',b'The shareholder does not belong to this company',b'Aksjon\xc3\xa6ren tilh\xc3\xb8rer ikke dette firmaet'
b'DocType: Dosage Form',b'Dosage Form',b'Doseringsform'
b'apps/erpnext/erpnext/config/selling.py +67',b'Price List master.',b'Prisliste mester.'
b'DocType: Task',b'Review Date',b'Omtale Dato'
b'DocType: Company',b'Series for Asset Depreciation Entry (Journal Entry)',b'Serie for Asset Depreciation Entry (Journal Entry)'
b'DocType: Membership',b'Member Since',b'Medlem siden'
b'DocType: Purchase Invoice',b'Advance Payments',b'Forskudd'
b'DocType: Purchase Taxes and Charges',b'On Net Total',b'On Net Total'
b'apps/erpnext/erpnext/controllers/item_variant.py +92',b'Value for Attribute {0} must be within the range of {1} to {2} in the increments of {3} for Item {4}',b'Verdi for Egenskap {0} m\xc3\xa5 v\xc3\xa6re innenfor omr\xc3\xa5det {1} til {2} i trinn p\xc3\xa5 {3} for Element {4}'
b'DocType: Restaurant Reservation',b'Waitlisted',b'ventelisten'
b'apps/erpnext/erpnext/accounts/doctype/account/account.py +124',b'Currency can not be changed after making entries using some other currency',b'Valuta kan ikke endres etter at oppf\xc3\xb8ringer ved hjelp av en annen valuta'
b'DocType: Shipping Rule',b'Fixed',b'fast'
b'DocType: Vehicle Service',b'Clutch Plate',b'clutch Plate'
b'DocType: Company',b'Round Off Account',b'Rund av konto'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +93',b'Administrative Expenses',b'Administrative utgifter'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +18',b'Consulting',b'Consulting'
b'DocType: Customer Group',b'Parent Customer Group',b'Parent Kundegruppe'
b'DocType: Journal Entry',b'Subscription',b'Abonnement'
b'DocType: Purchase Invoice',b'Contact Email',b'Kontakt Epost'
b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +11',b'Fee Creation Pending',b'Avgiftskapasitet venter'
b'DocType: Appraisal Goal',b'Score Earned',b'Resultat tjent'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +241',b'Notice Period',b'Oppsigelsestid'
b'DocType: Asset Category',b'Asset Category Name',b'Asset Category Name'
b'apps/erpnext/erpnext/setup/doctype/territory/territory.js +13',b'This is a root territory and cannot be edited.',b'Dette er en rot territorium og kan ikke redigeres.'
b'apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js +5',b'New Sales Person Name',b'New Sales Person navn'
b'DocType: Packing Slip',b'Gross Weight UOM',b'Bruttovekt m\xc3\xa5lenheter'
b'DocType: Asset Maintenance Task',b'Preventive Maintenance',b'Forebyggende vedlikehold'
b'DocType: Delivery Note Item',b'Against Sales Invoice',b'Mot Salg Faktura'
b'DocType: Purchase Invoice',b'07-Others',b'07-Andre'
b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +151',b'Please enter serial numbers for serialized item ',b'Vennligst skriv inn serienumre for serialisert element'
b'DocType: Bin',b'Reserved Qty for Production',b'Reservert Antall for produksjon'
b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +43',b'EcritureNum',b'EcritureNum'
b'DocType: Student Group Creation Tool',"b""Leave unchecked if you don't want to consider batch while making course based groups. """,b'La v\xc3\xa6re ukontrollert hvis du ikke vil vurdere batch mens du lager kursbaserte grupper.'
b'DocType: Student Group Creation Tool',"b""Leave unchecked if you don't want to consider batch while making course based groups. """,b'La v\xc3\xa6re ukontrollert hvis du ikke vil vurdere batch mens du lager kursbaserte grupper.'
b'DocType: Asset',b'Frequency of Depreciation (Months)',b'Frekvens av Avskrivninger (m\xc3\xa5neder)'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +500',b'Credit Account',b'Credit konto'
b'DocType: Landed Cost Item',b'Landed Cost Item',b'Landed Cost Element'
b'apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.js +57',b'Show zero values',b'Vis nullverdier'
b'DocType: BOM',b'Quantity of item obtained after manufacturing / repacking from given quantities of raw materials',b'Antall element oppn\xc3\xa5dd etter produksjon / nedpakking fra gitte mengder r\xc3\xa5varer'
b'DocType: Lab Test',b'Test Group',b'Testgruppe'
b'DocType: Payment Reconciliation',b'Receivable / Payable Account',b'Fordringer / gjeld konto'
b'DocType: Delivery Note Item',b'Against Sales Order Item',b'Mot kundeordreposisjon'
b'DocType: Company',b'Company Logo',b'Firmalogo'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +709',b'Please specify Attribute Value for attribute {0}',b'Vennligst oppgi data Verdi for attributtet {0}'
b'DocType: Item',b'Default Warehouse',b'Standard Warehouse'
b'apps/erpnext/erpnext/accounts/doctype/budget/budget.py +45',b'Budget cannot be assigned against Group Account {0}',b'Budsjettet kan ikke overdras mot gruppekonto {0}'
b'DocType: Healthcare Settings',b'Patient Registration',b'Pasientregistrering'
b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +22',b'Please enter parent cost center',b'Skriv inn forelder kostnadssted'
b'DocType: Delivery Note',b'Print Without Amount',b'Skriv ut Uten Bel\xc3\xb8p'
b'apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +57',b'Depreciation Date',b'avskrivninger Dato'
,b'Work Orders in Progress',b'Arbeidsordrer p\xc3\xa5g\xc3\xa5r'
b'DocType: Issue',b'Support Team',b'Support Team'
b'apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +36',b'Expiry (In Days)',b'Utl\xc3\xb8ps (i dager)'
b'DocType: Appraisal',b'Total Score (Out of 5)',b'Total poengsum (av 5)'
b'DocType: Fee Structure',b'FS.',b'FS.'
b'DocType: Student Attendance Tool',b'Batch',b'Parti'
b'DocType: Donor',b'Donor Type',b'Donor Type'
b'apps/erpnext/erpnext/stock/doctype/item/item.js +27',b'Balance',b'Balanse'
b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +66',b'Please select the Company',b'Vennligst velg firmaet'
b'DocType: Room',b'Seating Capacity',b'Antall seter'
b'DocType: Issue',b'ISS-',b'ISS-'
b'DocType: Lab Test Groups',b'Lab Test Groups',b'Lab Test Grupper'
b'DocType: Project',b'Total Expense Claim (via Expense Claims)',b'Total Expense krav (via Utgifts Krav)'
b'DocType: GST Settings',b'GST Summary',b'GST Sammendrag'
b'apps/erpnext/erpnext/hr/doctype/daily_work_summary_group/daily_work_summary_group.py +16',b'Please enable default incoming account before creating Daily Work Summary Group',b'Vennligst aktiver standard innkommende konto f\xc3\xb8r du oppretter Daglig arbeidsoppsummeringsgruppe'
b'DocType: Assessment Result',b'Total Score',b'Total poengsum'
b'DocType: Journal Entry',b'Debit Note',b'Debitnota'
b'DocType: Stock Entry',b'As per Stock UOM',b'Pr Stock m\xc3\xa5lenheter'
b'apps/erpnext/erpnext/stock/doctype/batch/batch_list.js +7',b'Not Expired',b'Ikke utl\xc3\xb8pt'
b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +49',b'ValidDate',b'Gyldig dato'
b'DocType: Student Log',b'Achievement',b'Oppn\xc3\xa5else'
b'DocType: Batch',b'Source Document Type',b'Kilde dokumenttype'
b'DocType: Batch',b'Source Document Type',b'Kilde dokumenttype'
b'apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +24',b'Following course schedules were created',b'F\xc3\xb8lgende kursplaner ble opprettet'
b'DocType: Journal Entry',b'Total Debit',b'Total debet'
b'DocType: Manufacturing Settings',b'Default Finished Goods Warehouse',b'Standardferdigvarelageret'
b'apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.js +108',b'Please select Patient',b'Vennligst velg Pasient'
b'apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +76',b'Sales Person',b'Sales Person'
b'DocType: Hotel Room Package',b'Amenities',b'fasiliteter'
b'apps/erpnext/erpnext/config/accounts.py +233',b'Budget and Cost Center',b'Budsjett og kostnadssted'
b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +65',b'Multiple default mode of payment is not allowed',b'Flere standard betalingsm\xc3\xa5ter er ikke tillatt'
b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +5',b'for the',b'for'
,b'Appointment Analytics',b'Avtale Analytics'
b'DocType: Vehicle Service',b'Half Yearly',b'Halv\xc3\xa5rlig'
b'DocType: Lead',b'Blog Subscriber',b'Blogg Subscriber'
b'DocType: Guardian',b'Alternate Number',b'Alternativ nummer'
b'DocType: Healthcare Settings',b'Consultations in valid days',b'Konsultasjoner i gyldige dager'
b'DocType: Assessment Plan Criteria',b'Maximum Score',b'maksimal score'
b'apps/erpnext/erpnext/config/setup.py +83',b'Create rules to restrict transactions based on values.',b'Lage regler for \xc3\xa5 begrense transaksjoner basert p\xc3\xa5 verdier.'
b'DocType: Cash Flow Mapping Accounts',b'Cash Flow Mapping Accounts',b'Kontantstr\xc3\xb8mmappekontoer'
b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +49',b' Group Roll No',b'Grupperulle nr'
b'DocType: Batch',b'Manufacturing Date',b'Produksjonsdato'
b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +9',b'Fee Creation Failed',b'Fee Creation mislyktes'
b'DocType: Opening Invoice Creation Tool',b'Create Missing Party',b'Opprett manglende parti'
b'DocType: Student Group Creation Tool',b'Leave blank if you make students groups per year',b'La v\xc3\xa6re tom hvis du lager studentgrupper hvert \xc3\xa5r'
b'DocType: Student Group Creation Tool',b'Leave blank if you make students groups per year',b'La v\xc3\xa6re tom hvis du lager studentgrupper hvert \xc3\xa5r'
b'DocType: HR Settings',"b'If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day'","b'Hvis det er merket, Total nei. arbeidsdager vil omfatte helligdager, og dette vil redusere verdien av L\xc3\xb8nn per dag'"
b'DocType: Purchase Invoice',b'Total Advance',b'Total Advance'
b'apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +27',b'Change Template Code',b'Endre malkode'
b'apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +23',b'The Term End Date cannot be earlier than the Term Start Date. Please correct the dates and try again.',"b'Begrepet Sluttdatoen kan ikke v\xc3\xa6re tidligere enn Term startdato. Korriger datoene, og pr\xc3\xb8v igjen.'"
b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +19',b'Quot Count',b'Sitatall'
b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +19',b'Quot Count',b'Sitatall'
,b'BOM Stock Report',b'BOM aksjerapport'
b'DocType: Stock Reconciliation Item',b'Quantity Difference',b'Antall Difference'
b'DocType: Employee Advance',b'EA-',b'EA'
b'DocType: Opportunity Item',b'Basic Rate',b'Basic Rate'
b'DocType: GL Entry',b'Credit Amount',b'Credit Bel\xc3\xb8p'
b'DocType: Cheque Print Template',b'Signatory Position',b'Signataren plassering'
b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +173',b'Set as Lost',b'Sett som tapte'
b'DocType: Timesheet',b'Total Billable Hours',b'Totalt fakturerbare timer'
b'apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +4',b'Payment Receipt Note',b'Betaling Kvittering Note'
b'apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +6',b'This is based on transactions against this Customer. See timeline below for details',b'Dette er basert p\xc3\xa5 transaksjoner mot denne kunden. Se tidslinjen nedenfor for detaljer'
b'apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +162',b'Row {0}: Allocated amount {1} must be less than or equals to Payment Entry amount {2}',b'Rad {0}: Avsatt bel\xc3\xb8p {1} m\xc3\xa5 v\xc3\xa6re mindre enn eller lik Betaling Entry mengden {2}'
b'DocType: Program Enrollment Tool',b'New Academic Term',b'Ny faglig term'
,b'Course wise Assessment Report',b'Kursbasert vurderingsrapport'
b'DocType: Purchase Invoice',b'Availed ITC State/UT Tax',b'Availed ITC State / UT skatt'
b'DocType: Tax Rule',b'Tax Rule',b'Skatt Rule'
b'DocType: Selling Settings',b'Maintain Same Rate Throughout Sales Cycle',b'Opprettholde samme hastighet Gjennom Salgssyklus'
b'DocType: Manufacturing Settings',b'Plan time logs outside Workstation Working Hours.',b'Planlegg tids logger utenfor arbeidsstasjon arbeidstid.'
b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +115',b'Dr {0} does not have a Physician Schedule. Add it in Physician master',b'Dr {0} har ikke en legeplan. Legg det i lege master'
b'apps/erpnext/erpnext/public/js/pos/pos.html +98',b'Customers in Queue',b'Kunder i k\xc3\xb8'
b'DocType: Driver',b'Issuing Date',b'Utstedelsesdato'
b'DocType: Student',b'Nationality',b'Nasjonalitet'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +109',b'Submit this Work Order for further processing.',b'Send inn denne arbeidsordren for videre behandling.'
,b'Items To Be Requested',b'Elementer \xc3\xa5 bli forespurt'
b'DocType: Purchase Order',b'Get Last Purchase Rate',b'F\xc3\xa5 siste kj\xc3\xb8p Ranger'
b'DocType: Company',b'Company Info',b'Selskap Info'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +1385',b'Select or add new customer',b'Velg eller legg til ny kunde'
b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +173',b'Cost center is required to book an expense claim',b'Kostnadssted er n\xc3\xb8dvendig \xc3\xa5 bestille en utgift krav'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +9',b'Application of Funds (Assets)',b'Anvendelse av midler (aktiva)'
b'apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +6',b'This is based on the attendance of this Employee',b'Dette er basert p\xc3\xa5 tilstedev\xc3\xa6relse av denne Employee'
b'DocType: Assessment Result',b'Summary',b'Sammendrag'
b'apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +112',b'Mark Attendance',b'Mark Attendance'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +494',b'Debit Account',b'Debet konto'
b'DocType: Fiscal Year',b'Year Start Date',b'\xc3\x85r Startdato'
b'DocType: Attendance',b'Employee Name',b'Ansattes Navn'
b'DocType: Restaurant Order Entry Item',b'Restaurant Order Entry Item',b'Restaurant Bestillingsinngang'
b'DocType: Purchase Invoice',b'Rounded Total (Company Currency)',b'Avrundet Total (Selskap Valuta)'
b'apps/erpnext/erpnext/accounts/doctype/account/account.py +96',b'Cannot covert to Group because Account Type is selected.',b'Kan ikke covert til konsernet fordi Kontotype er valgt.'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +260',b'{0} {1} has been modified. Please refresh.',b'{0} {1} har blitt endret. Vennligst oppdater.'
b'DocType: Leave Block List',b'Stop users from making Leave Applications on following days.',b'Stoppe brukere fra \xc3\xa5 gj\xc3\xb8re La Applications p\xc3\xa5 f\xc3\xb8lgende dager.'
b'DocType: Asset Maintenance Team',b'Maintenance Team Members',b'Vedlikeholdsteammedlemmer'
b'apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +63',b'Purchase Amount',b'kj\xc3\xb8pesummen'
b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +261',b'Supplier Quotation {0} created',b'Leverand\xc3\xb8r sitat {0} er opprettet'
b'apps/erpnext/erpnext/accounts/report/financial_statements.py +103',b'End Year cannot be before Start Year',b'Slutt \xc3\x85r kan ikke v\xc3\xa6re f\xc3\xb8r start \xc3\x85r'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +234',b'Employee Benefits',b'Ytelser til ansatte'
b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +264',b'Packed quantity must equal quantity for Item {0} in row {1}',b'Pakket mengde m\xc3\xa5 v\xc3\xa6re lik mengde for Element {0} i rad {1}'
b'DocType: Work Order',b'Manufactured Qty',b'Produsert Antall'
b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +78',"b""The shares don't exist with the {0}""",b'Aksjene eksisterer ikke med {0}'
b'apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +64',b'Invoice Created',b'Faktura er opprettet'
b'DocType: Asset',b'Out of Order',b'I ustand'
b'DocType: Purchase Receipt Item',b'Accepted Quantity',b'Akseptert Antall'
b'DocType: Projects Settings',b'Ignore Workstation Time Overlap',b'Ignorer arbeidsstasjonstidoverlapping'
b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +242',b'Please set a default Holiday List for Employee {0} or Company {1}',b'Vennligst angi en standard Holiday Liste for Employee {0} eller selskapet {1}'
b'apps/erpnext/erpnext/accounts/party.py +30',b'{0}: {1} does not exists',b'{0}: {1} ikke eksisterer'
b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +76',b'Select Batch Numbers',b'Velg batchnumre'
b'apps/erpnext/erpnext/config/accounts.py +12',b'Bills raised to Customers.',b'Regninger hevet til kundene.'
b'apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26',b'Project Id',b'Prosjekt Id'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +534',b'Row No {0}: Amount cannot be greater than Pending Amount against Expense Claim {1}. Pending Amount is {2}',b'Row Nei {0}: Bel\xc3\xb8pet kan ikke v\xc3\xa6re st\xc3\xb8rre enn utest\xc3\xa5ende bel\xc3\xb8pet mot Expense krav {1}. Avventer Bel\xc3\xb8p er {2}'
b'DocType: Patient Service Unit',b'Medical Administrator',b'Medisinsk administrator'
b'DocType: Assessment Plan',b'Schedule',b'Tidsplan'
b'DocType: Account',b'Parent Account',b'Parent konto'
b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +266',b'Available',b'Tilgjengelig'
b'DocType: Quality Inspection Reading',b'Reading 3',b'Reading 3'
b'DocType: Stock Entry',b'Source Warehouse Address',b'Source Warehouse Adresse'
,b'Hub',b'Hub'
b'DocType: GL Entry',b'Voucher Type',b'Kupong Type'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +1717',b'Price List not found or disabled',b'Prisliste ikke funnet eller deaktivert'
b'DocType: Student Applicant',b'Approved',b'Godkjent'
b'apps/erpnext/erpnext/public/js/pos/pos_selected_item.html +15',b'Price',b'Pris'
b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +267',"b""Employee relieved on {0} must be set as 'Left'""",b'Ansatt lettet p\xc3\xa5 {0} m\xc3\xa5 v\xc3\xa6re angitt som &quot;venstre&quot;'
b'DocType: Hub Settings',b'Last Sync On',b'Sist synk p\xc3\xa5'
b'DocType: Guardian',b'Guardian',b'Guardian'
b'DocType: Opening Invoice Creation Tool',b'Create missing customer or supplier.',b'Opprett manglende kunde eller leverand\xc3\xb8r.'
b'apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +42',b'Appraisal {0} created for Employee {1} in the given date range',b'Appraisal {0} skapt for Employee {1} i den gitte datointervall'
b'DocType: Academic Term',b'Education',b'Utdanning'
b'apps/erpnext/erpnext/public/js/pos/pos.html +89',b'Del',b'del'
b'DocType: Selling Settings',b'Campaign Naming By',b'Kampanje Naming Av'
b'DocType: Employee',b'Current Address Is',b'Gjeldende adresse Er'
b'apps/erpnext/erpnext/utilities/user_progress.py +51',b'Monthly Sales Target (',b'M\xc3\xa5nedlig salgsm\xc3\xa5l ('
b'DocType: Physician Service Unit Schedule',b'Physician Service Unit Schedule',b'Leger Service Unit Schedule'
b'apps/erpnext/erpnext/templates/includes/projects/project_tasks.html +9',b'modified',b'modifisert'
b'apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +43',"b""Optional. Sets company's default currency, if not specified.""","b'Valgfritt. Setter selskapets standardvaluta, hvis ikke spesifisert.'"
b'DocType: Sales Invoice',b'Customer GSTIN',b'Kunde GSTIN'
b'DocType: Crop Cycle',"b""List of diseases detected on the field. When selected it'll automatically add a list of tasks to deal with the disease ""","b'Liste over sykdommer oppdaget p\xc3\xa5 feltet. N\xc3\xa5r den er valgt, vil den automatisk legge til en liste over oppgaver for \xc3\xa5 h\xc3\xa5ndtere sykdommen'"
b'DocType: Asset Repair',b'Repair Status',b'Reparasjonsstatus'
b'apps/erpnext/erpnext/config/accounts.py +67',b'Accounting journal entries.',b'Regnskap posteringer.'
b'DocType: Delivery Note Item',b'Available Qty at From Warehouse',b'Tilgjengelig Antall p\xc3\xa5 From Warehouse'
b'DocType: POS Profile',b'Account for Change Amount',b'Konto for Change Bel\xc3\xb8p'
b'DocType: Purchase Invoice',b'input service',b'inntjeningstjeneste'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +217',b'Row {0}: Party / Account does not match with {1} / {2} in {3} {4}',b'Rad {0}: Party / Account samsvarer ikke med {1} / {2} i {3} {4}'
b'DocType: Maintenance Team Member',b'Maintenance Team Member',b'Vedlikeholdsteammedlem'
b'DocType: Agriculture Analysis Criteria',b'Soil Analysis',b'Jordanalyse'
b'apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +13',b'Course Code: ',b'Bankkode:'
b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +240',b'Please enter Expense Account',b'Skriv inn Expense konto'
b'DocType: Account',b'Stock',b'Lager'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1095',"b'Row #{0}: Reference Document Type must be one of Purchase Order, Purchase Invoice or Journal Entry'","b'Row # {0}: Reference Document Type m\xc3\xa5 v\xc3\xa6re en av innkj\xc3\xb8psordre, faktura eller bilagsregistrering'"
b'DocType: Employee',b'Current Address',b'N\xc3\xa5v\xc3\xa6rende Adresse'
b'DocType: Item',"b'If item is a variant of another item then description, image, pricing, taxes etc will be set from the template unless explicitly specified'","b'Hvis elementet er en variant av et annet element da beskrivelse, image, priser, avgifter osv vil bli satt fra malen uten eksplisitt spesifisert'"
b'DocType: Serial No',b'Purchase / Manufacture Details',b'Kj\xc3\xb8p / Produksjon Detaljer'
b'DocType: Assessment Group',b'Assessment Group',b'Assessment Group'
b'apps/erpnext/erpnext/config/stock.py +329',b'Batch Inventory',b'Batch Lager'
b'DocType: Employee',b'Contract End Date',b'Kontraktssluttdato'
b'DocType: Sales Order',b'Track this Sales Order against any Project',b'Spor dette Salgsordre mot ethvert prosjekt'
b'DocType: Sales Invoice Item',b'Discount and Margin',b'Rabatt og Margin'
b'DocType: Lab Test',b'Prescription',b'Resept'
b'DocType: Project',b'Second Email',b'Andre e-post'
b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +111',b'Not Available',b'Ikke Tilgjengelig'
b'DocType: Pricing Rule',b'Min Qty',b'Min Antall'
b'apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +36',b'Disable Template',b'Deaktiver mal'
b'DocType: GL Entry',b'Transaction Date',b'Transaksjonsdato'
b'DocType: Production Plan Item',b'Planned Qty',b'Planlagt Antall'
b'apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +121',b'Total Tax',b'Total Skatte'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +204',b'For Quantity (Manufactured Qty) is mandatory',b'For Mengde (Produsert Stk) er obligatorisk'
b'DocType: Stock Entry',b'Default Target Warehouse',b'Standard Target Warehouse'
b'DocType: Purchase Invoice',b'Net Total (Company Currency)',b'Net Total (Selskap Valuta)'
b'apps/erpnext/erpnext/education/doctype/academic_year/academic_year.py +14',b'The Year End Date cannot be earlier than the Year Start Date. Please correct the dates and try again.',"b'\xc3\x85ret Sluttdatoen kan ikke v\xc3\xa6re tidligere enn \xc3\xa5ret startdato. Korriger datoene, og pr\xc3\xb8v igjen.'"
b'DocType: Notification Control',b'Purchase Receipt Message',b'Kvitteringen Message'
b'DocType: BOM',b'Scrap Items',b'skrap Items'
b'DocType: Work Order',b'Actual Start Date',b'Faktisk startdato'
b'DocType: Sales Order',b'% of materials delivered against this Sales Order',b'% Av materialer leveres mot denne kundeordre'
b'apps/erpnext/erpnext/config/manufacturing.py +18',b'Generate Material Requests (MRP) and Work Orders.',b'Generere materialforesp\xc3\xb8rsler (MRP) og arbeidsordre.'
b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +62',b'Set default mode of payment',b'Angi standard betalingsm\xc3\xa5te'
b'DocType: Grant Application',b'Withdrawn',b'Tilbaketrukket'
b'DocType: Hub Settings',b'Hub Settings',b'Hub-innstillinger'
b'DocType: Project',b'Gross Margin %',b'Bruttomargin%'
b'DocType: BOM',b'With Operations',b'Med Operations'
b'apps/erpnext/erpnext/accounts/party.py +259',b'Accounting entries have already been made in currency {0} for company {1}. Please select a receivable or payable account with currency {0}.',b'Regnskapspostene har allerede blitt gjort i valuta {0} for selskap {1}. Vennligst velg en fordring eller betales konto med valuta {0}.'
b'DocType: Asset',b'Is Existing Asset',b'Er Eksisterende Asset'
b'DocType: Salary Detail',b'Statistical Component',b'Statistisk komponent'
b'DocType: Salary Detail',b'Statistical Component',b'Statistisk komponent'
b'DocType: Warranty Claim',b'If different than customer address',b'Hvis annerledes enn kunden adresse'
b'DocType: Purchase Invoice',b'Without Payment of Tax',b'Uten betaling av skatt'
b'DocType: BOM Operation',b'BOM Operation',b'BOM Operation'
b'apps/erpnext/erpnext/config/stock.py +141',b'Fulfilment',b'Oppfyllelse'
b'DocType: Purchase Taxes and Charges',b'On Previous Row Amount',b'P\xc3\xa5 Forrige Row Bel\xc3\xb8p'
b'DocType: Item',b'Has Expiry Date',b'Har utl\xc3\xb8psdato'
b'apps/erpnext/erpnext/assets/doctype/asset/asset.js +282',b'Transfer Asset',b'Transfer Asset'
b'DocType: POS Profile',b'POS Profile',b'POS Profile'
b'DocType: Training Event',b'Event Name',b'Aktivitetsnavn'
b'DocType: Physician',b'Phone (Office)',b'Telefon (kontor)'
b'apps/erpnext/erpnext/hooks.py +151',b'Admission',b'Adgang'
b'apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +29',b'Admissions for {0}',b'Innleggelser for {0}'
b'apps/erpnext/erpnext/config/accounts.py +257',"b'Seasonality for setting budgets, targets etc.'","b'Sesong for \xc3\xa5 sette budsjetter, m\xc3\xa5l etc.'"
b'DocType: Supplier Scorecard Scoring Variable',b'Variable Name',b'Variabelt navn'
b'apps/erpnext/erpnext/stock/get_item_details.py +144',"b'Item {0} is a template, please select one of its variants'","b'Element {0} er en mal, kan du velge en av variantene'"
b'DocType: Asset',b'Asset Category',b'Asset Kategori'
b'apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +31',b'Net pay cannot be negative',b'Nettol\xc3\xb8nn kan ikke v\xc3\xa6re negativ'
b'DocType: Purchase Order',b'Advance Paid',b'Advance Betalt'
b'DocType: Item',b'Item Tax',b'Sak Skatte'
b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +883',b'Material to Supplier',b'Materiale til Leverand\xc3\xb8r'
b'DocType: Soil Texture',b'Loamy Sand',b'Loamy Sand'
b'DocType: Production Plan',b'Material Request Planning',b'Material Request Planning'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +638',b'Excise Invoice',b'Vesenet Faktura'
b'apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py +16',b'Treshold {0}% appears more than once',b'Treshold {0}% kommer mer enn \xc3\xa9n gang'
b'DocType: Expense Claim',b'Employees Email Id',b'Ansatte Email Id'
b'DocType: Employee Attendance Tool',b'Marked Attendance',b'merket Oppm\xc3\xb8te'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +138',b'Current Liabilities',b'Kortsiktig gjeld'
b'apps/erpnext/erpnext/config/selling.py +297',b'Send mass SMS to your contacts',b'Sende masse SMS til kontaktene dine'
b'DocType: Patient',b'A Positive',b'En positiv'
b'DocType: Program',b'Program Name',b'Programnavn'
b'DocType: Purchase Taxes and Charges',b'Consider Tax or Charge for',b'Tenk Skatte eller Charge for'
b'DocType: Driver',b'Driving License Category',b'Kj\xc3\xb8relisens kategori'
b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +158',b'No Reference',b'Ingen referanse'
b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +57',b'Actual Qty is mandatory',b'Selve Antall er obligatorisk'
b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +92',"b'{0} currently has a {1} Supplier Scorecard standing, and Purchase Orders to this supplier should be issued with caution.'","b'{0} har for \xc3\xb8yeblikket en {1} leverand\xc3\xb8r scorecard, og innkj\xc3\xb8psordre til denne leverand\xc3\xb8ren skal utstedes med forsiktighet.'"
b'DocType: Asset Maintenance Team',b'Asset Maintenance Team',b'Asset Maintenance Team'
b'DocType: Employee Loan',b'Loan Type',b'l\xc3\xa5ne~~POS=TRUNC'
b'DocType: Scheduling Tool',b'Scheduling Tool',b'planlegging Tool'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +180',b'Credit Card',b'Kredittkort'
b'DocType: BOM',b'Item to be manufactured or repacked',b'Elementet som skal produseres eller pakkes'
b'DocType: Employee Education',b'Major/Optional Subjects',b'Store / valgfrie emner'
b'DocType: Sales Invoice Item',b'Drop Ship',b'Drop Ship'
b'DocType: Driver',b'Suspended',b'suspendert'
b'DocType: Training Event',b'Attendees',b'Deltakere'
b'DocType: Employee',"b'Here you can maintain family details like name and occupation of parent, spouse and children'","b'Her kan du opprettholde familie informasjon som navn og okkupasjon av foreldre, ektefelle og barn'"
b'DocType: Academic Term',b'Term End Date',b'Term Sluttdato'
b'DocType: Purchase Invoice',b'Taxes and Charges Deducted (Company Currency)',b'Skatter og avgifter fratrukket (Company Valuta)'
b'DocType: Item Group',b'General Settings',b'Generelle Innstillinger'
b'apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py +23',b'From Currency and To Currency cannot be same',b'Fra Valuta og til valuta kan ikke v\xc3\xa6re det samme'
b'DocType: Stock Entry',b'Repack',b'Pakk'
b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +6',b'You must Save the form before proceeding',b'Du m\xc3\xa5 Lagre skjemaet f\xc3\xb8r du fortsetter'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +113',b'Please select the Company first',b'Vennligst velg selskapet f\xc3\xb8rst'
b'DocType: Item Attribute',b'Numeric Values',b'Numeriske verdier'
b'apps/erpnext/erpnext/public/js/setup_wizard.js +56',b'Attach Logo',b'Fest Logo'
b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +51',b'Stock Levels',b'lagerniv\xc3\xa5er'
b'DocType: Customer',b'Commission Rate',b'Kommisjon'
b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +187',b'Created {0} scorecards for {1} between: ',b'Lagde {0} scorecards for {1} mellom:'
b'apps/erpnext/erpnext/stock/doctype/item/item.js +505',b'Make Variant',b'Gj\xc3\xb8r Variant'
b'apps/erpnext/erpnext/config/hr.py +87',b'Block leave applications by department.',b'Block permisjon applikasjoner ved avdelingen.'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +155',"b'Payment Type must be one of Receive, Pay and Internal Transfer'","b'Betalingstype m\xc3\xa5 v\xc3\xa6re en av Motta, L\xc3\xb8nn og Internal Transfer'"
b'apps/erpnext/erpnext/config/selling.py +184',b'Analytics',b'Analytics'
b'apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html +25',b'Cart is Empty',b'Handlevognen er tom'
b'DocType: Vehicle',b'Model',b'Modell'
b'DocType: Work Order',b'Actual Operating Cost',b'Faktiske driftskostnader'
b'DocType: Payment Entry',b'Cheque/Reference No',b'Sjekk / referansenummer'
b'DocType: Soil Texture',b'Clay Loam',b'Clay Loam'
b'apps/erpnext/erpnext/accounts/doctype/account/account.py +81',b'Root cannot be edited.',b'Root kan ikke redigeres.'
b'DocType: Item',b'Units of Measure',b'M\xc3\xa5leenheter'
b'DocType: Manufacturing Settings',b'Allow Production on Holidays',b'Tillat Produksjonen p\xc3\xa5 helligdager'
b'DocType: Sales Invoice',"b""Customer's Purchase Order Date""",b'Kundens Purchase Order Date'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +163',b'Capital Stock',b'Kapitalbeholdningen'
b'DocType: Shopping Cart Settings',b'Show Public Attachments',b'Vis offentlige vedlegg'
b'DocType: Packing Slip',b'Package Weight Details',b'Pakken vektdetaljer'
b'DocType: Restaurant Reservation',b'Reservation Time',b'Reservasjonstid'
b'DocType: Payment Gateway Account',b'Payment Gateway Account',b'Betaling Gateway konto'
b'DocType: Shopping Cart Settings',b'After payment completion redirect user to selected page.',b'Etter betaling ferdigstillelse omdirigere brukeren til valgt side.'
b'DocType: Company',b'Existing Company',b'eksisterende selskapet'
b'DocType: Healthcare Settings',b'Result Emailed',b'Resultat sendt'
b'apps/erpnext/erpnext/controllers/buying_controller.py +87',"b'Tax Category has been changed to ""Total"" because all the Items are non-stock items'",b'Skattekategori har blitt endret til &quot;Totalt&quot; fordi alle elementene er ikke-varelager'
b'apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +103',b'Please select a csv file',b'Vennligst velg en csv-fil'
b'DocType: Student Leave Application',b'Mark as Present',b'Merk som Present'
b'DocType: Supplier Scorecard',b'Indicator Color',b'Indikatorfarge'
b'DocType: Purchase Order',b'To Receive and Bill',b'\xc3\x85 motta og Bill'
b'apps/erpnext/erpnext/controllers/buying_controller.py +445',b'Row #{0}: Reqd by Date cannot be before Transaction Date',b'Row # {0}: Reqd by Date kan ikke v\xc3\xa6re f\xc3\xb8r transaksjonsdato'
b'apps/erpnext/erpnext/templates/pages/home.html +14',b'Featured Products',b'Utvalgte produkter'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +136',b'Designer',b'Designer'
b'apps/erpnext/erpnext/config/selling.py +163',b'Terms and Conditions Template',b'Betingelser Mal'
b'DocType: Serial No',b'Delivery Details',b'Levering Detaljer'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +495',b'Cost Center is required in row {0} in Taxes table for type {1}',b'Kostnadssted er n\xc3\xb8dvendig i rad {0} i skatter tabell for typen {1}'
b'DocType: Program',b'Program Code',b'programkode'
b'DocType: Terms and Conditions',b'Terms and Conditions Help',b'Betingelser Hjelp'
,b'Item-wise Purchase Register',b'Element-messig Purchase Register'
b'DocType: Driver',b'Expiry Date',b'Utl\xc3\xb8psdato'
b'DocType: Healthcare Settings',b'Employee name and designation in print',b'Ansattes navn og betegnelse p\xc3\xa5 trykk'
,b'accounts-browser',b'kontoer-browser'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +368',b'Please select Category first',b'Vennligst f\xc3\xb8rste velg kategori'
b'apps/erpnext/erpnext/config/projects.py +13',b'Project master.',b'Prosjektet mester.'
b'apps/erpnext/erpnext/controllers/status_updater.py +212',"b'To allow over-billing or over-ordering, update ""Allowance"" in Stock Settings or the Item.'","b'\xc3\x85 tillate overfakturering eller over-bestilling, oppdatere &quot;Fradrag&quot; p\xc3\xa5 lager Innstillinger eller elementet.'"
b'DocType: Global Defaults',b'Do not show any symbol like $ etc next to currencies.',b'Ikke viser noen symbol som $ etc ved siden av valutaer.'
b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +431',b' (Half Day)',b'(Halv Dag)'
b'DocType: Payment Term',b'Credit Days',b'Kreditt Days'
b'apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +145',b'Please select Patient to get Lab Tests',b'Vennligst velg Pasient for \xc3\xa5 f\xc3\xa5 Lab Tests'
b'apps/erpnext/erpnext/utilities/activation.py +128',b'Make Student Batch',b'Gj\xc3\xb8r Student Batch'
b'DocType: Fee Schedule',b'FRQ.',b'FRQ.'
b'DocType: Leave Type',b'Is Carry Forward',b'Er fremf\xc3\xb8ring'
b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +841',b'Get Items from BOM',b'F\xc3\xa5 Elementer fra BOM'
b'apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +40',b'Lead Time Days',b'Ledetid Days'
b'DocType: Cash Flow Mapping',b'Is Income Tax Expense',b'Er inntektsskatt utgift'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +621',b'Row #{0}: Posting Date must be same as purchase date {1} of asset {2}',b'Row # {0}: konteringsdato m\xc3\xa5 v\xc3\xa6re det samme som kj\xc3\xb8psdato {1} av eiendelen {2}'
b'DocType: Program Enrollment',"b""Check this if the Student is residing at the Institute's Hostel.""",b'Sjekk dette hvis studenten er bosatt ved instituttets Hostel.'
b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +125',b'Please enter Sales Orders in the above table',b'Fyll inn salgsordrer i tabellen ovenfor'
,b'Stock Summary',b'Stock oppsummering'
b'apps/erpnext/erpnext/config/assets.py +54',b'Transfer an asset from one warehouse to another',b'Overf\xc3\xb8r en eiendel fra en lagerbygning til en annen'
b'DocType: Vehicle',b'Petrol',b'Bensin'
b'apps/erpnext/erpnext/config/learn.py +217',b'Bill of Materials',b'Bill of Materials'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +105',b'Row {0}: Party Type and Party is required for Receivable / Payable account {1}',b'Rad {0}: Party Type og Party er n\xc3\xb8dvendig for fordringer / gjeld kontoen {1}'
b'apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +94',b'Ref Date',b'Ref Dato'
b'DocType: Employee',b'Reason for Leaving',b'Grunn til \xc3\xa5 forlate'
b'DocType: BOM Operation',b'Operating Cost(Company Currency)',b'Driftskostnader (Selskap Valuta)'
b'DocType: Employee Loan Application',b'Rate of Interest',b'Rente'
b'DocType: Expense Claim Detail',b'Sanctioned Amount',b'Sanksjonert Bel\xc3\xb8p'
b'DocType: Item',b'Shelf Life In Days',b'Holdbarhet i dager'
b'DocType: GL Entry',b'Is Opening',b'Er \xc3\x85pnings'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +196',b'Row {0}: Debit entry can not be linked with a {1}',b'Rad {0}: Debet oppf\xc3\xb8ring kan ikke v\xc3\xa6re knyttet til en {1}'
b'DocType: Journal Entry',b'Subscription Section',b'Abonnementsseksjon'
b'apps/erpnext/erpnext/accounts/doctype/account/account.py +177',b'Account {0} does not exist',b'Konto {0} finnes ikke'
b'DocType: Training Event',b'Training Program',b'Treningsprogram'
b'DocType: Account',b'Cash',b'Kontanter'
b'DocType: Employee',b'Short biography for website and other publications.',b'Kort biografi for hjemmeside og andre publikasjoner.'
