DocType: Accounting Period,Period Name,Navn på periode
DocType: Employee,Salary Mode,Løn-tilstand
apps/erpnext/erpnext/public/js/hub/marketplace.js +108,Register,Tilmeld
DocType: Patient,Divorced,Skilt
DocType: Support Settings,Post Route Key,Indtast rute nøgle
DocType: Buying Settings,Allow Item to be added multiple times in a transaction,Tillad vare der skal tilføjes flere gange i en transaktion
apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +33,Cancel Material Visit {0} before cancelling this Warranty Claim,"Annuller Materiale Besøg {0}, før den annullerer denne garanti krav"
apps/erpnext/erpnext/config/education.py +118,Assessment Reports,Evalueringsrapporter
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +19,Consumer Products,Forbrugerprodukter
DocType: Supplier Scorecard,Notify Supplier,Underret Leverandør
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.js +52,Please select Party Type first,Vælg Party Type først
DocType: Item,Customer Items,Kundevarer
DocType: Project,Costing and Billing,Omkostningsberegning og fakturering
apps/erpnext/erpnext/hr/doctype/employee_advance/employee_advance.py +43,Advance account currency should be same as company currency {0},Advance-valuta skal være den samme som virksomhedens valuta {0}
DocType: QuickBooks Migrator,Token Endpoint,Token Endpoint
apps/erpnext/erpnext/accounts/doctype/account/account.py +55,Account {0}: Parent account {1} can not be a ledger,Konto {0}: Forældre-konto {1} kan ikke være en finanskonto
DocType: Item,Publish Item to hub.erpnext.com,Udgive Vare til hub.erpnext.com
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +270,Cannot find active Leave Period,Kan ikke finde aktiv afgangsperiode
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +22,Evaluation,Evaluering
DocType: Item,Default Unit of Measure,Standard Måleenhed
DocType: SMS Center,All Sales Partner Contact,Alle forhandlerkontakter
DocType: Department,Leave Approvers,Fraværsgodkendere
DocType: Employee,Bio / Cover Letter,Bio / Cover Letter
DocType: Patient Encounter,Investigations,Undersøgelser
DocType: Restaurant Order Entry,Click Enter To Add,Klik på Enter for at tilføje
apps/erpnext/erpnext/erpnext_integrations/doctype/shopify_settings/shopify_settings.py +29,"Missing value for Password, API Key or Shopify URL","Manglende værdi for Password, API Key eller Shopify URL"
DocType: Employee,Rented,Lejet
apps/erpnext/erpnext/public/js/setup_wizard.js +243,All Accounts,Alle konti
apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py +15,Cannot transfer Employee with status Left,Kan ikke overføre medarbejder med status til venstre
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +216,"Stopped Production Order cannot be cancelled, Unstop it first to cancel","Stoppet produktionsordre kan ikke annulleres, Unstop det første til at annullere"
DocType: Vehicle Service,Mileage,Kilometerpenge
apps/erpnext/erpnext/assets/doctype/asset/asset.js +338,Do you really want to scrap this asset?,Vil du virkelig kassere dette anlægsaktiv?
DocType: Drug Prescription,Update Schedule,Opdateringsplan
apps/erpnext/erpnext/buying/report/quoted_item_comparison/quoted_item_comparison.js +44,Select Default Supplier,Vælg Standard Leverandør
apps/erpnext/erpnext/hr/doctype/job_offer/job_offer.js +26,Show Employee,Vis medarbejder
DocType: Exchange Rate Revaluation Account,New Exchange Rate,Ny valutakurs
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +38,Currency is required for Price List {0},Valuta er nødvendig for prisliste {0}
DocType: Sales Taxes and Charges Template,* Will be calculated in the transaction.,* Vil blive beregnet i transaktionen.
DocType: Delivery Trip,MAT-DT-.YYYY.-,MAT-DT-.YYYY.-
DocType: Purchase Order,Customer Contact,Kundeservicekontakt
DocType: Patient Appointment,Check availability,Tjek tilgængelighed
DocType: Retention Bonus,Bonus Payment Date,Bonus Betalingsdato
DocType: Employee,Job Applicant,Ansøger
apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py +6,This is based on transactions against this Supplier. See timeline below for details,Dette er baseret på transaktioner for denne leverandør. Se tidslinje nedenfor for detaljer
DocType: Manufacturing Settings,Overproduction Percentage For Work Order,Overproduktionsprocent for arbejdsordre
DocType: Landed Cost Voucher,MAT-LCV-.YYYY.-,MAT-LCV-.YYYY.-
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +393,Legal,Juridisk
DocType: Delivery Note,Transport Receipt Date,Transportkvitteringsdato
DocType: Shopify Settings,Sales Order Series,Salgsordre Serie
DocType: Vital Signs,Tongue,Tunge
apps/erpnext/erpnext/hr/utils.py +222,"More than one selection for {0} not \
			allowed",Mere end et valg for {0} ikke \ tilladt
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +204,Actual type tax cannot be included in Item rate in row {0},"Faktiske type skat, kan ikke indgå i vare sats i række {0}"
DocType: Allowed To Transact With,Allowed To Transact With,Tilladt at transagere med
DocType: Bank Guarantee,Customer,Kunde
DocType: Purchase Receipt Item,Required By,Kræves By
DocType: Delivery Note,Return Against Delivery Note,Retur mod følgeseddel
DocType: Asset Category,Finance Book Detail,Finans Bog Detail
DocType: Purchase Order,% Billed,% Faktureret
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +41,Exchange Rate must be same as {0} {1} ({2}),Vekselkurs skal være det samme som {0} {1} ({2})
DocType: Employee Tax Exemption Declaration,HRA Exemption,HRA-fritagelse
DocType: Sales Invoice,Customer Name,Kundennavn
DocType: Vehicle,Natural Gas,Naturgas
apps/erpnext/erpnext/setup/setup_wizard/operations/company_setup.py +63,Bank account cannot be named as {0},Bankkonto kan ikke blive navngivet som {0}
DocType: Employee Tax Exemption Declaration,HRA as per Salary Structure,HRA som pr. Lønstruktur
DocType: Account,Heads (or groups) against which Accounting Entries are made and balances are maintained.,Hoveder (eller grupper) mod hvilken regnskabsposter er lavet og balancer opretholdes.
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +197,Outstanding for {0} cannot be less than zero ({1}),Enestående for {0} kan ikke være mindre end nul ({1})
apps/erpnext/erpnext/public/js/controllers/transaction.js +882,Service Stop Date cannot be before Service Start Date,Service Stop Date kan ikke være før service startdato
DocType: Manufacturing Settings,Default 10 mins,Standard 10 min
DocType: Leave Type,Leave Type Name,Fraværstypenavn
apps/erpnext/erpnext/templates/pages/projects.js +66,Show open,Vis åben
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +163,Series Updated Successfully,Nummerserien opdateret
apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html +6,Checkout,bestilling
apps/erpnext/erpnext/controllers/accounts_controller.py +788,{0} in row {1},{0} i række {1}
DocType: Asset Finance Book,Depreciation Start Date,Afskrivning Startdato
DocType: Pricing Rule,Apply On,Gælder for
DocType: Item Price,Multiple Item prices.,Flere varepriser.
,Purchase Order Items To Be Received,"Købsordre, der modtages"
DocType: SMS Center,All Supplier Contact,Alle Leverandør Kontakt
DocType: Support Settings,Support Settings,Support Indstillinger
apps/erpnext/erpnext/projects/doctype/project/project.py +84,Expected End Date can not be less than Expected Start Date,Forventet slutdato kan ikke være mindre end forventet startdato
DocType: Amazon MWS Settings,Amazon MWS Settings,Amazon MWS-indstillinger
apps/erpnext/erpnext/utilities/transaction_base.py +126,Row #{0}: Rate must be same as {1}: {2} ({3} / {4}) ,Row # {0}: Pris skal være samme som {1}: {2} ({3} / {4})
,Batch Item Expiry Status,Partivare-udløbsstatus
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +137,Bank Draft,Bank Draft
DocType: Journal Entry,ACC-JV-.YYYY.-,ACC-JV-.YYYY.-
DocType: Mode of Payment Account,Mode of Payment Account,Betalingsmådekonto
apps/erpnext/erpnext/config/healthcare.py +8,Consultation,Konsultation
DocType: Accounts Settings,Show Payment Schedule in Print,Vis betalingsplan i udskrivning
apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py +21,Sales and Returns,Salg og retur
apps/erpnext/erpnext/stock/doctype/item/item.js +58,Show Variants,Vis varianter
DocType: Academic Term,Academic Term,Akademisk betegnelse
DocType: Employee Tax Exemption Sub Category,Employee Tax Exemption Sub Category,Beskatningsfritagelse for arbejdstager underkategori
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py +14,Material,Materiale
apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py +61,"Maximum benefit of employee {0} exceeds {1} by the sum {2} of benefit application pro-rata component\
			amount and previous claimed amount",Maksimal fordel for medarbejderen {0} overstiger {1} med summen {2} af fordelingsprogrammet pro rata komponent \ beløb og tidligere hævd beløb
DocType: Opening Invoice Creation Tool Item,Quantity,Mængde
,Customers Without Any Sales Transactions,Kunder uden salgstransaktioner
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +590,Accounts table cannot be blank.,Regnskab tabel kan ikke være tom.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +164,Loans (Liabilities),Lån (passiver)
DocType: Patient Encounter,Encounter Time,Encounter Time
DocType: Staffing Plan Detail,Total Estimated Cost,Samlede anslåede omkostninger
DocType: Employee Education,Year of Passing,År for Passing
DocType: Routing,Routing Name,Routing Name
DocType: Item,Country of Origin,Oprindelsesland
DocType: Soil Texture,Soil Texture Criteria,Kriterier for jordstruktur
apps/erpnext/erpnext/templates/includes/product_page.js +34,In Stock,På lager
apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js +16,Primary Contact Details,Primær kontaktoplysninger
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +46,Open Issues,Åbne spørgsmål
DocType: Production Plan Item,Production Plan Item,Produktion Plan Vare
apps/erpnext/erpnext/hr/doctype/employee/employee.py +166,User {0} is already assigned to Employee {1},Bruger {0} er allerede tildelt Medarbejder {1}
DocType: Lab Test Groups,Add new line,Tilføj ny linje
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +31,Health Care,Health Care
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +65,Delay in payment (Days),Forsinket betaling (dage)
DocType: Payment Terms Template Detail,Payment Terms Template Detail,Betalingsbetingelser Skabelondetaljer
DocType: Hotel Room Reservation,Guest Name,Gæste navn
DocType: Delivery Note,Issue Credit Note,Udstedelse af kreditnota
DocType: Lab Prescription,Lab Prescription,Lab Prescription
,Delay Days,Forsinkelsesdage
apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py +26,Service Expense,tjenesten Expense
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +1009,Serial Number: {0} is already referenced in Sales Invoice: {1},Serienummer: {0} er allerede refereret i salgsfaktura: {1}
DocType: Bank Statement Transaction Invoice Item,Invoice,Faktura
DocType: Purchase Invoice Item,Item Weight Details,Vægt Vægt Detaljer
DocType: Asset Maintenance Log,Periodicity,Hyppighed
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +21,Fiscal Year {0} is required,Regnskabsår {0} er påkrævet
DocType: Crop Cycle,The minimum distance between rows of plants for optimum growth,Den minimale afstand mellem rækker af planter for optimal vækst
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +21,Defense,Forsvar
DocType: Salary Component,Abbr,Forkortelse
DocType: Appraisal Goal,Score (0-5),Score (0-5)
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +257,Row {0}: {1} {2} does not match with {3},Række {0}: {1} {2} passer ikke med {3}
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +78,Row # {0}:,Række # {0}:
DocType: Timesheet,Total Costing Amount,Total Costing Beløb
DocType: Delivery Note,Vehicle No,Køretøjsnr.
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +177,Please select Price List,Vælg venligst prisliste
DocType: Accounts Settings,Currency Exchange Settings,Valutavekslingsindstillinger
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +94,Row #{0}: Payment document is required to complete the trasaction,Row # {0}: Betaling dokument er nødvendig for at fuldføre trasaction
DocType: Work Order Operation,Work In Progress,Varer i arbejde
apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py +13,Please select date,Vælg venligst dato
DocType: Item Price,Minimum Qty ,Minimum antal
DocType: Finance Book,Finance Book,Finans Bog
DocType: Patient Encounter,HLC-ENC-.YYYY.-,HLC-ENC-.YYYY.-
DocType: Daily Work Summary Group,Holiday List,Helligdagskalender
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +90,Accountant,Revisor
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +61,Selling Price List,Salgsprisliste
DocType: Patient,Tobacco Current Use,Tobaks nuværende anvendelse
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +68,Selling Rate,Salgspris
DocType: Cost Center,Stock User,Lagerbruger
DocType: Soil Analysis,(Ca+Mg)/K,(Ca + Mg) / K
DocType: Delivery Stop,Contact Information,Kontakt information
DocType: Company,Phone No,Telefonnr.
DocType: Delivery Trip,Initial Email Notification Sent,Indledende Email Notification Sent
DocType: Bank Statement Settings,Statement Header Mapping,Statement Header Mapping
,Sales Partners Commission,Forhandlerprovision
DocType: Soil Texture,Sandy Clay Loam,Sandy Clay Loam
DocType: Purchase Invoice,Rounding Adjustment,Afrundingsjustering
apps/erpnext/erpnext/setup/doctype/company/company.py +50,Abbreviation cannot have more than 5 characters,Forkortelse kan ikke have mere end 5 tegn
DocType: Amazon MWS Settings,AU,AU
apps/erpnext/erpnext/accounts/doctype/payment_order/payment_order.js +7,Payment Request,Betalingsanmodning
apps/erpnext/erpnext/config/accounts.py +556,To view logs of Loyalty Points assigned to a Customer.,"For at få vist logfiler af loyalitetspoint, der er tildelt en kunde."
DocType: Asset,Value After Depreciation,Værdi efter afskrivninger
DocType: Student,O+,O +
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan_dashboard.py +8,Related,Relaterede
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +46,Attendance date can not be less than employee's joining date,Fremmødedato kan ikke være mindre end medarbejderens ansættelsesdato
DocType: Grading Scale,Grading Scale Name,Karakterbekendtgørelsen Navn
apps/erpnext/erpnext/public/js/hub/marketplace.js +147,Add Users to Marketplace,Tilføj brugere til Marketplace
apps/erpnext/erpnext/accounts/doctype/account/account.js +37,This is a root account and cannot be edited.,Dette er en rod-konto og kan ikke redigeres.
DocType: POS Profile,Company Address,Virksomhedsadresse
DocType: BOM,Operations,Operationer
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +38,Cannot set authorization on basis of Discount for {0},Kan ikke sætte godkendelse på grundlag af Rabat for {0}
DocType: Subscription,Subscription Start Date,Abonnements startdato
DocType: Healthcare Settings,Default receivable accounts to be used if not set in Patient to book Appointment charges.,"Standardfordelbare konti, der skal bruges, hvis de ikke er indstillet til patienten for at bestille aftalebeløb."
DocType: Rename Tool,"Attach .csv file with two columns, one for the old name and one for the new name","Vedhæft .csv fil med to kolonner, en for det gamle navn og et til det nye navn"
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +195,From Address 2,Fra adresse 2
apps/erpnext/erpnext/accounts/utils.py +74,{0} {1} not in any active Fiscal Year.,{0} {1} ikke i noget aktivt regnskabsår.
DocType: Packed Item,Parent Detail docname,Parent Detail docname
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +69,"Reference: {0}, Item Code: {1} and Customer: {2}","Reference: {0}, varekode: {1} og kunde: {2}"
apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.py +377,{0} {1} is not present in the parent company,{0} {1} er ikke til stede i moderselskabet
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +215,Trial Period End Date Cannot be before Trial Period Start Date,Prøveperiode Slutdato kan ikke være før startperiode for prøveperiode
apps/erpnext/erpnext/utilities/user_progress.py +146,Kg,Kg
DocType: Tax Withholding Category,Tax Withholding Category,Skat tilbageholdende kategori
apps/erpnext/erpnext/assets/doctype/asset_value_adjustment/asset_value_adjustment.py +23,Cancel the journal entry {0} first,Annuller journalindtastningen {0} først
DocType: Purchase Invoice,ACC-PINV-.YYYY.-,ACC-PINV-.YYYY.-
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +113,BOM is not specified for subcontracting item {0} at row {1},BOM er ikke specificeret til underleverancer punkt {0} i række {1}
DocType: Vital Signs,Reflexes,reflekser
apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js +149,{0} Result submittted,{0} Resultat indsendt
DocType: Item Attribute,Increment,Tilvækst
apps/erpnext/erpnext/utilities/page/leaderboard/leaderboard.js +74,Timespan,Tidsperiode
apps/erpnext/erpnext/templates/pages/search_help.py +13,Help Results for,Hjælp Resultater til
apps/erpnext/erpnext/public/js/stock_analytics.js +58,Select Warehouse...,Vælg lager ...
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +6,Advertising,Reklame
apps/erpnext/erpnext/accounts/doctype/mode_of_payment/mode_of_payment.py +22,Same Company is entered more than once,Samme firma er indtastet mere end én gang
DocType: Patient,Married,Gift
apps/erpnext/erpnext/accounts/party.py +42,Not permitted for {0},Ikke tilladt for {0}
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +624,Get items from,Hent varer fra
DocType: Price List,Price Not UOM Dependant,Pris Ikke UOM Afhængig
DocType: Purchase Invoice,Apply Tax Withholding Amount,Anvend Skat tilbageholdelsesbeløb
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +539,Stock cannot be updated against Delivery Note {0},Lager kan ikke opdateres mod følgeseddel {0}
apps/erpnext/erpnext/accounts/report/tds_computation_summary/tds_computation_summary.py +124,Total Amount Credited,Samlede beløb krediteret
apps/erpnext/erpnext/templates/pages/home.py +25,Product {0},Produkt {0}
apps/erpnext/erpnext/templates/generators/item_group.html +33,No items listed,Ingen emner opført
DocType: Asset Repair,Error Description,Fejlbeskrivelse
DocType: Payment Reconciliation,Reconcile,Forene
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +30,Grocery,Købmand
DocType: Quality Inspection Reading,Reading 1,Læsning 1
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +40,Pension Funds,Pensionskasser
DocType: Exchange Rate Revaluation Account,Gain/Loss,Gevinst / Tab
DocType: Crop,Perennial,Perennial
DocType: Patient Appointment,Procedure,Procedure
DocType: Accounts Settings,Use Custom Cash Flow Format,Brug Custom Cash Flow Format
DocType: SMS Center,All Sales Person,Alle salgsmedarbejdere
DocType: Monthly Distribution,**Monthly Distribution** helps you distribute the Budget/Target across months if you have seasonality in your business.,"** Månedlig Distribution ** hjælper dig distribuere Budget / Mål på tværs af måneder, hvis du har sæsonudsving i din virksomhed."
apps/erpnext/erpnext/accounts/page/pos/pos.js +1768,Not items found,Ikke varer fundet
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +267,Salary Structure Missing,Lønstruktur mangler
DocType: Lead,Person Name,Navn
DocType: Sales Invoice Item,Sales Invoice Item,Salgsfakturavare
DocType: Account,Credit,Kredit
DocType: POS Profile,Write Off Cost Center,Afskriv omkostningssted
apps/erpnext/erpnext/public/js/setup_wizard.js +117,"e.g. ""Primary School"" or ""University""",fx &quot;Primary School&quot; eller &quot;University&quot;
apps/erpnext/erpnext/config/stock.py +28,Stock Reports,Stock Rapporter
DocType: Warehouse,Warehouse Detail,Lagerinformation
apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +33,The Term End Date cannot be later than the Year End Date of the Academic Year to which the term is linked (Academic Year {}). Please correct the dates and try again.,"Den Term Slutdato kan ikke være senere end året Slutdato af skoleåret, som udtrykket er forbundet (Studieår {}). Ret de datoer og prøv igen."
apps/erpnext/erpnext/stock/doctype/item/item.py +298,"""Is Fixed Asset"" cannot be unchecked, as Asset record exists against the item","""Er anlægsaktiv"" kan ikke være umarkeret, da der eksisterer et anlægsaktiv på varen"
DocType: Delivery Trip,Departure Time,Afgangstid
DocType: Vehicle Service,Brake Oil,Bremse Oil
DocType: Tax Rule,Tax Type,Skat Type
,Completed Work Orders,Afsluttede arbejdsordrer
DocType: Support Settings,Forum Posts,Forumindlæg
apps/erpnext/erpnext/controllers/taxes_and_totals.py +603,Taxable Amount,Skattepligtigt beløb
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +161,You are not authorized to add or update entries before {0},Du har ikke tilladelse til at tilføje eller opdatere poster før {0}
DocType: Leave Policy,Leave Policy Details,Forlad politikoplysninger
DocType: BOM,Item Image (if not slideshow),Varebillede (hvis ikke lysbilledshow)
DocType: Work Order Operation,(Hour Rate / 60) * Actual Operation Time,(Timesats / 60) * TidsforbrugIMinutter
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1136,Row #{0}: Reference Document Type must be one of Expense Claim or Journal Entry,Row # {0}: Reference Document Type skal være en af Expense Claim eller Journal Entry
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1053,Select BOM,Vælg stykliste
DocType: SMS Log,SMS Log,SMS Log
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +27,Cost of Delivered Items,Omkostninger ved Leverede varer
apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +39,The holiday on {0} is not between From Date and To Date,Ferien på {0} er ikke mellem Fra dato og Til dato
DocType: Inpatient Record,Admission Scheduled,Adgang planlagt
DocType: Student Log,Student Log,Student Log
apps/erpnext/erpnext/config/buying.py +165,Templates of supplier standings.,Skabeloner af leverandørplaceringer.
DocType: Lead,Interested,Interesseret
apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py +27,Opening,Åbning
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +36,From {0} to {1},Fra {0} til {1}
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +234,Program: ,Program:
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +51,Failed to setup taxes,Kunne ikke oprette skatter
DocType: Item,Copy From Item Group,Kopier fra varegruppe
DocType: Journal Entry,Opening Entry,Åbningsbalance
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +25,Account Pay Only,Konto Betal kun
DocType: Loan,Repay Over Number of Periods,Tilbagebetale over antallet af perioder
DocType: Stock Entry,Additional Costs,Yderligere omkostninger
apps/erpnext/erpnext/accounts/doctype/account/account.py +145,Account with existing transaction can not be converted to group.,Konto med eksisterende transaktion kan ikke konverteres til gruppen.
DocType: Lead,Product Enquiry,Produkt Forespørgsel
DocType: Education Settings,Validate Batch for Students in Student Group,Valider batch for studerende i studentegruppe
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +38,No leave record found for employee {0} for {1},Ingen orlov rekord fundet for medarbejderen {0} for {1}
DocType: Company,Unrealized Exchange Gain/Loss Account,Urealiseret Exchange Gain / Loss-konto
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +23,Please enter company first,Indtast venligst firma først
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +626,Please select Company first,Vælg venligst firma først
DocType: Employee Education,Under Graduate,Under Graduate
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +290,Please set default template for Leave Status Notification in HR Settings.,Angiv standardskabelon for meddelelsen om statusstatus i HR-indstillinger.
apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.js +27,Target On,Target On
DocType: BOM,Total Cost,Omkostninger i alt
DocType: Soil Analysis,Ca/K,Ca / K
DocType: Salary Slip,Employee Loan,Medarbejderlån
DocType: Additional Salary,HR-ADS-.YY.-.MM.-,HR-ADS-.YY .-. MM.-
DocType: Fee Schedule,Send Payment Request Email,Send betalingsanmodning e-mail
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +282,Item {0} does not exist in the system or has expired,Vare {0} findes ikke i systemet eller er udløbet
DocType: Supplier,Leave blank if the Supplier is blocked indefinitely,"Forlad blank, hvis leverandøren er blokeret på ubestemt tid"
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +44,Real Estate,Real Estate
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html +1,Statement of Account,Kontoudtog
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +41,Pharmaceuticals,Lægemidler
DocType: Purchase Invoice Item,Is Fixed Asset,Er anlægsaktiv
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +355,"Available qty is {0}, you need {1}","Tilgængelige qty er {0}, du har brug for {1}"
DocType: Expense Claim Detail,Claim Amount,Beløb
DocType: Patient,HLC-PAT-.YYYY.-,HLC-PAT-.YYYY.-
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +646,Work Order has been {0},Arbejdsordre har været {0}
DocType: Budget,Applicable on Purchase Order,Gælder ved købsordre
DocType: Item,STO-ITEM-.YYYY.-,STO-item-.YYYY.-
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +56,Duplicate customer group found in the cutomer group table,Doppelt kundegruppe forefindes i Kundegruppetabellen
DocType: Location,Location Name,Navn på sted
DocType: Naming Series,Prefix,Præfiks
apps/erpnext/erpnext/hr/notification/training_scheduled/training_scheduled.html +7,Event Location,Event Location
DocType: Asset Settings,Asset Settings,Asset Settings
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +46,Consumable,Forbrugsmaterialer
DocType: Student,B-,B-
DocType: Assessment Result,Grade,Grad
DocType: Restaurant Table,No of Seats,Ingen pladser
DocType: Sales Invoice Item,Delivered By Supplier,Leveret af Leverandøren
DocType: Asset Maintenance Task,Asset Maintenance Task,Asset Maintenance Task
DocType: SMS Center,All Contact,Alle Kontakt
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +190,Annual Salary,Årsløn
DocType: Daily Work Summary,Daily Work Summary,Daglige arbejde Summary
DocType: Period Closing Voucher,Closing Fiscal Year,Lukning regnskabsår
apps/erpnext/erpnext/accounts/party.py +425,{0} {1} is frozen,{0} {1} er frosset
apps/erpnext/erpnext/setup/doctype/company/company.py +152,Please select Existing Company for creating Chart of Accounts,Vælg eksisterende firma for at danne kontoplanen
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +84,Stock Expenses,Stock Udgifter
apps/erpnext/erpnext/stock/doctype/batch/batch.js +111,Select Target Warehouse,Vælg Target Warehouse
apps/erpnext/erpnext/hr/doctype/employee/employee.js +87,Please enter Preferred Contact Email,Indtast foretrukket kontakt e-mail
DocType: Journal Entry,Contra Entry,Contra indtastning
DocType: Journal Entry Account,Credit in Company Currency,Kredit (firmavaluta)
DocType: Lab Test UOM,Lab Test UOM,Lab Test UOM
DocType: Delivery Note,Installation Status,Installation status
DocType: BOM,Quality Inspection Template,Kvalitetskontrolskabelon
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +136,"Do you want to update attendance?<br>Present: {0}\
					<br>Absent: {1}",Ønsker du at opdatere fremmøde? <br> Present: {0} \ <br> Fraværende: {1}
apps/erpnext/erpnext/controllers/buying_controller.py +433,Accepted + Rejected Qty must be equal to Received quantity for Item {0},Accepteret + Afvist antal skal være lig med modtaget antal for vare {0}
DocType: Item,Supply Raw Materials for Purchase,Supply råstoffer til Indkøb
DocType: Agriculture Analysis Criteria,Fertilizer,Gødning
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +441,"Cannot ensure delivery by Serial No as \
				Item {0} is added with and without Ensure Delivery by \
				Serial No.",Kan ikke sikre levering med serienummer som \ Item {0} tilføjes med og uden Sikre Levering med \ Serienr.
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +203,At least one mode of payment is required for POS invoice.,Mindst én form for betaling er nødvendig for POS faktura.
DocType: Bank Statement Transaction Invoice Item,Bank Statement Transaction Invoice Item,Bankoversigt Transaktionsfaktura
DocType: Products Settings,Show Products as a List,Vis produkterne på en liste
DocType: Salary Detail,Tax on flexible benefit,Skat på fleksibel fordel
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.py +43,Item {0} is not active or end of life has been reached,Vare {0} er ikke aktiv eller slutningen af livet er nået
DocType: Student Admission Program,Minimum Age,Mindstealder
apps/erpnext/erpnext/utilities/user_progress.py +190,Example: Basic Mathematics,Eksempel: Grundlæggende Matematik
DocType: Customer,Primary Address,Primæradresse
apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.py +39,Diff Qty,Diff Antal
DocType: Production Plan,Material Request Detail,Materialeforespørgsel Detail
DocType: Selling Settings,Default Quotation Validity Days,Standard Quotation Gyldighedsdage
apps/erpnext/erpnext/controllers/accounts_controller.py +886,"To include tax in row {0} in Item rate, taxes in rows {1} must also be included","Hvis du vil medtage skat i række {0} i Item sats, skatter i rækker {1} skal også medtages"
DocType: SMS Center,SMS Center,SMS-center
DocType: Payroll Entry,Validate Attendance,Validere tilstedeværelse
DocType: Sales Invoice,Change Amount,ændring beløb
DocType: Party Tax Withholding Config,Certificate Received,Certifikat modtaget
DocType: GST Settings,Set Invoice Value for B2C. B2CL and B2CS calculated based on this invoice value.,Angiv faktura værdi for B2C. B2CL og B2CS beregnet ud fra denne faktura værdi.
DocType: BOM Update Tool,New BOM,Ny stykliste
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +307,Prescribed Procedures,Foreskrevne procedurer
apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js +36,Show only POS,Vis kun POS
DocType: Supplier Group,Supplier Group Name,Leverandørgruppens navn
DocType: Driver,Driving License Categories,Kørekortskategorier
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +124,Please enter Delivery Date,Indtast venligst Leveringsdato
DocType: Depreciation Schedule,Make Depreciation Entry,Foretag Afskrivninger indtastning
DocType: Closed Document,Closed Document,Lukket dokument
DocType: HR Settings,Leave Settings,Forlad indstillinger
apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.js +76,Number of positions cannot be less then current count of employees,Antal stillinger kan ikke være mindre end nuværende antal medarbejdere
DocType: Appraisal Template Goal,KRA,KRA
DocType: Lead,Request Type,Anmodningstype
DocType: Purpose of Travel,Purpose of Travel,Formålet med rejser
DocType: Payroll Period,Payroll Periods,Lønningsperioder
apps/erpnext/erpnext/hr/doctype/job_offer/job_offer.js +18,Make Employee,Opret medarbejder
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +14,Broadcasting,Broadcasting
apps/erpnext/erpnext/config/accounts.py +538,Setup mode of POS (Online / Offline),Opsætningstilstand for POS (Online / Offline)
DocType: Manufacturing Settings,Disables creation of time logs against Work Orders. Operations shall not be tracked against Work Order,Deaktiverer oprettelse af tidslogfiler mod arbejdsordrer. Operationer må ikke spores mod Arbejdsordre
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +144,Execution,Udførelse
apps/erpnext/erpnext/config/manufacturing.py +62,Details of the operations carried out.,Oplysninger om de gennemførte transaktioner.
DocType: Asset Maintenance Log,Maintenance Status,Vedligeholdelsesstatus
apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py +10,Membership Details,Medlemskabsdetaljer
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +56,{0} {1}: Supplier is required against Payable account {2},{0} {1}: Leverandøren er påkrævet mod Betalings konto {2}
apps/erpnext/erpnext/config/selling.py +52,Items and Pricing,Varer og Priser
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +2,Total hours: {0},Total time: {0}
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +43,From Date should be within the Fiscal Year. Assuming From Date = {0},Fra dato skal være inden regnskabsåret. Antages Fra dato = {0}
DocType: Patient Medical Record,HLC-PMR-.YYYY.-,HLC-PMR-.YYYY.-
DocType: Drug Prescription,Interval,Interval
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +211,Preference,Preference
DocType: Supplier,Individual,Privatperson
DocType: Academic Term,Academics User,akademikere Bruger
DocType: Cheque Print Template,Amount In Figure,Beløb I figur
DocType: Loan Application,Loan Info,Låneinformation
apps/erpnext/erpnext/config/maintenance.py +12,Plan for maintenance visits.,Plan for vedligeholdelse besøg.
DocType: Supplier Scorecard Period,Supplier Scorecard Period,Leverandør Scorecard Periode
DocType: Support Settings,Search APIs,Søg API&#39;er
DocType: Share Transfer,Share Transfer,Deloverførsel
,Expiring Memberships,Udfaldne Medlemskaber
DocType: POS Profile,Customer Groups,Kundegrupper
apps/erpnext/erpnext/public/js/financial_statements.js +53,Financial Statements,Finansrapporter
DocType: Guardian,Students,Studerende
apps/erpnext/erpnext/config/selling.py +91,Rules for applying pricing and discount.,Regler for anvendelse af priser og rabat.
DocType: Daily Work Summary,Daily Work Summary Group,Daglig Arbejdsopsamlingsgruppe
DocType: Practitioner Schedule,Time Slots,Time Slots
apps/erpnext/erpnext/stock/doctype/price_list/price_list.py +14,Price List must be applicable for Buying or Selling,Prisliste skal være gældende for at købe eller sælge
DocType: Shift Assignment,Shift Request,Skiftforespørgsel
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +79,Installation date cannot be before delivery date for Item {0},Installation dato kan ikke være før leveringsdato for Item {0}
DocType: Pricing Rule,Discount on Price List Rate (%),Rabat på prisliste Rate (%)
apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +112,Item Template,Vare skabelon
DocType: Job Offer,Select Terms and Conditions,Vælg betingelser
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +87,Out Value,Out Value
DocType: Bank Statement Settings Item,Bank Statement Settings Item,Betalingsindstillinger for bankkonti
DocType: Woocommerce Settings,Woocommerce Settings,Woocommerce Indstillinger
DocType: Production Plan,Sales Orders,Salgsordrer
apps/erpnext/erpnext/selling/doctype/customer/customer.py +203,Multiple Loyalty Program found for the Customer. Please select manually.,Flere loyalitetsprogram fundet for kunden. Vælg venligst manuelt.
DocType: Purchase Taxes and Charges,Valuation,Værdiansættelse
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +436,Set as Default,Indstil som standard
,Purchase Order Trends,Indkøbsordre Trends
apps/erpnext/erpnext/utilities/user_progress.py +78,Go to Customers,Gå til kunder
DocType: Hotel Room Reservation,Late Checkin,Sen checkin
apps/erpnext/erpnext/templates/emails/request_for_quotation.html +7,The request for quotation can be accessed by clicking on the following link,Tilbudsforespørgslen findes ved at klikke på følgende link
DocType: SG Creation Tool Course,SG Creation Tool Course,SG Creation Tool Course
DocType: Bank Statement Transaction Invoice Item,Payment Description,Betalingsbeskrivelse
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +357,Insufficient Stock,Utilstrækkelig Stock
DocType: Manufacturing Settings,Disable Capacity Planning and Time Tracking,Deaktiver kapacitetsplanlægning og tidsregistrering
DocType: Email Digest,New Sales Orders,Nye salgsordrer
DocType: Bank Account,Bank Account,Bankkonto
DocType: Travel Itinerary,Check-out Date,Check-out dato
DocType: Leave Type,Allow Negative Balance,Tillad negativ fraværssaldo
apps/erpnext/erpnext/projects/doctype/project_type/project_type.py +13,You cannot delete Project Type 'External',Du kan ikke slette Project Type &#39;External&#39;
apps/erpnext/erpnext/public/js/utils.js +274,Select Alternate Item,Vælg alternativt element
DocType: Employee,Create User,Opret bruger
DocType: Selling Settings,Default Territory,Standardområde
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +53,Television,Fjernsyn
DocType: Work Order Operation,Updated via 'Time Log',Opdateret via &#39;Time Log&#39;
apps/erpnext/erpnext/accounts/doctype/bank_guarantee/bank_guarantee.py +13,Select the customer or supplier.,Vælg kunde eller leverandør.
apps/erpnext/erpnext/controllers/taxes_and_totals.py +449,Advance amount cannot be greater than {0} {1},Advance beløb kan ikke være større end {0} {1}
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js +55,"Time slot skiped, the slot {0} to {1} overlap exisiting slot {2} to {3}","Tidspausen overspring, spalten {0} til {1} overlapper ekspansionen slot {2} til {3}"
DocType: Naming Series,Series List for this Transaction,Serie Liste for denne transaktion
DocType: Company,Enable Perpetual Inventory,Aktiver evigt lager
DocType: Bank Guarantee,Charges Incurred,Afgifter opkrævet
DocType: Company,Default Payroll Payable Account,Standard Payroll Betales konto
apps/erpnext/erpnext/education/doctype/student_group/student_group.js +51,Update Email Group,Opdatér E-mailgruppe
DocType: Sales Invoice,Is Opening Entry,Åbningspost
DocType: Lab Test Template,"If unchecked, the item wont be appear in Sales Invoice, but can be used in group test creation. ","Hvis det ikke er markeret, vises varen ikke i salgsfaktura, men kan bruges til oprettelse af gruppetest."
DocType: Customer Group,Mention if non-standard receivable account applicable,"Nævne, hvis ikke-standard tilgodehavende konto gældende"
DocType: Course Schedule,Instructor Name,Instruktør Navn
DocType: Company,Arrear Component,Arrear Component
DocType: Supplier Scorecard,Criteria Setup,Kriterier opsætning
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +199,For Warehouse is required before Submit,Til lager skal angives før godkendelse
apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +8,Received On,Modtaget On
DocType: Codification Table,Medical Code,Medicinsk kode
apps/erpnext/erpnext/config/integrations.py +37,Connect Amazon with ERPNext,Forbind Amazon med ERPNext
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +20,Please enter Company,Indtast firma
DocType: Delivery Note Item,Against Sales Invoice Item,Mod salgsfakturavarer
DocType: Agriculture Analysis Criteria,Linked Doctype,Tilknyttet doktype
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +98,Net Cash from Financing,Netto kontant fra Finansiering
apps/erpnext/erpnext/accounts/page/pos/pos.js +2389,"LocalStorage is full , did not save","LocalStorage er fuld, kan ikke gemme"
DocType: Lead,Address & Contact,Adresse og kontaktperson
DocType: Leave Allocation,Add unused leaves from previous allocations,Tilføj ubrugt fravær fra tidligere tildelinger
DocType: Sales Partner,Partner website,Partner hjemmeside
DocType: Restaurant Order Entry,Add Item,Tilføj vare
DocType: Party Tax Withholding Config,Party Tax Withholding Config,Party Tax Withholding Config
DocType: Lab Test,Custom Result,Brugerdefineret resultat
DocType: Delivery Stop,Contact Name,Kontaktnavn
DocType: Course Assessment Criteria,Course Assessment Criteria,Kriterier for kursusvurdering
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +21,Tax Id: ,Skatte ID:
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +216,Student ID: ,Studiekort:
DocType: POS Customer Group,POS Customer Group,Kassesystem-kundegruppe
DocType: Healthcare Practitioner,Practitioner Schedules,Practitioner Schedules
DocType: Cheque Print Template,Line spacing for amount in words,Linjeafstand for beløb i ord
DocType: Vehicle,Additional Details,Yderligere detaljer
apps/erpnext/erpnext/templates/generators/bom.html +85,No description given,Ingen beskrivelse
apps/erpnext/erpnext/config/buying.py +13,Request for purchase.,Indkøbsanmodning.
DocType: POS Closing Voucher Details,Collected Amount,Samlet beløb
DocType: Lab Test,Submitted Date,Indsendt dato
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py +6,This is based on the Time Sheets created against this project,Dette er baseret på de timesedler oprettes imod denne sag
,Open Work Orders,Åbne arbejdsordrer
DocType: Healthcare Practitioner,Out Patient Consulting Charge Item,Out Patient Consulting Charge Item
DocType: Payment Term,Credit Months,Kredit måneder
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +494,Net Pay cannot be less than 0,Nettoløn kan ikke være mindre end 0
DocType: Contract,Fulfilled,opfyldt
DocType: Inpatient Record,Discharge Scheduled,Udledning planlagt
apps/erpnext/erpnext/hr/doctype/employee/employee.py +138,Relieving Date must be greater than Date of Joining,Fratrædelsesdato skal være større end ansættelsesdato
DocType: POS Closing Voucher,Cashier,Kasserer
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +198,Leaves per Year,Fravær pr. år
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +162,Row {0}: Please check 'Is Advance' against Account {1} if this is an advance entry.,"Række {0}: Tjek venligst &quot;Er Advance &#39;mod konto {1}, hvis dette er et forskud post."
apps/erpnext/erpnext/stock/utils.py +243,Warehouse {0} does not belong to company {1},Lager {0} ikke hører til firmaet {1}
DocType: Email Digest,Profit & Loss,Profit &amp; Loss
apps/erpnext/erpnext/utilities/user_progress.py +147,Litre,liter
DocType: Task,Total Costing Amount (via Time Sheet),Totale omkostninger (via tidsregistrering)
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.py +76,Please setup Students under Student Groups,Opsæt venligst studerende under elevgrupper
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.js +31,Complete Job,Komplet job
DocType: Item Website Specification,Item Website Specification,Varebeskrivelse til hjemmesiden
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +543,Leave Blocked,Fravær blokeret
apps/erpnext/erpnext/stock/doctype/item/item.py +818,Item {0} has reached its end of life on {1},Vare {0} har nået slutningen af sin levetid på {1}
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +82,Bank Entries,Bank Entries
DocType: Customer,Is Internal Customer,Er intern kunde
DocType: Crop,Annual,Årligt
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js +27,"If Auto Opt In is checked, then the customers will be automatically linked with the concerned Loyalty Program (on save)","Hvis Auto Opt In er markeret, bliver kunderne automatisk knyttet til det berørte loyalitetsprogram (ved at gemme)"
DocType: Stock Reconciliation Item,Stock Reconciliation Item,Lagerafstemningsvare
DocType: Stock Entry,Sales Invoice No,Salgsfakturanr.
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +145,Supply Type,Forsyningstype
DocType: Material Request Item,Min Order Qty,Min. ordremængde
DocType: Student Group Creation Tool Course,Student Group Creation Tool Course,Elevgruppeværktøj til dannelse af fag
DocType: Lead,Do Not Contact,Må ikke komme i kontakt
apps/erpnext/erpnext/utilities/user_progress.py +210,People who teach at your organisation,Personer der underviser i din organisation
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +98,Software Developer,Software Developer
DocType: Item,Minimum Order Qty,Minimum ordremængde
DocType: Supplier,Supplier Type,Leverandørtype
DocType: Course Scheduling Tool,Course Start Date,Kursusstartdato
,Student Batch-Wise Attendance,Fremmøde efter elevgrupper
DocType: POS Profile,Allow user to edit Rate,Tillad brugeren at redigere satsen
DocType: Item,Publish in Hub,Offentliggør i Hub
DocType: Student Admission,Student Admission,Studerende optagelse
,Terretory,Terretory
apps/erpnext/erpnext/stock/doctype/item/item.py +840,Item {0} is cancelled,Vare {0} er aflyst
apps/erpnext/erpnext/assets/doctype/asset/asset.py +215,Depreciation Row {0}: Depreciation Start Date is entered as past date,Afskrivningsrække {0}: Afskrivning Startdato er indtastet som tidligere dato
DocType: Contract Template,Fulfilment Terms and Conditions,Opfyldelsesbetingelser
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1138,Material Request,Materialeanmodning
DocType: Bank Reconciliation,Update Clearance Date,Opdatering Clearance Dato
,GSTR-2,GSTR-2
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +494,Item {0} not found in 'Raw Materials Supplied' table in Purchase Order {1},Vare {0} ikke fundet i &quot;Raw Materials Leveres &#39;bord i Indkøbsordre {1}
DocType: Salary Slip,Total Principal Amount,Samlede hovedbeløb
DocType: Student Guardian,Relation,Relation
DocType: Student Guardian,Mother,Mor
DocType: Restaurant Reservation,Reservation End Time,Reservation Slut Tid
DocType: Crop,Biennial,Biennalen
,BOM Variance Report,BOM Variance Report
apps/erpnext/erpnext/config/selling.py +18,Confirmed orders from Customers.,Bekræftede ordrer fra kunder.
DocType: Purchase Receipt Item,Rejected Quantity,Afvist Mængde
apps/erpnext/erpnext/education/doctype/fees/fees.py +80,Payment request {0} created,Betalingsanmodning {0} oprettet
DocType: Inpatient Record,Admitted Datetime,Admitted Datetime
DocType: Work Order,Backflush raw materials from work-in-progress warehouse,Backflush råmaterialer fra arbejdet i arbejde
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +79,Open Orders,Åbn ordrer
apps/erpnext/erpnext/healthcare/setup.py +187,Low Sensitivity,Lav følsomhed
apps/erpnext/erpnext/erpnext_integrations/doctype/shopify_log/shopify_log.js +16,Order rescheduled for sync,Ordre omlagt til synkronisering
DocType: Notification Control,Notification Control,Meddelelse Kontrol
apps/erpnext/erpnext/templates/emails/training_event.html +17,Please confirm once you have completed your training,"Bekræft venligst, når du har afsluttet din træning"
DocType: Lead,Suggestions,Forslag
DocType: Territory,Set Item Group-wise budgets on this Territory. You can also include seasonality by setting the Distribution.,Sæt varegruppe-budgetter på dette område. Du kan også medtage sæsonudsving ved at sætte Distribution.
DocType: Payment Term,Payment Term Name,Betalingsbetegnelsens navn
DocType: Healthcare Settings,Create documents for sample collection,Opret dokumenter til prøveindsamling
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +308,Payment against {0} {1} cannot be greater than Outstanding Amount {2},Betaling mod {0} {1} kan ikke være større end udestående beløb {2}
apps/erpnext/erpnext/patches/v11_0/add_healthcare_service_unit_tree_root.py +16,All Healthcare Service Units,Alle sundhedsvæsener
DocType: Bank Account,Address HTML,Adresse HTML
DocType: Lead,Mobile No.,Mobiltelefonnr.
apps/erpnext/erpnext/selling/doctype/pos_closing_voucher/closing_voucher_details.html +35,Mode of Payments,Betalingsmåde
DocType: Maintenance Schedule,Generate Schedule,Generer Schedule
DocType: Purchase Invoice Item,Expense Head,Expense Hoved
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +149,Please select Charge Type first,Vælg Charge Type først
DocType: Crop,"You can define all the tasks which need to carried out for this crop here. The day field is used to mention the day on which the task needs to be carried out, 1 being the 1st day, etc.. ","Du kan definere alle de opgaver, der skal udføres for denne afgrøde her. Dagfeltet bruges til at nævne den dag, hvorpå opgaven skal udføres, 1 er 1. dag mv."
DocType: Student Group Student,Student Group Student,Elev i elevgruppe
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +42,Latest,Seneste
DocType: Asset Maintenance Task,2 Yearly,2 årligt
DocType: Education Settings,Education Settings,Uddannelsesindstillinger
DocType: Vehicle Service,Inspection,Kontrol
DocType: Leave Allocation,HR-LAL-.YYYY.-,HR-LAL-.YYYY.-
DocType: Exchange Rate Revaluation Account,Balance In Base Currency,Balance i basisvaluta
DocType: Supplier Scorecard Scoring Standing,Max Grade,Max Grade
DocType: Email Digest,New Quotations,Nye tilbud
apps/erpnext/erpnext/hr/doctype/attendance_request/attendance_request.py +60,Attendance not submitted for {0} as {1} on leave.,Tilstedeværelse er ikke indsendt til {0} som {1} med orlov.
DocType: Journal Entry,Payment Order,Betalingsordre
DocType: HR Settings,Emails salary slip to employee based on preferred email selected in Employee,"Lønseddel sendes til medarbejderen på e-mail, på baggrund af den foretrukne e-mailadresse der er valgt for medarbejderen"
DocType: Tax Rule,Shipping County,Anvendes ikke
DocType: Currency Exchange,For Selling,Til salg
apps/erpnext/erpnext/config/desktop.py +159,Learn,Hjælp
DocType: Purchase Invoice Item,Enable Deferred Expense,Aktivér udskudt udgift
DocType: Asset,Next Depreciation Date,Næste afskrivningsdato
apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js +3,Activity Cost per Employee,Aktivitet Omkostninger per Medarbejder
DocType: Accounts Settings,Settings for Accounts,Indstillinger for regnskab
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +800,Supplier Invoice No exists in Purchase Invoice {0},Leverandør faktura nr eksisterer i købsfaktura {0}
apps/erpnext/erpnext/config/selling.py +118,Manage Sales Person Tree.,Administrer Sales Person Tree.
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +105,"Cannot process route, since Google Maps Settings is disabled.","Kan ikke behandle rute, da Google Maps-indstillinger er deaktiveret."
DocType: Job Applicant,Cover Letter,Følgebrev
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +37,Outstanding Cheques and Deposits to clear,Anvendes ikke
DocType: Item,Synced With Hub,Synkroniseret med Hub
DocType: Driver,Fleet Manager,Fleet manager
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +573,Row #{0}: {1} can not be negative for item {2},Rækken # {0}: {1} kan ikke være negativ for vare {2}
apps/erpnext/erpnext/setup/doctype/company/company.js +129,Wrong Password,Forkert adgangskode
DocType: Stock Reconciliation,MAT-RECO-.YYYY.-,MAT-RECO-.YYYY.-
DocType: Item,Variant Of,Variant af
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +387,Completed Qty can not be greater than 'Qty to Manufacture',Afsluttet Antal kan ikke være større end &#39;antal til Fremstilling&#39;
DocType: Period Closing Voucher,Closing Account Head,Lukning konto Hoved
DocType: Employee,External Work History,Ekstern Work History
apps/erpnext/erpnext/projects/doctype/task/task.py +114,Circular Reference Error,Cirkulær reference Fejl
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +206,Student Report Card,Studenterapport
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +207,From Pin Code,Fra Pin Code
DocType: Appointment Type,Is Inpatient,Er sygeplejerske
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +55,Guardian1 Name,Guardian1 Navn
DocType: Delivery Note,In Words (Export) will be visible once you save the Delivery Note.,"I ord (udlæsning) vil være synlig, når du gemmer følgesedlen."
DocType: Cheque Print Template,Distance from left edge,Afstand fra venstre kant
apps/erpnext/erpnext/utilities/bot.py +29,{0} units of [{1}](#Form/Item/{1}) found in [{2}](#Form/Warehouse/{2}),{0} enheder af [{1}] (# Form / vare / {1}) findes i [{2}] (# Form / Lager / {2})
DocType: Lead,Industry,Branche
DocType: BOM Item,Rate & Amount,Pris &amp; Beløb
DocType: BOM,Transfer Material Against Job Card,Overfør materiale mod jobkort
DocType: Stock Settings,Notify by Email on creation of automatic Material Request,Give besked på e-mail om oprettelse af automatiske materialeanmodninger
apps/erpnext/erpnext/healthcare/setup.py +191,Resistant,Resistente
apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.py +77,Please set Hotel Room Rate on {},Indstil hotelpris på {}
DocType: Journal Entry,Multi Currency,Multi Valuta
DocType: Bank Statement Transaction Invoice Item,Invoice Type,Fakturatype
DocType: Employee Benefit Claim,Expense Proof,Udgiftsbevis
apps/erpnext/erpnext/erpnext_integrations/doctype/quickbooks_migrator/quickbooks_migrator.py +318,Saving {0},Gemmer {0}
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +990,Delivery Note,Følgeseddel
DocType: Patient Encounter,Encounter Impression,Encounter Impression
apps/erpnext/erpnext/config/learn.py +82,Setting up Taxes,Opsætning Skatter
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +149,Cost of Sold Asset,Udgifter Solgt Asset
DocType: Volunteer,Morning,Morgen
apps/erpnext/erpnext/accounts/utils.py +374,Payment Entry has been modified after you pulled it. Please pull it again.,"Betaling indtastning er blevet ændret, efter at du trak det. Venligst trække det igen."
DocType: Program Enrollment Tool,New Student Batch,Ny Student Batch
apps/erpnext/erpnext/stock/doctype/item/item.py +510,{0} entered twice in Item Tax,{0} indtastet to gange i varemoms
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +121,Summary for this week and pending activities,Resumé for denne uge og verserende aktiviteter
DocType: Student Applicant,Admitted,Advokat
DocType: Workstation,Rent Cost,Leje Omkostninger
apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +116,Amount After Depreciation,Beløb efter afskrivninger
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +97,Upcoming Calendar Events,Kommende kalenderbegivenheder
apps/erpnext/erpnext/public/js/templates/item_quick_entry.html +1,Variant Attributes,Variant attributter
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +114,Please select month and year,Vælg måned og år
DocType: Employee,Company Email,Firma e-mail
DocType: GL Entry,Debit Amount in Account Currency,Debetbeløb i Kontoens valuta
DocType: Supplier Scorecard,Scoring Standings,Scoring Standings
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +21,Order Value,Ordreværdi
DocType: Certified Consultant,Certified Consultant,Certificeret konsulent
apps/erpnext/erpnext/config/accounts.py +29,Bank/Cash transactions against party or for internal transfer,Bank / Cash transaktioner mod fest eller til intern overførsel
DocType: Shipping Rule,Valid for Countries,Gælder for lande
apps/erpnext/erpnext/stock/doctype/item/item.js +57,This Item is a Template and cannot be used in transactions. Item attributes will be copied over into the variants unless 'No Copy' is set,"Dette element er en skabelon, og kan ikke anvendes i transaktioner. Item attributter kopieres over i varianterne medmindre &#39;Ingen Copy &quot;er indstillet"
DocType: Grant Application,Grant Application,Grant ansøgning
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +69,Total Order Considered,Samlet Order Anses
DocType: Certification Application,Not Certified,Ikke certificeret
DocType: Asset Value Adjustment,New Asset Value,Ny aktivværdi
DocType: Sales Invoice,Rate at which Customer Currency is converted to customer's base currency,"Hastighed, hvormed kunden Valuta omdannes til kundens basisvaluta"
DocType: Course Scheduling Tool,Course Scheduling Tool,Kursusplanlægningsværktøj
apps/erpnext/erpnext/controllers/accounts_controller.py +698,Row #{0}: Purchase Invoice cannot be made against an existing asset {1},Row # {0}: Køb Faktura kan ikke foretages mod en eksisterende aktiv {1}
DocType: Crop Cycle,LInked Analysis,Analyseret
DocType: POS Closing Voucher,POS Closing Voucher,POS Closing Voucher
DocType: Contract,Lapsed,bortfaldet
DocType: Item Tax,Tax Rate,Skat
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +107,Application period cannot be across two allocation records,Ansøgningsperioden kan ikke være på tværs af to tildelingsregistre
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +73,{0} already allocated for Employee {1} for period {2} to {3},{0} allerede afsat til Medarbejder {1} for perioden {2} til {3}
DocType: Buying Settings,Backflush Raw Materials of Subcontract Based On,Backflush råmaterialer af underentreprise baseret på
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +145,Purchase Invoice {0} is already submitted,Købsfaktura {0} er allerede godkendt
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +90,Row # {0}: Batch No must be same as {1} {2},Række # {0}: Partinr. skal være det samme som {1} {2}
DocType: Material Request Plan Item,Material Request Plan Item,Materialeforespørgsel Planlægning
DocType: Leave Type,Allow Encashment,Tillad Encashment
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +101,Convert to non-Group,Konverter til ikke-Group
DocType: Project Update,Good/Steady,Godt / Steady
DocType: Bank Statement Transaction Invoice Item,Invoice Date,Fakturadato
DocType: GL Entry,Debit Amount,Debetbeløb
apps/erpnext/erpnext/accounts/party.py +277,There can only be 1 Account per Company in {0} {1},Der kan kun være 1 konto pr. firma i {0} {1}
DocType: Support Search Source,Response Result Key Path,Response Result Key Path
DocType: Journal Entry,Inter Company Journal Entry,Inter Company Journal Entry
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +534,For quantity {0} should not be grater than work order quantity {1},For mængden {0} bør ikke være rifler end arbejdsmængde {1}
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +524,Please see attachment,Se venligst vedhæftede fil
DocType: Purchase Order,% Received,% Modtaget
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js +3,Create Student Groups,Opret Elevgrupper
DocType: Volunteer,Weekends,weekender
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +138,Credit Note Amount,Kredit Note Beløb
DocType: Setup Progress Action,Action Document,Handlingsdokument
DocType: Chapter Member,Website URL,Website URL
,Finished Goods,Færdigvarer
DocType: Delivery Note,Instructions,Instruktioner
DocType: Quality Inspection,Inspected By,Kontrolleret af
DocType: Asset,ACC-ASS-.YYYY.-,ACC-ASS-.YYYY.-
DocType: Asset Maintenance Log,Maintenance Type,Vedligeholdelsestype
apps/erpnext/erpnext/education/doctype/student_group/student_group.py +45,{0} - {1} is not enrolled in the Course {2},{0} - {1} er ikke tilmeldt kurset {2}
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +225,Student Name: ,Elevnavn:
DocType: POS Closing Voucher Details,Difference,Forskel
DocType: Delivery Settings,Delay between Delivery Stops,Forsinkelse mellem Leveringsstop
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +59,Serial No {0} does not belong to Delivery Note {1},Serienummer {0} hører ikke til følgeseddel {1}
apps/erpnext/erpnext/erpnext_integrations/doctype/gocardless_settings/gocardless_settings.py +97,"There seems to be an issue with the server's GoCardless configuration. Don't worry, in case of failure, the amount will get refunded to your account.","Der ser ud til at være et problem med serverens GoCardless-konfiguration. Du skal ikke bekymre dig, i tilfælde af fiasko vil beløbet blive refunderet til din konto."
apps/erpnext/erpnext/templates/pages/demo.html +47,ERPNext Demo,ERPNext Demo
apps/erpnext/erpnext/public/js/utils/item_selector.js +20,Add Items,Tilføj varer
DocType: Item Quality Inspection Parameter,Item Quality Inspection Parameter,Kvalitetskontrolparameter
DocType: Leave Application,Leave Approver Name,Fraværsgodkendernavn
DocType: Depreciation Schedule,Schedule Date,Tidsplan Dato
DocType: Amazon MWS Settings,FR,FR
DocType: Packed Item,Packed Item,Pakket vare
DocType: Job Offer Term,Job Offer Term,Jobtilbudsperiode
apps/erpnext/erpnext/config/buying.py +65,Default settings for buying transactions.,Standardindstillinger for at købe transaktioner.
apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +29,Activity Cost exists for Employee {0} against Activity Type - {1},Aktivitetsomkostninger eksisterer for Medarbejder {0} for aktivitetstype - {1}
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +20,Mandatory field - Get Students From,Obligatorisk felt - Få studerende fra
DocType: Program Enrollment,Enrolled courses,Indskrevne kurser
DocType: Currency Exchange,Currency Exchange,Valutaveksling
DocType: Opening Invoice Creation Tool Item,Item Name,Varenavn
DocType: Authorization Rule,Approving User  (above authorized value),Godkendelse Bruger (over autoriserede værdi)
DocType: Email Digest,Credit Balance,Kreditsaldo
DocType: Employee,Widowed,Enke
DocType: Request for Quotation,Request for Quotation,Anmodning om tilbud
DocType: Healthcare Settings,Require Lab Test Approval,Kræv labtestgodkendelse
DocType: Salary Slip Timesheet,Working Hours,Arbejdstider
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html +10,Total Outstanding,Samlet Udestående
DocType: Naming Series,Change the starting / current sequence number of an existing series.,Skift start / aktuelle sekvensnummer af en eksisterende serie.
DocType: Dosage Strength,Strength,Styrke
apps/erpnext/erpnext/accounts/page/pos/pos.js +1548,Create a new Customer,Opret ny kunde
apps/erpnext/erpnext/non_profit/report/expiring_memberships/expiring_memberships.py +17,Expiring On,Udløbsdato
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +59,"If multiple Pricing Rules continue to prevail, users are asked to set Priority manually to resolve conflict.","Hvis flere Priser Regler fortsat gældende, er brugerne bedt om at indstille prioritet manuelt for at løse konflikter."
apps/erpnext/erpnext/utilities/activation.py +90,Create Purchase Orders,Opret indkøbsordrer
,Purchase Register,Indkøb Register
apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +116,Patient not found,Patient ikke fundet
DocType: Scheduling Tool,Rechedule,Rechedule
DocType: Landed Cost Item,Applicable Charges,Gældende gebyrer
DocType: Workstation,Consumable Cost,Forbrugsmaterialer Cost
DocType: Purchase Receipt,Vehicle Date,Køretøj dato
DocType: Student Log,Medical,Medicinsk
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +186,Reason for losing,Tabsårsag
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1757,Please select Drug,Vælg venligst Drug
apps/erpnext/erpnext/crm/doctype/lead/lead.py +44,Lead Owner cannot be same as the Lead,Emneejer kan ikke være den samme som emnet
apps/erpnext/erpnext/accounts/utils.py +380,Allocated amount can not greater than unadjusted amount,Allokeret beløb kan ikke større end ikke-justerede beløb
DocType: Announcement,Receiver,Modtager
DocType: Location,Area UOM,Område UOM
apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +83,Workstation is closed on the following dates as per Holiday List: {0},Workstation er lukket på følgende datoer ifølge helligdagskalenderen: {0}
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +34,Opportunities,Salgsmuligheder
DocType: Lab Test Template,Single,Enkeltværelse
DocType: Compensatory Leave Request,Work From Date,Arbejde fra dato
DocType: Salary Slip,Total Loan Repayment,Samlet lån til tilbagebetaling
DocType: Project User,View attachments,Se vedhæftede filer
DocType: Account,Cost of Goods Sold,Vareforbrug
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +231,Please enter Cost Center,Indtast omkostningssted
DocType: Drug Prescription,Dosage,Dosering
DocType: Journal Entry Account,Sales Order,Salgsordre
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +67,Avg. Selling Rate,Gns. Salgssats
DocType: Assessment Plan,Examiner Name,Censornavn
DocType: Lab Test Template,No Result,ingen Resultat
DocType: Purchase Invoice Item,Quantity and Rate,Mængde og Pris
DocType: Delivery Note,% Installed,% Installeret
apps/erpnext/erpnext/utilities/user_progress.py +230,Classrooms/ Laboratories etc where lectures can be scheduled.,Klasseværelser / Laboratorier osv hvor foredrag kan planlægges.
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +1308,Company currencies of both the companies should match for Inter Company Transactions.,Selskabets valutaer for begge virksomheder skal matche for Inter Company Transactions.
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +95,Please enter company name first,Indtast venligst firmanavn først
DocType: Travel Itinerary,Non-Vegetarian,Ikke-Vegetarisk
DocType: Purchase Invoice,Supplier Name,Leverandørnavn
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +25,Read the ERPNext Manual,Læs ERPNext-håndbogen
DocType: HR Settings,Show Leaves Of All Department Members In Calendar,Vis blade af alle afdelingsmedlemmer i kalender
DocType: Purchase Invoice,01-Sales Return,01-Salg Retur
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js +15,Temporarily on Hold,Midlertidigt på hold
DocType: Account,Is Group,Er en kontogruppe
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +327,Credit Note {0} has been created automatically,Kreditnota {0} er oprettet automatisk
DocType: Stock Settings,Automatically Set Serial Nos based on FIFO,Angiv serienumrene automatisk baseret på FIFO-princippet
DocType: Accounts Settings,Check Supplier Invoice Number Uniqueness,Tjek entydigheden af  leverandørfakturanummeret
apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js +34,Primary Address Details,Primær adresseoplysninger
DocType: Vehicle Service,Oil Change,Olieskift
DocType: Leave Encashment,Leave Balance,Forløbsbalance
DocType: Asset Maintenance Log,Asset Maintenance Log,Asset Maintenance Log
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +57,'To Case No.' cannot be less than 'From Case No.','Til sag nr.' kan ikke være mindre end 'Fra sag nr.'
DocType: Certification Application,Non Profit,Non Profit
DocType: Production Plan,Not Started,Ikke igangsat
DocType: Lead,Channel Partner,Channel Partner
DocType: Account,Old Parent,Gammel Parent
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +24,Mandatory field - Academic Year,Obligatorisk felt - skoleår
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +221,{0} {1} is not associated with {2} {3},{0} {1} er ikke forbundet med {2} {3}
DocType: Notification Control,Customize the introductory text that goes as a part of that email. Each transaction has a separate introductory text.,"Tilpas den indledende tekst, der går som en del af denne e-mail. Hver transaktion har en separat indledende tekst."
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.py +56,Row {0} : Operation is required against the raw material item {1},Række {0}: Drift er påkrævet mod råvareelementet {1}
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +180,Please set default payable account for the company {0},Indtast venligst standardbetalt konto for virksomheden {0}
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +608,Transaction not allowed against stopped Work Order {0},Transaktion er ikke tilladt mod stoppet Arbejdsordre {0}
DocType: Setup Progress Action,Min Doc Count,Min Doc Count
apps/erpnext/erpnext/config/manufacturing.py +84,Global settings for all manufacturing processes.,Globale indstillinger for alle produktionsprocesser.
DocType: Accounts Settings,Accounts Frozen Upto,Regnskab Frozen Op
DocType: SMS Log,Sent On,Sendt On
apps/erpnext/erpnext/stock/doctype/item/item.py +778,Attribute {0} selected multiple times in Attributes Table,Attribut {0} valgt flere gange i attributter Tabel
DocType: HR Settings,Employee record is created using selected field. ,Medarbejder rekord er oprettet ved hjælp valgte felt.
DocType: Sales Order,Not Applicable,ikke gældende
DocType: Amazon MWS Settings,UK,UK
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +85,Opening Invoice Item,Åbning af fakturaelement
DocType: Request for Quotation Item,Required Date,Forfaldsdato
DocType: Delivery Note,Billing Address,Faktureringsadresse
DocType: Bank Statement Settings,Statement Headers,Statement Headers
DocType: Travel Request,Costing,Koster
DocType: Tax Rule,Billing County,Anvendes ikke
DocType: Purchase Taxes and Charges,"If checked, the tax amount will be considered as already included in the Print Rate / Print Amount","Hvis markeret, vil momsbeløbet blive betragtet som allerede inkluderet i Print Sats / Print Beløb"
DocType: Request for Quotation,Message for Supplier,Besked til leverandøren
DocType: Job Card,Work Order,Arbejdsordre
DocType: Sales Invoice,Total Qty,Antal i alt
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +62,Guardian2 Email ID,Guardian2 Email ID
DocType: Item,Show in Website (Variant),Vis på hjemmesiden (Variant)
DocType: Employee,Health Concerns,Sundhedsmæssige betænkeligheder
DocType: Payroll Entry,Select Payroll Period,Vælg Lønperiode
DocType: Purchase Invoice,Unpaid,Åben
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +49,Reserved for sale,Reserveret til salg
DocType: Packing Slip,From Package No.,Fra pakkenr.
DocType: Item Attribute,To Range,At Rækkevidde
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +30,Securities and Deposits,Værdipapirer og Indlån
apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +48,"Can't change valuation method, as there are transactions against some items which does not have it's own valuation method","Kan ikke ændre værdiansættelsesmetode, da der er transaktioner mod nogle poster, der ikke har egen værdiansættelsesmetode"
DocType: Student Report Generation Tool,Attended by Parents,Deltaget af forældre
apps/erpnext/erpnext/hr/doctype/shift_assignment/shift_assignment.py +39,Employee {0} has already applied for {1} on {2} : ,Medarbejder {0} har allerede ansøgt om {1} på {2}:
DocType: Inpatient Record,AB Positive,AB Positive
DocType: Job Opening,Description of a Job Opening,Beskrivelse af en ledig stilling
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +118,Pending activities for today,Afventende aktiviteter for i dag
DocType: Salary Structure,Salary Component for timesheet based payroll.,Lønart til tidsregistering
DocType: Driver,Applicable for external driver,Gælder for ekstern driver
DocType: Sales Order Item,Used for Production Plan,Bruges til Produktionsplan
DocType: Loan,Total Payment,Samlet betaling
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +117,Cannot cancel transaction for Completed Work Order.,Kan ikke annullere transaktionen for Afsluttet Arbejdsordre.
DocType: Manufacturing Settings,Time Between Operations (in mins),Time Between Operations (i minutter)
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +837,PO already created for all sales order items,PO allerede oprettet for alle salgsordre elementer
DocType: Healthcare Service Unit,Occupied,Optaget
DocType: Clinical Procedure,Consumables,Forbrugsstoffer
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +130,{0} {1} is cancelled so the action cannot be completed,"{0} {1} er annulleret, så handlingen kan ikke gennemføres"
DocType: Customer,Buyer of Goods and Services.,Køber af varer og tjenesteydelser.
DocType: Journal Entry,Accounts Payable,Kreditor
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +55,The amount of {0} set in this payment request is different from the calculated amount of all payment plans: {1}. Make sure this is correct before submitting the document.,"Antallet af {0} i denne betalingsanmodning adskiller sig fra det beregnede beløb for alle betalingsplaner: {1}. Sørg for, at dette er korrekt, inden du sender dokumentet."
DocType: Patient,Allergies,allergier
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +43,The selected BOMs are not for the same item,De valgte styklister er ikke for den samme vare
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js +32,Change Item Code,Skift varekode
DocType: Supplier Scorecard Standing,Notify Other,Underret Andet
DocType: Vital Signs,Blood Pressure (systolic),Blodtryk (systolisk)
DocType: Item Price,Valid Upto,Gyldig til
DocType: Training Event,Workshop,Værksted
DocType: Supplier Scorecard Scoring Standing,Warn Purchase Orders,Advarer indkøbsordrer
apps/erpnext/erpnext/utilities/user_progress.py +67,List a few of your customers. They could be organizations or individuals.,Nævn et par af dine kunder. Disse kunne være firmaer eller privatpersoner.
DocType: Employee Tax Exemption Proof Submission,Rented From Date,Lejet fra dato
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py +25,Enough Parts to Build,Nok Dele til Build
DocType: POS Profile User,POS Profile User,POS profil bruger
apps/erpnext/erpnext/assets/doctype/asset/asset.py +194,Row {0}: Depreciation Start Date is required,Række {0}: Afskrivning Startdato er påkrævet
DocType: Purchase Invoice Item,Service Start Date,Service Startdato
DocType: Subscription Invoice,Subscription Invoice,Abonnementsfaktura
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +135,Direct Income,Direkte indkomst
DocType: Patient Appointment,Date TIme,Dato Tid
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +53,"Can not filter based on Account, if grouped by Account","Kan ikke filtrere baseret på konto, hvis grupperet efter konto"
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +93,Administrative Officer,Kontorfuldmægtig
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +40,Setting up company and taxes,Opsætning af selskab og skatter
apps/erpnext/erpnext/education/doctype/student_group/student_group.py +22,Please select Course,Vælg kursus
DocType: Codification Table,Codification Table,Kodifikationstabel
DocType: Timesheet Detail,Hrs,timer
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +410,Please select Company,Vælg firma
DocType: Stock Entry Detail,Difference Account,Differencekonto
DocType: Purchase Invoice,Supplier GSTIN,Leverandør GSTIN
apps/erpnext/erpnext/projects/doctype/task/task.py +50,Cannot close task as its dependant task {0} is not closed.,"Opgaven kan ikke lukkes, da dens afhængige opgave {0} ikke er lukket."
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +435,Please enter Warehouse for which Material Request will be raised,Indtast venligst lager for hvilket materialeanmodning vil blive rejst
DocType: Work Order,Additional Operating Cost,Yderligere driftsomkostninger
DocType: Lab Test Template,Lab Routine,Lab Rutine
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +20,Cosmetics,Kosmetik
apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +18,Please select Completion Date for Completed Asset Maintenance Log,Vælg venligst Afslutningsdato for Udfyldt Asset Maintenance Log
apps/erpnext/erpnext/stock/doctype/item/item.py +583,"To merge, following properties must be same for both items","At fusionere, skal følgende egenskaber være ens for begge poster"
DocType: Supplier,Block Supplier,Bloker leverandør
DocType: Shipping Rule,Net Weight,Nettovægt
DocType: Job Opening,Planned number of Positions,Planlagt antal positioner
DocType: Employee,Emergency Phone,Emergency Phone
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +82,{0} {1} does not exist.,{0} {1} eksisterer ikke.
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +29,Buy,Køb
,Serial No Warranty Expiry,Serienummer garantiudløb
DocType: Sales Invoice,Offline POS Name,Offline-kassesystemnavn
apps/erpnext/erpnext/utilities/user_progress.py +180,Student Application,Student ansøgning
DocType: Bank Statement Transaction Payment Item,Payment Reference,Betalings reference
DocType: Supplier,Hold Type,Hold Type
apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py +20,Please define grade for Threshold 0%,Angiv venligst lønklasse for Tærskel 0%
DocType: Bank Statement Transaction Payment Item,Bank Statement Transaction Payment Item,Kontoudtog Transaktion Betalingselement
DocType: Sales Order,To Deliver,Til at levere
DocType: Purchase Invoice Item,Item,Vare
apps/erpnext/erpnext/healthcare/setup.py +188,High Sensitivity,Høj følsomhed
apps/erpnext/erpnext/config/non_profit.py +48,Volunteer Type information.,Frivilligt Type oplysninger.
DocType: Cash Flow Mapping Template,Cash Flow Mapping Template,Cash Flow Mapping Template
DocType: Travel Request,Costing Details,Costing Detaljer
apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.js +64,Show Return Entries,Vis Returindlæg
apps/erpnext/erpnext/accounts/page/pos/pos.js +2569,Serial no item cannot be a fraction,Serienummervare kan ikke være en brøkdel
DocType: Journal Entry,Difference (Dr - Cr),Difference (Dr - Cr)
DocType: Bank Guarantee,Providing,At sørge for
DocType: Account,Profit and Loss,Resultatopgørelse
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +99,"Not permitted, configure Lab Test Template as required","Ikke tilladt, konfigurere Lab Test Template efter behov"
DocType: Patient,Risk Factors,Risikofaktorer
DocType: Patient,Occupational Hazards and Environmental Factors,Arbejdsfarer og miljøfaktorer
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +321,Stock Entries already created for Work Order ,"Aktieindtægter, der allerede er oprettet til Arbejdsordre"
DocType: Vital Signs,Respiratory rate,Respirationsfrekvens
apps/erpnext/erpnext/config/stock.py +337,Managing Subcontracting,Håndtering af underleverancer
DocType: Vital Signs,Body Temperature,Kropstemperatur
DocType: Project,Project will be accessible on the website to these users,Sagen vil være tilgængelig på hjemmesiden for disse brugere
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +292,Cannot cancel {0} {1} because Serial No {2} does not belong to the warehouse {3},Kan ikke annullere {0} {1} fordi serienummer {2} ikke tilhører lageret {3}
DocType: Detected Disease,Disease,Sygdom
DocType: Company,Default Deferred Expense Account,Standard udskudt udgiftskonto
apps/erpnext/erpnext/config/projects.py +29,Define Project type.,Definer projekttype.
DocType: Supplier Scorecard,Weighting Function,Vægtningsfunktion
DocType: Healthcare Practitioner,OP Consulting Charge,OP Consulting Charge
apps/erpnext/erpnext/utilities/user_progress.py +28,Setup your ,Opsæt din
DocType: Student Report Generation Tool,Show Marks,Vis mærker
DocType: Support Settings,Get Latest Query,Få seneste forespørgsel
DocType: Quotation,Rate at which Price list currency is converted to company's base currency,"Hastighed, hvormed Prisliste valuta omregnes til virksomhedens basisvaluta"
apps/erpnext/erpnext/setup/doctype/company/company.py +74,Account {0} does not belong to company: {1},Konto {0} tilhører ikke virksomheden: {1}
apps/erpnext/erpnext/setup/doctype/company/company.py +56,Abbreviation already used for another company,Forkortelse allerede brugt til et andet selskab
DocType: Selling Settings,Default Customer Group,Standard kundegruppe
DocType: Employee,IFSC Code,IFSC-kode
DocType: Global Defaults,"If disable, 'Rounded Total' field will not be visible in any transaction","Hvis deaktivere, &#39;Afrundet Total&#39; felt, vil ikke være synlig i enhver transaktion"
DocType: BOM,Operating Cost,Driftsomkostninger
DocType: Crop,Produced Items,Producerede varer
DocType: Bank Statement Transaction Entry,Match Transaction to Invoices,Match transaktion til fakturaer
DocType: Sales Order Item,Gross Profit,Gross Profit
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +872,Unblock Invoice,Fjern blokering af faktura
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +49,Increment cannot be 0,Tilvækst kan ikke være 0
DocType: Company,Delete Company Transactions,Slet Company Transaktioner
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +366,Reference No and Reference Date is mandatory for Bank transaction,Referencenummer og reference Dato er obligatorisk for Bank transaktion
DocType: Purchase Receipt,Add / Edit Taxes and Charges,Tilføj / rediger Skatter og Afgifter
DocType: Payment Entry Reference,Supplier Invoice No,Leverandør fakturanr.
DocType: Territory,For reference,For reference
DocType: Healthcare Settings,Appointment Confirmation,Udnævnelse Bekræftelse
DocType: Inpatient Record,HLC-INP-.YYYY.-,HLC np-.YYYY.-
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +162,"Cannot delete Serial No {0}, as it is used in stock transactions","Kan ikke slette serienummer {0}, eftersom det bruges på lagertransaktioner"
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +278,Closing (Cr),Lukning (Cr)
apps/erpnext/erpnext/hr/notification/training_feedback/training_feedback.html +1,Hello,Hej
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +118,Move Item,Flyt vare
DocType: Employee Incentive,Incentive Amount,Incitamentsbeløb
DocType: Serial No,Warranty Period (Days),Garantiperiode (dage)
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +76,Total Credit/ Debit Amount should be same as linked Journal Entry,Samlet kredit- / debiteringsbeløb skal være det samme som tilknyttet tidsskriftindgang
DocType: Installation Note Item,Installation Note Item,Installation Bemærk Vare
DocType: Production Plan Item,Pending Qty,Afventende antal
DocType: Budget,Ignore,Ignorér
apps/erpnext/erpnext/accounts/party.py +429,{0} {1} is not active,{0} {1} er ikke aktiv
DocType: Woocommerce Settings,Freight and Forwarding Account,Fragt og videresendelse konto
apps/erpnext/erpnext/config/accounts.py +240,Setup cheque dimensions for printing,Anvendes ikke
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +33,Create Salary Slips,Opret lønningslister
DocType: Vital Signs,Bloated,Oppustet
DocType: Salary Slip,Salary Slip Timesheet,Lønseddel Timeseddel
apps/erpnext/erpnext/controllers/buying_controller.py +200,Supplier Warehouse mandatory for sub-contracted Purchase Receipt,Leverandør Warehouse obligatorisk for underentreprise købskvittering
DocType: Item Price,Valid From,Gyldig fra
DocType: Sales Invoice,Total Commission,Samlet provision
DocType: Tax Withholding Account,Tax Withholding Account,Skat tilbageholdende konto
DocType: Pricing Rule,Sales Partner,Forhandler
apps/erpnext/erpnext/config/buying.py +150,All Supplier scorecards.,Alle leverandør scorecards.
DocType: Buying Settings,Purchase Receipt Required,Købskvittering påkrævet
DocType: Delivery Note,Rail,Rail
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +267,Target warehouse in row {0} must be same as Work Order,Mållager i række {0} skal være det samme som Arbejdsordre
apps/erpnext/erpnext/stock/doctype/item/item.py +183,Valuation Rate is mandatory if Opening Stock entered,"Værdiansættelsesværdi er obligatorisk, hvis Åbning Stock indtastet"
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +143,No records found in the Invoice table,Ingen poster i faktureringstabellen
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js +36,Please select Company and Party Type first,Vælg Company og Party Type først
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +31,"Already set default in pos profile {0} for user {1}, kindly disabled default","Angiv allerede standard i pos profil {0} for bruger {1}, venligt deaktiveret standard"
apps/erpnext/erpnext/config/accounts.py +261,Financial / accounting year.,Finansiel / regnskabsår.
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.js +9,Accumulated Values,Akkumulerede værdier
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +166,"Sorry, Serial Nos cannot be merged","Beklager, serienumre kan ikke blive slået sammen"
DocType: Shopify Settings,Customer Group will set to selected group while syncing customers from Shopify,"Kundegruppe vil indstille til den valgte gruppe, mens du synkroniserer kunder fra Shopify"
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +72,Territory is Required in POS Profile,Område er påkrævet i POS-profil
DocType: Supplier,Prevent RFQs,Forebygg RFQs
DocType: Hub User,Hub User,Navbruger
apps/erpnext/erpnext/utilities/activation.py +83,Make Sales Order,Opret salgsordre
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +541,Salary Slip submitted for period from {0} to {1},Lønslip indgivet for perioden fra {0} til {1}
DocType: Project Task,Project Task,Sagsopgave
DocType: Loyalty Point Entry Redemption,Redeemed Points,Forladte point
,Lead Id,Emne-Id
DocType: C-Form Invoice Detail,Grand Total,Beløb i alt
DocType: Assessment Plan,Course,Kursus
apps/erpnext/erpnext/accounts/report/tds_computation_summary/tds_computation_summary.py +105,Section Code,Sektionskode
DocType: Timesheet,Payslip,Lønseddel
apps/erpnext/erpnext/hr/doctype/attendance_request/attendance_request.py +18,Half day date should be in between from date and to date,Halvdagsdagen skal være mellem dato og dato
apps/erpnext/erpnext/public/js/pos/pos.html +4,Item Cart,Varekurv
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +38,Fiscal Year Start Date should not be greater than Fiscal Year End Date,Regnskabsår Startdato må ikke være større end Skatteårsafslutning Dato
DocType: Issue,Resolution,Løsning
DocType: Employee,Personal Bio,Personlig Bio
DocType: C-Form,IV,IV
apps/erpnext/erpnext/non_profit/report/expiring_memberships/expiring_memberships.py +15,Membership ID,Medlemskab ID
apps/erpnext/erpnext/templates/pages/order.html +77,Delivered: {0},Leveret: {0}
DocType: QuickBooks Migrator,Connected to QuickBooks,Tilsluttet QuickBooks
DocType: Bank Statement Transaction Entry,Payable Account,Betales konto
DocType: Payment Entry,Type of Payment,Betalingsmåde
apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py +18,Half Day Date is mandatory,Halv dags dato er obligatorisk
DocType: Sales Order,Billing and Delivery Status,Fakturering og leveringsstatus
DocType: Job Applicant,Resume Attachment,Vedhæft CV
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +58,Repeat Customers,Gamle kunder
DocType: Leave Control Panel,Allocate,Tildel fravær
apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +108,Create Variant,Opret variant
DocType: Sales Invoice,Shipping Bill Date,Fragtregningsdato
DocType: Production Plan,Production Plan,Produktionsplan
DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,Åbning af fakturaoprettelsesværktøj
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +909,Sales Return,Salg Return
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +110,Note: Total allocated leaves {0} shouldn't be less than already approved leaves {1} for the period,Bemærk: I alt tildelt blade {0} bør ikke være mindre end allerede godkendte blade {1} for perioden
DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,Indstil antal i transaktioner baseret på serienummerindgang
,Total Stock Summary,Samlet lageroversigt
apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.py +68,"You can only plan for upto {0} vacancies and budget {1} \
				for {2} as per staffing plan {3} for parent company {4}.",Du kan kun planlægge op til {0} ledige stillinger og budget {1} \ for {2} som pr. Personaleplan {3} for moderselskabet {4}.
DocType: Announcement,Posted By,Bogført af
DocType: Item,Delivered by Supplier (Drop Ship),Leveret af Leverandøren (Drop Ship)
DocType: Healthcare Settings,Confirmation Message,Bekræftelsesmeddelelse
apps/erpnext/erpnext/config/crm.py +12,Database of potential customers.,Database over potentielle kunder.
DocType: Authorization Rule,Customer or Item,Kunde eller vare
apps/erpnext/erpnext/config/selling.py +28,Customer database.,Kundedatabase.
DocType: Quotation,Quotation To,Tilbud til
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +215,Middle Income,Midterste indkomst
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +250,Opening (Cr),Åbning (Cr)
apps/erpnext/erpnext/stock/doctype/item/item.py +950,Default Unit of Measure for Item {0} cannot be changed directly because you have already made some transaction(s) with another UOM. You will need to create a new Item to use a different Default UOM.,"Standard måleenhed for Item {0} kan ikke ændres direkte, fordi du allerede har gjort nogle transaktion (er) med en anden UOM. Du bliver nødt til at oprette en ny konto for at bruge en anden Standard UOM."
apps/erpnext/erpnext/accounts/utils.py +378,Allocated amount can not be negative,Tildelte beløb kan ikke være negativ
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +11,Please set the Company,Angiv venligst selskabet
DocType: Share Balance,Share Balance,Aktiebalance
DocType: Amazon MWS Settings,AWS Access Key ID,AWS Access Key ID
DocType: Employee Tax Exemption Declaration,Monthly House Rent,Månedlig husleje
DocType: Purchase Order Item,Billed Amt,Billed Amt
DocType: Training Result Employee,Training Result Employee,Træning Resultat Medarbejder
DocType: Warehouse,A logical Warehouse against which stock entries are made.,Et logisk lager hvor lagerændringer foretages.
apps/erpnext/erpnext/hr/doctype/loan/loan.js +134,Principal Amount,hovedstol
DocType: Loan Application,Total Payable Interest,Samlet Betales Renter
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +58,Total Outstanding: {0},Samlet Udestående: {0}
DocType: Sales Invoice Timesheet,Sales Invoice Timesheet,Salgsfaktura tidsregistrering
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +150,Reference No & Reference Date is required for {0},Referencenummer &amp; Reference Dato er nødvendig for {0}
DocType: Payroll Entry,Select Payment Account to make Bank Entry,Vælg Betalingskonto til bankbetalingerne
DocType: Hotel Settings,Default Invoice Naming Series,Standard faktura navngivningsserie
apps/erpnext/erpnext/utilities/activation.py +136,"Create Employee records to manage leaves, expense claims and payroll","Opret Medarbejder optegnelser til at styre blade, udgiftsopgørelser og løn"
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +712,An error occurred during the update process,Der opstod en fejl under opdateringsprocessen
DocType: Restaurant Reservation,Restaurant Reservation,Restaurant Reservation
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +143,Proposal Writing,Forslag Skrivning
DocType: Payment Entry Deduction,Payment Entry Deduction,Betaling indtastning Fradrag
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +15,Wrapping up,Afslutter
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +45,Notify Customers via Email,Underret kunder via e-mail
DocType: Item,Batch Number Series,Batch Nummer Serie
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +54,Another Sales Person {0} exists with the same Employee id,En anden salgsmedarbejder {0} eksisterer med samme Medarbejder-id
DocType: Employee Advance,Claimed Amount,Påstået beløb
DocType: QuickBooks Migrator,Authorization Settings,Autorisationsindstillinger
DocType: Travel Itinerary,Departure Datetime,Afrejse Datetime
DocType: Customer,CUST-.YYYY.-,CUST-.YYYY.-
DocType: Travel Request Costing,Travel Request Costing,Rejseforespørgsel Costing
apps/erpnext/erpnext/config/education.py +180,Masters,Masters
DocType: Employee Onboarding,Employee Onboarding Template,Medarbejder Onboarding Skabelon
DocType: Assessment Plan,Maximum Assessment Score,Maksimal Score Assessment
apps/erpnext/erpnext/config/accounts.py +134,Update Bank Transaction Dates,Opdatering Bank transaktionstidspunkterne
apps/erpnext/erpnext/config/projects.py +41,Time Tracking,Tidsregistrering
DocType: Purchase Invoice,DUPLICATE FOR TRANSPORTER,DUPLICERER FOR TRANSPORTØR
apps/erpnext/erpnext/hr/doctype/employee_advance/employee_advance.py +57,Row {0}# Paid Amount cannot be greater than requested advance amount,Række {0} # Betalt beløb kan ikke være større end det ønskede forskudsbeløb
DocType: Fiscal Year Company,Fiscal Year Company,Fiscal År Company
DocType: Packing Slip Item,DN Detail,DN Detail
DocType: Training Event,Conference,Konference
DocType: Employee Grade,Default Salary Structure,Standard lønstruktur
apps/erpnext/erpnext/hr/report/daily_work_summary_replies/daily_work_summary_replies.py +23,Replies,Svar
DocType: Timesheet,Billed,Billed
DocType: Batch,Batch Description,Partibeskrivelse
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js +12,Creating student groups,Oprettelse af elevgrupper
apps/erpnext/erpnext/accounts/utils.py +763,"Payment Gateway Account not created, please create one manually.","Betaling Gateway konto ikke oprettet, skal du oprette en manuelt."
DocType: Supplier Scorecard,Per Year,Per år
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +51,Not eligible for the admission in this program as per DOB,Ikke berettiget til optagelse i dette program i henhold til DOB
DocType: Sales Invoice,Sales Taxes and Charges,Salg Moms og afgifter
DocType: Supplier Scorecard Period,PU-SSP-.YYYY.-,PU-SSP-.YYYY.-
DocType: Vital Signs,Height (In Meter),Højde (i meter)
DocType: Student,Sibling Details,søskende Detaljer
DocType: Vehicle Service,Vehicle Service,Køretøj service
apps/erpnext/erpnext/config/setup.py +95,Automatically triggers the feedback request based on conditions.,udløser automatisk feedback anmodning baseret på betingelser.
DocType: Employee,Reason for Resignation,Årsag til Udmeldelse
DocType: Sales Invoice,Credit Note Issued,Kreditnota udstedt
DocType: Project Task,Weight,Vægt
DocType: Payment Reconciliation,Invoice/Journal Entry Details,Faktura / Kassekladdelinjer
apps/erpnext/erpnext/accounts/utils.py +84,{0} '{1}' not in Fiscal Year {2},{0} &#39;{1}&#39; ikke i regnskabsåret {2}
DocType: Buying Settings,Settings for Buying Module,Indstillinger til køb modul
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +22,Asset {0} does not belong to company {1},Asset {0} hører ikke til selskab {1}
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +70,Please enter Purchase Receipt first,Indtast venligst købskvittering først
DocType: Buying Settings,Supplier Naming By,Leverandørnavngivning af
DocType: Activity Type,Default Costing Rate,Standard Costing Rate
DocType: Maintenance Schedule,Maintenance Schedule,Vedligeholdelsesplan
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +163,"Then Pricing Rules are filtered out based on Customer, Customer Group, Territory, Supplier, Supplier Type, Campaign, Sales Partner etc.","Så vil prisreglerne blive filtreret på kunde, kundegruppe, område, leverandør, leverandørtype, kampagne, salgspartner etc."
DocType: Employee Promotion,Employee Promotion Details,Medarbejderfremmende detaljer
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +83,Net Change in Inventory,Netto Ændring i Inventory
DocType: Employee,Passport Number,Pasnummer
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +60,Relation with Guardian2,Forholdet til Guardian2
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +87,Manager,Leder
DocType: Payment Entry,Payment From / To,Betaling fra/til
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js +8,From Fiscal Year,Fra Skatteår
apps/erpnext/erpnext/selling/doctype/customer/customer.py +185,New credit limit is less than current outstanding amount for the customer. Credit limit has to be atleast {0},Ny kreditmaksimum er mindre end nuværende udestående beløb for kunden. Credit grænse skal være mindst {0}
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +453,Please set account in Warehouse {0},Venligst indstil konto i lager {0}
apps/erpnext/erpnext/controllers/trends.py +39,'Based On' and 'Group By' can not be same,'Baseret på' og 'Sortér efter ' ikke kan være samme
DocType: Sales Person,Sales Person Targets,Salgs person Mål
DocType: Work Order Operation,In minutes,I minutter
DocType: Issue,Resolution Date,Løsningsdato
DocType: Lab Test Template,Compound,Forbindelse
DocType: Opportunity,Probability (%),Sandsynlighed (%)
apps/erpnext/erpnext/patches/v11_0/add_default_dispatch_notification_template.py +11,Dispatch Notification,Dispatch Notification
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js +56,Select Property,Vælg Ejendom
DocType: Student Batch Name,Batch Name,Partinavn
DocType: Fee Validity,Max number of visit,Maks antal besøg
,Hotel Room Occupancy,Hotelværelse Occupancy
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +339,Timesheet created:,Timeseddel oprettet:
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +1213,Please set default Cash or Bank account in Mode of Payment {0},Indstil standard Kontant eller bank konto i mode for betaling {0}
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +24,Enroll,Indskrive
DocType: GST Settings,GST Settings,GST-indstillinger
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +81,Currency should be same as Price List Currency: {0},Valuta bør være den samme som Prisliste Valuta: {0}
DocType: Selling Settings,Customer Naming By,Kundenavngivning af
DocType: Student Leave Application,Will show the student as Present in Student Monthly Attendance Report,Vil vise den studerende som Present i Student Månedlig Deltagelse Rapport
DocType: Depreciation Schedule,Depreciation Amount,Afskrivningsbeløb
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +105,Convert to Group,Konverter til Group
DocType: Activity Cost,Activity Type,Aktivitetstype
DocType: Request for Quotation,For individual supplier,Til individuel leverandør
DocType: BOM Operation,Base Hour Rate(Company Currency),Basistimesats (firmavaluta)
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +48,Delivered Amount,Leveres Beløb
DocType: Loyalty Point Entry Redemption,Redemption Date,Indløsningsdato
DocType: Quotation Item,Item Balance,Item Balance
DocType: Sales Invoice,Packing List,Pakkeliste
apps/erpnext/erpnext/config/buying.py +28,Purchase Orders given to Suppliers.,Indkøbsordrer givet til leverandører.
DocType: Contract,Contract Template,Kontraktskabel
DocType: Clinical Procedure Item,Transfer Qty,Overførselsantal
DocType: Purchase Invoice Item,Asset Location,Asset Location
DocType: Tax Rule,Shipping Zipcode,Shipping Postnummer
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +43,Publishing,Udgivning
DocType: Accounts Settings,Report Settings,Rapportindstillinger
DocType: Activity Cost,Projects User,Sagsbruger
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41,Consumed,Forbrugt
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +158,{0}: {1} not found in Invoice Details table,{0}: {1} ikke fundet i fakturedetaljer tabel
DocType: Asset,Asset Owner Company,Asset Owner Company
DocType: Company,Round Off Cost Center,Afrundningsomkostningssted
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +257,Maintenance Visit {0} must be cancelled before cancelling this Sales Order,"Vedligeholdelsesbesøg {0} skal annulleres, før den denne salgordre annulleres"
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.js +14,Material Transfer,Materiale Transfer
DocType: Cost Center,Cost Center Number,Omkostningscenter nummer
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_variable/supplier_scorecard_variable.py +24,Could not find path for ,Kunne ikke finde vej til
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +243,Opening (Dr),Åbning (dr)
DocType: Compensatory Leave Request,Work End Date,Arbejdets slutdato
DocType: Loan,Applicant,Ansøger
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +37,Posting timestamp must be after {0},Udstationering tidsstempel skal være efter {0}
apps/erpnext/erpnext/config/accounts.py +293,To make recurring documents,At lave tilbagevendende dokumenter
,GST Itemised Purchase Register,GST Itemized Purchase Register
DocType: Course Scheduling Tool,Reschedule,Omlæg
DocType: Loan,Total Interest Payable,Samlet Renteudgifter
DocType: Landed Cost Taxes and Charges,Landed Cost Taxes and Charges,Landede Cost Skatter og Afgifter
DocType: Work Order Operation,Actual Start Time,Faktisk starttid
DocType: Purchase Invoice Item,Deferred Expense Account,Udskudt udgiftskonto
DocType: BOM Operation,Operation Time,Operation Time
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +466,Finish,Slutte
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +441,Base,Grundlag
DocType: Timesheet,Total Billed Hours,Total Billed Timer
DocType: Travel Itinerary,Travel To,Rejse til
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1659,Write Off Amount,Skriv Off Beløb
DocType: Leave Block List Allow,Allow User,Tillad Bruger
DocType: Journal Entry,Bill No,Bill Ingen
DocType: Company,Gain/Loss Account on Asset Disposal,Gevinst/tabskonto vedr. salg af anlægsaktiv
DocType: Vehicle Log,Service Details,Service Detaljer
DocType: Lab Test Template,Grouped,grupperet
DocType: Selling Settings,Delivery Note Required,Følgeseddel er påkrævet
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +537,Submitting Salary Slips...,Indsendelse af lønlister ...
DocType: Bank Guarantee,Bank Guarantee Number,Bankgaranti nummer
DocType: Assessment Criteria,Assessment Criteria,vurderingskriterier
DocType: BOM Item,Basic Rate (Company Currency),Basissats (firmavaluta)
apps/erpnext/erpnext/support/doctype/issue/issue.js +38,Split Issue,Split Issue
DocType: Student Attendance,Student Attendance,Student Fremmøde
DocType: Sales Invoice Timesheet,Time Sheet,Tidsregistrering
DocType: Manufacturing Settings,Backflush Raw Materials Based On,Backflush råstoffer baseret på
DocType: Sales Invoice,Port Code,Port kode
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1031,Reserve Warehouse,Reserve Warehouse
DocType: Lead,Lead is an Organization,Bly er en organisation
apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +10,Pre Sales,Pre-Sale
DocType: Instructor Log,Other Details,Andre detaljer
apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +18,Suplier,suplier
DocType: Lab Test,Test Template,Test skabelon
DocType: Restaurant Order Entry Item,Served,serveret
apps/erpnext/erpnext/config/non_profit.py +13,Chapter information.,Kapitelinformation.
DocType: Account,Accounts,Regnskab
DocType: Vehicle,Odometer Value (Last),Kilometerstand (sidste aflæsning)
apps/erpnext/erpnext/config/buying.py +160,Templates of supplier scorecard criteria.,Skabeloner af leverandør scorecard kriterier.
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +382,Marketing,Marketing
DocType: Sales Invoice,Redeem Loyalty Points,Indløs loyalitetspoint
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +348,Payment Entry is already created,Betalingspost er allerede dannet
DocType: Request for Quotation,Get Suppliers,Få leverandører
DocType: Purchase Receipt Item Supplied,Current Stock,Aktuel lagerbeholdning
apps/erpnext/erpnext/controllers/accounts_controller.py +681,Row #{0}: Asset {1} does not linked to Item {2},Row # {0}: Asset {1} ikke er knyttet til Vare {2}
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +408,Preview Salary Slip,Lønseddel kladde
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +64,Account {0} has been entered multiple times,Konto {0} er indtastet flere gange
DocType: Account,Expenses Included In Valuation,Udgifter inkluderet i Værdiansættelse
apps/erpnext/erpnext/non_profit/doctype/membership/membership.py +38,You can only renew if your membership expires within 30 days,"Du kan kun forny, hvis dit medlemskab udløber inden for 30 dage"
DocType: Shopping Cart Settings,Show Stock Availability,Vis lager tilgængelighed
apps/erpnext/erpnext/assets/doctype/asset/asset.py +519,Set {0} in asset category {1} or company {2},Indstil {0} i aktivkategori {1} eller firma {2}
DocType: Location,Longitude,Længde
,Absent Student Report,Ikke-tilstede studerende rapport
DocType: Crop,Crop Spacing UOM,Beskær afstanden UOM
DocType: Loyalty Program,Single Tier Program,Single Tier Program
DocType: Accounts Settings,Only select if you have setup Cash Flow Mapper documents,"Vælg kun, hvis du har opsætningen Cash Flow Mapper-dokumenter"
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +189,From Address 1,Fra adresse 1
DocType: Email Digest,Next email will be sent on:,Næste email vil blive sendt på:
DocType: Supplier Scorecard,Per Week,Per uge
apps/erpnext/erpnext/stock/doctype/item/item.py +725,Item has variants.,Vare har varianter.
apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +154,Total Student,Samlet studerende
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +65,Item {0} not found,Vare {0} ikke fundet
DocType: Bin,Stock Value,Stock Value
apps/erpnext/erpnext/accounts/doctype/account/account.py +202,Company {0} does not exist,Firma {0} findes ikke
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +43,{0} has fee validity till {1},{0} har gebyrgyldighed indtil {1}
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +54,Tree Type,Tree Type
DocType: BOM Explosion Item,Qty Consumed Per Unit,Antal Consumed Per Unit
DocType: GST Account,IGST Account,IGST-konto
DocType: Serial No,Warranty Expiry Date,Garanti udløbsdato
DocType: Material Request Item,Quantity and Warehouse,Mængde og lager
DocType: Sales Invoice,Commission Rate (%),Provisionssats (%)
apps/erpnext/erpnext/education/doctype/student_group/student_group.py +24,Please select Program,Vælg venligst Program
DocType: Project,Estimated Cost,Anslåede omkostninger
DocType: Request for Quotation,Link to material requests,Link til materialeanmodninger
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +7,Aerospace,Aerospace
,Fichier des Ecritures Comptables [FEC],Fichier des Ecritures Comptables [FEC]
DocType: Journal Entry,Credit Card Entry,Credit Card indtastning
apps/erpnext/erpnext/config/accounts.py +35,Company and Accounts,Firma og regnskab
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +85,In Value,I Value
DocType: Asset Settings,Depreciation Options,Afskrivningsmuligheder
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +28,Either location or employee must be required,Enten placering eller medarbejder skal være påkrævet
apps/erpnext/erpnext/utilities/transaction_base.py +29,Invalid Posting Time,Ugyldig postetid
DocType: Salary Component,Condition and Formula,Tilstand og formel
DocType: Lead,Campaign Name,Kampagne Navn
apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py +61,There is no leave period in between {0} and {1},Der er ingen ledig periode mellem {0} og {1}
DocType: Fee Validity,Healthcare Practitioner,Sundhedspleje
DocType: Hotel Room,Capacity,Kapacitet
DocType: Travel Request Costing,Expense Type,Udgiftstype
DocType: Selling Settings,Close Opportunity After Days,Luk salgsmulighed efter dage
,Reserved,Reserveret
DocType: Driver,License Details,Licens Detaljer
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +86,The field From Shareholder cannot be blank,Feltet fra aktionær kan ikke være tomt
DocType: Leave Allocation,Allocation,Tildeling
DocType: Purchase Order,Supply Raw Materials,Supply råmaterialer
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +10,Current Assets,Omsætningsaktiver
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +161,{0} is not a stock Item,{0} er ikke en lagervare
apps/erpnext/erpnext/hr/notification/training_feedback/training_feedback.html +6,Please share your feedback to the training by clicking on 'Training Feedback' and then 'New',Del venligst din feedback til træningen ved at klikke på &#39;Træningsfejl&#39; og derefter &#39;Ny&#39;
DocType: Mode of Payment Account,Default Account,Standard-konto
apps/erpnext/erpnext/stock/doctype/item/item.py +302,Please select Sample Retention Warehouse in Stock Settings first,Vælg venligst Sample Retention Warehouse i lagerindstillinger først
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js +62,Please select the Multiple Tier Program type for more than one collection rules.,Vælg venligst flere tierprogramtype for mere end én samlingsregler.
DocType: Payment Entry,Received Amount (Company Currency),Modtaget beløb (firmavaluta)
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +192,Lead must be set if Opportunity is made from Lead,"""Er emne"" skal markeres, hvis salgsmulighed er lavet fra emne"
apps/erpnext/erpnext/erpnext_integrations/doctype/gocardless_settings/gocardless_settings.py +136,Payment Cancelled. Please check your GoCardless Account for more details,Betaling annulleret. Tjek venligst din GoCardless-konto for flere detaljer
DocType: Contract,N/A,N / A
DocType: Delivery Settings,Send with Attachment,Send med vedhæftet fil
apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +30,Please select weekly off day,Vælg ugentlig fridag
DocType: Inpatient Record,O Negative,O Negativ
DocType: Work Order Operation,Planned End Time,Planlagt sluttid
,Sales Person Target Variance Item Group-Wise,Salg Person Target Variance Item Group-Wise
apps/erpnext/erpnext/accounts/doctype/account/account.py +100,Account with existing transaction cannot be converted to ledger,Konto med eksisterende transaktion kan ikke konverteres til finans
apps/erpnext/erpnext/config/non_profit.py +33,Memebership Type Details,Memebership Type Detaljer
DocType: Delivery Note,Customer's Purchase Order No,Kundens indkøbsordrenr.
DocType: Clinical Procedure,Consume Stock,Forbruge lager
DocType: Budget,Budget Against,Budget Against
apps/erpnext/erpnext/stock/reorder_item.py +194,Auto Material Requests Generated,Automatisk materialeanmodning dannet
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js +7,Lost,Tabt
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +184,You can not enter current voucher in 'Against Journal Entry' column,"Du kan ikke indtaste det aktuelle bilag i ""Mod Kassekladde 'kolonne"
DocType: Employee Benefit Application Detail,Max Benefit Amount,Max Benefit Amount
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +50,Reserved for manufacturing,Reserveret til fremstilling
DocType: Soil Texture,Sand,Sand
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +25,Energy,Energi
DocType: Opportunity,Opportunity From,Salgsmulighed fra
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +997,Row {0}: {1} Serial numbers required for Item {2}. You have provided {3}.,Række {0}: {1} Serienumre er nødvendige for punkt {2}. Du har angivet {3}.
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +79,Please select a table,Vælg venligst en tabel
DocType: BOM,Website Specifications,Website Specifikationer
DocType: Special Test Items,Particulars,Oplysninger
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +23,{0}: From {0} of type {1},{0}: Fra {0} af typen {1}
apps/erpnext/erpnext/controllers/buying_controller.py +399,Row {0}: Conversion Factor is mandatory,Række {0}: konverteringsfaktor er obligatorisk
DocType: Student,A+,A +
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +353,"Multiple Price Rules exists with same criteria, please resolve conflict by assigning priority. Price Rules: {0}","Flere Pris Regler eksisterer med samme kriterier, skal du løse konflikter ved at tildele prioritet. Pris Regler: {0}"
DocType: Exchange Rate Revaluation,Exchange Rate Revaluation Account,Valutakursomskrivningskonto
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +539,Cannot deactivate or cancel BOM as it is linked with other BOMs,"Kan ikke deaktivere eller annullere en stykliste, som det er forbundet med andre styklister"
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.js +106,Please select Company and Posting Date to getting entries,Vælg venligst Company og Posting Date for at få poster
DocType: Asset,Maintenance,Vedligeholdelse
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +28,Get from Patient Encounter,Få fra Patient Encounter
DocType: Subscriber,Subscriber,abonnent
DocType: Item Attribute Value,Item Attribute Value,Item Attribut Værdi
apps/erpnext/erpnext/projects/doctype/project/project.py +455,Please Update your Project Status,Opdater venligst din projektstatus
apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py +26,Currency Exchange must be applicable for Buying or for Selling.,Valutaveksling skal være gældende for køb eller salg.
DocType: Item,Maximum sample quantity that can be retained,"Maksimal prøvemængde, der kan opbevares"
DocType: Project Update,How is the Project Progressing Right Now?,Hvordan foregår Projektet lige nu?
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +505,Row {0}# Item {1} cannot be transferred more than {2} against Purchase Order {3},Række {0} # Item {1} kan ikke overføres mere end {2} imod indkøbsordre {3}
apps/erpnext/erpnext/config/selling.py +158,Sales campaigns.,Salgskampagner.
DocType: Project Task,Make Timesheet,Opret tidsregistreringskladde
DocType: Sales Taxes and Charges Template,"Standard tax template that can be applied to all Sales Transactions. This template can contain list of tax heads and also other expense / income heads like ""Shipping"", ""Insurance"", ""Handling"" etc.

#### Note

The tax rate you define here will be the standard tax rate for all **Items**. If there are **Items** that have different rates, they must be added in the **Item Tax** table in the **Item** master.

#### Description of Columns

1. Calculation Type: 
    - This can be on **Net Total** (that is the sum of basic amount).
    - **On Previous Row Total / Amount** (for cumulative taxes or charges). If you select this option, the tax will be applied as a percentage of the previous row (in the tax table) amount or total.
    - **Actual** (as mentioned).
2. Account Head: The Account ledger under which this tax will be booked
3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.
4. Description: Description of the tax (that will be printed in invoices / quotes).
5. Rate: Tax rate.
6. Amount: Tax amount.
7. Total: Cumulative total to this point.
8. Enter Row: If based on ""Previous Row Total"" you can select the row number which will be taken as a base for this calculation (default is the previous row).
9. Is this Tax included in Basic Rate?: If you check this, it means that this tax will not be shown below the item table, but will be included in the Basic Rate in your main item table. This is useful where you want give a flat price (inclusive of all taxes) price to customers.","Standard skat skabelon, der kan anvendes på alle salgstransaktioner. Denne skabelon kan indeholde liste over skatte- hoveder og også andre udgifter / indtægter hoveder som &quot;Shipping&quot;, &quot;forsikring&quot;, &quot;Håndtering&quot; osv #### Bemærk Skatteprocenten du definerer her, vil være standard skattesats for alle ** Varer **. Hvis der er ** Varer **, der har forskellige satser, skal de tilsættes i ** Item Skat ** bord i ** Item ** mester. #### Beskrivelse af kolonner 1. Beregning Type: - Dette kan være på ** Net Total ** (dvs. summen af grundbeløb). - ** På Forrige Row Total / Beløb ** (for kumulative skatter eller afgifter). Hvis du vælger denne mulighed, vil skatten blive anvendt som en procentdel af den forrige række (på skatteområdet tabel) beløb eller total. - ** Faktisk ** (som nævnt). 2. Konto Hoved: Account Finans hvorunder denne afgift vil være reserveret 3. Cost Center: Hvis skatten / afgiften er en indtægt (som shipping) eller omkostninger det skal reserveres mod en Cost Center. 4. Beskrivelse: Beskrivelse af skat (som vil blive trykt i fakturaer / citater). 5. Pris: Skatteprocent. 6. Beløb: Skat beløb. 7. Samlet: Kumulativ total til dette punkt. 8. Indtast Række: Hvis baseret på &quot;Forrige Row alt&quot; kan du vælge den række nummer, som vil blive taget som en base for denne beregning (standard er den forrige række). 9. Er det Tax inkluderet i Basic Rate ?: Hvis du markerer dette, betyder det, at denne skat ikke vil blive vist under elementet bordet, men vil indgå i Basic Rate i din vigtigste punkt bordet. Dette er nyttigt, når du ønsker at give en flad pris (inklusive alle afgifter) pris til kunderne."
DocType: Employee,Bank A/C No.,Bank A / C No.
DocType: Quality Inspection Reading,Reading 7,Reading 7
apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js +9,Partially Ordered,Delvist bestilt
DocType: Lab Test,Lab Test,Lab Test
DocType: Student Report Generation Tool,Student Report Generation Tool,Student Report Generation Tool
DocType: Healthcare Schedule Time Slot,Healthcare Schedule Time Slot,Healthcare Schedule Time Slot
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +163,Doc Name,Doc Navn
DocType: Expense Claim Detail,Expense Claim Type,Udlægstype
DocType: Shopping Cart Settings,Default settings for Shopping Cart,Standardindstillinger for Indkøbskurv
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js +27,Add Timeslots,Tilføj Timeslots
apps/erpnext/erpnext/stock/__init__.py +57,Please set Account in Warehouse {0} or Default Inventory Account in Company {1},Indstil konto i lager {0} eller standard lagerkonto i firma {1}
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +143,Asset scrapped via Journal Entry {0},Anlægsasset er kasseret via finanspost {0}
DocType: Loan,Interest Income Account,Renter Indkomst konto
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +61,Max benefits should be greater than zero to dispense benefits,Maksimale fordele skal være større end nul for at uddele fordele
apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.py +58,Review Invitation Sent,Gennemgå invitation sendt
DocType: Shift Assignment,Shift Assignment,Skift opgave
DocType: Employee Transfer Property,Employee Transfer Property,Medarbejderoverdragelsesejendom
apps/erpnext/erpnext/accounts/doctype/cashier_closing/cashier_closing.py +36,From Time Should Be Less Than To Time,Fra tiden skal være mindre end til tiden
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +13,Biotechnology,Bioteknologi
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1121,"Item {0} (Serial No: {1}) cannot be consumed as is reserverd\
						 to fullfill Sales Order {2}.","Konto {0} (Serienummer: {1}) kan ikke indtages, som er forbeholdt \ at fuldfylde salgsordre {2}."
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +116,Office Maintenance Expenses,Kontorholdudgifter
apps/erpnext/erpnext/utilities/user_progress.py +54,Go to ,Gå til
DocType: Shopify Settings,Update Price from Shopify To ERPNext Price List,Opdater pris fra Shopify til ERPNæste prisliste
apps/erpnext/erpnext/config/learn.py +47,Setting up Email Account,Opsætning Email-konto
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js +21,Please enter Item first,Indtast vare først
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +221,Needs Analysis,Behovsanalyse
DocType: Asset Repair,Downtime,nedetid
DocType: Account,Liability,Passiver
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +228,Sanctioned Amount cannot be greater than Claim Amount in Row {0}.,Bevilliget beløb kan ikke være større end udlægsbeløbet i række {0}.
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +14,Academic Term: ,Akademisk Term:
DocType: Salary Component,Do not include in total,Inkluder ikke i alt
DocType: Company,Default Cost of Goods Sold Account,Standard vareforbrug konto
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1287,Sample quantity {0} cannot be more than received quantity {1},Prøvekvantitet {0} kan ikke være mere end modtaget mængde {1}
apps/erpnext/erpnext/stock/get_item_details.py +523,Price List not selected,Prisliste ikke valgt
DocType: Employee,Family Background,Familiebaggrund
DocType: Request for Quotation Supplier,Send Email,Send e-mail
apps/erpnext/erpnext/stock/doctype/item/item.py +257,Warning: Invalid Attachment {0},Advarsel: ugyldig vedhæftet fil {0}
DocType: Item,Max Sample Quantity,Max prøve antal
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +810,No Permission,Ingen tilladelse
DocType: Contract Fulfilment Checklist,Contract Fulfilment Checklist,Kontrol Fulfillment Checklist
DocType: Vital Signs,Heart Rate / Pulse,Hjertefrekvens / puls
DocType: Company,Default Bank Account,Standard bankkonto
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +76,"To filter based on Party, select Party Type first","Hvis du vil filtrere baseret på Party, skal du vælge Party Type først"
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +46,'Update Stock' can not be checked because items are not delivered via {0},"'Opdater lager' kan ikke markeres, fordi varerne ikke leveres via {0}"
DocType: Vehicle,Acquisition Date,Erhvervelsesdato
apps/erpnext/erpnext/utilities/user_progress.py +146,Nos,Nummerserie
DocType: Item,Items with higher weightage will be shown higher,Elementer med højere weightage vises højere
apps/erpnext/erpnext/healthcare/doctype/inpatient_record/inpatient_record_dashboard.py +12,Lab Tests and Vital Signs,Lab Tests og Vital Signs
DocType: Bank Reconciliation Detail,Bank Reconciliation Detail,Bank Afstemning Detail
apps/erpnext/erpnext/controllers/accounts_controller.py +685,Row #{0}: Asset {1} must be submitted,Række # {0}: Aktiv {1} skal godkendes
apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +40,No employee found,Ingen medarbejder fundet
DocType: Item,If subcontracted to a vendor,Hvis underentreprise til en sælger
apps/erpnext/erpnext/education/doctype/student_group/student_group.js +113,Student Group is already updated.,Studentgruppen er allerede opdateret.
apps/erpnext/erpnext/config/projects.py +18,Project Update.,Projektopdatering.
DocType: SMS Center,All Customer Contact,Alle kundekontakter
DocType: Location,Tree Details,Tree Detaljer
DocType: Marketplace Settings,Registered,anbefalet
DocType: Training Event,Event Status,begivenhed status
DocType: Volunteer,Availability Timeslot,Tilgængelighed Timeslot
,Support Analytics,Supportanalyser
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +410,"If you have any questions, please get back to us.","Hvis du har spørgsmål, er du velkommen til at kontakte os."
DocType: Cash Flow Mapper,Cash Flow Mapper,Cash Flow Mapper
DocType: Item,Website Warehouse,Hjemmeside-lager
DocType: Payment Reconciliation,Minimum Invoice Amount,Mindste fakturabeløb
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +112,{0} {1}: Cost Center {2} does not belong to Company {3},{0} {1}: omkostningssted {2} tilhører ikke firma {3}
apps/erpnext/erpnext/utilities/user_progress.py +92,Upload your letter head (Keep it web friendly as 900px by 100px),Upload dit brevhoved (Hold det webvenligt som 900px ved 100px)
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +89,{0} {1}: Account {2} cannot be a Group,{0} {1}: Konto {2} kan ikke være en gruppe
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +367,Timesheet {0} is already completed or cancelled,Tidsregistreringskladde {0} er allerede afsluttet eller annulleret
DocType: QuickBooks Migrator,QuickBooks Migrator,QuickBooks Migrator
apps/erpnext/erpnext/templates/pages/projects.html +42,No tasks,Ingen opgaver
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +81,Sales Invoice {0} created as paid,Salgsfaktura {0} oprettet som betalt
DocType: Item Variant Settings,Copy Fields to Variant,Kopier felt til variant
DocType: Asset,Opening Accumulated Depreciation,Åbning Akkumulerede afskrivninger
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.js +50,Score must be less than or equal to 5,Score skal være mindre end eller lig med 5
DocType: Program Enrollment Tool,Program Enrollment Tool,Program Tilmelding Tool
apps/erpnext/erpnext/config/accounts.py +298,C-Form records,C-Form optegnelser
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +74,The shares already exist,Aktierne eksisterer allerede
apps/erpnext/erpnext/config/selling.py +322,Customer and Supplier,Kunde og leverandør
DocType: Email Digest,Email Digest Settings,Indstillinger for e-mail nyhedsbreve
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +412,Thank you for your business!,Tak for din forretning!
apps/erpnext/erpnext/config/support.py +12,Support queries from customers.,Support forespørgsler fra kunder.
DocType: Employee Property History,Employee Property History,Medarbejder Ejendomshistorie
DocType: Setup Progress Action,Action Doctype,Handling Doctype
DocType: HR Settings,Retirement Age,Pensionsalder
DocType: Bin,Moving Average Rate,Glidende gennemsnit Rate
DocType: Production Plan,Select Items,Vælg varer
DocType: Share Transfer,To Shareholder,Til aktionær
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +408,{0} against Bill {1} dated {2},{0} mod regning {1} dateret {2}
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +213,From State,Fra stat
apps/erpnext/erpnext/utilities/user_progress.py +27,Setup Institution,Opsætningsinstitution
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.py +73,Allocating leaves...,Tildele blade ...
DocType: Program Enrollment,Vehicle/Bus Number,Køretøj / busnummer
apps/erpnext/erpnext/education/doctype/course/course.js +17,Course Schedule,Kursusskema
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +570,"You have to Deduct Tax for Unsubmitted Tax Exemption Proof and Unclaimed \
					Employee Benefits in the last Salary Slip of Payroll Period",Du er nødt til at fradrage skat på ikke-meddelte skattefritagelsesbevis og uopkrævede medarbejderfordele i den sidste lønudbetalingstidsperiode
DocType: Request for Quotation Supplier,Quote Status,Citat Status
DocType: GoCardless Settings,Webhooks Secret,Webhooks Secret
DocType: Maintenance Visit,Completion Status,Afslutning status
DocType: Daily Work Summary Group,Select Users,Vælg brugere
DocType: Hotel Room Pricing Item,Hotel Room Pricing Item,Hotel Værelsestype
DocType: Loyalty Program Collection,Tier Name,Tiernavn
DocType: HR Settings,Enter retirement age in years,Indtast pensionsalderen i år
DocType: Crop,Target Warehouse,Target Warehouse
DocType: Payroll Employee Detail,Payroll Employee Detail,Betalingsmedarbejder Detail
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +135,Please select a warehouse,Vælg venligst et lager
DocType: Cheque Print Template,Starting location from left edge,Start fra venstre kant
DocType: Item,Allow over delivery or receipt upto this percent,Tillad levering eller modtagelse op til denne procent
DocType: Upload Attendance,Import Attendance,Importér fremmøde
apps/erpnext/erpnext/public/js/pos/pos.html +124,All Item Groups,Alle varegrupper
DocType: Work Order,Item To Manufacture,Item Til Fremstilling
apps/erpnext/erpnext/buying/utils.py +80,{0} {1} status is {2},{0} {1} status er {2}
DocType: Water Analysis,Collection Temperature ,Indsamlingstemperatur
DocType: Employee,Provide Email Address registered in company,Giv e-mailadresse registreret i selskab
DocType: Shopping Cart Settings,Enable Checkout,Aktiver bestilling
apps/erpnext/erpnext/config/learn.py +202,Purchase Order to Payment,Indkøbsordre til betaling
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +48,Projected Qty,Forventet antal
DocType: Sales Invoice,Payment Due Date,Sidste betalingsdato
DocType: Drug Prescription,Interval UOM,Interval UOM
DocType: Customer,"Reselect, if the chosen address is edited after save","Vælg igen, hvis den valgte adresse redigeres efter gem"
apps/erpnext/erpnext/stock/doctype/item/item.js +607,Item Variant {0} already exists with same attributes,Item Variant {0} findes allerede med samme attributter
DocType: Item,Hub Publishing Details,Hub Publishing Detaljer
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +153,'Opening','Åbner'
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +130,Open To Do,Åbn Opgaver
DocType: Issue,Via Customer Portal,Via kundeportalen
DocType: Notification Control,Delivery Note Message,Følgeseddelmeddelelse
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +322,SGST Amount,SGST Beløb
DocType: Lab Test Template,Result Format,Resultatformat
DocType: Expense Claim,Expenses,Udgifter
DocType: Item Variant Attribute,Item Variant Attribute,Item Variant Attribut
,Purchase Receipt Trends,Købskvittering Tendenser
DocType: Payroll Entry,Bimonthly,Hver anden måned
DocType: Vehicle Service,Brake Pad,Bremseklods
DocType: Fertilizer,Fertilizer Contents,Indhold af gødning
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +392,Research & Development,Forskning &amp; Udvikling
apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py +20,Amount to Bill,Beløb til fakturering
DocType: Company,Registration Details,Registrering Detaljer
DocType: Timesheet,Total Billed Amount,Samlet Faktureret beløb
DocType: Item Reorder,Re-Order Qty,Re-prisen evt
DocType: Leave Block List Date,Leave Block List Date,Fraværsblokeringsdato
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +101,BOM #{0}: Raw material cannot be same as main Item,BOM # {0}: Råmateriale kan ikke være det samme som hovedartikel
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +92,Total Applicable Charges in Purchase Receipt Items table must be same as Total Taxes and Charges,Total gældende takster i købskvitteringsvaretabel skal være det samme som de samlede skatter og afgifter
DocType: Sales Team,Incentives,Incitamenter
DocType: SMS Log,Requested Numbers,Anmodet Numbers
DocType: Volunteer,Evening,Aften
DocType: Customer,Bypass credit limit check at Sales Order,Bypass kreditgrænse tjek på salgsordre
DocType: Vital Signs,Normal,Normal
apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +106,"Enabling 'Use for Shopping Cart', as Shopping Cart is enabled and there should be at least one Tax Rule for Shopping Cart","Aktivering »anvendelse til indkøbskurv"", som indkøbskurv er aktiveret, og der skal være mindst én momsregel til Indkøbskurven"
DocType: Sales Invoice Item,Stock Details,Stock Detaljer
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +29,Project Value,Sagsværdi
apps/erpnext/erpnext/config/selling.py +332,Point-of-Sale,Kassesystem
DocType: Fee Schedule,Fee Creation Status,Fee Creation Status
DocType: Vehicle Log,Odometer Reading,kilometerstand
apps/erpnext/erpnext/accounts/doctype/account/account.py +123,"Account balance already in Credit, you are not allowed to set 'Balance Must Be' as 'Debit'","Konto balance er kredit, Du har ikke lov til at ændre 'Balancetype' til 'debet'"
DocType: Account,Balance must be,Balance skal være
DocType: Notification Control,Expense Claim Rejected Message,Udlæg afvist besked
,Available Qty,Tilgængelig Antal
DocType: Shopify Settings,Default Warehouse to to create Sales Order and Delivery Note,Standardlager til at oprette salgsordre og leveringsnotat
DocType: Purchase Taxes and Charges,On Previous Row Total,På Forrige Row Total
DocType: Purchase Invoice Item,Rejected Qty,afvist Antal
DocType: Setup Progress Action,Action Field,Handlingsfelt
DocType: Healthcare Settings,Manage Customer,Administrer kunde
DocType: Amazon MWS Settings,Always synch your products from Amazon MWS before synching the Orders details,"Synkroniser altid dine produkter fra Amazon MWS, før du synkroniserer bestillingsoplysningerne"
DocType: Delivery Trip,Delivery Stops,Levering stopper
DocType: Salary Slip,Working Days,Arbejdsdage
apps/erpnext/erpnext/accounts/deferred_revenue.py +33,Cannot change Service Stop Date for item in row {0},Kan ikke ændre Service Stop Date for element i række {0}
DocType: Serial No,Incoming Rate,Indgående sats
DocType: Packing Slip,Gross Weight,Bruttovægt
DocType: Leave Type,Encashment Threshold Days,Encashment Threshold Days
,Final Assessment Grades,Afsluttende bedømmelse
apps/erpnext/erpnext/public/js/setup_wizard.js +110,The name of your company for which you are setting up this system.,"Navnet på dit firma, som du oprette i dette system."
DocType: HR Settings,Include holidays in Total no. of Working Days,Medtag helligdage i det totale antal arbejdsdage
apps/erpnext/erpnext/setup/setup_wizard/operations/sample_data.py +107,Setup your Institute in ERPNext,Opsæt dit institut i ERPNext
DocType: Agriculture Analysis Criteria,Plant Analysis,Plant Analyse
DocType: Job Applicant,Hold,Hold
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +101,Alternate Item,Alternativt element
DocType: Project Update,Progress Details,Progress Details
DocType: Shopify Log,Request Data,Forespørgselsdata
DocType: Employee,Date of Joining,Ansættelsesdato
DocType: Naming Series,Update Series,Opdatering Series
DocType: Supplier Quotation,Is Subcontracted,Underentreprise
DocType: Restaurant Table,Minimum Seating,Mindste plads
DocType: Item Attribute,Item Attribute Values,Item Egenskab Værdier
DocType: Examination Result,Examination Result,eksamensresultat
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +928,Purchase Receipt,Købskvittering
,Received Items To Be Billed,Modtagne varer skal faktureres
apps/erpnext/erpnext/config/accounts.py +271,Currency exchange rate master.,Valutakursen mester.
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +210,Reference Doctype must be one of {0},Henvisning Doctype skal være en af {0}
apps/erpnext/erpnext/stock/report/warehouse_wise_item_balance_age_and_value/warehouse_wise_item_balance_age_and_value.js +46,Filter Total Zero Qty,Filter Total Nul Antal
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +322,Unable to find Time Slot in the next {0} days for Operation {1},Kan ikke finde Time Slot i de næste {0} dage til Operation {1}
DocType: Work Order,Plan material for sub-assemblies,Plan materiale til sub-enheder
apps/erpnext/erpnext/config/selling.py +97,Sales Partners and Territory,Forhandlere og områder
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +628,BOM {0} must be active,Stykliste {0} skal være aktiv
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +430,No Items available for transfer,Ingen emner til overførsel
DocType: Employee Boarding Activity,Activity Name,Aktivitetsnavn
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +867,Change Release Date,Skift Udgivelsesdato
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +218,Finished product quantity <b>{0}</b> and For Quantity <b>{1}</b> cannot be different,Færdig produktmængde <b>{0}</b> og For Mængde <b>{1}</b> kan ikke være anderledes
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +256,Closing (Opening + Total),Lukning (Åbning + I alt)
DocType: Delivery Settings,Dispatch Notification Attachment,Dispatch Notification Attachment
DocType: Payroll Entry,Number Of Employees,Antal medarbejdere
DocType: Journal Entry,Depreciation Entry,Afskrivninger indtastning
apps/erpnext/erpnext/selling/report/sales_person_commission_summary/sales_person_commission_summary.py +31,Please select the document type first,Vælg dokumenttypen først
apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py +65,Cancel Material Visits {0} before cancelling this Maintenance Visit,"Annuller Materiale Besøg {0}, før den annullerer denne vedligeholdelse Besøg"
DocType: Pricing Rule,Rate or Discount,Pris eller rabat
DocType: Vital Signs,One Sided,Ensidigt
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +218,Serial No {0} does not belong to Item {1},Serienummer {0} hører ikke til vare {1}
DocType: Purchase Receipt Item Supplied,Required Qty,Nødvendigt antal
DocType: Marketplace Settings,Custom Data,Brugerdefinerede data
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +127,Warehouses with existing transaction can not be converted to ledger.,Lager med eksisterende transaktioner kan ikke konverteres til Finans.
apps/erpnext/erpnext/controllers/buying_controller.py +582,Serial no is mandatory for the item {0},Serienummer er obligatorisk for varen {0}
DocType: Bank Reconciliation,Total Amount,Samlet beløb
apps/erpnext/erpnext/accounts/report/tds_computation_summary/tds_computation_summary.py +24,From Date and To Date lie in different Fiscal Year,Fra dato og til dato ligger i forskellige regnskabsår
apps/erpnext/erpnext/healthcare/utils.py +160,The Patient {0} do not have customer refrence to invoice,Patienten {0} har ikke kunderefrence til at fakturere
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +32,Internet Publishing,Internet Publishing
DocType: Prescription Duration,Number,Nummer
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +25,Creating {0} Invoice,Oprettelse af {0} faktura
DocType: Medical Code,Medical Code Standard,Medical Code Standard
DocType: Soil Texture,Clay Composition (%),Ler sammensætning (%)
DocType: Item Group,Item Group Defaults,Vare gruppe standard
apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js +102,Please save before assigning task.,Gem venligst før du tildeler opgave.
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +89,Balance Value,Balance Value
DocType: Lab Test,Lab Technician,Laboratorie tekniker
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +40,Sales Price List,Salgsprisliste
DocType: Healthcare Settings,"If checked, a customer will be created, mapped to Patient.
Patient Invoices will be created against this Customer. You can also select existing Customer while creating Patient.","Hvis markeret, oprettes en kunde, der er kortlagt til patienten. Patientfakturaer vil blive oprettet mod denne kunde. Du kan også vælge eksisterende kunde, mens du opretter patient."
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.py +63,Customer isn't enrolled in any Loyalty Program,Kunden er ikke indskrevet i noget loyalitetsprogram
DocType: Bank Reconciliation,Account Currency,Konto Valuta
DocType: Lab Test,Sample ID,Prøve ID
apps/erpnext/erpnext/accounts/general_ledger.py +178,Please mention Round Off Account in Company,Henvis Round Off-konto i selskabet
DocType: Purchase Receipt,Range,Periode
DocType: Supplier,Default Payable Accounts,Standard betales Konti
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +52,Employee {0} is not active or does not exist,Medarbejder {0} er ikke aktiv eller findes ikke
DocType: Fee Structure,Components,Lønarter
DocType: Support Search Source,Search Term Param Name,Søg term Param Navn
DocType: Item Barcode,Item Barcode,Item Barcode
DocType: Woocommerce Settings,Endpoints,endpoints
apps/erpnext/erpnext/stock/doctype/item/item.py +720,Item Variants {0} updated,Item Varianter {0} opdateret
DocType: Quality Inspection Reading,Reading 6,Læsning 6
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +994,Cannot {0} {1} {2} without any negative outstanding invoice,Kan ikke {0} {1} {2} uden nogen negativ udestående faktura
DocType: Share Transfer,From Folio No,Fra Folio nr
DocType: Purchase Invoice Advance,Purchase Invoice Advance,Købsfaktura Advance
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +231,Row {0}: Credit entry can not be linked with a {1},Række {0}: Kredit indgang ikke kan knyttes med en {1}
apps/erpnext/erpnext/config/accounts.py +214,Define budget for a financial year.,Definer budget for et regnskabsår.
DocType: Shopify Tax Account,ERPNext Account,ERPNæste konto
apps/erpnext/erpnext/controllers/accounts_controller.py +58,{0} is blocked so this transaction cannot proceed,"{0} er blokeret, så denne transaktion kan ikke fortsætte"
DocType: Budget,Action if Accumulated Monthly Budget Exceeded on MR,Handling hvis akkumuleret månedlig budget oversteg MR
DocType: Employee,Permanent Address Is,Fast adresse
DocType: Work Order Operation,Operation completed for how many finished goods?,Operation afsluttet for hvor mange færdigvarer?
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +130,Healthcare Practitioner {0} not available on {1},Healthcare Practitioner {0} ikke tilgængelig på {1}
DocType: Payment Terms Template,Payment Terms Template,Betalingsbetingelser skabelon
apps/erpnext/erpnext/public/js/setup_wizard.js +51,The Brand,Varemærket
DocType: Employee Tax Exemption Proof Submission,Rented To Date,Lejet til dato
DocType: Manufacturing Settings,Allow Multiple Material Consumption,Tillad flere forbrug af materiale
DocType: Employee,Exit Interview Details,Exit Interview Detaljer
DocType: Item,Is Purchase Item,Er Indkøbsvare
DocType: Bank Statement Transaction Invoice Item,Purchase Invoice,Købsfaktura
DocType: Manufacturing Settings,Allow multiple Material Consumption against a Work Order,Tillad flere materialforbrug mod en arbejdsordre
DocType: GL Entry,Voucher Detail No,Voucher Detail Nej
apps/erpnext/erpnext/accounts/page/pos/pos.js +796,New Sales Invoice,Nye salgsfaktura
DocType: Stock Entry,Total Outgoing Value,Samlet værdi udgående
DocType: Healthcare Practitioner,Appointments,Udnævnelser
apps/erpnext/erpnext/public/js/account_tree_grid.js +223,Opening Date and Closing Date should be within same Fiscal Year,Åbning Dato og Closing Datoen skal ligge inden samme regnskabsår
DocType: Lead,Request for Information,Anmodning om information
,LeaderBoard,LEADERBOARD
DocType: Sales Invoice Item,Rate With Margin (Company Currency),Rate med margen (Company Currency)
apps/erpnext/erpnext/accounts/page/pos/pos.js +809,Sync Offline Invoices,Synkroniser Offline fakturaer
DocType: Payment Request,Paid,Betalt
DocType: Program Fee,Program Fee,Program Fee
DocType: BOM Update Tool,"Replace a particular BOM in all other BOMs where it is used. It will replace the old BOM link, update cost and regenerate ""BOM Explosion Item"" table as per new BOM.
It also updates latest price in all the BOMs.","Udskift en bestemt BOM i alle andre BOM&#39;er, hvor den bruges. Det vil erstatte det gamle BOM-link, opdateringsomkostninger og genoprette &quot;BOM Explosion Item&quot; -tabellen som pr. Nye BOM. Det opdaterer også nyeste pris i alle BOM&#39;erne."
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +483,The following Work Orders were created:,Følgende arbejdsordrer blev oprettet:
DocType: Salary Slip,Total in words,I alt i ord
DocType: Inpatient Record,Discharged,udledt
DocType: Material Request Item,Lead Time Date,Leveringstid Dato
,Employee Advance Summary,Medarbejder Advance Summary
DocType: Asset,Available-for-use Date,Tilgængelig-til-brug-dato
DocType: Guardian,Guardian Name,Guardian Navn
DocType: Cheque Print Template,Has Print Format,Har Print Format
DocType: Support Settings,Get Started Sections,Kom i gang sektioner
DocType: Lead,CRM-LEAD-.YYYY.-,CRM-LEAD-.YYYY.-
DocType: Loan,Sanctioned,sanktioneret
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.js +8,Total Contribution Amount: {0},Samlet bidragsbeløb: {0}
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +179,Row #{0}: Please specify Serial No for Item {1},Række # {0}: Angiv serienummer for vare {1}
DocType: Payroll Entry,Salary Slips Submitted,Lønssedler indsendes
DocType: Crop Cycle,Crop Cycle,Afgrødecyklus
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +678,"For 'Product Bundle' items, Warehouse, Serial No and Batch No will be considered from the 'Packing List' table. If Warehouse and Batch No are same for all packing items for any 'Product Bundle' item, those values can be entered in the main Item table, values will be copied to 'Packing List' table.","For produktpakke-varer, lagre, serienumre og partier vil blive betragtet fra pakkelistetabellen. Hvis lager og parti er ens for alle pakkede varer for enhver produktpakkevare, kan disse værdier indtastes for den vigtigste vare, og værdierne vil blive kopieret til pakkelistetabellen."
DocType: Amazon MWS Settings,BR,BR
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +201,From Place,Fra Sted
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +460,Net Pay cannnot be negative,Net Pay kan ikke være negativ
DocType: Student Admission,Publish on website,Udgiv på hjemmesiden
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +778,Supplier Invoice Date cannot be greater than Posting Date,Leverandørfakturadato kan ikke være større end bogføringsdatoen
DocType: Installation Note,MAT-INS-.YYYY.-,MAT-INS-.YYYY.-
DocType: Subscription,Cancelation Date,Annulleringsdato
DocType: Purchase Invoice Item,Purchase Order Item,Indkøbsordre vare
DocType: Agriculture Task,Agriculture Task,Landbrugsopgave
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +139,Indirect Income,Indirekte Indkomst
DocType: Student Attendance Tool,Student Attendance Tool,Student Deltagelse Tool
DocType: Restaurant Menu,Price List (Auto created),Prisliste (Auto oprettet)
DocType: Cheque Print Template,Date Settings,Datoindstillinger
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +76,Variance,Varians
DocType: Employee Promotion,Employee Promotion Detail,Medarbejderfremmende detaljer
,Company Name,Firmaets navn
DocType: SMS Center,Total Message(s),Besked (er) i alt
DocType: Share Balance,Purchased,købt
DocType: Item Variant Settings,Rename Attribute Value in Item Attribute.,Omdøb attributværdi i vareattribut.
DocType: Purchase Invoice,Additional Discount Percentage,Ekstra rabatprocent
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +24,View a list of all the help videos,Se en liste over alle hjælpevideoerne
DocType: Agriculture Analysis Criteria,Soil Texture,Jordstruktur
DocType: Bank Reconciliation,Select account head of the bank where cheque was deposited.,Anvendes ikke
DocType: Selling Settings,Allow user to edit Price List Rate in transactions,Tillad brugeren at redigere prislistesatsen i transaktioner
DocType: Pricing Rule,Max Qty,Maksimal mængde
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.js +25,Print Report Card,Udskriv rapportkort
apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +30,"Row {0}: Invoice {1} is invalid, it might be cancelled / does not exist. \
						Please enter a valid Invoice","Række {0}: Faktura {1} er ugyldig, kan det blive annulleret / findes ikke. \ Indtast en gyldig faktura"
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +164,Row {0}: Payment against Sales/Purchase Order should always be marked as advance,Række {0}: Betaling mod Salg / Indkøbsordre bør altid blive markeret som forskud
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +16,Chemical,Kemisk
DocType: Salary Component Account,Default Bank / Cash account will be automatically updated in Salary Journal Entry when this mode is selected.,Standard Bank / Kontant konto vil automatisk blive opdateret i Løn Kassekladde når denne tilstand er valgt.
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +96,Total leaves allocated is mandatory for Leave Type {0},Samlet antal tildelte blade er obligatoriske for Forladetype {0}
DocType: BOM,Raw Material Cost(Company Currency),Råmaterialeomkostninger (firmavaluta)
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +86,Row # {0}: Rate cannot be greater than the rate used in {1} {2},"Row # {0}: Prisen kan ikke være større end den sats, der anvendes i {1} {2}"
apps/erpnext/erpnext/utilities/user_progress.py +147,Meter,Måler
DocType: Workstation,Electricity Cost,Elektricitetsomkostninger
apps/erpnext/erpnext/hr/doctype/additional_salary/additional_salary.py +15,Amount should be greater than zero.,Beløbet skal være større end nul.
apps/erpnext/erpnext/agriculture/doctype/water_analysis/water_analysis.py +23,Lab testing datetime cannot be before collection datetime,Lab testning datetime kan ikke være før datetime samling
DocType: Subscription Plan,Cost,Koste
DocType: HR Settings,Don't send Employee Birthday Reminders,Send ikke medarbejderfødselsdags- påmindelser
DocType: Expense Claim,Total Advance Amount,Samlet forskudsbeløb
DocType: Delivery Stop,Estimated Arrival,Forventet ankomst
apps/erpnext/erpnext/templates/pages/help.html +29,See All Articles,Se alle artikler
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +165,Walk In,Walk In
DocType: Item,Inspection Criteria,Kontrolkriterier
apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js +14,Transfered,Overført
DocType: BOM Website Item,BOM Website Item,BOM Website Item
apps/erpnext/erpnext/public/js/setup_wizard.js +52,Upload your letter head and logo. (you can edit them later).,Upload dit brevhoved og logo. (Du kan redigere dem senere).
DocType: Timesheet Detail,Bill,Faktureres
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +160,White,Hvid
DocType: SMS Center,All Lead (Open),Alle emner (åbne)
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +352,Row {0}: Qty not available for {4} in warehouse {1} at posting time of the entry ({2} {3}),Række {0}: Antal ikke tilgængelig for {4} i lageret {1} på udstationering tid af posten ({2} {3})
apps/erpnext/erpnext/accounts/doctype/cash_flow_mapping/cash_flow_mapping.py +18,You can only select a maximum of one option from the list of check boxes.,Du kan kun vælge maksimalt en mulighed fra listen over afkrydsningsfelter.
DocType: Purchase Invoice,Get Advances Paid,Få forskud
DocType: Item,Automatically Create New Batch,Opret automatisk et nyt parti
DocType: Supplier,Represents Company,Representerer firma
DocType: Student Admission,Admission Start Date,Optagelse Startdato
DocType: Journal Entry,Total Amount in Words,Samlet beløb i Words
apps/erpnext/erpnext/hr/doctype/employee/employee_tree.js +29,New Employee,Ny medarbejder
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +7,There was an error. One probable reason could be that you haven't saved the form. Please contact support@erpnext.com if the problem persists.,"Der opstod en fejl. En sandsynlig årsag kan være, at du ikke har gemt formularen. Kontakt venligst support@erpnext.com hvis problemet fortsætter."
apps/erpnext/erpnext/templates/pages/cart.html +5,My Cart,Indkøbskurv
apps/erpnext/erpnext/controllers/selling_controller.py +142,Order Type must be one of {0},Bestil type skal være en af {0}
DocType: Lead,Next Contact Date,Næste kontakt d.
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +36,Opening Qty,Åbning Antal
DocType: Healthcare Settings,Appointment Reminder,Aftalens påmindelse
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +550,Please enter Account for Change Amount,Indtast konto for returbeløb
DocType: Program Enrollment Tool Student,Student Batch Name,Elevgruppenavn
DocType: Holiday List,Holiday List Name,Helligdagskalendernavn
DocType: Repayment Schedule,Balance Loan Amount,Balance Lånebeløb
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js +132,Added to details,Tilføjet til detaljer
apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +14,Schedule Course,Kursusskema
DocType: Budget,Applicable on Material Request,Gælder for materialeanmodning
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +194,Stock Options,Aktieoptioner
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +628,No Items added to cart,Ingen varer tilføjet til indkøbsvogn
DocType: Journal Entry Account,Expense Claim,Udlæg
apps/erpnext/erpnext/assets/doctype/asset/asset.js +352,Do you really want to restore this scrapped asset?,Vil du virkelig gendanne dette kasserede anlægsaktiv?
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +530,Qty for {0},Antal for {0}
DocType: Leave Application,Leave Application,Ansøg om fravær
DocType: Patient,Patient Relation,Patientrelation
DocType: Item,Hub Category to Publish,Hub kategori til udgivelse
DocType: Leave Block List,Leave Block List Dates,Fraværsblokeringsdatoer
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +297,"Sales Order {0} has reservation for item {1}, you can
		only deliver reserved {1} against {0}. Serial No {2} cannot
		be delivered","Salgsordre {0} har forbehold for vare {1}, du kan kun levere reserveret {1} mod {0}. Serienummer {2} kan ikke leveres"
DocType: Sales Invoice,Billing Address GSTIN,Faktureringsadresse GSTIN
DocType: Employee Tax Exemption Proof Submission,Total Eligible HRA Exemption,Samlet støtteberettiget HRA-fritagelse
DocType: Assessment Plan,Evaluate,Vurdere
DocType: Workstation,Net Hour Rate,Netto timeløn
DocType: Landed Cost Purchase Receipt,Landed Cost Purchase Receipt,Landed Cost købskvittering
DocType: Company,Default Terms,Standardvilkår
DocType: Supplier Scorecard Period,Criteria,Kriterier
DocType: Packing Slip Item,Packing Slip Item,Pakkeseddelvare
DocType: Purchase Invoice,Cash/Bank Account,Kontant / Bankkonto
DocType: Travel Itinerary,Train,Tog
DocType: Healthcare Service Unit,Inpatient Occupancy,Inpatient Occupancy
DocType: Sample Collection,HLC-SC-.YYYY.-,HLC-SC-.YYYY.-
apps/erpnext/erpnext/public/js/queries.js +96,Please specify a {0},Angiv en {0}
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +74,Removed items with no change in quantity or value.,Fjernede elementer uden nogen ændringer i mængde eller værdi.
DocType: Delivery Note,Delivery To,Levering Til
apps/erpnext/erpnext/stock/doctype/item/item.js +471,Variant creation has been queued.,Variantoprettelse er blevet køet.
apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py +100,Work Summary for {0},Arbejdsoversigt for {0}
DocType: Department,The first Leave Approver in the list will be set as the default Leave Approver.,Den første tilladelse til tilladelse i listen vil blive indstillet som standardladetilladelse.
apps/erpnext/erpnext/stock/doctype/item/item.py +774,Attribute table is mandatory,Attributtabellen er obligatorisk
DocType: Production Plan,Get Sales Orders,Hent salgsordrer
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +69,{0} can not be negative,{0} kan ikke være negativ
apps/erpnext/erpnext/erpnext_integrations/doctype/quickbooks_migrator/quickbooks_migrator.js +37,Connect to Quickbooks,Opret forbindelse til Quickbooks
DocType: Training Event,Self-Study,Selvstudie
DocType: POS Closing Voucher,Period End Date,Periode Slutdato
apps/erpnext/erpnext/agriculture/doctype/soil_texture/soil_texture.py +27,Soil compositions do not add up to 100,Jordsammensætninger tilføjer ikke op til 100
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +623,Discount,Rabat
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +64,Row {0}: {1} is required to create the Opening {2} Invoices,Række {0}: {1} er påkrævet for at oprette åbningen {2} fakturaer
DocType: Membership,Membership,Medlemskab
DocType: Asset,Total Number of Depreciations,Samlet antal afskrivninger
DocType: Sales Invoice Item,Rate With Margin,Vurder med margen
DocType: Purchase Invoice,Is Return (Debit Note),Er retur (debit note)
DocType: Workstation,Wages,Løn
DocType: Asset Maintenance,Maintenance Manager Name,Maintenance Manager Navn
DocType: Agriculture Task,Urgent,Hurtigst muligt
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +187,Please specify a valid Row ID for row {0} in table {1},Angiv en gyldig Row ID for rækken {0} i tabel {1}
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py +84,Unable to find variable: ,Kan ikke finde variabel:
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +893,Please select a field to edit from numpad,Vælg venligst et felt for at redigere fra numpad
apps/erpnext/erpnext/stock/doctype/item/item.py +293,Cannot be a fixed asset item as Stock Ledger is created.,"Kan ikke være en fast aktivpost, da lagerliste oprettes."
DocType: Subscription Plan,Fixed rate,Fast pris
apps/erpnext/erpnext/healthcare/doctype/inpatient_record/inpatient_record.js +7,Admit,Indrømme
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +23,Go to the Desktop and start using ERPNext,Gå til skrivebordet og begynd at bruge ERPNext
apps/erpnext/erpnext/templates/pages/order.js +31,Pay Remaining,Betal resten
DocType: Item,Manufacturer,Producent
DocType: Landed Cost Item,Purchase Receipt Item,Købskvittering vare
DocType: Leave Allocation,Total Leaves Encashed,Samlede blade indsnævret
DocType: POS Profile,Sales Invoice Payment,Salgsfakturabetaling
DocType: Quality Inspection Template,Quality Inspection Template Name,Kvalitetsinspektionsskabelon
DocType: Project,First Email,Første Email
DocType: Company,Exception Budget Approver Role,Undtagelse Budget Approver Rol
DocType: Purchase Invoice,"Once set, this invoice will be on hold till the set date","Når den er indstillet, vil denne faktura være i venteposition indtil den fastsatte dato"
DocType: Cashier Closing,POS-CLO-,POS-CLO-
DocType: Production Plan Item,Reserved Warehouse in Sales Order / Finished Goods Warehouse,Reserveret Warehouse i kundeordre / færdigvarer Warehouse
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +69,Selling Amount,Salgsbeløb
DocType: Repayment Schedule,Interest Amount,Renter Beløb
DocType: Sales Invoice,Loyalty Amount,Loyalitetsbeløb
DocType: Employee Transfer,Employee Transfer Detail,Medarbejderoverførselsdetaljer
DocType: Serial No,Creation Document No,Oprettet med dok.-nr.
DocType: Location,Location Details,Placering detaljer
DocType: Share Transfer,Issue,Issue
apps/erpnext/erpnext/healthcare/doctype/patient_encounter/patient_encounter_dashboard.py +11,Records,Records
DocType: Asset,Scrapped,Skrottet
DocType: Item,Item Defaults,Standardindstillinger
DocType: Cashier Closing,Returns,Retur
DocType: Job Card,WIP Warehouse,Varer-i-arbejde-lager
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +195,Serial No {0} is under maintenance contract upto {1},Serienummer {0} er under vedligeholdelseskontrakt ind til d. {1}
apps/erpnext/erpnext/config/hr.py +231,Recruitment,Rekruttering
DocType: Lead,Organization Name,Organisationens navn
DocType: Support Settings,Show Latest Forum Posts,Vis seneste forumindlæg
DocType: Additional Salary Component,ASC-,ASC-
DocType: Tax Rule,Shipping State,Forsendelse stat
,Projected Quantity as Source,Forventet mængde som kilde
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +61,Item must be added using 'Get Items from Purchase Receipts' button,"Varer skal tilføjes ved hjælp af knappen: ""Hent varer fra købskvitteringer"""
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +914,Delivery Trip,Leveringsrejse
DocType: Student,A-,A-
DocType: Share Transfer,Transfer Type,Overførselstype
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +124,Sales Expenses,Salgsomkostninger
DocType: Diagnosis,Diagnosis,Diagnose
apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py +18,Standard Buying,Standard Buying
DocType: Attendance Request,Explanation,Forklaring
DocType: GL Entry,Against,Imod
DocType: Item Default,Sales Defaults,Salgsstandarder
DocType: Sales Order Item,Work Order Qty,Arbejdsordre Antal
DocType: Item Default,Default Selling Cost Center,Standard salgsomkostningssted
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +594,Disc,Disc
DocType: Buying Settings,Material Transferred for Subcontract,Materialet overført til underentreprise
DocType: Email Digest,Purchase Orders Items Overdue,Indkøbsordrer Varer Forfaldne
apps/erpnext/erpnext/accounts/page/pos/pos.js +1638,ZIP Code,Postnummer
apps/erpnext/erpnext/controllers/selling_controller.py +265,Sales Order {0} is {1},Salgsordre {0} er {1}
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +260,Select interest income account in loan {0},Vælg renteindtægter konto i lån {0}
DocType: Opportunity,Contact Info,Kontaktinformation
apps/erpnext/erpnext/config/stock.py +322,Making Stock Entries,Making Stock Angivelser
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.py +15,Cannot promote Employee with status Left,Kan ikke fremme medarbejder med status til venstre
DocType: Packing Slip,Net Weight UOM,Nettovægt vægtenhed
DocType: Item Default,Default Supplier,Standard Leverandør
DocType: Loan,Repayment Schedule,tilbagebetaling Schedule
DocType: Shipping Rule Condition,Shipping Rule Condition,Forsendelsesregelbetingelse
apps/erpnext/erpnext/hr/doctype/payroll_period/payroll_period.py +19,End Date can not be less than Start Date,Slutdato kan ikke være mindre end Startdato
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +262,Invoice can't be made for zero billing hour,Fakturaen kan ikke laves for nul faktureringstid
DocType: Company,Date of Commencement,Dato for påbegyndelse
DocType: Sales Person,Select company name first.,Vælg firmanavn først.
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +380,Email sent to {0},E-mail sendt til {0}
apps/erpnext/erpnext/config/buying.py +23,Quotations received from Suppliers.,Tilbud modtaget fra leverandører.
apps/erpnext/erpnext/config/manufacturing.py +74,Replace BOM and update latest price in all BOMs,Erstat BOM og opdater seneste pris i alle BOM&#39;er
apps/erpnext/erpnext/controllers/selling_controller.py +29,To {0} | {1} {2},Til {0} | {1} {2}
apps/erpnext/erpnext/setup/doctype/supplier_group/supplier_group.js +13,This is a root supplier group and cannot be edited.,Dette er en rodleverandørgruppe og kan ikke redigeres.
DocType: Delivery Note,Driver Name,Drivernavn
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41,Average Age,Gennemsnitlig alder
DocType: Education Settings,Attendance Freeze Date,Tilmelding senest d.
DocType: Payment Request,Inward,indad
apps/erpnext/erpnext/utilities/user_progress.py +110,List a few of your suppliers. They could be organizations or individuals.,Nævn et par af dine leverandører. Disse kunne være firmaer eller privatpersoner.
apps/erpnext/erpnext/templates/pages/home.html +32,View All Products,Se alle produkter
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +20,Minimum Lead Age (Days),Mindste levealder (dage)
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +60,All BOMs,Alle styklister
DocType: Company,Parent Company,Moderselskab
apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.py +35,Hotel Rooms of type {0} are unavailable on {1},Hotelværelser af typen {0} er ikke tilgængelige på {1}
DocType: Healthcare Practitioner,Default Currency,Standardvaluta
apps/erpnext/erpnext/controllers/selling_controller.py +150,Maximum discount for Item {0} is {1}%,Maksimal rabat for vare {0} er {1}%
DocType: Asset Movement,From Employee,Fra Medarbejder
DocType: Driver,Cellphone Number,telefon nummer
DocType: Project,Monitor Progress,Monitor Progress
apps/erpnext/erpnext/controllers/accounts_controller.py +545,Warning: System will not check overbilling since amount for Item {0} in {1} is zero,"Advarsel: Systemet vil ikke tjekke for overfakturering, da beløbet for vare {0} i {1} er nul"
DocType: Journal Entry,Make Difference Entry,Make Difference indtastning
DocType: Supplier Quotation,Auto Repeat Section,Automatisk gentag sektion
DocType: Upload Attendance,Attendance From Date,Fremmøde fradato
DocType: Appraisal Template Goal,Key Performance Area,Key Performance Area
DocType: Program Enrollment,Transportation,Transport
apps/erpnext/erpnext/controllers/item_variant.py +94,Invalid Attribute,Ugyldig Attribut
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +241,{0} {1} must be submitted,{0} {1} skal godkendes
DocType: Buying Settings,Default Supplier Group,Standardleverandørgruppe
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +159,Quantity must be less than or equal to {0},Antal skal være mindre end eller lig med {0}
apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py +44,Maximum amount eligible for the component {0} exceeds {1},"Maksimumsbeløb, der er berettiget til komponenten {0}, overstiger {1}"
DocType: Department Approver,Department Approver,Afdelingsgodkendelse
DocType: QuickBooks Migrator,Application Settings,Applikationsindstillinger
DocType: SMS Center,Total Characters,Total tegn
DocType: Employee Advance,Claimed,hævdede
DocType: Crop,Row Spacing,Rækkevidde
apps/erpnext/erpnext/controllers/buying_controller.py +204,Please select BOM in BOM field for Item {0},Vælg BOM i BOM vilkår for Item {0}
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +22,There isn't any item variant for the selected item,Der er ikke nogen varianter for det valgte emne
DocType: C-Form Invoice Detail,C-Form Invoice Detail,C-Form Faktura Detail
DocType: Payment Reconciliation Invoice,Payment Reconciliation Invoice,Betalingsafstemningsfaktura
DocType: Clinical Procedure,Procedure Template,Procedureskabelon
apps/erpnext/erpnext/selling/report/sales_person_commission_summary/sales_person_commission_summary.py +75,Contribution %,Bidrag%
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +245,"As per the Buying Settings if Purchase Order Required == 'YES', then for creating Purchase Invoice, user need to create Purchase Order first for item {0}","I henhold til købsindstillingerne, hvis købsordren er påkrævet == &#39;JA&#39; og derefter for at oprette Købsfaktura skal brugeren først oprette indkøbsordre for vare {0}"
,HSN-wise-summary of outward supplies,HSN-wise-sammendrag af ydre forsyninger
DocType: Company,Company registration numbers for your reference. Tax numbers etc.,Firma registreringsnumre til din reference. Skat numre etc.
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +261,To State,Til stat
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +122,Distributor,Distributør
DocType: Asset Finance Book,Asset Finance Book,Asset Finance Book
DocType: Shopping Cart Shipping Rule,Shopping Cart Shipping Rule,Indkøbskurv forsendelsesregler
apps/erpnext/erpnext/public/js/controllers/transaction.js +72,Please set 'Apply Additional Discount On',Venligst sæt &#39;Anvend Ekstra Rabat på&#39;
DocType: Party Tax Withholding Config,Applicable Percent,Gældende procent
,Ordered Items To Be Billed,Bestilte varer at blive faktureret
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +46,From Range has to be less than To Range,Fra Range skal være mindre end at ligge
DocType: Global Defaults,Global Defaults,Globale indstillinger
apps/erpnext/erpnext/projects/doctype/project/project.py +291,Project Collaboration Invitation,Invitation til sagssamarbejde
DocType: Salary Slip,Deductions,Fradrag
DocType: Setup Progress Action,Action Name,Handlingsnavn
apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.js +17,Start Year,Startår
apps/erpnext/erpnext/regional/india/utils.py +28,First 2 digits of GSTIN should match with State number {0},De første 2 cifre i GSTIN skal svare til statens nummer {0}
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +84,PDC/LC,PDC / LC
DocType: Purchase Invoice,Start date of current invoice's period,Startdato for nuværende fakturaperiode
DocType: Salary Slip,Leave Without Pay,Fravær uden løn
DocType: Payment Request,Outward,Udgående
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +366,Capacity Planning Error,Kapacitetsplanlægningsfejl
,Trial Balance for Party,Trial Balance til Party
DocType: Lead,Consultant,Konsulent
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +356,Parents Teacher Meeting Attendance,Forældres lærermøde
DocType: Salary Slip,Earnings,Indtjening
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +538,Finished Item {0} must be entered for Manufacture type entry,Færdig element {0} skal indtastes for Fremstilling typen post
apps/erpnext/erpnext/config/learn.py +87,Opening Accounting Balance,Åbning Regnskab Balance
,GST Sales Register,GST salgsregistrering
DocType: Sales Invoice Advance,Sales Invoice Advance,Salgsfaktura Advance
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +552,Nothing to request,Intet at anmode om
DocType: Stock Settings,Default Return Warehouse,Standard Return Warehouse
apps/erpnext/erpnext/public/js/setup_wizard.js +18,Select your Domains,Vælg dine domæner
apps/erpnext/erpnext/erpnext_integrations/doctype/shopify_settings/sync_product.py +228,Shopify Supplier,Shopify Leverandør
DocType: Bank Statement Transaction Entry,Payment Invoice Items,Betalingsfakturaelementer
DocType: Payroll Entry,Employee Details,Medarbejderdetaljer
DocType: Amazon MWS Settings,CN,CN
DocType: Item Variant Settings,Fields will be copied over only at time of creation.,Felter vil blive kopieret over kun på tidspunktet for oprettelsen.
DocType: Setup Progress Action,Domains,Domæner
apps/erpnext/erpnext/projects/doctype/task/task.py +44,'Actual Start Date' can not be greater than 'Actual End Date','Faktisk startdato' kan ikke være større end 'Faktisk slutdato'
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +390,Management,Ledelse
DocType: Cheque Print Template,Payer Settings,payer Indstillinger
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +651,No pending Material Requests found to link for the given items.,Ingen afventer materialeanmodninger fundet for at linke for de givne varer.
apps/erpnext/erpnext/public/js/utils/party.js +193,Select company first,Vælg firma først
DocType: Item Attribute Value,"This will be appended to the Item Code of the variant. For example, if your abbreviation is ""SM"", and the item code is ""T-SHIRT"", the item code of the variant will be ""T-SHIRT-SM""","Dette vil blive føjet til varen af varianten. For eksempel, hvis dit forkortelse er ""SM"", og varenummeret er ""T-SHIRT"", så vil variantens varenummer blive ""T-SHIRT-SM"""
DocType: Salary Slip,Net Pay (in words) will be visible once you save the Salary Slip.,"Nettoløn (i ord) vil være synlig, når du gemmer lønsedlen."
DocType: Delivery Note,Is Return,Er Return
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +89,Caution,Advarsel
apps/erpnext/erpnext/agriculture/doctype/disease/disease.py +17,Start day is greater than end day in task '{0}',Startdagen er større end slutdagen i opgaven &#39;{0}&#39;
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +893,Return / Debit Note,Retur / debetnota
DocType: Price List Country,Price List Country,Prislisteland
DocType: Item,UOMs,Enheder
apps/erpnext/erpnext/stock/utils.py +236,{0} valid serial nos for Item {1},{0} gyldige serienumre for vare {1}
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +61,Item Code cannot be changed for Serial No.,Varenr. kan ikke ændres for Serienummer
DocType: Purchase Invoice Item,UOM Conversion Factor,UOM Conversion Factor
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure/clinical_procedure.js +9,Please enter Item Code to get Batch Number,Indtast venligst varenr. for at få partinr.
DocType: Loyalty Point Entry,Loyalty Point Entry,Loyalitetspunkt indtastning
DocType: Stock Settings,Default Item Group,Standard varegruppe
DocType: Job Card,Time In Mins,Tid i min
apps/erpnext/erpnext/config/non_profit.py +93,Grant information.,Giv oplysninger.
apps/erpnext/erpnext/config/buying.py +38,Supplier database.,Leverandør database.
DocType: Contract Template,Contract Terms and Conditions,Kontraktvilkår og betingelser
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +425,You cannot restart a Subscription that is not cancelled.,"Du kan ikke genstarte en abonnement, der ikke annulleres."
DocType: Account,Balance Sheet,Balance
DocType: Leave Type,Is Earned Leave,Er tjent forladelse
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +797,Cost Center For Item with Item Code ',Omkostningssted for vare med varenr. '
DocType: Fee Validity,Valid Till,Gyldig til
DocType: Student Report Generation Tool,Total Parents Teacher Meeting,Samlet forældreundervisningsmøde
apps/erpnext/erpnext/accounts/page/pos/pos.js +2530,"Payment Mode is not configured. Please check, whether account has been set on Mode of Payments or on POS Profile.","Betalingsmåde er ikke konfigureret. Kontroller, om konto er blevet indstillet på betalingsmåden eller på Kassesystemprofilen."
apps/erpnext/erpnext/buying/utils.py +74,Same item cannot be entered multiple times.,Samme vare kan ikke indtastes flere gange.
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +30,"Further accounts can be made under Groups, but entries can be made against non-Groups","Kan gøres yderligere konti under grupper, men oplysningerne kan gøres mod ikke-grupper"
DocType: Lead,Lead,Emne
DocType: Email Digest,Payables,Gæld
DocType: Course,Course Intro,Kursusintroduktion
DocType: Amazon MWS Settings,MWS Auth Token,MWS Auth Token
apps/erpnext/erpnext/stock/doctype/batch/batch.js +105,Stock Entry {0} created,Lagerindtastning {0} oprettet
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.py +110,You don't have enought Loyalty Points to redeem,Du har ikke nok loyalitetspoint til at indløse
apps/erpnext/erpnext/accounts/doctype/tax_withholding_category/tax_withholding_category.py +23,Please set associated account in Tax Withholding Category {0} against Company {1},Indstil tilknyttet konto i Skatholdigheds kategori {0} mod firma {1}
apps/erpnext/erpnext/controllers/buying_controller.py +405,Row #{0}: Rejected Qty can not be entered in Purchase Return,Row # {0}: Afvist Antal kan ikke indtastes i Indkøb Return
apps/erpnext/erpnext/stock/doctype/item/item.js +203,Changing Customer Group for the selected Customer is not allowed.,Ændring af kundegruppe for den valgte kunde er ikke tilladt.
,Purchase Order Items To Be Billed,Indkøbsordre varer til fakturering
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +77,Updating estimated arrival times.,Opdaterer forventede ankomsttider.
DocType: Program Enrollment Tool,Enrollment Details,Indtastningsdetaljer
apps/erpnext/erpnext/stock/doctype/item/item.py +684,Cannot set multiple Item Defaults for a company.,Kan ikke indstille flere standardindstillinger for en virksomhed.
DocType: Purchase Invoice Item,Net Rate,Nettosats
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +194,Please select a customer,Vælg venligst en kunde
DocType: Leave Policy,Leave Allocations,Forlade tildelinger
DocType: Purchase Invoice Item,Purchase Invoice Item,Købsfaktura Item
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +58,Stock Ledger Entries and GL Entries are reposted for the selected Purchase Receipts,Lagerposter og finansposter er posteret om  for de valgte købskvitteringer
DocType: Student Report Generation Tool,Assessment Terms,Vurderingsbetingelser
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +8,Item 1,Vare 1
DocType: Holiday,Holiday,Holiday
apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py +25,Leave Type is madatory,Forlad Type er madatory
DocType: Support Settings,Close Issue After Days,Luk Issue efter dage
,Eway Bill,Eway Bill
apps/erpnext/erpnext/public/js/hub/marketplace.js +138,You need to be a user with System Manager and Item Manager roles to add users to Marketplace.,Du skal være bruger med System Manager og Item Manager roller for at tilføje brugere til Marketplace.
DocType: Leave Control Panel,Leave blank if considered for all branches,Lad feltet stå tomt hvis det skal gælde for alle filialer
DocType: Job Opening,Staffing Plan,Bemandingsplan
DocType: Bank Guarantee,Validity in Days,Gyldighed i dage
apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +21,C-form is not applicable for Invoice: {0},C-formen er ikke for faktura: {0}
DocType: Certified Consultant,Name of Consultant,Navn på konsulent
DocType: Payment Reconciliation,Unreconciled Payment Details,Ikke-afstemte Betalingsoplysninger
apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py +6,Member Activity,Medlem Aktivitet
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +20,Order Count,Ordreantal
DocType: Global Defaults,Current Fiscal Year,Indeværende regnskabsår
DocType: Purchase Invoice,Group same items,Gruppe samme elementer
DocType: Purchase Invoice,Disable Rounded Total,Deaktiver Afrundet Total
DocType: Marketplace Settings,Sync in Progress,Synkronisering i gang
DocType: Department,Parent Department,Forældreafdeling
DocType: Loan Application,Repayment Info,tilbagebetaling Info
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +486,'Entries' cannot be empty,'Indlæg' kan ikke være tomt
DocType: Maintenance Team Member,Maintenance Role,Vedligeholdelsesrolle
apps/erpnext/erpnext/utilities/transaction_base.py +97,Duplicate row {0} with same {1},Duplikér række {0} med samme {1}
DocType: Marketplace Settings,Disable Marketplace,Deaktiver Marketplace
,Trial Balance,Trial Balance
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +467,Fiscal Year {0} not found,Regnskabsår {0} blev ikke fundet
apps/erpnext/erpnext/config/hr.py +394,Setting up Employees,Opsætning af Medarbejdere
DocType: Hotel Room Reservation,Hotel Reservation User,Hotel Reservation Bruger
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +165,Please select prefix first,Vælg venligst præfiks først
DocType: Contract,Fulfilment Deadline,Opfyldelsesfrist
DocType: Student,O-,O-
DocType: Subscription Settings,Subscription Settings,Abonnementsindstillinger
DocType: Purchase Invoice,Update Auto Repeat Reference,Opdater Auto Repeat Reference
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +273,Optional Holiday List not set for leave period {0},"Valgfri ferieliste, der ikke er indstillet for orlovsperioden {0}"
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +142,Research,Forskning
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +243,To Address 2,Til adresse 2
DocType: Maintenance Visit Purpose,Work Done,Arbejdet udført
apps/erpnext/erpnext/controllers/item_variant.py +35,Please specify at least one attribute in the Attributes table,Angiv mindst én attribut i Attributter tabellen
DocType: Announcement,All Students,Alle studerende
apps/erpnext/erpnext/assets/doctype/asset/asset.py +56,Item {0} must be a non-stock item,Vare {0} skal være en ikke-lagervare
apps/erpnext/erpnext/stock/doctype/batch/batch.js +18,View Ledger,Se kladde
DocType: Grading Scale,Intervals,Intervaller
DocType: Bank Statement Transaction Entry,Reconciled Transactions,Afstemte transaktioner
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +42,Earliest,Tidligste
DocType: Crop Cycle,Linked Location,Linked Location
apps/erpnext/erpnext/stock/doctype/item/item.py +557,"An Item Group exists with same name, please change the item name or rename the item group","Der eksisterer en varegruppe med samme navn, og du bedes derfor ændre varenavnet eller omdøbe varegruppen"
DocType: Crop Cycle,Less than a year,Mindre end et år
apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py +52,Student Mobile No.,Studerende mobiltelefonnr.
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +105,Rest Of The World,Resten af verden
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +81,The Item {0} cannot have Batch,Vare {0} kan ikke have parti
DocType: Crop,Yield UOM,Udbytte UOM
,Budget Variance Report,Budget Variance Report
DocType: Salary Slip,Gross Pay,Bruttoløn
DocType: Item,Is Item from Hub,Er vare fra nav
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1642,Get Items from Healthcare Services,Få artikler fra sundhedsydelser
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +124,Row {0}: Activity Type is mandatory.,Række {0}: Aktivitetstypen er obligatorisk.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +176,Dividends Paid,Betalt udbytte
apps/erpnext/erpnext/buying/doctype/supplier/supplier.js +39,Accounting Ledger,Regnskab Ledger
DocType: Asset Value Adjustment,Difference Amount,Differencebeløb
DocType: Purchase Invoice,Reverse Charge,Reverse Charge
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +182,Retained Earnings,Overført overskud
DocType: Job Card,Timing Detail,Timing Detail
DocType: Purchase Invoice,05-Change in POS,05-ændring i POS
DocType: Vehicle Log,Service Detail,service Detail
DocType: BOM,Item Description,Varebeskrivelse
DocType: Student Sibling,Student Sibling,Student Søskende
apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py +20,Payment Mode,Betaling tilstand
DocType: Purchase Invoice,Supplied Items,Medfølgende varer
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +85,Please set an active menu for Restaurant {0},Indstil en aktiv menu for Restaurant {0}
apps/erpnext/erpnext/selling/report/sales_person_commission_summary/sales_person_commission_summary.py +81,Commission Rate %,Kommissionens sats%
DocType: Work Order,Qty To Manufacture,Antal at producere
DocType: Email Digest,New Income,Ny Indkomst
DocType: Buying Settings,Maintain same rate throughout purchase cycle,Bevar samme sats i hele køb cyklus
DocType: Opportunity Item,Opportunity Item,Salgsmulighed Vare
,Student and Guardian Contact Details,Studerende og Guardian Kontaktoplysninger
apps/erpnext/erpnext/accounts/doctype/account/account.js +51,Merge Account,Fusionskonto
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +53,Row {0}: For supplier {0} Email Address is required to send email,Række {0}: For leverandør {0} E-mail-adresse er nødvendig for at sende e-mail
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +76,Temporary Opening,Midlertidig åbning
,Employee Leave Balance,Medarbejder Leave Balance
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +148,Balance for Account {0} must always be {1},Balance for konto {0} skal altid være {1}
DocType: Patient Appointment,More Info,Mere info
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +181,Valuation Rate required for Item in row {0},Værdiansættelsesbeløb påkrævet for varen i række {0}
DocType: Supplier Scorecard,Scorecard Actions,Scorecard Actions
apps/erpnext/erpnext/utilities/user_progress.py +169,Example: Masters in Computer Science,Eksempel: Masters i Computer Science
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py +67,Supplier {0} not found in {1},Leverandør {0} ikke fundet i {1}
DocType: Purchase Invoice,Rejected Warehouse,Afvist lager
DocType: GL Entry,Against Voucher,Modbilag
DocType: Item Default,Default Buying Cost Center,Standard købsomkostningssted
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +6,"To get the best out of ERPNext, we recommend that you take some time and watch these help videos.","For at få det bedste ud af ERPNext, anbefaler vi, at du tager lidt tid og se disse hjælpe videoer."
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +1046,For Default Supplier (optional),For standardleverandør (valgfrit)
DocType: Supplier Quotation Item,Lead Time in days,Gennemsnitlig leveringstid i dage
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +83,Accounts Payable Summary,Kreditorer Resumé
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +214,Not authorized to edit frozen Account {0},Ikke autoriseret til at redigere låst konto {0}
DocType: Journal Entry,Get Outstanding Invoices,Hent åbne fakturaer
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +84,Sales Order {0} is not valid,Salgsordre {0} er ikke gyldig
DocType: Supplier Scorecard,Warn for new Request for Quotations,Advar om ny anmodning om tilbud
apps/erpnext/erpnext/utilities/activation.py +91,Purchase orders help you plan and follow up on your purchases,Indkøbsordrer hjælpe dig med at planlægge og følge op på dine køb
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +146,Lab Test Prescriptions,Lab Test Prescriptions
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +164,"The total Issue / Transfer quantity {0} in Material Request {1}  \
							cannot be greater than requested quantity {2} for Item {3}",Den samlede overførselsmængde {0} i materialeanmodning {1} \ kan ikke være større end den anmodede mængde {2} for vare {3}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +149,Small,Lille
DocType: Shopify Settings,"If Shopify not contains a customer in Order, then while syncing Orders, the system will consider default customer for order","Hvis Shopify ikke indeholder en kunde i Bestil, så vil systemet overveje standardkunder for ordre, mens du synkroniserer Ordrer"
DocType: Opening Invoice Creation Tool Item,Opening Invoice Creation Tool Item,Åbning af fakturaoprettelsesværktøj
DocType: Cashier Closing Payments,Cashier Closing Payments,Kasseindbetalinger
DocType: Education Settings,Employee Number,Medarbejdernr.
DocType: Subscription Settings,Cancel Invoice After Grace Period,Annuller faktura efter Grace Period
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +67,Case No(s) already in use. Try from Case No {0},"(E), der allerede er i brug Case Ingen. Prøv fra sag {0}"
DocType: Project,% Completed,% afsluttet
,Invoiced Amount (Exculsive Tax),Faktureret beløb (exculsive Tax)
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +14,Item 2,Vare 2
DocType: QuickBooks Migrator,Authorization Endpoint,Autorisation Endpoint
DocType: Travel Request,International,International
DocType: Training Event,Training Event,Træning begivenhed
DocType: Item,Auto re-order,Auto re-ordre
apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.py +59,Total Achieved,Total Opnået
DocType: Employee,Place of Issue,Udstedelsessted
DocType: Contract,Contract,Kontrakt
DocType: Plant Analysis,Laboratory Testing Datetime,Laboratorietestning Datetime
DocType: Email Digest,Add Quote,Tilføj tilbud
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1246,UOM coversion factor required for UOM: {0} in Item: {1},UOM coversion faktor kræves for Pakke: {0} i Konto: {1}
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +99,Indirect Expenses,Indirekte udgifter
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +128,Row {0}: Qty is mandatory,Række {0}: Antal er obligatorisk
DocType: Agriculture Analysis Criteria,Agriculture,Landbrug
apps/erpnext/erpnext/manufacturing/doctype/blanket_order/blanket_order.js +15,Create Sales Order,Opret salgsordre
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +516,Accounting Entry for Asset,Regnskabsføring for aktiv
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +878,Block Invoice,Blokfaktura
apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.js +16,Quantity to Make,Mængde at gøre
apps/erpnext/erpnext/accounts/page/pos/pos.js +801,Sync Master Data,Sync Master Data
DocType: Asset Repair,Repair Cost,Reparationsomkostninger
apps/erpnext/erpnext/utilities/user_progress.py +138,Your Products or Services,Dine produkter eller tjenester
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +16,Failed to login,Kunne ikke logge ind
apps/erpnext/erpnext/controllers/buying_controller.py +629,Asset {0} created,Asset {0} oprettet
DocType: Special Test Items,Special Test Items,Særlige testelementer
apps/erpnext/erpnext/public/js/hub/marketplace.js +101,You need to be a user with System Manager and Item Manager roles to register on Marketplace.,Du skal være en bruger med System Manager og Item Manager roller til at registrere på Marketplace.
DocType: Bank Statement Transaction Payment Item,Mode of Payment,Betalingsmåde
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py +25,As per your assigned Salary Structure you cannot apply for benefits,I henhold til din tildelte lønstruktur kan du ikke søge om ydelser
apps/erpnext/erpnext/stock/doctype/item/item.py +231,Website Image should be a public file or website URL,Website Billede bør være en offentlig fil eller webadresse
DocType: Purchase Invoice Item,BOM,Stykliste
apps/erpnext/erpnext/setup/doctype/item_group/item_group.js +71,This is a root item group and cannot be edited.,Dette er en rod-varegruppe og kan ikke redigeres.
apps/erpnext/erpnext/accounts/doctype/account/account.js +133,Merge,Fusionere
DocType: Journal Entry Account,Purchase Order,Indkøbsordre
DocType: Vehicle,Fuel UOM,Brændstofsenhed
DocType: Warehouse,Warehouse Contact Info,Lagerkontaktinformation
DocType: Payment Entry,Write Off Difference Amount,Skriv Off Forskel Beløb
DocType: Volunteer,Volunteer Name,Frivilligt navn
apps/erpnext/erpnext/controllers/accounts_controller.py +793,Rows with duplicate due dates in other rows were found: {0},Rækker med dubletter forfaldsdatoer i andre rækker blev fundet: {0}
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +535,"{0}: Employee email not found, hence email not sent","{0}: Medarbejderens e-mail er ikke fundet, og derfor er e-mailen ikke sendt"
apps/erpnext/erpnext/hr/doctype/leave_encashment/leave_encashment.py +55,No Salary Structure assigned for Employee {0} on given date {1},Ingen lønstrukturer tildelt medarbejder {0} på en given dato {1}
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +85,Shipping rule not applicable for country {0},Forsendelsesregel gælder ikke for land {0}
DocType: Item,Foreign Trade Details,Udenrigshandel Detaljer
,Assessment Plan Status,Evalueringsplan Status
DocType: Email Digest,Annual Income,Årlige indkomst
DocType: Serial No,Serial No Details,Serienummeroplysninger
DocType: Purchase Invoice Item,Item Tax Rate,Varemoms-%
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +176,From Party Name,Fra Party Name
DocType: Student Group Student,Group Roll Number,Gruppe Roll nummer
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +177,"For {0}, only credit accounts can be linked against another debit entry",For {0} kan kun kredit konti knyttes mod en anden debet post
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +660,Delivery Note {0} is not submitted,Følgeseddel {0} er ikke godkendt
apps/erpnext/erpnext/stock/get_item_details.py +167,Item {0} must be a Sub-contracted Item,Vare {0} skal være en underentreprise Vare
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +44,Capital Equipments,Capital Udstyr
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +33,"Pricing Rule is first selected based on 'Apply On' field, which can be Item, Item Group or Brand.","Prisfastsættelsesregel skal først baseres på feltet 'Gælder for', som kan indeholde vare, varegruppe eller varemærke."
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +372,Please set the Item Code first,Indstil varenummeret først
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +157,Doc Type,Doc Type
apps/erpnext/erpnext/controllers/selling_controller.py +135,Total allocated percentage for sales team should be 100,Samlede fordelte procentdel for salgsteam bør være 100
DocType: Subscription Plan,Billing Interval Count,Faktureringsintervaltælling
apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py +10,Appointments and Patient Encounters,Aftaler og patientmøder
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js +135,Value missing,Værdi mangler
DocType: Employee,Department and Grade,Afdeling og Grad
DocType: Sales Invoice Item,Edit Description,Rediger beskrivelse
DocType: Antibiotic,Antibiotic,Antibiotikum
,Team Updates,Team opdateringer
apps/erpnext/erpnext/accounts/doctype/payment_order/payment_order.js +39,For Supplier,For Leverandøren
DocType: Account,Setting Account Type helps in selecting this Account in transactions.,Indstilling Kontotype hjælper med at vælge denne konto i transaktioner.
DocType: Purchase Invoice,Grand Total (Company Currency),Beløb i alt (firmavaluta)
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +9,Create Print Format,Opret Print Format
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +5,Fee Created,Gebyr oprettet
apps/erpnext/erpnext/utilities/bot.py +39,Did not find any item called {0},"Fandt ikke nogen post, kaldet {0}"
apps/erpnext/erpnext/stock/report/item_prices/item_prices.js +8,Items Filter,Elementer Filter
DocType: Supplier Scorecard Criteria,Criteria Formula,Kriterier Formel
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +42,Total Outgoing,Samlet Udgående
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +39,"There can only be one Shipping Rule Condition with 0 or blank value for ""To Value""","Der kan kun være én forsendelsesregelbetingelse med 0 eller blank værdi i feltet ""til værdi"""
DocType: Bank Statement Transaction Settings Item,Transaction,Transaktion
DocType: Patient Appointment,Duration,Varighed
apps/erpnext/erpnext/controllers/status_updater.py +160,"For an item {0}, quantity must be positive number",For en vare {0} skal mængden være positivt tal
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +76,Note: This Cost Center is a Group. Cannot make accounting entries against groups.,Bemærk: Dette omkostningssted er en gruppe. Kan ikke postere mod grupper.
apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py +44,Compensatory leave request days not in valid holidays,Forsøgsfrihed anmodningsdage ikke i gyldige helligdage
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +54,Child warehouse exists for this warehouse. You can not delete this warehouse.,eksisterer Child lager for dette lager. Du kan ikke slette dette lager.
DocType: Item,Website Item Groups,Hjemmeside-varegrupper
DocType: Purchase Invoice,Total (Company Currency),I alt (firmavaluta)
DocType: Daily Work Summary Group,Reminder,Påmindelse
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +304,Accessable Value,Tilgængelig værdi
apps/erpnext/erpnext/stock/utils.py +231,Serial number {0} entered more than once,Serienummer {0} indtastet mere end én gang
DocType: Bank Statement Transaction Invoice Item,Journal Entry,Kassekladde
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +183,From GSTIN,Fra GSTIN
DocType: Expense Claim Advance,Unclaimed amount,Uopkrævet beløb
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +269,{0} items in progress,{0} igangværende varer
DocType: Workstation,Workstation Name,Workstation Navn
DocType: Grading Scale Interval,Grade Code,Grade kode
DocType: POS Item Group,POS Item Group,Kassesystem-varegruppe
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +17,Email Digest:,E-mail nyhedsbrev:
apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py +23,Alternative item must not be same as item code,Alternativt element må ikke være det samme som varekode
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +644,BOM {0} does not belong to Item {1},Stykliste {0} hører ikke til vare {1}
DocType: Sales Partner,Target Distribution,Target Distribution
DocType: Purchase Invoice,06-Finalization of Provisional assessment,06-Afslutning af foreløbig vurdering
DocType: Salary Slip,Bank Account No.,Bankkonto No.
DocType: Naming Series,This is the number of the last created transaction with this prefix,Dette er antallet af sidste skabte transaktionen med dette præfiks
DocType: Supplier Scorecard,"Scorecard variables can be used, as well as:
{total_score} (the total score from that period),
{period_number} (the number of periods to present day)
","Scorecard-variabler kan bruges, samt: {total_score} (den samlede score fra den periode), {period_number} (antallet af perioder til nutidens dag)"
apps/erpnext/erpnext/public/js/setup_wizard.js +254,Collapse All,Skjul alle
apps/erpnext/erpnext/manufacturing/doctype/blanket_order/blanket_order.js +27,Create Purchase Order,Opret indkøbsordre
DocType: Quality Inspection Reading,Reading 8,Reading 8
DocType: Inpatient Record,Discharge Note,Udledning Note
DocType: Purchase Invoice,Taxes and Charges Calculation,Skatter og Afgifter Beregning
DocType: Accounts Settings,Book Asset Depreciation Entry Automatically,Bogføring af aktivernes afskrivning automatisk
DocType: BOM Operation,Workstation,Arbejdsstation
DocType: Request for Quotation Supplier,Request for Quotation Supplier,Anmodning om tilbud Leverandør
DocType: Healthcare Settings,Registration Message,Registreringsmeddelelse
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +120,Hardware,Hardware
DocType: Prescription Dosage,Prescription Dosage,Receptpligtig dosering
DocType: Contract,HR Manager,HR-chef
apps/erpnext/erpnext/accounts/party.py +196,Please select a Company,Vælg firma
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +70,Privilege Leave,Privilege Forlad
DocType: Purchase Invoice,Supplier Invoice Date,Leverandør fakturadato
DocType: Asset Settings,This value is used for pro-rata temporis calculation,Denne værdi anvendes til pro rata temporis beregning
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +91,You need to enable Shopping Cart,Du skal aktivere Indkøbskurven
DocType: Payment Entry,Writeoff,Skrive af
DocType: Maintenance Visit,MAT-MVS-.YYYY.-,MAT-MVS-.YYYY.-
DocType: Stock Settings,Naming Series Prefix,Navngivning Serie Prefix
DocType: Appraisal Template Goal,Appraisal Template Goal,Skabelon til vurderingsmål
DocType: Salary Component,Earning,Tillæg
DocType: Supplier Scorecard,Scoring Criteria,Scoringskriterier
DocType: Purchase Invoice,Party Account Currency,Party Account Valuta
DocType: Delivery Trip,Total Estimated Distance,Samlet estimeret afstand
,BOM Browser,Styklistesøgning
apps/erpnext/erpnext/templates/emails/training_event.html +13,Please update your status for this training event,Opdater venligst din status for denne træningsbegivenhed
DocType: Item Barcode,EAN,EAN
DocType: Purchase Taxes and Charges,Add or Deduct,Tilføje eller fratrække
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +148,Overlapping conditions found between:,Overlappende betingelser fundet mellem:
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +188,Against Journal Entry {0} is already adjusted against some other voucher,Mod Kassekladde {0} er allerede justeret mod et andet bilag
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +68,Total Order Value,Samlet ordreværdi
apps/erpnext/erpnext/demo/setup/setup_data.py +341,Food,Mad
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +42,Ageing Range 3,Ageing Range 3
DocType: POS Closing Voucher Details,POS Closing Voucher Details,POS Closing Voucher Detaljer
DocType: Shopify Log,Shopify Log,Shopify Log
DocType: Inpatient Occupancy,Check In,Check ind
DocType: Maintenance Schedule Item,No of Visits,Antal besøg
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +165,Maintenance Schedule {0} exists against {1},Vedligeholdelsesplan {0} eksisterer imod {1}
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +36,Enrolling student,tilmelding elev
apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +33,Currency of the Closing Account must be {0},Valuta for Lukning Der skal være {0}
apps/erpnext/erpnext/hr/doctype/appraisal_template/appraisal_template.py +21,Sum of points for all goals should be 100. It is {0},Sum af point for alle mål skal være 100. Det er {0}
DocType: Project,Start and End Dates,Start- og slutdato
DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,Kontraktskabelopfyldelsesbetingelser
,Delivered Items To Be Billed,Leverede varer at blive faktureret
apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html +16,Open BOM {0},Åben stykliste {0}
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +64,Warehouse cannot be changed for Serial No.,Lager kan ikke ændres for serienummeret
DocType: Authorization Rule,Average Discount,Gennemsnitlig rabat
DocType: Project Update,Great/Quickly,Great / Hurtigt
DocType: Purchase Invoice Item,UOM,Enhed
DocType: Employee Tax Exemption Declaration,Annual HRA Exemption,Årlig HRA-fritagelse
DocType: Rename Tool,Utilities,Forsyningsvirksomheder
DocType: POS Profile,Accounting,Regnskab
DocType: Asset,Purchase Receipt Amount,Købsmodtagelsesbeløb
DocType: Employee Separation,Exit Interview Summary,Exit Interview Summary
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +140,Please select batches for batched item ,Vælg venligst batches for batched item
DocType: Asset,Depreciation Schedules,Afskrivninger Tidsplaner
apps/erpnext/erpnext/erpnext_integrations/doctype/shopify_settings/shopify_settings.py +37,"Support for public app is deprecated. Please setup private app, for more details refer user manual","Støtten til offentlig app er afskediget. Venligst opsæt privat app, for flere detaljer, se brugervejledningen"
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py +202,Following accounts might be selected in GST Settings:,Følgende konti kan vælges i GST-indstillinger:
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +104,Application period cannot be outside leave allocation period,Ansøgningsperiode kan ikke være uden for orlov tildelingsperiode
DocType: Activity Cost,Projects,Sager
DocType: Payment Request,Transaction Currency,Transaktionsvaluta
apps/erpnext/erpnext/controllers/buying_controller.py +34,From {0} | {1} {2},Fra {0} | {1} {2}
apps/erpnext/erpnext/public/js/hub/marketplace.js +163,Some emails are invalid,Nogle e-mails er ugyldige
DocType: Work Order Operation,Operation Description,Operation Beskrivelse
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +34,Cannot change Fiscal Year Start Date and Fiscal Year End Date once the Fiscal Year is saved.,Kan ikke ændre regnskabsår Start Dato og Skatteårsafslutning Dato når regnskabsår er gemt.
DocType: Quotation,Shopping Cart,Indkøbskurv
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +42,Avg Daily Outgoing,Gennemsnitlig Daily Udgående
DocType: POS Profile,Campaign,Kampagne
DocType: Supplier,Name and Type,Navn og type
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +64,Approval Status must be 'Approved' or 'Rejected',Godkendelsesstatus skal &quot;Godkendt&quot; eller &quot;Afvist&quot;
DocType: Healthcare Practitioner,Contacts and Address,Kontakter og adresse
DocType: Salary Structure,Max Benefits (Amount),Maksimale fordele (Beløb)
DocType: Purchase Invoice,Contact Person,Kontaktperson
apps/erpnext/erpnext/projects/doctype/task/task.py +41,'Expected Start Date' can not be greater than 'Expected End Date','Forventet startdato' kan ikke være større end 'Forventet slutdato '
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.js +107,No data for this period,Ingen data for denne periode
DocType: Course Scheduling Tool,Course End Date,Kursus slutdato
DocType: Holiday List,Holidays,Helligdage
DocType: Sales Order Item,Planned Quantity,Planlagt mængde
DocType: Purchase Invoice Item,Item Tax Amount,Varemomsbeløb
DocType: Water Analysis,Water Analysis Criteria,Vandanalyse Kriterier
DocType: Item,Maintain Stock,Vedligehold lageret
DocType: Employee,Prefered Email,foretrukket Email
DocType: Student Admission,Eligibility and Details,Støtteberettigelse og detaljer
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +92,Net Change in Fixed Asset,Nettoændring i anlægsaktiver
apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.py +38,Reqd Qty,Reqd Antal
DocType: Leave Control Panel,Leave blank if considered for all designations,Lad feltet stå tomt hvis det skal gælde for alle betegnelser
apps/erpnext/erpnext/controllers/accounts_controller.py +892,Charge of type 'Actual' in row {0} cannot be included in Item Rate,Afgift af typen &#39;Actual &quot;i rækken {0} kan ikke indgå i Item Rate
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +531,Max: {0},Max: {0}
apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py +24,From Datetime,Fra datotid
DocType: Shopify Settings,For Company,Til firma
apps/erpnext/erpnext/config/support.py +17,Communication log.,Kommunikation log.
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +195,"Request for Quotation is disabled to access from portal, for more check portal settings.",Adgang til portal er deaktiveret for anmodning om tilbud. Check portal instillinger
DocType: Supplier Scorecard Scoring Variable,Supplier Scorecard Scoring Variable,Leverandør Scorecard Scoringsvariabel
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +70,Buying Amount,Køb Beløb
DocType: POS Closing Voucher,Modes of Payment,Betalingsmåder
DocType: Sales Invoice,Shipping Address Name,Leveringsadressenavn
DocType: Material Request,Terms and Conditions Content,Vilkår og -betingelsesindhold
apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +18,There were errors creating Course Schedule,Der opstod fejl ved at oprette kursusplan
DocType: Department,The first Expense Approver in the list will be set as the default Expense Approver.,Den første udgiftsgodkendelse i listen bliver indstillet som standard Expense Approver.
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +611,cannot be greater than 100,må ikke være større end 100
apps/erpnext/erpnext/public/js/hub/marketplace.js +96,You need to be a user other than Administrator with System Manager and Item Manager roles to register on Marketplace.,Du skal være en anden bruger end Administrator med System Manager og Item Manager roller for at registrere dig på Marketplace.
apps/erpnext/erpnext/stock/doctype/item/item.py +830,Item {0} is not a stock Item,Vare {0} er ikke en lagervare
DocType: Packing Slip,MAT-PAC-.YYYY.-,MAT-PAC-.YYYY.-
DocType: Maintenance Visit,Unscheduled,Uplanlagt
DocType: Employee,Owned,Ejet
DocType: Salary Component,Depends on Leave Without Pay,Afhænger af fravær uden løn
DocType: Pricing Rule,"Higher the number, higher the priority","Desto højere tallet er, jo højere prioritet"
,Purchase Invoice Trends,Købsfaktura Trends
DocType: Employee,Better Prospects,Bedre udsigter
DocType: Travel Itinerary,Gluten Free,Glutenfri
DocType: Loyalty Program Collection,Minimum Total Spent,Minimum samlet forbrug
apps/erpnext/erpnext/stock/doctype/batch/batch.py +222,"Row #{0}: The batch {1} has only {2} qty. Please select another batch which has {3} qty available or split the row into multiple rows, to deliver/issue from multiple batches","Række # {0}: Parti {1} har kun {2} mængde. Vælg venligst et andet parti, der har {3} antal tilgængelige eller opdel rækken i flere rækker for at kunne levere fra flere partier"
DocType: Loyalty Program,Expiry Duration (in days),Udløbsperiode (i dage)
DocType: Inpatient Record,Discharge Date,Udladningsdato
DocType: Subscription Plan,Price Determination,Prisfastsættelse
DocType: Vehicle,License Plate,Nummerplade
apps/erpnext/erpnext/hr/doctype/department/department_tree.js +18,New Department,Ny afdeling
DocType: Compensatory Leave Request,Worked On Holiday,Arbejdet på ferie
DocType: Appraisal,Goals,Mål
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +399,Select POS Profile,Vælg POS-profil
DocType: Warranty Claim,Warranty / AMC Status,Garanti / AMC status
,Accounts Browser,Konti Browser
DocType: Procedure Prescription,Referral,Henvisning
DocType: Payment Entry Reference,Payment Entry Reference,Betalingspost reference
DocType: GL Entry,GL Entry,GL indtastning
DocType: Support Search Source,Response Options,Respons Options
DocType: HR Settings,Employee Settings,Medarbejderindstillinger
apps/erpnext/erpnext/templates/pages/integrations/gocardless_checkout.html +13,Loading Payment System,Indlæser betalingssystem
,Batch-Wise Balance History,Historik sorteret pr. parti
apps/erpnext/erpnext/controllers/accounts_controller.py +1122,Row #{0}: Cannot set Rate if amount is greater than billed amount for Item {1}.,Row # {0}: Kan ikke indstille Rate hvis beløb er større end faktureret beløb for Item {1}.
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +73,Print settings updated in respective print format,Udskriftsindstillinger opdateret i respektive print format
DocType: Package Code,Package Code,Pakkekode
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +83,Apprentice,Lærling
DocType: Purchase Invoice,Company GSTIN,Firma GSTIN
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +106,Negative Quantity is not allowed,Negative Mængde er ikke tilladt
DocType: Purchase Invoice Item,"Tax detail table fetched from item master as a string and stored in this field.
Used for Taxes and Charges",Skat detalje tabel hentes fra post mester som en streng og opbevares i dette område. Bruges til skatter og afgifter
apps/erpnext/erpnext/hr/doctype/employee/employee.py +171,Employee cannot report to himself.,Medarbejder kan ikke referere til sig selv.
DocType: Leave Type,Max Leaves Allowed,Maks. Tilladte blade
DocType: Account,"If the account is frozen, entries are allowed to restricted users.","Hvis kontoen er frossen, er poster lov til begrænsede brugere."
DocType: Email Digest,Bank Balance,Bank Balance
apps/erpnext/erpnext/accounts/party.py +269,Accounting Entry for {0}: {1} can only be made in currency: {2},Regnskab Punktet om {0}: {1} kan kun foretages i valuta: {2}
DocType: HR Settings,Leave Approver Mandatory In Leave Application,Forlad godkendelsesprocedure
DocType: Job Opening,"Job profile, qualifications required etc.","Stillingsprofil, kvalifikationskrav mv."
DocType: Journal Entry Account,Account Balance,Konto saldo
apps/erpnext/erpnext/config/accounts.py +179,Tax Rule for transactions.,Momsregel til transaktioner.
DocType: Rename Tool,Type of document to rename.,Type dokument omdøbe.
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +53,{0} {1}: Customer is required against Receivable account {2},{0} {1}: Kunden er påkrævet mod Tilgodehavende konto {2}
DocType: Purchase Invoice,Total Taxes and Charges (Company Currency),Moms i alt (firmavaluta)
DocType: Weather,Weather Parameter,Vejr Parameter
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +76,Show unclosed fiscal year's P&L balances,Vis uafsluttede finanspolitiske års P &amp; L balancer
DocType: Item,Asset Naming Series,Asset Naming Series
DocType: Appraisal,HR-APR-.YY.-.MM.,HR-APR-.YY.-.MM.
apps/erpnext/erpnext/regional/india/utils.py +179,House rented dates should be atleast 15 days apart,Husleje datoer skal være mindst 15 dage fra hinanden
DocType: Clinical Procedure Template,Collection Details,Indsamlingsdetaljer
DocType: POS Profile,Allow Print Before Pay,Tillad Print før betaling
DocType: Linked Soil Texture,Linked Soil Texture,Sammenknyttet jordstruktur
DocType: Shipping Rule,Shipping Account,Forsendelse konto
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +93,{0} {1}: Account {2} is inactive,{0} {1}: Konto {2} er inaktiv
apps/erpnext/erpnext/utilities/activation.py +82,Make Sales Orders to help you plan your work and deliver on-time,Opret salgsordrer til at hjælpe dig med at planlægge dit arbejde og levere til tiden
DocType: Bank Statement Transaction Entry,Bank Transaction Entries,Bankoverførselsangivelser
DocType: Quality Inspection,Readings,Aflæsninger
DocType: Stock Entry,Total Additional Costs,Yderligere omkostninger i alt
apps/erpnext/erpnext/crm/report/lead_conversion_time/lead_conversion_time.py +47,No of Interactions,Ingen af interaktioner
DocType: BOM,Scrap Material Cost(Company Currency),Skrot materialeomkostninger (firmavaluta)
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +44,Sub Assemblies,Sub forsamlinger
DocType: Asset,Asset Name,Aktivnavn
DocType: Project,Task Weight,Opgavevægtning
DocType: Shipping Rule Condition,To Value,Til Value
DocType: Loyalty Program,Loyalty Program Type,Loyalitetsprogramtype
DocType: Asset Movement,Stock Manager,Stock manager
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +250,Source warehouse is mandatory for row {0},Kilde lageret er obligatorisk for rækken {0}
apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +38,The Payment Term at row {0} is possibly a duplicate.,Betalingsperioden i række {0} er muligvis et duplikat.
apps/erpnext/erpnext/public/js/setup_wizard.js +30,Agriculture (beta),Landbrug (beta)
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +919,Packing Slip,Pakkeseddel
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +117,Office Rent,Kontorleje
apps/erpnext/erpnext/config/setup.py +105,Setup SMS gateway settings,Opsætning SMS gateway-indstillinger
DocType: Disease,Common Name,Almindeligt navn
DocType: Employee Boarding Activity,Employee Boarding Activity,Medarbejder boarding aktivitet
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +61,Import Failed!,Import mislykkedes!
apps/erpnext/erpnext/public/js/templates/address_list.html +20,No address added yet.,Ingen adresse tilføjet endnu.
DocType: Workstation Working Hour,Workstation Working Hour,Workstation Working Hour
DocType: Vital Signs,Blood Pressure,Blodtryk
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +88,Analyst,Analytiker
apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py +20,{0} is not in a valid Payroll Period,{0} er ikke i en gyldig lønseddel
DocType: Employee Benefit Application,Max Benefits (Yearly),Maksimale fordele (Årlig)
DocType: Item,Inventory,Inventory
DocType: Item,Sales Details,Salg Detaljer
DocType: Opportunity,With Items,Med varer
DocType: Asset Maintenance,Maintenance Team,Vedligeholdelse Team
DocType: Salary Component,Is Additional Component,Er ekstra komponent
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37,In Qty,I Antal
DocType: Education Settings,Validate Enrolled Course for Students in Student Group,Valider indskrevet kursus for studerende i studentegruppe
DocType: Notification Control,Expense Claim Rejected,Udlæg afvist
DocType: Item,Item Attribute,Item Attribut
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +112,Government,Regeringen
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +40,Expense Claim {0} already exists for the Vehicle Log,Udlæg {0} findes allerede for kørebogen
DocType: Asset Movement,Source Location,Kildeplacering
apps/erpnext/erpnext/public/js/setup_wizard.js +64,Institute Name,Institut Navn
apps/erpnext/erpnext/hr/doctype/loan/loan.py +127,Please enter repayment Amount,Indtast tilbagebetaling Beløb
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js +18,There can be multiple tiered collection factor based on the total spent. But the conversion factor for redemption will always be same for all the tier.,Der kan være flere lagdelt indsamlingsfaktor baseret på det samlede forbrug. Men konverteringsfaktoren til indløsning vil altid være den samme for alle niveauer.
apps/erpnext/erpnext/config/stock.py +312,Item Variants,Item Varianter
apps/erpnext/erpnext/public/js/setup_wizard.js +29,Services,Tjenester
DocType: Payment Order,PMO-,PMO-
DocType: HR Settings,Email Salary Slip to Employee,E-mail lønseddel til medarbejder
DocType: Cost Center,Parent Cost Center,Overordnet omkostningssted
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1098,Select Possible Supplier,Vælg Mulig leverandør
DocType: Sales Invoice,Source,Kilde
DocType: Customer,"Select, to make the customer searchable with these fields","Vælg, for at gøre kunden søgbar med disse felter"
DocType: Shopify Settings,Import Delivery Notes from Shopify on Shipment,Import leveringsnotater fra Shopify på forsendelse
apps/erpnext/erpnext/templates/pages/projects.html +31,Show closed,Vis lukket
DocType: Leave Type,Is Leave Without Pay,Er fravær uden løn
apps/erpnext/erpnext/stock/doctype/item/item.py +290,Asset Category is mandatory for Fixed Asset item,Aktivkategori er obligatorisk for en anlægsaktivvare
DocType: Fee Validity,Fee Validity,Gebyrets gyldighed
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +146,No records found in the Payment table,Ingen resultater i Payment tabellen
apps/erpnext/erpnext/education/utils.py +19,This {0} conflicts with {1} for {2} {3},Dette {0} konflikter med {1} for {2} {3}
DocType: Student Attendance Tool,Students HTML,Studerende HTML
DocType: POS Profile,Apply Discount,Anvend rabat
DocType: GST HSN Code,GST HSN Code,GST HSN-kode
DocType: Employee External Work History,Total Experience,Total Experience
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +70,Open Projects,Åbne sager
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +300,Packing Slip(s) cancelled,Pakkeseddel (ler) annulleret
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +90,Cash Flow from Investing,Pengestrømme fra investeringsaktiviteter
DocType: Program Course,Program Course,Kursusprogram
DocType: Healthcare Service Unit,Allow Appointments,Tillad aftaler
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +106,Freight and Forwarding Charges,Fragt og Forwarding Afgifter
DocType: Homepage,Company Tagline for website homepage,Firma Tagline for website hjemmeside
DocType: Item Group,Item Group Name,Varegruppenavn
apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py +28,Taken,Taget
DocType: Student,Date of Leaving,Dato for Leaving
DocType: Pricing Rule,For Price List,For prisliste
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +27,Executive Search,Executive Search
DocType: Employee Advance,HR-EAD-.YYYY.-,HR-EAD-.YYYY.-
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +56,Setting defaults,Indstilling af standardindstillinger
DocType: Loyalty Program,Auto Opt In (For all customers),Auto Opt In (For alle kunder)
apps/erpnext/erpnext/utilities/activation.py +63,Create Leads,Opret emner
DocType: Maintenance Schedule,Schedules,Tidsplaner
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +515,POS Profile is required to use Point-of-Sale,POS-profil er påkrævet for at bruge Point-of-Sale
DocType: Cashier Closing,Net Amount,Nettobeløb
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +139,{0} {1} has not been submitted so the action cannot be completed,"{0} {1} er ikke indsendt, så handlingen kan ikke gennemføres"
DocType: Purchase Order Item Supplied,BOM Detail No,BOM Detail Nej
DocType: Landed Cost Voucher,Additional Charges,Ekstragebyrer
DocType: Support Search Source,Result Route Field,Resultatrutefelt
DocType: Supplier,PAN,PANDE
DocType: Purchase Invoice,Additional Discount Amount (Company Currency),Ekstra rabatbeløb (firmavaluta)
DocType: Supplier Scorecard,Supplier Scorecard,Leverandør Scorecard
DocType: Plant Analysis,Result Datetime,Resultat Datetime
,Support Hour Distribution,Support Time Distribution
DocType: Maintenance Visit,Maintenance Visit,Vedligeholdelsesbesøg
DocType: Student,Leaving Certificate Number,Leaving Certificate Number
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +100,"Appointment cancelled, Please review and cancel the invoice {0}","Aftale annulleret, bedes gennemgå og annullere fakturaen {0}"
DocType: Sales Invoice Item,Available Batch Qty at Warehouse,Tilgængeligt batch-antal på lageret
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +9,Update Print Format,Opdater Print Format
DocType: Bank Account,Is Company Account,Er virksomhedskonto
apps/erpnext/erpnext/hr/doctype/leave_encashment/leave_encashment.py +58,Leave Type {0} is not encashable,Forladetype {0} er ikke inkashable
DocType: Landed Cost Voucher,Landed Cost Help,Landed Cost Hjælp
DocType: Vehicle Log,HR-VLOG-.YYYY.-,HR-vlog-.YYYY.-
DocType: Purchase Invoice,Select Shipping Address,Vælg leveringsadresse
DocType: Timesheet Detail,Expected Hrs,Forventet tid
apps/erpnext/erpnext/config/non_profit.py +28,Memebership Details,Memebership Detaljer
DocType: Leave Block List,Block Holidays on important days.,Blokér ferie på vigtige dage.
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +194,Please input all required Result Value(s),Indtast alle nødvendige Resultatværdier (r)
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js +137,Accounts Receivable Summary,Debitor Resumé
DocType: POS Closing Voucher,Linked Invoices,Tilknyttede fakturaer
DocType: Loan,Monthly Repayment Amount,Månedlige ydelse Beløb
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html +9,Opening Invoices,Åbning af fakturaer
DocType: Contract,Contract Details,Kontrakt Detaljer
DocType: Employee,Leave Details,Forlad Detaljer
apps/erpnext/erpnext/hr/doctype/employee/employee.py +218,Please set User ID field in an Employee record to set Employee Role,Indstil Bruger-id feltet i en Medarbejder rekord at indstille Medarbejder Rolle
DocType: UOM,UOM Name,Enhedsnavn
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +237,To Address 1,Til adresse 1
DocType: GST HSN Code,HSN Code,HSN kode
apps/erpnext/erpnext/selling/report/sales_person_commission_summary/sales_person_commission_summary.py +87,Contribution Amount,Bidrag Beløb
DocType: Inpatient Record,Patient Encounter,Patient Encounter
DocType: Purchase Invoice,Shipping Address,Leveringsadresse
DocType: Stock Reconciliation,This tool helps you to update or fix the quantity and valuation of stock in the system. It is typically used to synchronise the system values and what actually exists in your warehouses.,Dette værktøj hjælper dig med at opdatere eller fastsætte mængden og værdiansættelse på lager i systemet. Det bruges typisk til at synkronisere systemets værdier og hvad der rent faktisk eksisterer i dine lagre.
DocType: Delivery Note,In Words will be visible once you save the Delivery Note.,"""I ord"" vil være synlig, når du gemmer følgesedlen."
apps/erpnext/erpnext/erpnext_integrations/utils.py +22,Unverified Webhook Data,Uverificerede Webhook-data
DocType: Water Analysis,Container,Beholder
apps/erpnext/erpnext/education/utils.py +50,Student {0} - {1} appears Multiple times in row {2} & {3},Student {0} - {1} forekommer flere gange i træk {2} &amp; {3}
DocType: Item Alternative,Two-way,To-vejs
DocType: Project,Day to Send,Dag til afsendelse
DocType: Healthcare Settings,Manage Sample Collection,Administrer prøveudtagning
DocType: Production Plan,Ignore Existing Ordered Quantity,Ignorer eksisterende bestilt mængde
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +73,Please set the series to be used.,"Indstil den serie, der skal bruges."
DocType: Patient,Tobacco Past Use,Tidligere brug af tobak
DocType: Travel Itinerary,Mode of Travel,Rejsemåden
DocType: Sales Invoice Item,Brand Name,Varemærkenavn
DocType: Purchase Receipt,Transporter Details,Transporter Detaljer
apps/erpnext/erpnext/accounts/page/pos/pos.js +2714,Default warehouse is required for selected item,Standardlageret er påkrævet for den valgte vare
apps/erpnext/erpnext/utilities/user_progress.py +146,Box,Kasse
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1095,Possible Supplier,mulig leverandør
DocType: Budget,Monthly Distribution,Månedlig Distribution
apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +72,Receiver List is empty. Please create Receiver List,Modtager List er tom. Opret Modtager liste
apps/erpnext/erpnext/public/js/setup_wizard.js +31,Healthcare (beta),Sundhedspleje (beta)
DocType: Production Plan Sales Order,Production Plan Sales Order,Produktion Plan kundeordre
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +433,"No active BOM found for item {0}. Delivery by \
						Serial No cannot be ensured",Ingen aktiv BOM fundet for punkt {0}. Levering med \ Serienummer kan ikke sikres
DocType: Sales Partner,Sales Partner Target,Forhandlermål
DocType: Loan Type,Maximum Loan Amount,Maksimalt lånebeløb
DocType: Pricing Rule,Pricing Rule,Prisfastsættelsesregel
apps/erpnext/erpnext/education/doctype/student_group/student_group.py +58,Duplicate roll number for student {0},Dupliceringsrulle nummer for studerende {0}
apps/erpnext/erpnext/config/learn.py +197,Material Request to Purchase Order,Materialeanmodning til indkøbsordre
DocType: Shopping Cart Settings,Payment Success URL,Betaling gennemført URL
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +79,Row # {0}: Returned Item {1} does not exists in {2} {3},Row # {0}: returnerede vare {1} ikke eksisterer i {2} {3}
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +16,Bank Accounts,Bankkonti
,Bank Reconciliation Statement,Bank Saldoopgørelsen
DocType: Patient Encounter,Medical Coding,Medicinsk kodning
DocType: Healthcare Settings,Reminder Message,Påmindelsesmeddelelse
,Lead Name,Emnenavn
,POS,Kassesystem
DocType: C-Form,III,III
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +219,Prospecting,Forundersøgelse
apps/erpnext/erpnext/config/stock.py +317,Opening Stock Balance,Åbning Stock Balance
DocType: Asset Category Account,Capital Work In Progress Account,Capital Work Progress Account
apps/erpnext/erpnext/assets/doctype/asset/asset.js +92,Asset Value Adjustment,Asset Value Adjustment
DocType: Additional Salary,Payroll Date,Lønningsdato
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +58,{0} must appear only once,{0} må kun optræde én gang
apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +59,Leaves Allocated Successfully for {0},Fravær blev succesfuldt tildelt til {0}
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +42,No Items to pack,Ingen varer at pakke
DocType: Shipping Rule Condition,From Value,Fra Value
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +717,Manufacturing Quantity is mandatory,Produktionmængde er obligatorisk
DocType: Loan,Repayment Method,tilbagebetaling Metode
DocType: Products Settings,"If checked, the Home page will be the default Item Group for the website","Hvis markeret, vil hjemmesiden være standard varegruppe til hjemmesiden"
DocType: Quality Inspection Reading,Reading 4,Reading 4
apps/erpnext/erpnext/utilities/activation.py +118,"Students are at the heart of the system, add all your students","Studerende er i hjertet af systemet, tilføje alle dine elever"
apps/erpnext/erpnext/non_profit/report/expiring_memberships/expiring_memberships.py +16,Member ID,Medlems ID
DocType: Employee Tax Exemption Proof Submission,Monthly Eligible Amount,Månedlig støtteberettiget beløb
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +97,Row #{0}: Clearance date {1} cannot be before Cheque Date {2},Anvendes ikke {0} {1} {2}
DocType: Asset Maintenance Task,Certificate Required,Certifikat er påkrævet
DocType: Company,Default Holiday List,Standard helligdagskalender
DocType: Pricing Rule,Supplier Group,Leverandørgruppe
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +61,{0} Digest,{0} Digest
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +163,Row {0}: From Time and To Time of {1} is overlapping with {2},Række {0}: Fra tid og til tid af {1} overlapper med {2}
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +152,Stock Liabilities,Stock Passiver
DocType: Purchase Invoice,Supplier Warehouse,Leverandør Warehouse
DocType: Opportunity,Contact Mobile No,Kontakt mobiltelefonnr.
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +53,Select Company,Vælg firma
,Material Requests for which Supplier Quotations are not created,Materialeanmodninger under hvilke leverandørtilbud ikke er oprettet
DocType: Student Report Generation Tool,Print Section,Udskrivningsafsnit
DocType: Staffing Plan Detail,Estimated Cost Per Position,Anslået pris pr. Position
DocType: Employee,HR-EMP-,HR-EMP-
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +34,User {0} doesn't have any default POS Profile. Check Default at Row {1} for this User.,Bruger {0} har ingen standard POS-profil. Tjek standard i række {1} for denne bruger.
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +166,Employee Referral,Medarbejder Henvisning
DocType: Student Group,Set 0 for no limit,Sæt 0 for ingen grænse
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +191,The day(s) on which you are applying for leave are holidays. You need not apply for leave.,"Den dag (e), som du ansøger om orlov er helligdage. Du har brug for ikke søge om orlov."
DocType: Customer,Primary Address and Contact Detail,Primæradresse og kontaktdetaljer
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +21,Resend Payment Email,Gensend Betaling E-mail
apps/erpnext/erpnext/templates/pages/projects.html +27,New task,Ny opgave
DocType: Clinical Procedure,Appointment,Aftale
apps/erpnext/erpnext/utilities/activation.py +74,Make Quotation,Opret tilbud
apps/erpnext/erpnext/config/education.py +230,Other Reports,Andre rapporter
apps/erpnext/erpnext/public/js/setup_wizard.js +39,Please select at least one domain.,Vælg mindst et domæne.
DocType: Dependent Task,Dependent Task,Afhængig opgave
DocType: Shopify Settings,Shopify Tax Account,Shopify Skatkonto
apps/erpnext/erpnext/stock/doctype/item/item.py +475,Conversion factor for default Unit of Measure must be 1 in row {0},Omregningsfaktor for standard Måleenhed skal være 1 i række {0}
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +257,Leave of type {0} cannot be longer than {1},Fravær af typen {0} må ikke vare længere end {1}
DocType: Delivery Trip,Optimize Route,Optimer ruten
DocType: Manufacturing Settings,Try planning operations for X days in advance.,Prøv at planlægge operationer for X dage i forvejen.
apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.py +90,"{0} vacancies and {1} budget for {2} already planned for subsidiary companies of {3}. \
				You can only plan for upto {4} vacancies and and budget {5} as per staffing plan {6} for parent company {3}.","{0} ledige stillinger og {1} budget for {2}, der allerede er planlagt til datterselskaber af {3}. \ Du kan kun planlægge op til {4} ledige stillinger og og budget {5} i henhold til personaleplan {6} for moderselskabet {3}."
DocType: HR Settings,Stop Birthday Reminders,Stop Fødselsdag Påmindelser
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +207,Please set Default Payroll Payable Account in Company {0},Venligst sæt Standard Payroll Betales konto i Company {0}
DocType: Amazon MWS Settings,Get financial breakup of Taxes and charges data by Amazon ,Få økonomisk opsplitning af skatter og afgifter data fra Amazon
DocType: SMS Center,Receiver List,Modtageroversigt
apps/erpnext/erpnext/accounts/page/pos/pos.js +1108,Search Item,Søg Vare
DocType: Payment Schedule,Payment Amount,Betaling Beløb
apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py +20,Half Day Date should be in between Work From Date and Work End Date,Halvdagsdato skal være mellem arbejde fra dato og arbejdsdato
DocType: Healthcare Settings,Healthcare Service Items,Sundhedsydelser
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +47,Consumed Amount,Forbrugt Mængde
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +69,Net Change in Cash,Nettoændring i kontanter
DocType: Assessment Plan,Grading Scale,karakterbekendtgørelsen
apps/erpnext/erpnext/stock/doctype/item/item.py +469,Unit of Measure {0} has been entered more than once in Conversion Factor Table,Måleenhed {0} er indtastet mere end én gang i Conversion Factor Table
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +617,Already completed,Allerede afsluttet
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +34,Stock In Hand,Stock i hånden
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py +68,"Please add the remaining benefits {0} to the application as \
				pro-rata component",Tilføj venligst de resterende fordele {0} til applikationen som \ pro-rata-komponent
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +64,Import Successful!,Import vellykket!
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +35,Payment Request already exists {0},Betalingsanmodning findes allerede {0}
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +27,Cost of Issued Items,Omkostninger ved Udstedte Varer
DocType: Healthcare Practitioner,Hospital,Sygehus
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +534,Quantity must not be more than {0},Antal må ikke være mere end {0}
DocType: Travel Request Costing,Funded Amount,Finansieret beløb
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +120,Previous Financial Year is not closed,Foregående regnskabsår er ikke lukket
DocType: Practitioner Schedule,Practitioner Schedule,Practitioner Schedule
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +69,Age (Days),Alder (dage)
DocType: Instructor,EDU-INS-.YYYY.-,EDU-INS-.YYYY.-
DocType: Additional Salary,Additional Salary,Yderligere løn
DocType: Quotation Item,Quotation Item,Tilbudt vare
DocType: Customer,Customer POS Id,Kundens POS-id
DocType: Account,Account Name,Kontonavn
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +536,From Date cannot be greater than To Date,Fra dato ikke kan være større end til dato
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +203,Serial No {0} quantity {1} cannot be a fraction,Serienummer {0} mængde {1} kan ikke være en brøkdel
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.py +96,Please enter Woocommerce Server URL,Indtast venligst Woocommerce Server URL
DocType: Purchase Order Item,Supplier Part Number,Leverandør Part Number
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +137,Conversion rate cannot be 0 or 1,Omregningskurs kan ikke være 0 eller 1
DocType: Share Balance,To No,Til nr
apps/erpnext/erpnext/hr/doctype/employee_onboarding/employee_onboarding.py +27,All the mandatory Task for employee creation hasn't been done yet.,Al den obligatoriske opgave for medarbejderskabelse er endnu ikke blevet udført.
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +227,{0} {1} is cancelled or stopped,{0} {1} er aflyst eller stoppet
DocType: Accounts Settings,Credit Controller,Credit Controller
DocType: Loan,Applicant Type,Ansøgers Type
DocType: Purchase Invoice,03-Deficiency in services,03-mangel på tjenesteydelser
DocType: Healthcare Settings,Default Medical Code Standard,Standard Medical Code Standard
DocType: Purchase Invoice Item,HSN/SAC,HSN / SAC
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +267,Purchase Receipt {0} is not submitted,Købskvittering {0} er ikke godkendt
DocType: Company,Default Payable Account,Standard Betales konto
apps/erpnext/erpnext/config/website.py +17,"Settings for online shopping cart such as shipping rules, price list etc.","Indstillinger for online indkøbskurv, såsom forsendelsesregler, prisliste mv."
DocType: Purchase Receipt,MAT-PRE-.YYYY.-,MAT-PRE-.YYYY.-
apps/erpnext/erpnext/controllers/website_list_for_contact.py +113,{0}% Billed,{0}% Faktureret
apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +73,Reserved Qty,Reserveret mængde
DocType: Party Account,Party Account,Party Account
apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.py +142,Please select Company and Designation,Vælg venligst Firma og Betegnelse
apps/erpnext/erpnext/config/setup.py +116,Human Resources,Medarbejdere
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +216,Upper Income,Upper Indkomst
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +17,Reject,Afvise
DocType: Journal Entry Account,Debit in Company Currency,Debet (firmavaluta)
DocType: BOM Item,BOM Item,Styklistevarer
DocType: Appraisal,For Employee,Til medarbejder
DocType: Vital Signs,Full,Fuld
apps/erpnext/erpnext/hr/doctype/loan/loan.js +69,Make Disbursement Entry,Make Udbetaling indtastning
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +170,Row {0}: Advance against Supplier must be debit,Række {0}: Advance mod Leverandøren skal debitere
DocType: Company,Default Values,Standardværdier
DocType: Certification Application,INR,INR
DocType: Expense Claim,Total Amount Reimbursed,Samlede godtgjorte beløb
apps/erpnext/erpnext/hr/doctype/vehicle/vehicle_dashboard.py +5,This is based on logs against this Vehicle. See timeline below for details,Dette er baseret på kørebogen for køretøjet. Se tidslinje nedenfor for detaljer
apps/erpnext/erpnext/hr/doctype/additional_salary/additional_salary.py +21,Payroll date can not be less than employee's joining date,Lønningsdato kan ikke være mindre end medarbejderens tilmeldingsdato
apps/erpnext/erpnext/accounts/doctype/payment_order/payment_order.py +87,{0} {1} created,{0} {1} oprettet
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +46,"Job Openings for designation {0} already open \
					or hiring completed as per Staffing Plan {1}",Jobåbninger til betegnelse {0} allerede åben \ eller ansættelse afsluttet som pr. Personaleplan {1}
DocType: Vital Signs,Constipated,forstoppet
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +118,Against Supplier Invoice {0} dated {1},Imod Leverandør Faktura {0} dateret {1}
DocType: Customer,Default Price List,Standardprisliste
apps/erpnext/erpnext/assets/doctype/asset/asset.py +492,Asset Movement record {0} created,Asset Movement rekord {0} skabt
apps/erpnext/erpnext/utilities/page/leaderboard/leaderboard.js +175,No items found.,Ingen emner fundet.
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +51,You cannot delete Fiscal Year {0}. Fiscal Year {0} is set as default in Global Settings,Du kan ikke slette Fiscal År {0}. Regnskabsår {0} er indstillet som standard i Globale indstillinger
DocType: Share Transfer,Equity/Liability Account,Egenkapital / Ansvarskonto
apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.py +20,A customer with the same name already exists,En kunde med samme navn eksisterer allerede
DocType: Contract,Inactive,inaktive
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +224,This will submit Salary Slips and create accrual Journal Entry. Do you want to proceed?,Dette vil indgive Lønningslister og skabe periodiseringsjournalindtastning. Vil du fortsætte?
DocType: Purchase Invoice,Total Net Weight,Samlet nettovægt
DocType: Purchase Order,Order Confirmation No,Bekræftelsesbekendtgørelse nr
DocType: Purchase Invoice,Eligibility For ITC,Støtteberettigelse til ITC
DocType: Student Applicant,EDU-APP-.YYYY.-,EDU-APP-.YYYY.-
DocType: Journal Entry,Entry Type,Posttype
,Customer Credit Balance,Customer Credit Balance
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +82,Net Change in Accounts Payable,Netto Ændring i Kreditor
apps/erpnext/erpnext/selling/doctype/customer/customer.py +257,Credit limit has been crossed for customer {0} ({1}/{2}),Kreditgrænsen er overskredet for kunden {0} ({1} / {2})
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +42,Customer required for 'Customerwise Discount',Kunden kræves for &#39;Customerwise Discount&#39;
apps/erpnext/erpnext/config/accounts.py +136,Update bank payment dates with journals.,Opdatér bankbetalingsdatoerne med kladderne.
apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +26,Pricing,Priser
DocType: Quotation,Term Details,Betingelsesdetaljer
DocType: Employee Incentive,Employee Incentive,Medarbejderincitamenter
apps/erpnext/erpnext/education/doctype/student_group/student_group.py +30,Cannot enroll more than {0} students for this student group.,Kan ikke tilmelde mere end {0} studerende til denne elevgruppe.
apps/erpnext/erpnext/templates/print_formats/includes/total.html +4,Total (Without Tax),I alt (uden skat)
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +17,Lead Count,Lead Count
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +42,Stock Available,Lager til rådighed
DocType: Manufacturing Settings,Capacity Planning For (Days),Kapacitet Planlægning For (dage)
apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py +10,Procurement,Indkøb
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +67,None of the items have any change in quantity or value.,Ingen af varerne har nogen ændring i mængde eller værdi.
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +22,Mandatory field - Program,Obligatorisk felt - Program
DocType: Special Test Template,Result Component,Resultat Komponent
apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.js +46,Warranty Claim,Garantikrav
,Lead Details,Emnedetaljer
DocType: Volunteer,Availability and Skills,Tilgængelighed og færdigheder
DocType: Salary Slip,Loan repayment,Tilbagebetaling af lån
DocType: Share Transfer,Asset Account,Aktivkonto
DocType: Purchase Invoice,End date of current invoice's period,Slutdato for aktuelle faktura menstruation
DocType: Pricing Rule,Applicable For,Gældende For
DocType: Lab Test,Technician Name,Tekniker navn
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +425,"Cannot ensure delivery by Serial No as \
					Item {0} is added with and without Ensure Delivery by \
					Serial No.",Kan ikke sikre levering med serienummer som \ Item {0} tilføjes med og uden Sikre Levering med \ Serienr.
DocType: Accounts Settings,Unlink Payment on Cancellation of Invoice,Fjern link Betaling ved Annullering af faktura
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +16,Current Odometer reading entered should be greater than initial Vehicle Odometer {0},Aktuel kilometerstand indtastet bør være større end Køretøjets indledende kilometerstand {0}
DocType: Restaurant Reservation,No Show,Ingen Vis
DocType: Shipping Rule Country,Shipping Rule Country,Forsendelsesregelland
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +10,Leave and Attendance,Fravær og fremmøde
DocType: Asset,Comprehensive Insurance,Omfattende Forsikring
DocType: Maintenance Visit,Partially Completed,Delvist afsluttet
apps/erpnext/erpnext/selling/doctype/customer/customer.js +118,Loyalty Point: {0},Loyalitetspunkt: {0}
apps/erpnext/erpnext/public/js/event.js +15,Add Leads,Tilføj Leads
apps/erpnext/erpnext/healthcare/setup.py +189,Moderate Sensitivity,Moderat følsomhed
DocType: Leave Type,Include holidays within leaves as leaves,Medtag helligdage indenfor fraværsperioden som fravær
DocType: Loyalty Program,Redemption,Frelse
DocType: Sales Invoice,Packed Items,Pakkede varer
DocType: Tax Withholding Category,Tax Withholding Rates,Skat tilbageholdelsessatser
DocType: Contract,Contract Period,Kontraktperiode
apps/erpnext/erpnext/config/support.py +27,Warranty Claim against Serial No.,Garantikrav mod serienummer
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +237,'Total','I alt'
DocType: Employee,Permanent Address,Permanent adresse
DocType: Loyalty Program,Collection Tier,Collection Tier
apps/erpnext/erpnext/hr/utils.py +156,From date can not be less than employee's joining date,Fra datoen kan ikke være mindre end medarbejderens tilmeldingsdato
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +292,"Advance paid against {0} {1} cannot be greater \
						than Grand Total {2}",Forskud mod {0} {1} kan ikke være større \ end Grand alt {2}
DocType: Patient,Medication,Medicin
DocType: Production Plan,Include Non Stock Items,Inkluder ikke-lagerartikler
DocType: Project Update,Challenging/Slow,Udfordrende / Slow
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +147,Please select item code,Vælg Varenr.
DocType: Student Sibling,Studying in Same Institute,At studere i samme institut
DocType: Leave Type,Earned Leave,Tjenet forladt
DocType: Employee,Salary Details,Løn Detaljer
DocType: Territory,Territory Manager,Områdechef
DocType: Packed Item,To Warehouse (Optional),Til lager (valgfrit)
DocType: GST Settings,GST Accounts,GST-konti
DocType: Payment Entry,Paid Amount (Company Currency),Betalt beløb (firmavaluta)
DocType: Purchase Invoice,Additional Discount,Ekstra rabat
DocType: Selling Settings,Selling Settings,Salgsindstillinger
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +39,Online Auctions,Online Auktioner
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +101,Please specify either Quantity or Valuation Rate or both,Angiv venligst enten mængde eller værdiansættelsebeløb eller begge
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order_dashboard.py +18,Fulfillment,Opfyldelse
apps/erpnext/erpnext/templates/generators/item.html +101,View in Cart,Se i indkøbskurven
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +110,Marketing Expenses,Markedsføringsomkostninger
,Item Shortage Report,Item Mangel Rapport
apps/erpnext/erpnext/education/doctype/assessment_criteria/assessment_criteria.py +15,Can't create standard criteria. Please rename the criteria,Kan ikke oprette standard kriterier. Venligst omdøber kriterierne
apps/erpnext/erpnext/stock/doctype/item/item.js +366,"Weight is mentioned,\nPlease mention ""Weight UOM"" too","Vægt er nævnt, \ nVenligst nævne &quot;Weight UOM&quot; for"
DocType: Stock Entry Detail,Material Request used to make this Stock Entry,Materialeanmodning brugt til denne lagerpost
DocType: Hub User,Hub Password,Nav adgangskode
DocType: Student Group Creation Tool,Separate course based Group for every Batch,Separat kursusbaseret gruppe for hver batch
apps/erpnext/erpnext/config/support.py +32,Single unit of an Item.,Enkelt enhed af et element.
DocType: Fee Category,Fee Category,Gebyr Kategori
DocType: Agriculture Task,Next Business Day,Næste forretningsdag
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html +3,Allocated Leaves,Tildelte blade
DocType: Drug Prescription,Dosage by time interval,Dosering efter tidsinterval
DocType: Cash Flow Mapper,Section Header,Sektion Header
,Student Fee Collection,Student afgiftsopkrævning
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js +24,Appointment Duration (mins),Aftale Varighed (minutter)
DocType: Accounts Settings,Make Accounting Entry For Every Stock Movement,Lav Regnskab indtastning For hver Stock Movement
DocType: Leave Allocation,Total Leaves Allocated,Tildelt fravær i alt
apps/erpnext/erpnext/public/js/setup_wizard.js +178,Please enter valid Financial Year Start and End Dates,Indtast venligst det gyldige regnskabsårs start- og slutdatoer
DocType: Employee,Date Of Retirement,Dato for pensionering
DocType: Upload Attendance,Get Template,Hent skabelon
,Sales Person Commission Summary,Salgs personkommissionsoversigt
DocType: Additional Salary Component,Additional Salary Component,Yderligere lønkomponent
DocType: Material Request,Transferred,overført
DocType: Vehicle,Doors,Døre
apps/erpnext/erpnext/setup/setup_wizard/operations/defaults_setup.py +118,ERPNext Setup Complete!,ERPNext opsætning er afsluttet !
DocType: Healthcare Settings,Collect Fee for Patient Registration,Indsamle gebyr for patientregistrering
apps/erpnext/erpnext/stock/doctype/item/item.py +737,Cannot change Attributes after stock transaction. Make a new Item and transfer stock to the new Item,Kan ikke ændre attributter efter aktiehandel. Lav en ny vare og overfør lager til den nye vare
DocType: Course Assessment Criteria,Weightage,Vægtning
DocType: Purchase Invoice,Tax Breakup,Skatteafbrydelse
DocType: Employee,Joining Details,Sammenføjning Detaljer
DocType: Member,Non Profit Member,Ikke-profitmedlem
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +67,{0} {1}: Cost Center is required for 'Profit and Loss' account {2}. Please set up a default Cost Center for the Company.,{0} {1}: omkostningssted er påkrævet for resultatopgørelsekonto {2}. Opret venligst et standard omkostningssted for firmaet.
DocType: Payment Schedule,Payment Term,Betalingsbetingelser
apps/erpnext/erpnext/selling/doctype/customer/customer.py +175,A Customer Group exists with same name please change the Customer name or rename the Customer Group,En kundegruppe med samme navn findes. Ret Kundens navn eller omdøb kundegruppen
DocType: Location,Area,Areal
apps/erpnext/erpnext/public/js/templates/contact_list.html +37,New Contact,Ny kontakt
DocType: Company,Company Description,Virksomhedsbeskrivelse
DocType: Territory,Parent Territory,Overordnet område
DocType: Purchase Invoice,Place of Supply,Leveringssted
DocType: Quality Inspection Reading,Reading 2,Reading 2
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py +101,Employee {0} already submited an apllication {1} for the payroll period {2},Medarbejder {0} har allerede indgivet en ansøgning {1} for lønningsperioden {2}
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +891,Material Receipt,Materiale Kvittering
DocType: Bank Statement Transaction Entry,Submit/Reconcile Payments,Indsend / afstem Betalinger
DocType: Campaign,SAL-CAM-.YYYY.-,SAL-CAM-.YYYY.-
DocType: Homepage,Products,Produkter
DocType: Announcement,Instructor,Instruktør
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js +102,Select Item (optional),Vælg emne (valgfrit)
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.py +103,The Loyalty Program isn't valid for the selected company,Loyalitetsprogrammet er ikke gyldigt for det valgte firma
DocType: Fee Schedule Student Group,Fee Schedule Student Group,Fee Schedule Student Group
DocType: Student,AB+,AB +
DocType: Item,"If this item has variants, then it cannot be selected in sales orders etc.","Hvis denne vare har varianter, kan den ikke vælges i salgsordrer mv"
DocType: Lead,Next Contact By,Næste kontakt af
DocType: Compensatory Leave Request,Compensatory Leave Request,Kompenserende Forladelsesanmodning
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +339,Quantity required for Item {0} in row {1},"Mængde, der kræves for Item {0} i række {1}"
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +46,Warehouse {0} can not be deleted as quantity exists for Item {1},"Lager {0} kan ikke slettes, da der eksisterer et antal varer {1} på lageret"
DocType: Blanket Order,Order Type,Bestil Type
,Item-wise Sales Register,Vare-wise Sales Register
DocType: Asset,Gross Purchase Amount,Bruttokøbesum
apps/erpnext/erpnext/utilities/user_progress.py +39,Opening Balances,Åbning af saldi
DocType: Asset,Depreciation Method,Afskrivningsmetode
DocType: Purchase Taxes and Charges,Is this Tax included in Basic Rate?,Er denne Tax inkluderet i Basic Rate?
apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.py +59,Total Target,Samlet Target
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +224,Perception Analysis,Perception Analysis
DocType: Soil Texture,Sand Composition (%),Sandkomposition (%)
DocType: Job Applicant,Applicant for a Job,Ansøger
DocType: Production Plan Material Request,Production Plan Material Request,Produktionsplan-Materialeanmodning
DocType: Purchase Invoice,Release Date,Udgivelses dato
DocType: Stock Reconciliation,Reconciliation JSON,Afstemning JSON
apps/erpnext/erpnext/accounts/report/financial_statements.html +5,Too many columns. Export the report and print it using a spreadsheet application.,For mange kolonner. Udlæs rapporten og udskriv den ved hjælp af et regnearksprogram.
DocType: Purchase Invoice Item,Batch No,Partinr.
DocType: Marketplace Settings,Hub Seller Name,Hub Sælger Navn
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +27,Employee Advances,Medarbejderudviklingen
DocType: Selling Settings,Allow multiple Sales Orders against a Customer's Purchase Order,Tillad flere salgsordrer mod kundens indkøbsordre
DocType: Student Group Instructor,Student Group Instructor,Studentgruppeinstruktør
DocType: Grant Application,Assessment  Mark (Out of 10),Bedømmelsesmærke (ud af 10)
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +61,Guardian2 Mobile No,Formynder 2 mobiltelefonnr.
apps/erpnext/erpnext/setup/doctype/company/company.py +263,Main,Hoved
apps/erpnext/erpnext/controllers/buying_controller.py +774,Following item {0} is not marked as {1} item. You can enable them as {1} item from its Item master,Følgende element {0} er ikke markeret som {1} element. Du kan aktivere dem som {1} element fra dets Item master
apps/erpnext/erpnext/stock/doctype/item/item.js +74,Variant,Variant
apps/erpnext/erpnext/controllers/status_updater.py +163,"For an item {0}, quantity must be negative number",For en vare {0} skal mængden være negativt tal
DocType: Naming Series,Set prefix for numbering series on your transactions,Sæt præfiks for nummerering serie om dine transaktioner
DocType: Employee Attendance Tool,Employees HTML,Medarbejdere HTML
apps/erpnext/erpnext/stock/doctype/item/item.py +489,Default BOM ({0}) must be active for this item or its template,Standard stykliste ({0}) skal være aktiv for denne vare eller dens skabelon
DocType: Employee,Leave Encashed?,Skal fravær udbetales?
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +32,Opportunity From field is mandatory,Salgsmulighed Fra-feltet er obligatorisk
DocType: Email Digest,Annual Expenses,årlige Omkostninger
DocType: Item,Variants,Varianter
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1309,Make Purchase Order,Opret indkøbsordre
DocType: SMS Center,Send To,Send til
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +201,There is not enough leave balance for Leave Type {0},Der er ikke nok dage til rådighed til fraværstype {0}
DocType: Payment Reconciliation Payment,Allocated amount,Tildelte beløb
DocType: Sales Team,Contribution to Net Total,Bidrag til Net Total
DocType: Sales Invoice Item,Customer's Item Code,Kundens varenr.
DocType: Stock Reconciliation,Stock Reconciliation,Lagerafstemning
DocType: Territory,Territory Name,Områdenavn
DocType: Email Digest,Purchase Orders to Receive,Indkøbsordrer til modtagelse
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +197,Work-in-Progress Warehouse is required before Submit,"Work-in-Progress Warehouse er nødvendig, før Indsend"
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +71,You can only have Plans with the same billing cycle in a Subscription,Du kan kun have planer med samme faktureringsperiode i en abonnement
DocType: Bank Statement Transaction Settings Item,Mapped Data,Mappede data
DocType: Purchase Order Item,Warehouse and Reference,Lager og reference
DocType: Payroll Period Date,Payroll Period Date,Lønningsperiode Dato
DocType: Supplier,Statutory info and other general information about your Supplier,Lovpligtig information og andre generelle oplysninger om din leverandør
DocType: Item,Serial Nos and Batches,Serienummer og partier
apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py +42,Student Group Strength,Studentgruppens styrke
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +262,Against Journal Entry {0} does not have any unmatched {1} entry,Mod Kassekladde {0} har ikke nogen uovertruffen {1} indgang
apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.py +113,"Subsidiary companies have already planned for {1} vacancies at a budget of {2}. \
				Staffing Plan for {0} should allocate more vacancies and budget for {3} than planned for its subsidiary companies",Datterselskaber har allerede planlagt for {1} ledige stillinger på et budget på {2}. \ Staffing Plan for {0} bør afsætte flere ledige stillinger og budget til {3} end planlagt for dets datterselskaber
apps/erpnext/erpnext/config/hr.py +166,Appraisals,Medarbejdervurderinger
apps/erpnext/erpnext/hr/doctype/training_program/training_program_dashboard.py +8,Training Events,Træningsarrangementer
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +210,Duplicate Serial No entered for Item {0},Doppelte serienumre er indtastet for vare {0}
apps/erpnext/erpnext/config/selling.py +179,Track Leads by Lead Source.,Sporledninger af blykilde.
DocType: Shipping Rule Condition,A condition for a Shipping Rule,Betingelse for en forsendelsesregel
apps/erpnext/erpnext/hr/doctype/employee/employee.py +182,Please enter ,Kom ind
apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js +64,Maintenance Log,Vedligeholdelseslog
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +256,Please set filter based on Item or Warehouse,Indstil filter baseret på Item eller Warehouse
DocType: Packing Slip,The net weight of this package. (calculated automatically as sum of net weight of items),Nettovægten af denne pakke. (Beregnes automatisk som summen af nettovægt på poster)
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +43,Make Inter Company Journal Entry,Lav Inter Company Journal Entry
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +901,Discount amount cannot be greater than 100%,Rabatbeløb kan ikke være større end 100%
DocType: Opportunity,CRM-OPP-.YYYY.-,CRM-OPP-.YYYY.-
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +26,"Number of new Cost Center, it will be included in the cost center name as a prefix","Antal nye Omkostningscenter, det vil blive inkluderet i priscenternavnet som et præfiks"
DocType: Sales Order,To Deliver and Bill,At levere og Bill
DocType: Student Group,Instructors,Instruktører
DocType: GL Entry,Credit Amount in Account Currency,Credit Beløb i Konto Valuta
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +631,BOM {0} must be submitted,Stykliste {0} skal godkendes
apps/erpnext/erpnext/config/accounts.py +429,Share Management,Aktieforvaltning
DocType: Authorization Control,Authorization Control,Authorization Kontrol
apps/erpnext/erpnext/controllers/buying_controller.py +416,Row #{0}: Rejected Warehouse is mandatory against rejected Item {1},Række # {0}: Afvist Warehouse er obligatorisk mod afvist element {1}
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +887,Payment,Betaling
apps/erpnext/erpnext/controllers/stock_controller.py +96,"Warehouse {0} is not linked to any account, please mention the account in  the warehouse record or set default inventory account in company {1}.","Lager {0} er ikke knyttet til nogen konto, angiv venligst kontoen i lagerplaceringen eller angiv standard lagerkonto i firma {1}."
apps/erpnext/erpnext/utilities/activation.py +81,Manage your orders,Administrér dine ordrer
DocType: Work Order Operation,Actual Time and Cost,Aktuel leveringstid og omkostninger
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +57,Material Request of maximum {0} can be made for Item {1} against Sales Order {2},Materialeanmodning af maksimum {0} kan oprettes for vare {1} mod salgsordre {2}
DocType: Amazon MWS Settings,DE,DE
DocType: Crop,Crop Spacing,Beskæringsafstand
DocType: Course,Course Abbreviation,Kursusforkortelse
DocType: Budget,Action if Annual Budget Exceeded on PO,Handling hvis årligt budget oversteg på PO
DocType: Student Leave Application,Student Leave Application,Student Leave Application
DocType: Item,Will also apply for variants,Vil også gælde for varianter
apps/erpnext/erpnext/assets/doctype/asset/asset.py +297,"Asset cannot be cancelled, as it is already {0}","Asset kan ikke annulleres, da det allerede er {0}"
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +31,Employee {0} on Half day on {1},Medarbejder {0} på halv tid den {1}
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +59,Total working hours should not be greater than max working hours {0},Arbejdstid i alt bør ikke være større end maksimal arbejdstid {0}
apps/erpnext/erpnext/templates/pages/task_info.html +90,On,På
apps/erpnext/erpnext/config/selling.py +62,Bundle items at time of sale.,Bundle elementer på salgstidspunktet.
DocType: Delivery Settings,Dispatch Settings,Dispatch Settings
DocType: Material Request Plan Item,Actual Qty,Faktiske Antal
DocType: Sales Invoice Item,References,Referencer
DocType: Quality Inspection Reading,Reading 10,Reading 10
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +48,Serial nos {0} does not belongs to the location {1},Serienummer {0} tilhører ikke placeringen {1}
DocType: Item,Barcodes,Stregkoder
DocType: Hub Tracked Item,Hub Node,Hub Node
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +78,You have entered duplicate items. Please rectify and try again.,"Du har indtastet dubletter. Venligst rette, og prøv igen."
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +92,Associate,Associate
DocType: Asset Movement,Asset Movement,Asset Movement
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +605,Work Order {0} must be submitted,Arbejdsordre {0} skal indsendes
apps/erpnext/erpnext/accounts/page/pos/pos.js +2227,New Cart,Ny kurv
DocType: Taxable Salary Slab,From Amount,Fra beløb
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +44,Item {0} is not a serialized Item,Vare {0} er ikke en serienummervare
DocType: Leave Type,Encashment,indløsning
DocType: Delivery Settings,Delivery Settings,Leveringsindstillinger
apps/erpnext/erpnext/erpnext_integrations/doctype/quickbooks_migrator/quickbooks_migrator.js +50,Fetch Data,Hent data
apps/erpnext/erpnext/hr/doctype/leave_policy/leave_policy.py +16,Maximum leave allowed in the leave type {0} is {1},Maksimal tilladelse tilladt i orlovstypen {0} er {1}
DocType: SMS Center,Create Receiver List,Opret Modtager liste
apps/erpnext/erpnext/assets/doctype/asset/asset.py +98,Available-for-use Date should be after purchase date,Tilgængelig til brug Dato bør være efter købsdato
DocType: Vehicle,Wheels,Hjul
DocType: Packing Slip,To Package No.,Til pakkenr.
DocType: Patient Relation,Family,Familie
DocType: Sales Invoice Item,Deferred Revenue Account,Udskudt indtjeningskonto
DocType: Production Plan,Material Requests,Materialeanmodninger
DocType: Warranty Claim,Issue Date,Udstedelsesdagen
DocType: Activity Cost,Activity Cost,Aktivitetsomkostninger
DocType: Sales Invoice Timesheet,Timesheet Detail,Timeseddel Detaljer
DocType: Purchase Receipt Item Supplied,Consumed Qty,Forbrugt Antal
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +52,Telecommunications,Telekommunikation
apps/erpnext/erpnext/accounts/party.py +292,Billing currency must be equal to either default company's currency or party account currency,Faktureringsvaluta skal være lig med enten standardfirmaets valuta eller part konto konto valuta
DocType: Packing Slip,Indicates that the package is a part of this delivery (Only Draft),"Angiver, at pakken er en del af denne leverance (Kun udkast)"
DocType: Soil Texture,Loam,lerjord
apps/erpnext/erpnext/controllers/accounts_controller.py +786,Row {0}: Due Date cannot be before posting date,Række {0}: Forfaldsdato kan ikke være før bogføringsdato
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +37,Make Payment Entry,Indtast indbetaling
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +129,Quantity for Item {0} must be less than {1},Mængde for vare {0} skal være mindre end {1}
,Sales Invoice Trends,Salgsfaktura Trends
DocType: Leave Application,Apply / Approve Leaves,Anvend / Godkend fravær
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +180,Can refer row only if the charge type is 'On Previous Row Amount' or 'Previous Row Total',"Kan henvise rækken, hvis gebyret type er &#39;On Forrige Row Beløb &quot;eller&quot; Forrige Row alt&#39;"
DocType: Sales Order Item,Delivery Warehouse,Levering Warehouse
DocType: Leave Type,Earned Leave Frequency,Optjent Levefrekvens
apps/erpnext/erpnext/config/accounts.py +209,Tree of financial Cost Centers.,Tree of finansielle omkostningssteder.
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +151,Sub Type,Undertype
DocType: Serial No,Delivery Document No,Levering dokument nr
DocType: Sales Order Item,Ensure Delivery Based on Produced Serial No,Sørg for levering baseret på produceret serienummer
DocType: Vital Signs,Furry,Furry
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +197,Please set 'Gain/Loss Account on Asset Disposal' in Company {0},"Sæt venligst ""Gevinst/tabskonto vedr. salg af anlægsaktiv"" i firma {0}"
DocType: Landed Cost Voucher,Get Items From Purchase Receipts,Hent varer fra købskvitteringer
DocType: Serial No,Creation Date,Oprettet d.
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +55,Target Location is required for the asset {0},Målplacering er påkrævet for aktivet {0}
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +42,"Selling must be checked, if Applicable For is selected as {0}","Selling skal kontrolleres, om nødvendigt er valgt som {0}"
DocType: Production Plan Material Request,Material Request Date,Materialeanmodningsdato
DocType: Purchase Order Item,Supplier Quotation Item,Leverandør tibudt Varer
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +208,Material Consumption is not set in Manufacturing Settings.,Materialforbrug er ikke angivet i fremstillingsindstillinger.
DocType: Quality Inspection,MAT-QA-.YYYY.-,MAT-QA-.YYYY.-
apps/erpnext/erpnext/templates/pages/help.html +46,Visit the forums,Besøg fora
DocType: Student,Student Mobile Number,Studerende mobiltelefonnr.
DocType: Item,Has Variants,Har Varianter
DocType: Employee Benefit Claim,Claim Benefit For,Claim fordele for
apps/erpnext/erpnext/templates/emails/training_event.html +11,Update Response,Opdater svar
apps/erpnext/erpnext/public/js/utils.js +538,You have already selected items from {0} {1},Du har allerede valgt elementer fra {0} {1}
DocType: Monthly Distribution,Name of the Monthly Distribution,Navnet på den månedlige Distribution
apps/erpnext/erpnext/stock/doctype/batch/batch.py +100,Batch ID is mandatory,Parti-id er obligatorisk
DocType: Sales Person,Parent Sales Person,Parent Sales Person
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +102,No items to be received are overdue,"Ingen emner, der skal modtages, er for sent"
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +101,The seller and the buyer cannot be the same,Sælgeren og køberen kan ikke være det samme
DocType: Project,Collect Progress,Indsamle fremskridt
DocType: Delivery Note,MAT-DN-.YYYY.-,MAT-DN-.YYYY.-
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +24,Select the program first,Vælg programmet først
DocType: Patient Appointment,Patient Age,Patientalder
apps/erpnext/erpnext/config/learn.py +253,Managing Projects,Håndtering af sager
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +229,Serial no {0} has been already returned,Serienummeret {0} er allerede returneret
DocType: Supplier,Supplier of Goods or Services.,Leverandør af varer eller tjenesteydelser.
DocType: Budget,Fiscal Year,Regnskabsår
DocType: Asset Maintenance Log,Planned,planlagt
apps/erpnext/erpnext/hr/utils.py +199,A {0} exists between {1} and {2} (,En {0} eksisterer mellem {1} og {2} (
DocType: Vehicle Log,Fuel Price,Brændstofpris
DocType: Bank Guarantee,Margin Money,Margen penge
DocType: Budget,Budget,Budget
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +83,Set Open,Sæt Åbn
apps/erpnext/erpnext/stock/doctype/item/item.py +287,Fixed Asset Item must be a non-stock item.,Anlægsaktiv-varen skal være en ikke-lagervare.
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +60,"Budget cannot be assigned against {0}, as it's not an Income or Expense account","Budget kan ikke tildeles mod {0}, da det ikke er en indtægt eller omkostning konto"
apps/erpnext/erpnext/hr/utils.py +228,Max exemption amount for {0} is {1},Maks. Fritagelsesbeløb for {0} er {1}
apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.py +51,Achieved,Opnået
DocType: Student Admission,Application Form Route,Ansøgningsskema Route
DocType: Healthcare Settings,Patient Encounters in valid days,Patientmøder i gyldige dage
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +58,Leave Type {0} cannot be allocated since it is leave without pay,"Fraværstype {0} kan ikke fordeles, da den er af typen uden løn"
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +167,Row {0}: Allocated amount {1} must be less than or equals to invoice outstanding amount {2},Række {0}: Allokeret mængde {1} skal være mindre end eller lig med at fakturere udestående beløb {2}
DocType: Sales Invoice,In Words will be visible once you save the Sales Invoice.,"""I ord"" vil være synlig, når du gemmer salgsfakturaen."
DocType: Lead,Follow Up,Opfølgning
DocType: Item,Is Sales Item,Er salgsvare
apps/erpnext/erpnext/setup/doctype/item_group/item_group.js +55,Item Group Tree,Varegruppetræ
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +73,Item {0} is not setup for Serial Nos. Check Item master,Vare {0} er ikke sat op til serienumre. Tjek vare-masteren
DocType: Maintenance Visit,Maintenance Time,Vedligeholdelsestid
,Amount to Deliver,"Beløb, Deliver"
DocType: Asset,Insurance Start Date,Forsikrings Startdato
DocType: Salary Component,Flexible Benefits,Fleksible fordele
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +350,Same item has been entered multiple times. {0},Samme vare er indtastet flere gange. {0}
apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +30,The Term Start Date cannot be earlier than the Year Start Date of the Academic Year to which the term is linked (Academic Year {}). Please correct the dates and try again.,"Betingelsernes startdato kan ikke være tidligere end startdatoen for skoleåret, som udtrykket er forbundet med (Studieår {}). Ret venligst datoerne og prøv igen."
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +201,There were errors.,Der var fejl.
apps/erpnext/erpnext/hr/doctype/shift_request/shift_request.py +68,Employee {0} has already applied for {1} between {2} and {3} : ,Medarbejder {0} har allerede ansøgt om {1} mellem {2} og {3}:
DocType: Guardian,Guardian Interests,Guardian Interesser
apps/erpnext/erpnext/accounts/doctype/account/account.js +45,Update Account Name / Number,Opdater konto navn / nummer
DocType: Naming Series,Current Value,Aktuel værdi
apps/erpnext/erpnext/controllers/accounts_controller.py +331,Multiple fiscal years exist for the date {0}. Please set company in Fiscal Year,Flere regnskabsår findes for den dato {0}. Indstil selskab i regnskabsåret
DocType: Education Settings,Instructor Records to be created by,"Instruktør Records, der skal oprettes af"
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +229,{0} created,{0} oprettet
DocType: GST Account,GST Account,GST-konto
DocType: Delivery Note Item,Against Sales Order,Mod kundeordre
,Serial No Status,Serienummerstatus
DocType: Payment Entry Reference,Outstanding,Udestående
DocType: Supplier,Warn POs,Advarer PO&#39;er
,Daily Timesheet Summary,Daglig Tidsregisteringsoversigt
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +137,"Row {0}: To set {1} periodicity, difference between from and to date \
						must be greater than or equal to {2}","Række {0}: For at indstille {1} periodicitet, skal forskellen mellem fra og til dato \ være større end eller lig med {2}"
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +6,This is based on stock movement. See {0} for details,Dette er baseret på lager bevægelse. Se {0} for detaljer
DocType: Pricing Rule,Selling,Salg
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +394,Amount {0} {1} deducted against {2},Mængden {0} {1} trækkes mod {2}
DocType: Sales Person,Name and Employee ID,Navn og medarbejdernr.
DocType: Website Item Group,Website Item Group,Hjemmeside-varegruppe
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +550,No salary slip found to submit for the above selected criteria OR salary slip already submitted,Ingen lønseddel fundet for at indsende for ovennævnte udvalgte kriterier ELLER lønsliste allerede indsendt
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +160,Duties and Taxes,Skatter og afgifter
DocType: Projects Settings,Projects Settings,Projekter Indstillinger
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +392,Please enter Reference date,Indtast referencedato
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +44,{0} payment entries can not be filtered by {1},{0} betalingsposter ikke kan filtreres med {1}
DocType: Item Website Specification,Table for Item that will be shown in Web Site,"Tabel til Vare, der vil blive vist i Web Site"
DocType: Purchase Order Item Supplied,Supplied Qty,Medfølgende Antal
DocType: Clinical Procedure,HLC-CPR-.YYYY.-,HLC-CPR-.YYYY.-
DocType: Purchase Order Item,Material Request Item,Materialeanmodningsvare
apps/erpnext/erpnext/assets/doctype/asset/asset.py +303,Please cancel Purchase Receipt {0} first,Annuller købs kvittering {0} først
apps/erpnext/erpnext/config/selling.py +75,Tree of Item Groups.,Varegruppetræer
DocType: Production Plan,Total Produced Qty,I alt produceret antal
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +190,Cannot refer row number greater than or equal to current row number for this Charge type,Kan ikke henvise rækken tal større end eller lig med aktuelle række nummer til denne Charge typen
DocType: Asset,Sold,solgt
,Item-wise Purchase History,Vare-wise Købshistorik
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +230,Please click on 'Generate Schedule' to fetch Serial No added for Item {0},"Klik på ""Generer plan"" for at hente serienummeret tilføjet til vare {0}"
DocType: Account,Frozen,Frosne
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +382,Vehicle Type,Køretøjstype
DocType: Sales Invoice Payment,Base Amount (Company Currency),Base Beløb (Company Currency)
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1002,Raw Materials,Råmateriale
DocType: Payment Reconciliation Payment,Reference Row,henvisning Row
DocType: Installation Note,Installation Time,Installation Time
DocType: Sales Invoice,Accounting Details,Regnskabsdetaljer
DocType: Shopify Settings,status html,status html
apps/erpnext/erpnext/setup/doctype/company/company.js +133,Delete all the Transactions for this Company,Slette alle transaktioner for denne Company
DocType: Inpatient Record,O Positive,O Positive
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +72,Investments,Investeringer
DocType: Issue,Resolution Details,Løsningsdetaljer
apps/erpnext/erpnext/accounts/report/tds_payable_monthly/tds_payable_monthly.py +170,Transaction Type,Transaktionstype
DocType: Item Quality Inspection Parameter,Acceptance Criteria,Accept kriterier
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +159,Please enter Material Requests in the above table,Indtast materialeanmodninger i ovenstående tabel
apps/erpnext/erpnext/hr/doctype/loan/loan.py +154,No repayments available for Journal Entry,Ingen tilbagebetalinger til rådighed for Journal Entry
DocType: Hub Tracked Item,Image List,Billedliste
DocType: Item Attribute,Attribute Name,Attribut Navn
DocType: Subscription,Generate Invoice At Beginning Of Period,Generer faktura ved begyndelsen af perioden
DocType: BOM,Show In Website,Vis på hjemmesiden
DocType: Loan Application,Total Payable Amount,Samlet Betales Beløb
DocType: Task,Expected Time (in hours),Forventet tid (i timer)
DocType: Item Reorder,Check in (group),Check i (gruppe)
DocType: Soil Texture,Silt,silt
,Qty to Order,Antal til ordre
DocType: Period Closing Voucher,"The account head under Liability or Equity, in which Profit/Loss will be booked","Kontoen under passiver eller egenkapital, i hviken gevinst/tab vil blive bogført"
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +44,Another Budget record '{0}' already exists against {1} '{2}' and account '{3}' for fiscal year {4},En anden budgetpost &#39;{0}&#39; eksisterer allerede mod {1} &#39;{2}&#39; og konto &#39;{3}&#39; for regnskabsår {4}
apps/erpnext/erpnext/config/projects.py +36,Gantt chart of all tasks.,Gantt-diagram af alle opgaver.
DocType: Opportunity,Mins to First Response,Minutter til første reaktion
DocType: Pricing Rule,Margin Type,Margin Type
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +15,{0} hours,{0} timer
DocType: Course,Default Grading Scale,Standard karakterbekendtgørelsen
DocType: Appraisal,For Employee Name,Til medarbejdernavn
DocType: Holiday List,Clear Table,Ryd tabellen
DocType: Woocommerce Settings,Tax Account,Skatkonto
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +138,Available slots,Tilgængelige slots
DocType: C-Form Invoice Detail,Invoice No,Fakturanr.
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +408,Make Payment,Foretag indbetaling
DocType: Room,Room Name,Værelsesnavn
DocType: Prescription Duration,Prescription Duration,Receptpligtig varighed
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +115,"Leave cannot be applied/cancelled before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}","Fravær kan ikke anvendes/annulleres før {0}, da fraværssaldoen allerede har været carry-fremsendt i fremtiden orlov tildeling rekord {1}"
DocType: Activity Cost,Costing Rate,Costing Rate
apps/erpnext/erpnext/config/selling.py +234,Customer Addresses And Contacts,Kundeadresser og kontakter
,Campaign Efficiency,Kampagneeffektivitet
DocType: Discussion,Discussion,Diskussion
DocType: Payment Entry,Transaction ID,Transaktions-ID
DocType: Payroll Entry,Deduct Tax For Unsubmitted Tax Exemption Proof,Fradragsafgift for ikke-meddelt skattefritagelse bevis
DocType: Volunteer,Anytime,Når som helst
DocType: Bank Account,Bank Account No,Bankkonto nr
DocType: Employee Tax Exemption Proof Submission,Employee Tax Exemption Proof Submission,Beskæftigelse af medarbejderskattefritagelse
DocType: Patient,Surgical History,Kirurgisk historie
DocType: Bank Statement Settings Item,Mapped Header,Mapped Header
DocType: Employee,Resignation Letter Date,Udmeldelse Brev Dato
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +39,Pricing Rules are further filtered based on quantity.,Prisfastsættelsesregler er yderligere filtreret på mængden.
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +417,Please set the Date Of Joining for employee {0},Angiv ansættelsesdatoen for medarbejder {0}
DocType: Inpatient Record,Discharge,udledning
DocType: Task,Total Billing Amount (via Time Sheet),Faktureret beløb i alt (via Tidsregistrering)
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +61,Repeat Customer Revenue,Omsætning gamle kunder
DocType: Soil Texture,Silty Clay Loam,Silty Clay Loam
DocType: Bank Statement Settings,Mapped Items,Mappede elementer
DocType: Amazon MWS Settings,IT,DET
DocType: Chapter,Chapter,Kapitel
apps/erpnext/erpnext/utilities/user_progress.py +146,Pair,Par
DocType: Mode of Payment Account,Default account will be automatically updated in POS Invoice when this mode is selected.,"Standardkontoen opdateres automatisk i POS-faktura, når denne tilstand er valgt."
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1048,Select BOM and Qty for Production,Vælg stykliste og produceret antal
DocType: Asset,Depreciation Schedule,Afskrivninger Schedule
apps/erpnext/erpnext/config/selling.py +124,Sales Partner Addresses And Contacts,Forhandleradresser og kontakter
DocType: Bank Reconciliation Detail,Against Account,Mod konto
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +84,Half Day Date should be between From Date and To Date,Halv Dag Dato skal være mellem Fra dato og Til dato
DocType: Maintenance Schedule Detail,Actual Date,Faktisk dato
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +135,Please set the Default Cost Center in {0} company.,Angiv standardkostningscenteret i {0} firmaet.
DocType: Item,Has Batch No,Har partinr.
DocType: Shopify Webhook Detail,Shopify Webhook Detail,Shopify Webhook Detail
apps/erpnext/erpnext/config/accounts.py +479,Goods and Services Tax (GST India),Varer og tjenesteydelser Skat (GST Indien)
DocType: Delivery Note,Excise Page Number,Excise Sidetal
DocType: Asset,Purchase Date,Købsdato
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js +33,Could not generate Secret,Kunne ikke generere Secret
DocType: Volunteer,Volunteer Type,Frivilligtype
DocType: Payment Request,ACC-PRQ-.YYYY.-,ACC-PRQ-.YYYY.-
DocType: Shift Assignment,Shift Type,Skift type
DocType: Student,Personal Details,Personlige oplysninger
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +199,Please set 'Asset Depreciation Cost Center' in Company {0},Venligst sæt &#39;Asset Afskrivninger Omkostninger Centers i Company {0}
,Maintenance Schedules,Vedligeholdelsesplaner
DocType: Task,Actual End Date (via Time Sheet),Faktisk Slutdato (via Tidsregistreringen)
DocType: Soil Texture,Soil Type,Jordtype
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +389,Amount {0} {1} against {2} {3},Mængden {0} {1} mod {2} {3}
,Quotation Trends,Tilbud trends
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +166,Item Group not mentioned in item master for item {0},Varegruppe ikke er nævnt i vare-masteren for vare {0}
DocType: GoCardless Mandate,GoCardless Mandate,GoCardless Mandat
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +440,Debit To account must be a Receivable account,Debit-Til konto skal være et tilgodehavende konto
DocType: Shipping Rule,Shipping Amount,Forsendelsesmængde
DocType: Supplier Scorecard Period,Period Score,Periode score
apps/erpnext/erpnext/public/js/event.js +19,Add Customers,Tilføj kunder
apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +20,Pending Amount,Afventende beløb
DocType: Lab Test Template,Special,Særlig
DocType: Loyalty Program,Conversion Factor,Konverteringsfaktor
DocType: Purchase Order,Delivered,Leveret
,Vehicle Expenses,Køretøjsudgifter
DocType: Healthcare Settings,Create Lab Test(s) on Sales Invoice Submit,Opret labtest (er) på salgsfaktura Send
DocType: Serial No,Invoice Details,Faktura detaljer
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +72,Please enable Google Maps Settings to estimate and optimize routes,Aktivér Google Maps Indstillinger til at estimere og optimere ruter
DocType: Grant Application,Show on Website,Vis på hjemmesiden
apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +29,Start on,Start på
DocType: Hub Tracked Item,Hub Category,Nav kategori
DocType: Purchase Invoice,SEZ,SEZ
DocType: Purchase Receipt,Vehicle Number,Køretøjsnummer
DocType: Loan,Loan Amount,Lånebeløb
DocType: Student Report Generation Tool,Add Letterhead,Tilføj brevpapir
DocType: Program Enrollment,Self-Driving Vehicle,Selvkørende køretøj
DocType: Supplier Scorecard Standing,Supplier Scorecard Standing,Leverandør Scorecard Standing
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +479,Row {0}: Bill of Materials not found for the Item {1},Række {0}: stykliste ikke fundet for vare {1}
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +112,Total allocated leaves {0} cannot be less than already approved leaves {1} for the period,Samlede fordelte blade {0} kan ikke være mindre end allerede godkendte blade {1} for perioden
DocType: Contract Fulfilment Checklist,Requirement,Krav
DocType: Journal Entry,Accounts Receivable,Tilgodehavender
DocType: Travel Itinerary,Meal Preference,Måltidspræference
,Supplier-Wise Sales Analytics,Salgsanalyser pr. leverandør
DocType: Purchase Invoice,Availed ITC Central Tax,Benyttet ITC Central Tax
DocType: POS Profile,Company Address Name,Virksomhedens adresse navn
DocType: Work Order,Use Multi-Level BOM,Brug Multi-Level BOM
DocType: Bank Reconciliation,Include Reconciled Entries,Medtag Afstemt Angivelser
DocType: Course,"Parent Course (Leave blank, if this isn't part of Parent Course)","Overordnet kursus (markér ikke, hvis dette ikke er en del af et overordnet kursus)"
DocType: Leave Control Panel,Leave blank if considered for all employee types,"Lad feltet stå tomt, hvis det skal gælde for alle medarbejdertyper"
DocType: Landed Cost Voucher,Distribute Charges Based On,Distribuere afgifter baseret på
DocType: Projects Settings,Timesheets,Tidsregistreringskladder
DocType: HR Settings,HR Settings,HR-indstillinger
DocType: Salary Slip,net pay info,nettoløn info
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +334,CESS Amount,CESS-beløb
DocType: Woocommerce Settings,Enable Sync,Aktivér synkronisering
DocType: Tax Withholding Rate,Single Transaction Threshold,Single Transaction Threshold
DocType: Lab Test Template,This value is updated in the Default Sales Price List.,Denne værdi opdateres i standard salgsprislisten.
DocType: Email Digest,New Expenses,Nye udgifter
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +114,PDC/LC Amount,PDC / LC beløb
DocType: Shareholder,Shareholder,Aktionær
DocType: Purchase Invoice,Additional Discount Amount,Ekstra rabatbeløb
DocType: Cash Flow Mapper,Position,Position
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1803,Get Items from Prescriptions,Få artikler fra recepter
DocType: Patient,Patient Details,Patientdetaljer
DocType: Inpatient Record,B Positive,B positiv
apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py +31,"Maximum benefit of employee {0} exceeds {1} by the sum {2} of previous claimed\
			amount",Maksimal fordel for medarbejderen {0} overstiger {1} med summen {2} af tidligere hævdede beløb
apps/erpnext/erpnext/controllers/accounts_controller.py +671,"Row #{0}: Qty must be 1, as item is a fixed asset. Please use separate row for multiple qty.","Række # {0}: Antal skal være én, eftersom varen er et anlægsaktiv. Brug venligst separat række til flere antal."
DocType: Leave Block List Allow,Leave Block List Allow,Tillad blokerede fraværsansøgninger
apps/erpnext/erpnext/setup/doctype/company/company.py +349,Abbr can not be blank or space,Forkortelsen kan ikke være tom eller bestå af mellemrum
DocType: Patient Medical Record,Patient Medical Record,Patient Medical Record
apps/erpnext/erpnext/accounts/doctype/account/account.js +67,Group to Non-Group,Gruppe til ikke-Group
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +50,Sports,Sport
DocType: Loan Type,Loan Name,Lånenavn
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +85,Total Actual,Samlede faktiske
DocType: Student Siblings,Student Siblings,Student Søskende
DocType: Subscription Plan Detail,Subscription Plan Detail,Abonnementsplandetaljer
apps/erpnext/erpnext/utilities/user_progress.py +146,Unit,Enhed
apps/erpnext/erpnext/stock/get_item_details.py +157,Please specify Company,Angiv venligst firma
,Customer Acquisition and Loyalty,Kundetilgang og -loyalitet
DocType: Asset Maintenance Task,Maintenance Task,Vedligeholdelsesopgave
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py +125,Please set B2C Limit in GST Settings.,Indstil venligst B2C-begrænsning i GST-indstillinger.
DocType: Marketplace Settings,Marketplace Settings,Marketplace-indstillinger
DocType: Purchase Invoice,Warehouse where you are maintaining stock of rejected items,"Lager, hvor du vedligeholder lager af afviste varer"
DocType: Work Order,Skip Material Transfer,Spring over overførsel af materiale
apps/erpnext/erpnext/setup/utils.py +112,Unable to find exchange rate for {0} to {1} for key date {2}. Please create a Currency Exchange record manually,Kan ikke finde valutakurs for {0} til {1} for nøgle dato {2}. Opret venligst en valutaudvekslingsoptegnelse manuelt
DocType: POS Profile,Price List,Prisliste
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +22,{0} is now the default Fiscal Year. Please refresh your browser for the change to take effect.,{0} er nu standard regnskabsår. Opdater venligst din browser for at ændringen træder i kraft.
apps/erpnext/erpnext/projects/doctype/task/task.js +45,Expense Claims,Udlæg
DocType: Issue,Support,Support
DocType: Employee Tax Exemption Declaration,Total Exemption Amount,Samlet fritagelsesbeløb
,BOM Search,BOM Søg
DocType: Project,Total Consumed Material Cost  (via Stock Entry),Samlet forbrugt materialeomkostning (via lagerindtastning)
DocType: Subscription,Subscription Period,Abonnementsperiode
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.js +169,To Date cannot be less than From Date,Dato kan ikke være mindre end fra dato
DocType: Item,"Publish ""In Stock"" or ""Not in Stock"" on Hub based on stock available in this warehouse.",Udgiv &quot;På lager&quot; eller &quot;Ikke på lager&quot; på Hub baseret på lager tilgængelig på dette lager.
DocType: Vehicle,Fuel Type,Brændstofstype
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +27,Please specify currency in Company,Angiv venligst valuta i firmaet
DocType: Workstation,Wages per hour,Timeløn
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +47,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},Lagersaldo i parti {0} vil blive negativ {1} for vare {2} på lager {3}
apps/erpnext/erpnext/templates/emails/reorder_item.html +1,Following Material Requests have been raised automatically based on Item's re-order level,Følgende materialeanmodninger er blevet dannet automatisk baseret på varens genbestillelsesniveau
apps/erpnext/erpnext/controllers/accounts_controller.py +376,Account {0} is invalid. Account Currency must be {1},Konto {0} er ugyldig. Konto Valuta skal være {1}
apps/erpnext/erpnext/hr/doctype/salary_structure_assignment/salary_structure_assignment.py +31,From Date {0} cannot be after employee's relieving Date {1},Fra dato {0} kan ikke være efter medarbejderens lindrende dato {1}
DocType: Supplier,Is Internal Supplier,Er intern leverandør
DocType: Employee,Create User Permission,Opret brugertilladelse
DocType: Employee Benefit Claim,Employee Benefit Claim,Ansættelsesfordel
DocType: Healthcare Settings,Remind Before,Påmind før
apps/erpnext/erpnext/buying/utils.py +34,UOM Conversion factor is required in row {0},UOM Omregningsfaktor kræves i række {0}
DocType: Production Plan Item,material_request_item,material_request_item
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1120,"Row #{0}: Reference Document Type must be one of Sales Order, Sales Invoice or Journal Entry","Række # {0}: referencedokumenttype skal være en af følgende: salgsordre, salgsfaktura eller kassekladde"
DocType: Loyalty Program,1 Loyalty Points = How much base currency?,1 Loyalitetspoint = Hvor meget base valuta?
DocType: Salary Component,Deduction,Fradrag
DocType: Item,Retain Sample,Behold prøve
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +121,Row {0}: From Time and To Time is mandatory.,Række {0}: Fra tid og til tid er obligatorisk.
DocType: Stock Reconciliation Item,Amount Difference,Differencebeløb
apps/erpnext/erpnext/stock/get_item_details.py +416,Item Price added for {0} in Price List {1},Varepris tilføjet for {0} i prisliste {1}
DocType: Delivery Stop,Order Information,Ordreinformation
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js +8,Please enter Employee Id of this sales person,Indtast venligst Medarbejder Id dette salg person
DocType: Territory,Classification of Customers by region,Klassifikation af kunder efter region
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +78,In Production,I produktion
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +66,Difference Amount must be zero,Differencebeløb skal være nul
DocType: Project,Gross Margin,Gross Margin
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +74,{0} applicable after {1} working days,{0} gælder efter {1} arbejdsdage
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +60,Please enter Production Item first,Indtast venligst Produktion Vare først
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +45,Calculated Bank Statement balance,Beregnede kontoudskrift balance
DocType: Normal Test Template,Normal Test Template,Normal testskabelon
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +64,disabled user,Deaktiveret bruger
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +970,Quotation,Tilbud
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1041,Cannot set a received RFQ to No Quote,Kan ikke indstille en modtaget RFQ til No Quote
DocType: Salary Slip,Total Deduction,Fradrag i alt
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +22,Select an account to print in account currency,"Vælg en konto, der skal udskrives i kontovaluta"
,Production Analytics,Produktionsanalyser
apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +6,This is based on transactions against this Patient. See timeline below for details,Dette er baseret på transaktioner mod denne patient. Se tidslinjen nedenfor for detaljer
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +218,Cost Updated,Omkostninger opdateret
DocType: Inpatient Record,Date of Birth,Fødselsdato
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +136,Item {0} has already been returned,Element {0} er allerede blevet returneret
DocType: Fiscal Year,**Fiscal Year** represents a Financial Year. All accounting entries and other major transactions are tracked against **Fiscal Year**.,** Regnskabsår ** repræsenterer et regnskabsår. Alle regnskabsposteringer og andre større transaktioner spores mod ** regnskabsår **.
DocType: Opportunity,Customer / Lead Address,Kunde / Emne Adresse
DocType: Supplier Scorecard Period,Supplier Scorecard Setup,Leverandør Scorecard Setup
apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +133,Assessment Plan Name,Evalueringsplan Navn
DocType: Work Order Operation,Work Order Operation,Arbejdsordreoperation
apps/erpnext/erpnext/stock/doctype/item/item.py +262,Warning: Invalid SSL certificate on attachment {0},Advarsel: Ugyldigt SSL-certifikat på vedhæftet fil {0}
apps/erpnext/erpnext/utilities/activation.py +64,"Leads help you get business, add all your contacts and more as your leads","Leads hjælpe dig virksomhed, tilføje alle dine kontakter, og flere som din fører"
DocType: Work Order Operation,Actual Operation Time,Faktiske Operation Time
DocType: Authorization Rule,Applicable To (User),Gælder for (Bruger)
DocType: Purchase Taxes and Charges,Deduct,Fratræk
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +196,Job Description,Stillingsbeskrivelse
DocType: Student Applicant,Applied,Anvendt
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +942,Re-open,Genåbne
DocType: Sales Invoice Item,Qty as per Stock UOM,Mængde pr. lagerenhed
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +59,Guardian2 Name,Guardian2 Navn
DocType: Attendance,Attendance Request,Deltagelse anmodning
DocType: Purchase Invoice,02-Post Sale Discount,02-post salg rabat
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +139,"Special Characters except ""-"", ""#"", ""."" and ""/"" not allowed in naming series","Specialtegn undtagen &quot;-&quot; &quot;.&quot;, &quot;#&quot;, og &quot;/&quot; ikke tilladt i navngivning serie"
DocType: Campaign,"Keep Track of Sales Campaigns. Keep track of Leads, Quotations, Sales Order etc from Campaigns to gauge Return on Investment.","Hold styr på salgskampagner. Hold styr på emner, tilbud, salgsordrer osv fra kampagne til Return on Investment."
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.py +115,You can't redeem Loyalty Points having more value than the Grand Total.,"Du kan ikke indløse loyalitetspoint, der har mere værdi end Grand Total."
DocType: Department Approver,Approver,Godkender
,SO Qty,SO Antal
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +92,The field To Shareholder cannot be blank,Feltet Til Aktionær kan ikke være tomt
DocType: Guardian,Work Address,Arbejdsadresse
DocType: Appraisal,Calculate Total Score,Beregn Total Score
DocType: Employee,Health Insurance,Sygesikring
DocType: Asset Repair,Manufacturing Manager,Produktionschef
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +191,Serial No {0} is under warranty upto {1},Serienummer {0} er under garanti op til {1}
DocType: Plant Analysis Criteria,Minimum Permissible Value,Mindste tilladelige værdi
apps/erpnext/erpnext/education/doctype/guardian/guardian.py +41,User {0} already exists,Bruger {0} eksisterer allerede
apps/erpnext/erpnext/hooks.py +115,Shipments,Forsendelser
DocType: Payment Entry,Total Allocated Amount (Company Currency),Samlet tildelte beløb (Company Currency)
DocType: Purchase Order Item,To be delivered to customer,Der skal leveres til kunden
DocType: BOM,Scrap Material Cost,Skrot materialeomkostninger
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +243,Serial No {0} does not belong to any Warehouse,Serienummer {0} tilhører ikke noget lager
DocType: Grant Application,Email Notification Sent,E-mail-meddelelse sendt
DocType: Purchase Invoice,In Words (Company Currency),I Words (Company Valuta)
apps/erpnext/erpnext/accounts/doctype/bank_account/bank_account.py +24,Company is manadatory for company account,Virksomheden er manadatorisk for virksomhedskonto
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1092,"Item Code, warehouse, quantity are required on row","Varenummer, lager, mængde er påkrævet på række"
DocType: Bank Guarantee,Supplier,Leverandør
apps/erpnext/erpnext/accounts/doctype/payment_order/payment_order.js +9,Get From,Få Fra
apps/erpnext/erpnext/hr/doctype/department/department.js +9,This is a root department and cannot be edited.,Dette er en rodafdeling og kan ikke redigeres.
apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js +41,Show Payment Details,Vis betalingsoplysninger
apps/erpnext/erpnext/crm/report/lead_conversion_time/lead_conversion_time.py +53,Duration in Days,Varighed i dage
DocType: C-Form,Quarter,Kvarter
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +113,Miscellaneous Expenses,Diverse udgifter
DocType: Global Defaults,Default Company,Standardfirma
DocType: Company,Transactions Annual History,Transaktioner Årlig Historie
apps/erpnext/erpnext/controllers/stock_controller.py +231,Expense or Difference account is mandatory for Item {0} as it impacts overall stock value,"Udgifts- eller differencekonto er obligatorisk for vare {0}, da det påvirker den samlede lagerværdi"
DocType: Bank,Bank Name,Bank navn
apps/erpnext/erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.py +78,-Above,-over
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1301,Leave the field empty to make purchase orders for all suppliers,Lad feltet være tomt for at foretage indkøbsordrer for alle leverandører
DocType: Healthcare Practitioner,Inpatient Visit Charge Item,Inpatient Visit Charge Item
DocType: Vital Signs,Fluid,Væske
DocType: Leave Application,Total Leave Days,Totalt antal fraværsdage
DocType: Email Digest,Note: Email will not be sent to disabled users,Bemærk: E-mail vil ikke blive sendt til deaktiverede brugere
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +14,Number of Interaction,Antal interaktioner
apps/erpnext/erpnext/stock/doctype/item/item.js +107,Item Variant Settings,Variantindstillinger
apps/erpnext/erpnext/public/js/account_tree_grid.js +57,Select Company...,Vælg firma ...
DocType: Leave Control Panel,Leave blank if considered for all departments,"Lad feltet stå tomt, hvis det skal gælde for alle afdelinger"
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +506,{0} is mandatory for Item {1},{0} er obligatorisk for vare {1}
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js +149,"Item {0}: {1} qty produced, ","Vare {0}: {1} produceret mængde,"
DocType: Payroll Entry,Fortnightly,Hver 14. dag
DocType: Currency Exchange,From Currency,Fra Valuta
DocType: Vital Signs,Weight (In Kilogram),Vægt (i kilogram)
DocType: Chapter,"chapters/chapter_name
leave blank automatically set after saving chapter.",kapitler / kapitelnavn skal efterlades automatisk automatisk efter opbevaring af kapitel.
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py +218,Please set GST Accounts in GST Settings,Indstil venligst GST-konti i GST-indstillinger
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js +46,Type of Business,Type virksomhed
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +171,"Please select Allocated Amount, Invoice Type and Invoice Number in atleast one row","Vælg tildelte beløb, Faktura Type og Fakturanummer i mindst én række"
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +143,Cost of New Purchase,Udgifter til nye køb
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +98,Sales Order required for Item {0},Salgsordre påkrævet for vare {0}
DocType: Grant Application,Grant Description,Grant Beskrivelse
DocType: Purchase Invoice Item,Rate (Company Currency),Sats (firmavaluta)
DocType: Student Guardian,Others,Andre
DocType: Subscription,Discounts,Rabatter
DocType: Payment Entry,Unallocated Amount,Ufordelt beløb
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +77,Please enable Applicable on Purchase Order and Applicable on Booking Actual Expenses,Aktivér venligst ved købsordre og gældende ved bestilling af faktiske udgifter
apps/erpnext/erpnext/templates/includes/product_page.js +101,Cannot find a matching Item. Please select some other value for {0}.,Kan ikke finde en matchende Item. Vælg en anden værdi for {0}.
DocType: POS Profile,Taxes and Charges,Moms
DocType: Item,"A Product or a Service that is bought, sold or kept in stock.","En vare eller tjenesteydelse, der købes, sælges eller opbevares på lager."
apps/erpnext/erpnext/hr/page/team_updates/team_updates.js +44,No more updates,Ikke flere opdateringer
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +184,Cannot select charge type as 'On Previous Row Amount' or 'On Previous Row Total' for first row,Kan ikke vælge charge type som &#39;On Forrige Row Beløb&#39; eller &#39;On Forrige Row alt &quot;for første række
DocType: Purchase Order,PUR-ORD-.YYYY.-,PUR-ORD-.YYYY.-
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py +6,This covers all scorecards tied to this Setup,Dette dækker alle scorecards knyttet til denne opsætning
apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.py +29,Child Item should not be a Product Bundle. Please remove item `{0}` and save,Underordnet vare bør ikke være en produktpakke. Fjern vare `{0}` og gem
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +12,Banking,Banking
apps/erpnext/erpnext/utilities/activation.py +108,Add Timesheets,Tilføj Tidsregistreringskladder
DocType: Vehicle Service,Service Item,tjenesten Item
DocType: Bank Guarantee,Bank Guarantee,Bank garanti
DocType: Payment Request,Transaction Details,overførselsdetaljer
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +39,Please click on 'Generate Schedule' to get schedule,Klik på &quot;Generer Schedule &#39;for at få tidsplan
DocType: Blanket Order Item,Ordered Quantity,Bestilt antal
apps/erpnext/erpnext/public/js/setup_wizard.js +118,"e.g. ""Build tools for builders""",fx &quot;Byg værktøjer til bygherrer&quot;
DocType: Grading Scale,Grading Scale Intervals,Grading Scale Intervaller
DocType: Item Default,Purchase Defaults,Indkøbsvalg
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +117,Make Job Card,Lav jobkort
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +329,"Could not create Credit Note automatically, please uncheck 'Issue Credit Note' and submit again",Kunne ikke oprette kreditnota automatisk. Fjern venligst afkrydsningsfeltet &quot;Udsted kreditnota&quot; og send igen
apps/erpnext/erpnext/accounts/report/profit_and_loss_statement/profit_and_loss_statement.py +39,Profit for the year,Årets resultat
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +126,{0} {1}: Accounting Entry for {2} can only be made in currency: {3},{0} {1}: Regnskabsføring for {2} kan kun foretages i valuta: {3}
DocType: Fee Schedule,In Process,I Process
DocType: Authorization Rule,Itemwise Discount,Itemwise Discount
apps/erpnext/erpnext/config/accounts.py +53,Tree of financial accounts.,Tree af finansielle konti.
DocType: Bank Guarantee,Reference Document Type,Referencedokument type
DocType: Cash Flow Mapping,Cash Flow Mapping,Cash Flow Mapping
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +400,{0} against Sales Order {1},{0} mod salgsordre {1}
DocType: Account,Fixed Asset,Anlægsaktiv
DocType: Amazon MWS Settings,After Date,Efter dato
apps/erpnext/erpnext/config/stock.py +327,Serialized Inventory,Serienummer-lager
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +1173,Invalid {0} for Inter Company Invoice.,Ugyldig {0} for interfirmafaktura.
,Department Analytics,Afdeling Analytics
apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +74,Email not found in default contact,Email ikke fundet i standardkontakt
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js +23,Generate Secret,Generer Secret
DocType: Loan,Account Info,Kontooplysninger
DocType: Activity Type,Default Billing Rate,Standard-faktureringssats
DocType: Fees,Include Payment,Inkluder betaling
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +77,{0} Student Groups created.,{0} Student gruppe oprettet.
DocType: Sales Invoice,Total Billing Amount,Samlet faktureringsbeløb
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.py +50,Program in the Fee Structure and Student Group {0} are different.,Program i gebyrstrukturen og studentegruppen {0} er forskellige.
DocType: Bank Statement Transaction Entry,Receivable Account,Tilgodehavende konto
apps/erpnext/erpnext/stock/doctype/item_price/item_price.py +31,Valid From Date must be lesser than Valid Upto Date.,Gyldig fra dato skal være mindre end gyldig upto dato.
apps/erpnext/erpnext/controllers/accounts_controller.py +689,Row #{0}: Asset {1} is already {2},Row # {0}: Asset {1} er allerede {2}
DocType: Quotation Item,Stock Balance,Stock Balance
apps/erpnext/erpnext/config/selling.py +327,Sales Order to Payment,Salgsordre til betaling
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +86,CEO,Direktør
DocType: Purchase Invoice,With Payment of Tax,Med betaling af skat
DocType: Expense Claim Detail,Expense Claim Detail,Udlægsdetalje
DocType: Purchase Invoice,TRIPLICATE FOR SUPPLIER,TRIPLIKAT FOR LEVERANDØR
DocType: Exchange Rate Revaluation Account,New Balance In Base Currency,Ny balance i basisvaluta
DocType: Location,Is Container,Er Container
DocType: Crop Cycle,This will be day 1 of the crop cycle,Dette bliver dag 1 i afgrødecyklussen
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +915,Please select correct account,Vælg korrekt konto
DocType: Salary Structure Assignment,Salary Structure Assignment,Lønstrukturstrukturopgave
DocType: Purchase Invoice Item,Weight UOM,Vægtenhed
apps/erpnext/erpnext/config/accounts.py +435,List of available Shareholders with folio numbers,Liste over tilgængelige aktionærer med folio numre
DocType: Salary Structure Employee,Salary Structure Employee,Lønstruktur medarbejder
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.js +62,Show Variant Attributes,Vis variant attributter
DocType: Student,Blood Group,Blood Group
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +48,The payment gateway account in plan {0} is different from the payment gateway account in this payment request,Betalingsgateway-kontoen i plan {0} er forskellig fra betalingsgateway-kontoen i denne betalingsanmodning
DocType: Course,Course Name,Kursusnavn
apps/erpnext/erpnext/accounts/doctype/tax_withholding_category/tax_withholding_category.py +50,No Tax Withholding data found for the current Fiscal Year.,Ingen skat indeholdende data fundet for indeværende regnskabsår.
DocType: Employee Leave Approver,Users who can approve a specific employee's leave applications,"Brugere, der kan godkende en bestemt medarbejders orlov applikationer"
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +53,Office Equipments,Kontorudstyr
DocType: Purchase Invoice Item,Qty,Antal
DocType: Fiscal Year,Companies,Firmaer
DocType: Supplier Scorecard,Scoring Setup,Scoring Setup
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +24,Electronics,Elektronik
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +364,Debit ({0}),Debitering ({0})
DocType: BOM,Allow Same Item Multiple Times,Tillad samme vare flere gange
DocType: Stock Settings,Raise Material Request when stock reaches re-order level,Start materialeanmodningen når lagerbestanden når genbestilningsniveauet
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +76,Full-time,Fuld tid
DocType: Payroll Entry,Employees,Medarbejdere
DocType: Employee,Contact Details,Kontaktoplysninger
DocType: C-Form,Received Date,Modtaget d.
DocType: Delivery Note,"If you have created a standard template in Sales Taxes and Charges Template, select one and click on the button below.","Hvis du har oprettet en standardskabelon under Salg Moms- og afgiftsskabelon, skal du vælge en, og klik på knappen nedenfor."
DocType: BOM Scrap Item,Basic Amount (Company Currency),Grundbeløb (Company Currency)
DocType: Student,Guardians,Guardians
apps/erpnext/erpnext/templates/pages/integrations/gocardless_confirmation.html +13,Payment Confirmation,Betalingsbekræftelse
DocType: Shopping Cart Settings,Prices will not be shown if Price List is not set,"Priserne vil ikke blive vist, hvis prisliste ikke er indstillet"
DocType: Stock Entry,Total Incoming Value,Samlet værdi indgående
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +434,Debit To is required,Debet-til skal angives
DocType: Clinical Procedure,Inpatient Record,Inpatient Record
apps/erpnext/erpnext/utilities/activation.py +109,"Timesheets help keep track of time, cost and billing for activites done by your team","Tidskladder hjælper med at holde styr på tid, omkostninger og fakturering for aktiviteter udført af dit team"
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +41,Purchase Price List,Indkøbsprisliste
apps/erpnext/erpnext/accounts/report/tds_payable_monthly/tds_payable_monthly.py +164,Date of Transaction,Dato for transaktion
apps/erpnext/erpnext/config/buying.py +155,Templates of supplier scorecard variables.,Skabeloner af leverandør scorecard variabler.
DocType: Job Offer Term,Offer Term,Tilbudsbetingelser
DocType: Asset,Quality Manager,Kvalitetschef
DocType: Job Applicant,Job Opening,Rekrutteringssag
DocType: Payment Reconciliation,Payment Reconciliation,Afstemning af betalinger
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +153,Please select Incharge Person's name,Vælg Incharge Person navn
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +51,Technology,Teknologi
DocType: BOM Website Operation,BOM Website Operation,BOM Website Operation
DocType: Bank Statement Transaction Payment Item,outstanding_amount,Utrolig mængde
DocType: Supplier Scorecard,Supplier Score,Leverandør score
apps/erpnext/erpnext/healthcare/doctype/patient_encounter/patient_encounter.js +37,Schedule Admission,Planlægning Adgang
DocType: Tax Withholding Rate,Cumulative Transaction Threshold,Kumulativ transaktionstærskel
apps/erpnext/erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.py +27,Total Invoiced Amt,Samlet faktureret beløb
DocType: Supplier,Warn RFQs,Advar RFQ&#39;er
DocType: BOM,Conversion Rate,Omregningskurs
apps/erpnext/erpnext/templates/pages/product_search.html +3,Product Search,Søg efter vare
DocType: Cashier Closing,To Time,Til Time
apps/erpnext/erpnext/hr/utils.py +202,) for {0},) for {0}
DocType: Authorization Rule,Approving Role (above authorized value),Godkendelse (over autoriserede værdi) Rolle
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +147,Credit To account must be a Payable account,Kredit til konto skal være en Betales konto
DocType: Loan,Total Amount Paid,Samlede beløb betalt
DocType: Asset,Insurance End Date,Forsikrings Slutdato
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +43,Please select Student Admission which is mandatory for the paid student applicant,"Vælg venligst Student Admission, som er obligatorisk for den betalte studentansøger"
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +370,BOM recursion: {0} cannot be parent or child of {2},BOM rekursion: {0} kan ikke være forælder eller barn af {2}
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +40,Budget List,Budgetliste
DocType: Work Order Operation,Completed Qty,Afsluttet Antal
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +180,"For {0}, only debit accounts can be linked against another credit entry",For {0} kan kun betalingskort konti knyttes mod en anden kredit post
DocType: Manufacturing Settings,Allow Overtime,Tillad overarbejde
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +149,"Serialized Item {0} cannot be updated using Stock Reconciliation, please use Stock Entry","Serienummervare {0} kan ikke opdateres ved hjælp af lagerafstemning, brug venligst lagerposter"
DocType: Training Event Employee,Training Event Employee,Træning Begivenhed Medarbejder
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1299,Maximum Samples - {0} can be retained for Batch {1} and Item {2}.,Maksimale prøver - {0} kan beholdes for Batch {1} og Item {2}.
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js +7,Add Time Slots,Tilføj tidspor
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +206,{0} Serial Numbers required for Item {1}. You have provided {2}.,"{0} serienumre, der kræves for vare {1}. Du har angivet {2}."
DocType: Stock Reconciliation Item,Current Valuation Rate,Aktuel Værdiansættelsesbeløb
DocType: Training Event,Advance,Rykke
apps/erpnext/erpnext/config/integrations.py +13,GoCardless payment gateway settings,GoCardless betalings gateway indstillinger
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +129,Exchange Gain/Loss,Exchange Gevinst / Tab
DocType: Opportunity,Lost Reason,Tabsårsag
DocType: Amazon MWS Settings,Enable Amazon,Aktivér Amazon
apps/erpnext/erpnext/controllers/accounts_controller.py +322,Row #{0}: Account {1} does not belong to company {2},Række nr. {0}: Konto {1} tilhører ikke firma {2}
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +30,Unable to find DocType {0},Kunne ikke finde DocType {0}
apps/erpnext/erpnext/public/js/templates/address_list.html +22,New Address,Ny adresse
DocType: Quality Inspection,Sample Size,Sample Size
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +47,Please enter Receipt Document,Indtast Kvittering Dokument
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +412,All items have already been invoiced,Alle varer er allerede blevet faktureret
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +49,Please specify a valid 'From Case No.',Angiv en gyldig &quot;Fra sag nr &#39;
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +24,Further cost centers can be made under Groups but entries can be made against non-Groups,Yderligere omkostninger centre kan foretages under Grupper men indtastninger kan foretages mod ikke-grupper
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +40,Total allocated leaves are more days than maximum allocation of {0} leave type for employee {1} in the period,Samlede tildelte blade er flere dage end maksimal tildeling af {0} ferie type for medarbejder {1} i perioden
apps/erpnext/erpnext/config/setup.py +66,Users and Permissions,Brugere og tilladelser
DocType: Branch,Branch,Filial
DocType: Soil Analysis,Ca/(K+Ca+Mg),Ca / (K + Ca + Mg)
DocType: Delivery Trip,Fulfillment User,Fulfillment User
apps/erpnext/erpnext/config/setup.py +61,Printing and Branding,Udskriving
DocType: Company,Total Monthly Sales,Samlet salg pr. måned
DocType: Payment Request,Subscription Plans,Abonnementsplaner
DocType: Agriculture Analysis Criteria,Weather,Vejr
DocType: Bin,Actual Quantity,Faktiske Mængde
DocType: Shipping Rule,example: Next Day Shipping,eksempel: Næste dages levering
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +187,Serial No {0} not found,Serienummer {0} ikke fundet
DocType: Fee Schedule Program,Fee Schedule Program,Fee Schedule Program
DocType: Fee Schedule Program,Student Batch,Elevgruppe
apps/erpnext/erpnext/utilities/activation.py +119,Make Student,Opret studerende
DocType: Supplier Scorecard Scoring Standing,Min Grade,Min Grade
DocType: Healthcare Service Unit Type,Healthcare Service Unit Type,Sundhedsvæsen Service Type
apps/erpnext/erpnext/projects/doctype/project/project.py +279,You have been invited to collaborate on the project: {0},Du er blevet inviteret til at samarbejde om sag: {0}
DocType: Supplier Group,Parent Supplier Group,Moderselskabets leverandørgruppe
DocType: Email Digest,Purchase Orders to Bill,Købsordrer til Bill
apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.js +54,Accumulated Values in Group Company,Akkumulerede værdier i koncernselskabet
DocType: Leave Block List Date,Block Date,Blokeringsdato
DocType: Crop,Crop,Afgrøde
DocType: Purchase Receipt,Supplier Delivery Note,Leverandør levering Note
apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +70,Apply Now,Ansøg nu
DocType: Employee Tax Exemption Proof Submission Detail,Type of Proof,Type bevis
apps/erpnext/erpnext/stock/dashboard/item_dashboard_list.html +25,Actual Qty {0} / Waiting Qty {1},Faktisk antal {0} / ventende antal {1}
DocType: Purchase Invoice,E-commerce GSTIN,E-handel GSTIN
DocType: Sales Order,Not Delivered,Ikke leveret
,Bank Clearance Summary,Bank Clearance Summary
apps/erpnext/erpnext/config/setup.py +100,"Create and manage daily, weekly and monthly email digests.","Opret og administrér de daglige, ugentlige og månedlige e-mail-nyhedsbreve."
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_dashboard.py +6,This is based on transactions against this Sales Person. See timeline below for details,Dette er baseret på transaktioner mod denne Salgsperson. Se tidslinjen nedenfor for detaljer
DocType: Appraisal Goal,Appraisal Goal,Vurderingsmål
DocType: Stock Reconciliation Item,Current Amount,Det nuværende beløb
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +59,Buildings,Bygninger
apps/erpnext/erpnext/hr/doctype/employee_tax_exemption_declaration/employee_tax_exemption_declaration.py +24,Tax Declaration of {0} for period {1} already submitted.,"Skatteerklæring af {0} for periode {1}, der allerede er indsendt."
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.py +76,Leaves has been granted sucessfully,Blade er blevet givet succesfuldt
DocType: Fee Schedule,Fee Structure,Gebyr struktur
DocType: Timesheet Detail,Costing Amount,Koster Beløb
DocType: Student Admission Program,Application Fee,Tilmeldingsgebyr
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +75,Submit Salary Slip,Godkend lønseddel
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js +13,On Hold,I venteposition
DocType: Account,Inter Company Account,Inter Company Account
apps/erpnext/erpnext/stock/doctype/item_price/item_price.js +17,Import in Bulk,Import i bulk
DocType: Sales Partner,Address & Contacts,Adresse & kontaktpersoner
DocType: SMS Log,Sender Name,Afsendernavn
DocType: Vital Signs,Very Hyper,Meget Hyper
DocType: Agriculture Analysis Criteria,Agriculture Analysis Criteria,Landbrugsanalyse kriterier
DocType: HR Settings,Leave Approval Notification Template,Forlad godkendelsesskabelonen
DocType: POS Profile,[Select],[Vælg]
DocType: Staffing Plan Detail,Number Of Positions,Antal positioner
DocType: Vital Signs,Blood Pressure (diastolic),Blodtryk (diastolisk)
DocType: SMS Log,Sent To,Sendt Til
DocType: Agriculture Task,Holiday Management,Holiday Management
DocType: Payment Request,Make Sales Invoice,Opret salgsfaktura
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +62,Softwares,Softwares
apps/erpnext/erpnext/crm/doctype/lead/lead.py +53,Next Contact Date cannot be in the past,Næste kontakt d. kan ikke være i fortiden
DocType: Company,For Reference Only.,Kun til reference.
apps/erpnext/erpnext/accounts/page/pos/pos.js +2595,Select Batch No,Vælg partinr.
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +80,Invalid {0}: {1},Ugyldig {0}: {1}
,GSTR-1,GSTR-1
DocType: Fee Validity,Reference Inv,Reference Inv
DocType: Sales Invoice Advance,Advance Amount,Advance Beløb
DocType: Manufacturing Settings,Capacity Planning,Kapacitetsplanlægning
DocType: Supplier Quotation,Rounding Adjustment (Company Currency,Afrundingsjustering (Virksomhedsvaluta
DocType: Asset,Policy number,Policenummer
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +43,'From Date' is required,'Fra dato' er nødvendig
DocType: Journal Entry,Reference Number,Referencenummer
DocType: Employee,New Workplace,Ny Arbejdsplads
DocType: Retention Bonus,Retention Bonus,Retention Bonus
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +458,Material Consumption,Materialeforbrug
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +17,Set as Closed,Angiv som Lukket
apps/erpnext/erpnext/stock/get_item_details.py +146,No Item with Barcode {0},Ingen vare med stregkode {0}
DocType: Normal Test Items,Require Result Value,Kræver resultatværdi
DocType: Item,Show a slideshow at the top of the page,Vis et diasshow på toppen af siden
DocType: Tax Withholding Rate,Tax Withholding Rate,Skattefradrag
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +552,Boms,styklister
apps/erpnext/erpnext/stock/doctype/item/item.py +191,Stores,Butikker
DocType: Project Type,Projects Manager,Projekter manager
DocType: Serial No,Delivery Time,Leveringstid
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +15,Ageing Based On,Aldring Baseret på
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +103,Appointment cancelled,Afstemning annulleret
DocType: Item,End of Life,End of Life
apps/erpnext/erpnext/demo/setup/setup_data.py +344,Travel,Rejser
DocType: Student Report Generation Tool,Include All Assessment Group,Inkluder alle vurderingsgrupper
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +266,No active or default Salary Structure found for employee {0} for the given dates,Ingen aktiv eller standard-lønstruktur fundet for medarbejder {0} for de givne datoer
DocType: Leave Block List,Allow Users,Tillad brugere
DocType: Purchase Order,Customer Mobile No,Kunde mobiltelefonnr.
DocType: Cash Flow Mapping Template Details,Cash Flow Mapping Template Details,Cash Flow Mapping Template Detaljer
apps/erpnext/erpnext/config/non_profit.py +68,Loan Management,Lånestyring
DocType: Cost Center,Track separate Income and Expense for product verticals or divisions.,Spor separat indtægter og omkostninger for produkt- vertikaler eller afdelinger.
DocType: Rename Tool,Rename Tool,Omdøb Tool
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +81,Update Cost,Opdatering Omkostninger
DocType: Item Reorder,Item Reorder,Genbestil vare
DocType: Delivery Note,Mode of Transport,Transportform
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +488,Show Salary Slip,Vis lønseddel
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +881,Transfer Material,Transfer Materiale
DocType: Fees,Send Payment Request,Send betalingsanmodning
DocType: BOM,"Specify the operations, operating cost and give a unique Operation no to your operations.","Angiv operationer, driftsomkostninger og giver en unik Operation nej til dine operationer."
DocType: Travel Request,Any other details,Eventuelle andre detaljer
DocType: Water Analysis,Origin,Oprindelse
apps/erpnext/erpnext/controllers/status_updater.py +207,This document is over limit by {0} {1} for item {4}. Are you making another {3} against the same {2}?,Dette dokument er over grænsen ved {0} {1} for vare {4}. Er du gør en anden {3} mod samme {2}?
apps/erpnext/erpnext/public/js/controllers/transaction.js +1288,Please set recurring after saving,Venligst sæt tilbagevendende efter besparelse
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +874,Select change amount account,Vælg ændringsstørrelse konto
DocType: Purchase Invoice,Price List Currency,Prisliste Valuta
DocType: Naming Series,User must always select,Brugeren skal altid vælge
DocType: Stock Settings,Allow Negative Stock,Tillad negativ lagerbeholdning
DocType: Installation Note,Installation Note,Installation Bemærk
DocType: Soil Texture,Clay,Ler
DocType: Topic,Topic,Emne
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +99,Cash Flow from Financing,Pengestrømme fra finansaktiviteter
DocType: Budget Account,Budget Account,Budget-konto
DocType: Quality Inspection,Verified By,Bekræftet af
DocType: Travel Request,Name of Organizer,Navn på arrangør
apps/erpnext/erpnext/setup/doctype/company/company.py +84,"Cannot change company's default currency, because there are existing transactions. Transactions must be cancelled to change the default currency.","Kan ikke ændre virksomhedens standard valuta, fordi den anvendes i eksisterende transaktioner. Transaktioner skal annulleres for at ændre standard valuta."
DocType: Cash Flow Mapping,Is Income Tax Liability,Er indkomstskat ansvar
DocType: Grading Scale Interval,Grade Description,Grade Beskrivelse
DocType: Clinical Procedure,Is Invoiced,Faktureres
DocType: Stock Entry,Purchase Receipt No,Købskvitteringsnr.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +31,Earnest Money,Earnest Money
DocType: Sales Invoice, Shipping Bill Number,Forsendelsesregning nummer
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +34,Traceability,Sporbarhed
DocType: Asset Maintenance Log,Actions performed,Handlinger udført
DocType: Cash Flow Mapper,Section Leader,Sektion Leader
DocType: Delivery Note,Transport Receipt No,Transport kvittering nr
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +144,Source of Funds (Liabilities),Finansieringskilde (Passiver)
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +52,Source and Target Location cannot be same,Kilde og målplacering kan ikke være ens
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +522,Quantity in row {0} ({1}) must be same as manufactured quantity {2},"Antal i række {0} ({1}), skal være det samme som den fremstillede mængde {2}"
DocType: Supplier Scorecard Scoring Standing,Employee,Medarbejder
DocType: Bank Guarantee,Fixed Deposit Number,Fast indbetalingsnummer
DocType: Asset Repair,Failure Date,Fejldato
DocType: Support Search Source,Result Title Field,Resultat Titel Field
DocType: Sample Collection,Collected Time,Samlet tid
DocType: Company,Sales Monthly History,Salg Månedlig historie
DocType: Asset Maintenance Task,Next Due Date,Næste Forfaldsdato
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +242,Select Batch,Vælg Batch
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +276,{0} {1} is fully billed,{0} {1} er fuldt faktureret
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +30,Vital Signs,Vitale tegn
DocType: Payment Entry,Payment Deductions or Loss,Betalings Fradrag eller Tab
DocType: Soil Analysis,Soil Analysis Criterias,Jordanalysekriterier
apps/erpnext/erpnext/config/setup.py +42,Standard contract terms for Sales or Purchase.,Standardkontraktvilkår for Salg eller Indkøb.
DocType: BOM Item,Item operation,Vareoperation
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +56,Group by Voucher,Sortér efter Bilagstype
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +391,Are you sure you want to cancel this appointment?,"Er du sikker på, at du vil annullere denne aftale?"
DocType: Hotel Room Pricing Package,Hotel Room Pricing Package,Hotel værelsesprispakke
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.js +42,Sales Pipeline,Salgspipeline
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +167,Please set default account in Salary Component {0},Angiv standardkonto i lønart {0}
apps/erpnext/erpnext/templates/form_grid/material_request_grid.html +7,Required On,Forfalder den
DocType: Rename Tool,File to Rename,Fil der skal omdøbes
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +200,Please select BOM for Item in Row {0},Vælg BOM for Item i række {0}
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js +13,Fetch Subscription Updates,Hent abonnementsopdateringer
apps/erpnext/erpnext/accounts/doctype/mode_of_payment/mode_of_payment.py +28,Account {0} does not match with Company {1} in Mode of Account: {2},Konto {0} stemmer ikke overens med virksomhed {1} i kontoens tilstand: {2}
apps/erpnext/erpnext/controllers/buying_controller.py +719,Specified BOM {0} does not exist for Item {1},Specificeret stykliste {0} findes ikke for vare {1}
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +301,Course: ,Rute:
DocType: Soil Texture,Sandy Loam,Sandy Loam
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +246,Maintenance Schedule {0} must be cancelled before cancelling this Sales Order,"Vedligeholdelsesplan {0} skal annulleres, før denne salgsordre kan annulleres"
DocType: POS Profile,Applicable for Users,Gælder for brugere
DocType: Supplier Quotation,PUR-SQTN-.YYYY.-,PUR-SQTN-.YYYY.-
DocType: Notification Control,Expense Claim Approved,Udlæg godkendt
DocType: Purchase Invoice,Set Advances and Allocate (FIFO),Indstil Advances and Allocate (FIFO)
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +231,No Work Orders created,Ingen arbejdsordrer er oprettet
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +403,Salary Slip of employee {0} already created for this period,Lønseddel for medarbejder {0} er allerede oprettet for denne periode
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +121,Pharmaceutical,Farmaceutiske
apps/erpnext/erpnext/hr/doctype/leave_encashment/leave_encashment.py +24,You can only submit Leave Encashment for a valid encashment amount,Du kan kun indsende Leave Encashment for en gyldig indsatsbeløb
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26,Cost of Purchased Items,Omkostninger ved Købte varer
DocType: Employee Separation,Employee Separation Template,Medarbejderseparationsskabelon
DocType: Selling Settings,Sales Order Required,Salgsordre påkrævet
apps/erpnext/erpnext/public/js/hub/marketplace.js +106,Become a Seller,Bliv sælger
DocType: Purchase Invoice,Credit To,Credit Til
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +33,Active Leads / Customers,Aktive Emner / Kunder
DocType: Delivery Settings,Leave blank to use the standard Delivery Note format,Forlad blanket for at bruge standardleveringsformatet
DocType: Employee Education,Post Graduate,Post Graduate
DocType: Maintenance Schedule Detail,Maintenance Schedule Detail,Vedligeholdelsesplandetaljer
DocType: Supplier Scorecard,Warn for new Purchase Orders,Advarer om nye indkøbsordrer
DocType: Quality Inspection Reading,Reading 9,Reading 9
DocType: Supplier,Is Frozen,Er Frozen
apps/erpnext/erpnext/stock/utils.py +248,Group node warehouse is not allowed to select for transactions,Gruppe node lager er ikke tilladt at vælge for transaktioner
DocType: Buying Settings,Buying Settings,Indkøbsindstillinger
DocType: Stock Entry Detail,BOM No. for a Finished Good Item,Styklistenr. for en færdigvare
DocType: Upload Attendance,Attendance To Date,Fremmøde tildato
DocType: Request for Quotation Supplier,No Quote,Intet citat
DocType: Support Search Source,Post Title Key,Posttitelnøgle
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +232,For Job Card,Til jobkort
DocType: Warranty Claim,Raised By,Oprettet af
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1556,Prescriptions,Recepter
DocType: Payment Gateway Account,Payment Account,Betalingskonto
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +1112,Please specify Company to proceed,Angiv venligst firma for at fortsætte
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +81,Net Change in Accounts Receivable,Nettoændring i Debitor
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +66,Compensatory Off,Kompenserende Off
DocType: Job Offer,Accepted,Accepteret
DocType: POS Closing Voucher,Sales Invoices Summary,Salgsfakturaoversigt
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +225,To Party Name,Til partenavn
DocType: Grant Application,Organization,Organisation
DocType: BOM Update Tool,BOM Update Tool,BOM Update Tool
DocType: SG Creation Tool Course,Student Group Name,Elevgruppenavn
apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.js +23,Show exploded view,Vis eksploderet visning
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +7,Creating Fees,Oprettelse af gebyrer
apps/erpnext/erpnext/setup/doctype/company/company.js +111,Please make sure you really want to delete all the transactions for this company. Your master data will remain as it is. This action cannot be undone.,"Kontroller, at du virkelig ønsker at slette alle transaktioner for dette selskab. Dine stamdata vil forblive som den er. Denne handling kan ikke fortrydes."
apps/erpnext/erpnext/templates/pages/product_search.html +21,Search Results,Søgeresultater
DocType: Room,Room Number,Værelsesnummer
apps/erpnext/erpnext/utilities/transaction_base.py +112,Invalid reference {0} {1},Ugyldig henvisning {0} {1}
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +187,{0} ({1}) cannot be greater than planned quanitity ({2}) in Production Order {3},{0} ({1}) kan ikke være større end planlagt antal ({2}) på produktionsordre {3}
DocType: Shipping Rule,Shipping Rule Label,Forsendelseregeltekst
DocType: Journal Entry Account,Payroll Entry,Lønning Entry
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +76,View Fees Records,Se Gebyrer Records
apps/erpnext/erpnext/setup/doctype/company/company.js +55,Make Tax Template,Lav skatskabelon
apps/erpnext/erpnext/public/js/conf.js +28,User Forum,Brugerforum
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +333,Raw Materials cannot be blank.,Råmaterialer kan ikke være tom.
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +1029,Row #{0} (Payment Table): Amount must be negative,Row # {0} (Betalingstabel): Beløbet skal være negativt
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +570,"Could not update stock, invoice contains drop shipping item.","Kunne ikke opdatere lager, faktura indeholder drop shipping element."
DocType: Contract,Fulfilment Status,Opfyldelsesstatus
DocType: Lab Test Sample,Lab Test Sample,Lab Test prøve
DocType: Item Variant Settings,Allow Rename Attribute Value,Tillad omdøbe attributværdi
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +533,Quick Journal Entry,Hurtig kassekladde
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +244,You can not change rate if BOM mentioned agianst any item,"Du kan ikke ændre kurs, hvis BOM nævnt agianst ethvert element"
DocType: Restaurant,Invoice Series Prefix,Faktura Serie Prefix
DocType: Employee,Previous Work Experience,Tidligere erhvervserfaring
apps/erpnext/erpnext/accounts/doctype/account/account.js +140,Update Account Number / Name,Opdater konto nummer / navn
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +413,Assign Salary Structure,Tildel lønstrukturen
DocType: Support Settings,Response Key List,Response Key List
DocType: Job Card,For Quantity,For Mængde
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +205,Please enter Planned Qty for Item {0} at row {1},Indtast venligst Planned Antal for Item {0} på rækken {1}
DocType: Support Search Source,API,API
DocType: Support Search Source,Result Preview Field,Resultatforhåndsvisningsfelt
DocType: Item Price,Packing Unit,Pakningsenhed
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +273,{0} {1} is not submitted,{0} {1} er ikke godkendt
DocType: Subscription,Trialling,afprøvning
DocType: Sales Invoice Item,Deferred Revenue,Udskudte indtægter
DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,Kontantkonto bruges til oprettelse af salgsfaktura
DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,Fritagelsesunderkategori
DocType: Member,Membership Expiry Date,Medlemskabets udløbsdato
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +134,{0} must be negative in return document,{0} skal være negativ til retur dokument
DocType: Employee Tax Exemption Proof Submission,Submission Date,Indsendelsesdato
,Minutes to First Response for Issues,Minutter til First Response for Issues
DocType: Purchase Invoice,Terms and Conditions1,Vilkår og betingelser 1
apps/erpnext/erpnext/public/js/setup_wizard.js +109,The name of the institute for which you are setting up this system.,"Navnet på det institut, som du konfigurerer dette system."
DocType: Accounts Settings,"Accounting entry frozen up to this date, nobody can do / modify entry except role specified below.","Kontering frosset op til denne dato, kan ingen gøre / ændre post undtagen rolle angivet nedenfor."
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +116,Please save the document before generating maintenance schedule,"Gem venligst dokumentet, før generere vedligeholdelsesplan"
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.js +45,Latest price updated in all BOMs,Seneste pris opdateret i alle BOMs
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +28,Project Status,Sagsstatus
DocType: UOM,Check this to disallow fractions. (for Nos),Markér dette for at forbyde fraktioner. (For NOS)
DocType: Student Admission Program,Naming Series (for Student Applicant),Navngivningsnummerserie (for elevansøger)
apps/erpnext/erpnext/hr/doctype/retention_bonus/retention_bonus.py +16,Bonus Payment Date cannot be a past date,Bonus Betalingsdato kan ikke være en tidligere dato
DocType: Travel Request,Copy of Invitation/Announcement,Kopi af invitation / meddelelse
DocType: Practitioner Service Unit Schedule,Practitioner Service Unit Schedule,Practitioner Service Unit Schedule
DocType: Delivery Note,Transporter Name,Transporter Navn
DocType: Authorization Rule,Authorized Value,Autoriseret Værdi
DocType: BOM,Show Operations,Vis Operations
,Minutes to First Response for Opportunity,Minutter til første reaktion for salgsmulighed
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +97,Total Absent,Ialt ikke-tilstede
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1064,Item or Warehouse for row {0} does not match Material Request,Vare eller lager for række {0} matcher ikke materialeanmodningen
apps/erpnext/erpnext/config/stock.py +194,Unit of Measure,Måleenhed
DocType: Fiscal Year,Year End Date,Sidste dag i året
DocType: Task Depends On,Task Depends On,Opgave afhænger af
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1083,Opportunity,Salgsmulighed
DocType: Operation,Default Workstation,Standard Workstation
DocType: Notification Control,Expense Claim Approved Message,Udlæg godkendelsesbesked
DocType: Payment Entry,Deductions or Loss,Fradrag eller Tab
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +279,{0} {1} is closed,{0} {1} er lukket
DocType: Email Digest,How frequently?,Hvor ofte?
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +56,Total Collected: {0},Samlet samlet: {0}
DocType: Purchase Receipt,Get Current Stock,Hent aktuel lagerbeholdning
DocType: Purchase Invoice,ineligible,støtteberettigede
apps/erpnext/erpnext/config/manufacturing.py +46,Tree of Bill of Materials,Styklistetræ
DocType: Student,Joining Date,Ansættelsesdato
,Employees working on a holiday,"Medarbejdere, der arbejder på en helligdag"
,TDS Computation Summary,TDS-beregningsoversigt
DocType: Share Balance,Current State,Nuværende tilstand
apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +152,Mark Present,Marker tilstede
DocType: Share Transfer,From Shareholder,Fra Aktionær
DocType: Project,% Complete Method,%Komplet metode
apps/erpnext/erpnext/healthcare/setup.py +180,Drug,Medicin
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +200,Maintenance start date can not be before delivery date for Serial No {0},Vedligeholdelsesstartdato kan ikke være før leveringsdato for serienummer {0}
DocType: Job Card,Actual End Date,Faktisk slutdato
DocType: Cash Flow Mapping,Is Finance Cost Adjustment,Er finansiering omkostningsjustering
DocType: BOM,Operating Cost (Company Currency),Driftsomkostninger (Company Valuta)
DocType: Authorization Rule,Applicable To (Role),Gælder for (Rolle)
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html +10,Pending Leaves,Afventer blade
DocType: BOM Update Tool,Replace BOM,Udskift BOM
apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.py +113,Code {0} already exist,Kode {0} eksisterer allerede
DocType: Patient Encounter,Procedures,Procedurer
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py +37,Sales orders are not available for production,Salgsordrer er ikke tilgængelige til produktion
DocType: Asset Movement,Purpose,Formål
DocType: Company,Fixed Asset Depreciation Settings,Anlægsaktiv nedskrivning Indstillinger
DocType: Item,Will also apply for variants unless overrridden,"Vil også gælde for varianter, medmindre overrridden"
DocType: Purchase Invoice,Advances,Forskud
DocType: Work Order,Manufacture against Material Request,Produktion mod materialeanmodning
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +17,Assessment Group: ,Bedømmelsesgruppe:
DocType: Item Reorder,Request for,Anmodning om
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +32,Approving User cannot be same as user the rule is Applicable To,Godkendelse Brugeren kan ikke være det samme som brugeren er reglen gælder for
DocType: Stock Entry Detail,Basic Rate (as per Stock UOM),Grundlæggende sats (som pr. lagerenhed)
DocType: SMS Log,No of Requested SMS,Antal  af forespurgte SMS'er
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +328,Leave Without Pay does not match with approved Leave Application records,Fravær uden løn stemmer ikke med de godkendte fraværsansøgninger
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +21,Next Steps,Næste skridt
DocType: Travel Request,Domestic,Indenlandsk
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +853,Please supply the specified items at the best possible rates,Angiv venligst de angivne poster på de bedste mulige priser
apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py +19,Employee Transfer cannot be submitted before Transfer Date ,Medarbejderoverførsel kan ikke indsendes før Overførselsdato
DocType: Certification Application,USD,USD
apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.js +7,Make Invoice,Make Faktura
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +121,Remaining Balance,Resterende saldo
DocType: Selling Settings,Auto close Opportunity after 15 days,Luk automatisk salgsmulighed efter 15 dage
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +83,Purchase Orders are not allowed for {0} due to a scorecard standing of {1}.,Indkøbsordrer er ikke tilladt for {0} på grund af et scorecard stående på {1}.
apps/erpnext/erpnext/stock/doctype/item/item.py +529,Barcode {0} is not a valid {1} code,Stregkode {0} er ikke en gyldig {1} kode
apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.js +25,End Year,Slutår
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +23,Quot/Lead %,Tilbud/emne %
apps/erpnext/erpnext/hr/doctype/employee/employee.py +141,Contract End Date must be greater than Date of Joining,Fratrædelsesdato skal være større end ansættelsesdato
DocType: Driver,Driver,Chauffør
DocType: Vital Signs,Nutrition Values,Ernæringsværdier
DocType: Lab Test Template,Is billable,Kan faktureres
DocType: Sales Partner,A third party distributor / dealer / commission agent / affiliate / reseller who sells the companies products for a commission.,"En distributør, forhandler, sælger eller butik, der sælger firmaets varer og tjenesteydelser mod en provision."
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +412,{0} against Purchase Order {1},{0} mod indkøbsordre {1}
DocType: Patient,Patient Demographics,Patient Demografi
DocType: Task,Actual Start Date (via Time Sheet),Faktisk startdato (via Tidsregistreringen)
apps/erpnext/erpnext/portal/doctype/homepage/homepage.py +15,This is an example website auto-generated from ERPNext,Dette er et eksempel website auto-genereret fra ERPNext
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +28,Ageing Range 1,Ageing Range 1
DocType: Shopify Settings,Enable Shopify,Aktivér Shopify
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +220,Total advance amount cannot be greater than total claimed amount,Samlet forskudsbeløb kan ikke være større end det samlede beløb
DocType: Purchase Taxes and Charges Template,"Standard tax template that can be applied to all Purchase Transactions. This template can contain list of tax heads and also other expense heads like ""Shipping"", ""Insurance"", ""Handling"" etc.

#### Note

The tax rate you define here will be the standard tax rate for all **Items**. If there are **Items** that have different rates, they must be added in the **Item Tax** table in the **Item** master.

#### Description of Columns

1. Calculation Type: 
    - This can be on **Net Total** (that is the sum of basic amount).
    - **On Previous Row Total / Amount** (for cumulative taxes or charges). If you select this option, the tax will be applied as a percentage of the previous row (in the tax table) amount or total.
    - **Actual** (as mentioned).
2. Account Head: The Account ledger under which this tax will be booked
3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.
4. Description: Description of the tax (that will be printed in invoices / quotes).
5. Rate: Tax rate.
6. Amount: Tax amount.
7. Total: Cumulative total to this point.
8. Enter Row: If based on ""Previous Row Total"" you can select the row number which will be taken as a base for this calculation (default is the previous row).
9. Consider Tax or Charge for: In this section you can specify if the tax / charge is only for valuation (not a part of total) or only for total (does not add value to the item) or for both.
10. Add or Deduct: Whether you want to add or deduct the tax.","Standard momsskabelon, der kan anvendes på alle købstransaktioner. Denne skabelon kan indeholde liste over skatte- hoveder og også andre bekostning hoveder som ""Shipping"", ""forsikring"", ""Håndtering"" osv #### Bemærk Skatteprocenten du definerer her, vil være standard skattesats for alle ** Varer * *. Hvis der er ** Varer **, der har forskellige satser, skal de tilsættes i ** Item Skat ** bord i ** Item ** mester. #### Beskrivelse af kolonner 1. Beregning Type: - Dette kan være på ** Net Total ** (dvs. summen af grundbeløb). - ** På Forrige Row Total / Beløb ** (for kumulative skatter eller afgifter). Hvis du vælger denne mulighed, vil skatten blive anvendt som en procentdel af den forrige række (på skatteområdet tabel) beløb eller total. - ** Faktisk ** (som nævnt). 2. Konto Hoved: Account Finans hvorunder denne afgift vil være reserveret 3. Cost Center: Hvis skatten / afgiften er en indtægt (som shipping) eller omkostninger det skal reserveres mod en Cost Center. 4. Beskrivelse: Beskrivelse af skat (som vil blive trykt i fakturaer / citater). 5. Pris: Skatteprocent. 6. Beløb: Skat beløb. 7. Samlet: Kumulativ total til dette punkt. 8. Indtast Række: Hvis baseret på ""Forrige Row alt"" kan du vælge den række nummer, som vil blive taget som en base for denne beregning (standard er den forrige række). 9. Overvej Skat eller Gebyr for: I dette afsnit kan du angive, om skatten / afgiften er kun for værdiansættelse (ikke en del af det samlede) eller kun for total (ikke tilføre værdi til emnet) eller til begge. 10. Tilføj eller fratrække: Uanset om du ønsker at tilføje eller fratrække afgiften."
DocType: Homepage,Homepage,Hjemmeside
DocType: Grant Application,Grant Application Details ,Giv ansøgningsoplysninger
DocType: Employee Separation,Employee Separation,Medarbejder adskillelse
DocType: BOM Item,Original Item,Originalelement
DocType: Purchase Receipt Item,Recd Quantity,RECD Mængde
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +170,Doc Date,Dok Dato
apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py +64,Fee Records Created - {0},Fee Records Oprettet - {0}
DocType: Asset Category Account,Asset Category Account,Asset Kategori konto
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +1024,Row #{0} (Payment Table): Amount must be positive,Row # {0} (Betalingstabel): Beløbet skal være positivt
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +137,Cannot produce more Item {0} than Sales Order quantity {1},Kan ikke producere mere Item {0} end Sales Order mængde {1}
apps/erpnext/erpnext/stock/doctype/item/item.js +446,Select Attribute Values,Vælg Attributværdier
DocType: Purchase Invoice,Reason For Issuing document,Årsag til udstedelse af dokument
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +583,Stock Entry {0} is not submitted,Lagerindtastning {0} er ikke godkendt
DocType: Payment Reconciliation,Bank / Cash Account,Bank / kontantautomat konto
apps/erpnext/erpnext/crm/doctype/lead/lead.py +47,Next Contact By cannot be same as the Lead Email Address,Næste kontakt af kan ikke være den samme som emnets e-mailadresse
DocType: Tax Rule,Billing City,Fakturering By
DocType: Asset,Manual,Manuel
DocType: Salary Component Account,Salary Component Account,Lønrtskonto
DocType: Global Defaults,Hide Currency Symbol,Skjul Valuta Symbol
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.js +281,Sales Opportunities by Source,Salgsmuligheder ved kilde
apps/erpnext/erpnext/config/non_profit.py +58,Donor information.,Donor information.
apps/erpnext/erpnext/config/accounts.py +287,"e.g. Bank, Cash, Credit Card","fx Bank, Kontant, Kreditkort"
DocType: Job Applicant,Source Name,Kilde Navn
DocType: Vital Signs,"Normal resting blood pressure in an adult is approximately 120 mmHg systolic, and 80 mmHg diastolic, abbreviated ""120/80 mmHg""","Normal hvilende blodtryk hos en voksen er ca. 120 mmHg systolisk og 80 mmHg diastolisk, forkortet &quot;120/80 mmHg&quot;"
apps/erpnext/erpnext/stock/doctype/batch/batch.py +124,"Set items shelf life in days, to set expiry based on manufacturing_date plus self life","Indstil varer holdbarhed om dage, for at indstille udløb baseret på manufacturing_date plus selvliv"
DocType: Journal Entry,Credit Note,Kreditnota
DocType: Projects Settings,Ignore Employee Time Overlap,Ignorer medarbejdertidens overlapning
DocType: Warranty Claim,Service Address,Tjeneste Adresse
DocType: Asset Maintenance Task,Calibration,Kalibrering
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +182,{0} is a company holiday,{0} er en firmas ferie
apps/erpnext/erpnext/patches/v11_0/add_default_email_template_for_leave.py +19,Leave Status Notification,Forlad statusmeddelelse
DocType: Patient Appointment,Procedure Prescription,Procedure Recept
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +50,Furnitures and Fixtures,Havemøbler og Kampprogram
DocType: Travel Request,Travel Type,Rejsetype
DocType: Item,Manufacture,Fremstilling
DocType: Blanket Order,MFG-BLR-.YYYY.-,MFG-BLR-.YYYY.-
apps/erpnext/erpnext/utilities/user_progress.py +27,Setup Company,Setup Company
,Lab Test Report,Lab Test Report
DocType: Employee Benefit Application,Employee Benefit Application,Ansættelsesfordel Ansøgning
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +13,Please Delivery Note first,Vælg følgeseddel først
DocType: Student Applicant,Application Date,Ansøgningsdato
DocType: Salary Component,Amount based on formula,Beløb baseret på formlen
DocType: Purchase Invoice,Currency and Price List,Valuta- og prisliste
DocType: Opportunity,Customer / Lead Name,Kunde / Emne navn
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +115,Clearance Date not mentioned,Clearance Dato ikke nævnt
DocType: Payroll Period,Taxable Salary Slabs,Skattepligtige lønplader
apps/erpnext/erpnext/config/manufacturing.py +7,Production,Produktion
DocType: Guardian,Occupation,Beskæftigelse
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +210,For Quantity must be less than quantity {0},For Mængde skal være mindre end mængde {0}
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +74,Row {0}:Start Date must be before End Date,Række {0}: Start dato skal være før slutdato
DocType: Salary Component,Max Benefit Amount (Yearly),Max Benefit Amount (Årlig)
apps/erpnext/erpnext/accounts/report/tds_computation_summary/tds_computation_summary.py +118,TDS Rate %,TDS-sats%
DocType: Crop,Planting Area,Planteområde
apps/erpnext/erpnext/controllers/trends.py +19,Total(Qty),I alt (antal)
DocType: Installation Note Item,Installed Qty,Antal installeret
apps/erpnext/erpnext/utilities/user_progress.py +31,You added ,Du tilføjede
DocType: Purchase Taxes and Charges,Parenttype,Parenttype
apps/erpnext/erpnext/hr/doctype/training_event/training_event.js +10,Training Result,Træning Resultat
DocType: Purchase Invoice,Is Paid,er betalt
DocType: Salary Structure,Total Earning,Samlet Earning
DocType: Purchase Receipt,Time at which materials were received,"Tidspunkt, hvor materialer blev modtaget"
DocType: Products Settings,Products per Page,Produkter pr. Side
DocType: Stock Ledger Entry,Outgoing Rate,Udgående Rate
apps/erpnext/erpnext/controllers/accounts_controller.py +377, or ,eller
DocType: Sales Order,Billing Status,Faktureringsstatus
apps/erpnext/erpnext/public/js/conf.js +32,Report an Issue,Rapporter et problem
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +127,Utility Expenses,"El, vand og varmeudgifter"
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +64,90-Above,90-over
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +253,Row #{0}: Journal Entry {1} does not have account {2} or already matched against another voucher,Row # {0}: Kassekladde {1} har ikke konto {2} eller allerede matchet mod en anden kupon
DocType: Supplier Scorecard Criteria,Criteria Weight,Kriterier Vægt
apps/erpnext/erpnext/patches/v11_0/add_default_email_template_for_leave.py +7,Leave Approval Notification,Forlad godkendelsesmeddelelse
DocType: Buying Settings,Default Buying Price List,Standard indkøbsprisliste
DocType: Payroll Entry,Salary Slip Based on Timesheet,Lønseddel baseret på timeregistreringen
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +55,Buying Rate,Købspris
apps/erpnext/erpnext/controllers/buying_controller.py +602,Row {0}: Enter location for the asset item {1},Række {0}: Indtast placering for aktivposten {1}
DocType: Request for Quotation,PUR-RFQ-.YYYY.-,PUR-RFQ-.YYYY.-
DocType: Company,About the Company,Om virksomheden
DocType: Notification Control,Sales Order Message,Salgsordrebesked
apps/erpnext/erpnext/config/setup.py +15,"Set Default Values like Company, Currency, Current Fiscal Year, etc.","Indstil standardværdier som Firma, Valuta, indeværende regnskabsår, m.v."
DocType: Payment Entry,Payment Type,Betalingstype
apps/erpnext/erpnext/stock/doctype/batch/batch.py +245,Please select a Batch for Item {0}. Unable to find a single batch that fulfills this requirement,"Vælg venligst et parti for vare {0}. Kunne ikke finde et eneste parti, der opfylder dette krav"
DocType: Asset Maintenance Log,ACC-AML-.YYYY.-,ACC-AML-.YYYY.-
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1184,No gain or loss in the exchange rate,Ingen gevinst eller tab i valutakursen
DocType: Payroll Entry,Select Employees,Vælg Medarbejdere
DocType: Shopify Settings,Sales Invoice Series,Salgsfaktura-serien
DocType: Opportunity,Potential Sales Deal,Potentielle Sales Deal
DocType: Complaint,Complaints,klager
DocType: Employee Tax Exemption Declaration,Employee Tax Exemption Declaration,Skattefritagelseserklæring fra ansatte
DocType: Payment Entry,Cheque/Reference Date,Anvendes ikke
DocType: Purchase Invoice,Total Taxes and Charges,Moms i alt
DocType: Employee,Emergency Contact,Emergency Kontakt
DocType: Bank Reconciliation Detail,Payment Entry,Betaling indtastning
,sales-browser,salg-browser
apps/erpnext/erpnext/accounts/doctype/account/account.js +78,Ledger,Ledger
DocType: Drug Prescription,Drug Code,Drug Code
DocType: Target Detail,Target  Amount,Målbeløbet
DocType: POS Profile,Print Format for Online,Printformat til online
DocType: Shopping Cart Settings,Shopping Cart Settings,Indkøbskurv Indstillinger
DocType: Journal Entry,Accounting Entries,Bogføringsposter
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +17,"If selected Pricing Rule is made for 'Rate', it will overwrite Price List. Pricing Rule rate is the final rate, so no further discount should be applied. Hence, in transactions like Sales Order, Purchase Order etc, it will be fetched in 'Rate' field, rather than 'Price List Rate' field.","Hvis den valgte prissætningsregel er lavet til &#39;Rate&#39;, overskrives den Prisliste. Prissætning Regelpris er den endelige sats, så ingen yderligere rabat bør anvendes. Derfor vil i transaktioner som salgsordre, indkøbsordre osv. Blive hentet i feltet &#39;Rate&#39; i stedet for &#39;Prislistefrekvens&#39;."
DocType: Journal Entry,Paid Loan,Betalt lån
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +24,Duplicate Entry. Please check Authorization Rule {0},Duplicate indtastning. Forhør Authorization Rule {0}
DocType: Journal Entry Account,Reference Due Date,Reference Due Date
DocType: Purchase Order,Ref SQ,Ref SQ
DocType: Leave Type,Applicable After (Working Days),Gældende efter (arbejdsdage)
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +55,Receipt document must be submitted,Kvittering skal godkendes
DocType: Purchase Invoice Item,Received Qty,Modtaget Antal
DocType: Stock Entry Detail,Serial No / Batch,Serienummer / Parti
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +359,Not Paid and Not Delivered,Ikke betalte og ikke leveret
DocType: Product Bundle,Parent Item,Overordnet vare
DocType: Account,Account Type,Kontotype
DocType: Shopify Settings,Webhooks Details,Webhooks Detaljer
apps/erpnext/erpnext/templates/pages/projects.html +58,No time sheets,Ingen tidsregistreringer
DocType: GoCardless Mandate,GoCardless Customer,GoCardless kunde
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +160,Leave Type {0} cannot be carry-forwarded,Fraværstype {0} kan ikke bæres videre
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +215,Maintenance Schedule is not generated for all the items. Please click on 'Generate Schedule',"Vedligeholdelsesplan er ikke dannet for alle varer. Klik på ""Generér plan'"
,To Produce,At producere
DocType: Leave Encashment,Payroll,Løn
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +209,"For row {0} in {1}. To include {2} in Item rate, rows {3} must also be included","For rækken {0} i {1}. For at inkludere {2} i Item sats, rækker {3} skal også medtages"
DocType: Healthcare Service Unit,Parent Service Unit,Moderselskab
apps/erpnext/erpnext/utilities/activation.py +101,Make User,Opret Bruger
DocType: Packing Slip,Identification of the package for the delivery (for print),Identifikation af emballagen for levering (til print)
DocType: Bin,Reserved Quantity,Reserveret mængde
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +34,Please enter valid email address,Indtast venligst en gyldig e-mailadresse
DocType: Volunteer Skill,Volunteer Skill,Frivillig Færdighed
DocType: Bank Reconciliation,Include POS Transactions,Inkluder POS-transaktioner
DocType: Purchase Invoice,Inter Company Invoice Reference,Interfirma faktura Reference
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +883,Please select an item in the cart,Vælg venligst et emne i vognen
DocType: Landed Cost Voucher,Purchase Receipt Items,Købskvittering varer
apps/erpnext/erpnext/config/learn.py +21,Customizing Forms,Tilpasning Forms
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +52,Arrear,bagud
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +173,Depreciation Amount during the period,Afskrivningsbeløb i perioden
DocType: Sales Invoice,Is Return (Credit Note),Er Retur (Kredit Bemærk)
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.js +26,Start Job,Start Job
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +32,Serial no is required for the asset {0},Serienummer er påkrævet for aktivet {0}
apps/erpnext/erpnext/accounts/doctype/sales_taxes_and_charges_template/sales_taxes_and_charges_template.py +43,Disabled template must not be default template,Deaktiveret skabelon må ikke være standardskabelon
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py +542,For row {0}: Enter planned qty,For række {0}: Indtast planlagt antal
DocType: Account,Income Account,Indtægtskonto
DocType: Payment Request,Amount in customer's currency,Beløb i kundens valuta
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +880,Delivery,Levering
DocType: Stock Reconciliation Item,Current Qty,Aktuel Antal
DocType: Restaurant Menu,Restaurant Menu,Restaurant Menu
apps/erpnext/erpnext/public/js/event.js +23,Add Suppliers,Tilføj leverandører
DocType: Sales Invoice,ACC-SINV-.YYYY.-,ACC-SINV-.YYYY.-
DocType: Loyalty Program,Help Section,Hjælp sektion
apps/erpnext/erpnext/templates/generators/item_group.html +26,Prev,forrige
DocType: Appraisal Goal,Key Responsibility Area,Key Responsibility Area
DocType: Delivery Trip,Distance UOM,Afstand UOM
apps/erpnext/erpnext/utilities/activation.py +127,"Student Batches help you track attendance, assessments and fees for students","Elevgrupper hjælper dig med at administrere fremmøde, vurderinger og gebyrer for eleverne"
DocType: Payment Entry,Total Allocated Amount,Samlet bevilgede beløb
apps/erpnext/erpnext/setup/doctype/company/company.py +163,Set default inventory account for perpetual inventory,Indstil standard lagerkonto for evigvarende opgørelse
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +261,"Cannot deliver Serial No {0} of item {1} as it is reserved to \
												fullfill Sales Order {2}","Kan ikke aflevere serienummer {0} af vare {1}, da det er forbeholdt \ fuldfill salgsordre {2}"
DocType: Item Reorder,Material Request Type,Materialeanmodningstype
apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.js +17,Send Grant Review Email,Send Grant Review Email
apps/erpnext/erpnext/accounts/page/pos/pos.js +859,"LocalStorage is full, did not save","LocalStorage er fuld, kan ikke gemme"
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +130,Row {0}: UOM Conversion Factor is mandatory,Række {0}: Enhedskode-konverteringsfaktor er obligatorisk
DocType: Employee Benefit Claim,Claim Date,Claim Date
apps/erpnext/erpnext/utilities/user_progress.py +235,Room Capacity,Rum Kapacitet
apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py +28,Already record exists for the item {0},Der findes allerede en rekord for varen {0}
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html +28,Ref,Ref
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js +48,You will lose records of previously generated invoices. Are you sure you want to restart this subscription?,"Du vil miste optegnelser over tidligere genererede fakturaer. Er du sikker på, at du vil genstarte dette abonnement?"
DocType: Lab Test,LP-,LP-
DocType: Healthcare Settings,Registration Fee,Registreringsafgift
DocType: Loyalty Program Collection,Loyalty Program Collection,Loyalitetsprogramindsamling
DocType: Stock Entry Detail,Subcontracted Item,Underentreprise
apps/erpnext/erpnext/education/__init__.py +9,Student {0} does not belong to group {1},Student {0} tilhører ikke gruppe {1}
DocType: Budget,Cost Center,Omkostningssted
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +57,Voucher #,Bilagsnr.
DocType: Notification Control,Purchase Order Message,Indkøbsordre meddelelse
DocType: Tax Rule,Shipping Country,Forsendelsesland
DocType: Selling Settings,Hide Customer's Tax Id from Sales Transactions,Skjul kundens CVR-nummer fra salgstransaktioner
DocType: Upload Attendance,Upload HTML,Upload HTML
DocType: Employee,Relieving Date,Lindre Dato
DocType: Purchase Invoice,Total Quantity,Samlet mængde
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +14,"Pricing Rule is made to overwrite Price List / define discount percentage, based on some criteria.",Prisfastsættelseregler laves for at overskrive prislisten og for at fastlægge rabatprocenter baseret på forskellige kriterier.
DocType: Serial No,Warehouse can only be changed via Stock Entry / Delivery Note / Purchase Receipt,"Lager kan kun ændres via lagerindtastning, følgeseddel eller købskvittering"
DocType: Employee Education,Class / Percentage,Klasse / Procent
DocType: Shopify Settings,Shopify Settings,Shopify Indstillinger
DocType: Amazon MWS Settings,Market Place ID,Markedsplads ID
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +97,Head of Marketing and Sales,Salg- og marketingschef
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +50,Income Tax,Indkomstskat
apps/erpnext/erpnext/config/selling.py +174,Track Leads by Industry Type.,Analysér emner efter branchekode.
apps/erpnext/erpnext/utilities/user_progress.py +101,Go to Letterheads,Gå til Letterheads
DocType: Subscription,Cancel At End Of Period,Annuller ved slutningen af perioden
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js +114,Property already added,Ejendom tilføjet allerede
DocType: Item Supplier,Item Supplier,Vareleverandør
apps/erpnext/erpnext/public/js/controllers/transaction.js +1389,Please enter Item Code to get batch no,Indtast venligst varenr. for at få partinr.
apps/erpnext/erpnext/selling/doctype/quotation/quotation.js +928,Please select a value for {0} quotation_to {1},Vælg en værdi for {0} quotation_to {1}
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +435,No Items selected for transfer,Ingen emner valgt til overførsel
apps/erpnext/erpnext/config/selling.py +46,All Addresses.,Alle adresser.
DocType: Company,Stock Settings,Lagerindstillinger
apps/erpnext/erpnext/accounts/doctype/account/account.py +244,"Merging is only possible if following properties are same in both records. Is Group, Root Type, Company","Sammenlægning er kun muligt, hvis følgende egenskaber er ens i begge poster: Er en kontogruppe, Rodtype og firma"
DocType: Vehicle,Electric,Elektrisk
DocType: Task,% Progress,% fremskridt
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +130,Gain/Loss on Asset Disposal,Gevinst/tab vedr. salg af anlægsaktiv
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.js +24,"Only the Student Applicant with the status ""Approved"" will be selected in the table below.",Kun den studerendes ansøger med statusen &quot;Godkendt&quot; vælges i nedenstående tabel.
DocType: Tax Withholding Category,Rates,priser
apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +121,Account number for account {0} is not available.<br> Please setup your Chart of Accounts correctly.,Kontonummer for konto {0} er ikke tilgængeligt. <br> Opsæt venligst dit kontoplan korrekt.
DocType: Task,Depends on Tasks,Afhænger af opgaver
apps/erpnext/erpnext/config/selling.py +36,Manage Customer Group Tree.,Administrér Kundegruppetræ.
DocType: Normal Test Items,Result Value,Resultatværdi
DocType: Hotel Room,Hotels,Hoteller
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +22,New Cost Center Name,Ny Cost center navn
DocType: Leave Control Panel,Leave Control Panel,Fravær Kontrolpanel
DocType: Project,Task Completion,Opgaveafslutning
apps/erpnext/erpnext/templates/includes/product_page.js +31,Not in Stock,Ikke på lager
DocType: Volunteer,Volunteer Skills,Frivillige Færdigheder
DocType: Additional Salary,HR User,HR-bruger
DocType: Bank Guarantee,Reference Document Name,Reference dokumentnavn
DocType: Purchase Invoice,Taxes and Charges Deducted,Skatter og Afgifter Fratrukket
DocType: Support Settings,Issues,Spørgsmål
DocType: Loyalty Program,Loyalty Program Name,Loyalitetsprogramnavn
apps/erpnext/erpnext/controllers/status_updater.py +12,Status must be one of {0},Status skal være en af {0}
apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +64,Reminder to update GSTIN Sent,Påmindelse om at opdatere GSTIN Sendt
DocType: Sales Invoice,Debit To,Debit Til
DocType: Restaurant Menu Item,Restaurant Menu Item,Restaurant menupunkt
DocType: Delivery Note,Required only for sample item.,Kræves kun for prøve element.
DocType: Stock Ledger Entry,Actual Qty After Transaction,Aktuel Antal Efter Transaktion
,Pending SO Items For Purchase Request,Afventende salgsordre-varer til indkøbsanmodning
apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +35,Student Admissions,Studerende optagelser
apps/erpnext/erpnext/accounts/party.py +421,{0} {1} is disabled,{0} {1} er deaktiveret
DocType: Supplier,Billing Currency,Fakturering Valuta
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +152,Extra Large,Extra Large
DocType: Loan,Loan Application,Lån ansøgning
DocType: Crop,Scientific Name,Videnskabeligt navn
DocType: Healthcare Service Unit,Service Unit Type,Service Unit Type
DocType: Bank Account,Branch Code,Branchkode
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +97,Total Leaves,Fravær i alt
DocType: Customer,"Reselect, if the chosen contact is edited after save","Vælg, hvis den valgte kontakt redigeres efter gem"
DocType: Patient Encounter,In print,Udskriv
,Profit and Loss Statement,Resultatopgørelse
DocType: Bank Reconciliation Detail,Cheque Number,Anvendes ikke
apps/erpnext/erpnext/healthcare/utils.py +264,The item referenced by {0} - {1} is already invoiced,"Varen, der henvises til af {0} - {1}, er allerede faktureret"
,Sales Browser,Salg Browser
DocType: Journal Entry,Total Credit,Samlet kredit
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +586,Warning: Another {0} # {1} exists against stock entry {2},Advarsel: En anden {0} # {1} eksisterer mod lagerpost {2}
apps/erpnext/erpnext/utilities/user_progress_utils.py +66,Local,Lokal
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +26,Loans and Advances (Assets),Udlån (aktiver)
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +12,Debtors,Debitorer
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +151,Large,Stor
DocType: Bank Statement Settings,Bank Statement Settings,Indstillinger for bankerklæring
DocType: Shopify Settings,Customer Settings,Kundeindstillinger
DocType: Homepage Featured Product,Homepage Featured Product,Hjemmeside Featured Product
apps/erpnext/erpnext/manufacturing/doctype/blanket_order/blanket_order.js +12,View Orders,Se ordrer
DocType: Marketplace Settings,Marketplace URL (to hide and update label),Markedsplads-URL (for at skjule og opdatere etiket)
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +206,All Assessment Groups,Alle Assessment Grupper
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js +15,New Warehouse Name,Nyt lagernavn
DocType: Shopify Settings,App Type,App Type
apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.py +401,Total {0} ({1}),I alt {0} ({1})
DocType: C-Form Invoice Detail,Territory,Område
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +151,Please mention no of visits required,"Henvis ikke af besøg, der kræves"
DocType: Stock Settings,Default Valuation Method,Standard værdiansættelsesmetode
apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +26,Fee,Betaling
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js +59,Show Cumulative Amount,Vis kumulativ mængde
apps/erpnext/erpnext/setup/doctype/company/company.js +174,Update in progress. It might take a while.,Opdatering i gang. Det kan tage et stykke tid.
DocType: Production Plan Item,Produced Qty,Produceret antal
DocType: Vehicle Log,Fuel Qty,Brændstofmængde
DocType: Stock Entry,Target Warehouse Name,Mållagernavn
DocType: Work Order Operation,Planned Start Time,Planlagt starttime
DocType: Course,Assessment,Vurdering
DocType: Payment Entry Reference,Allocated,Allokeret
apps/erpnext/erpnext/config/accounts.py +235,Close Balance Sheet and book Profit or Loss.,Luk Balance og book resultatopgørelsen.
DocType: Student Applicant,Application Status,Ansøgning status
DocType: Additional Salary,Salary Component Type,Løn Komponent Type
DocType: Sensitivity Test Items,Sensitivity Test Items,Sensitivitetstest
DocType: Project Update,Project Update,Projektopdatering
DocType: Fees,Fees,Gebyrer
DocType: Currency Exchange,Specify Exchange Rate to convert one currency into another,Angiv Exchange Rate til at konvertere en valuta til en anden
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +165,Quotation {0} is cancelled,Tilbud {0} er ikke længere gyldigt
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +139,Total Outstanding Amount,Samlede udestående beløb
DocType: Sales Partner,Targets,Mål
apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].js +40,Please register the SIREN number in the company information file,Indtast venligst SIREN-nummeret i virksomhedens informationsfil
DocType: Email Digest,Sales Orders to Bill,Salgsordrer til Bill
DocType: Price List,Price List Master,Master-Prisliste
DocType: GST Account,CESS Account,CESS-konto
DocType: Sales Person,All Sales Transactions can be tagged against multiple **Sales Persons** so that you can set and monitor targets.,"Alt salg Transaktioner kan mærkes mod flere ** Sales Personer **, så du kan indstille og overvåge mål."
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1185,Link to Material Request,Link til materialeanmodning
apps/erpnext/erpnext/templates/pages/help.html +35,Forum Activity,Forumaktivitet
,S.O. No.,SÅ No.
DocType: Bank Statement Transaction Settings Item,Bank Statement Transaction Settings Item,Bankoversigt Transaktionsindstillinger Item
apps/erpnext/erpnext/hr/utils.py +158,To date can not greater than employee's relieving date,Til dato kan ikke større end medarbejderens lindrende dato
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +242,Please create Customer from Lead {0},Opret kunde fra emne {0}
apps/erpnext/erpnext/healthcare/page/medical_record/patient_select.html +3,Select Patient,Vælg patient
DocType: Price List,Applicable for Countries,Gældende for lande
DocType: Supplier Scorecard Scoring Variable,Parameter Name,Parameternavn
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +46,Only Leave Applications with status 'Approved' and 'Rejected' can be submitted,Kun Lad Applikationer med status &quot;Godkendt&quot; og &quot;Afvist&quot; kan indsendes
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +52,Student Group Name is mandatory in row {0},Elevgruppenavn er obligatorisk i rækken {0}
DocType: Homepage,Products to be shown on website homepage,Produkter til at blive vist på hjemmesidens startside
apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.js +13,This is a root customer group and cannot be edited.,Dette er en rod-kundegruppe og kan ikke redigeres.
DocType: Student,AB-,AB-
DocType: Budget,Action if Accumulated Monthly Budget Exceeded on PO,Handling hvis akkumuleret månedlig budget oversteg PO
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +249,To Place,At placere
DocType: Exchange Rate Revaluation,Exchange Rate Revaluation,Valutakursomskrivning
DocType: POS Profile,Ignore Pricing Rule,Ignorér prisfastsættelsesregel
DocType: Employee Education,Graduate,Graduate
DocType: Leave Block List,Block Days,Blokér dage
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +83,"Shipping Address does not have country, which is required for this Shipping Rule","Forsendelsesadresse har ikke land, som er påkrævet for denne forsendelsesregel"
DocType: Journal Entry,Excise Entry,Excise indtastning
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +69,Warning: Sales Order {0} already exists against Customer's Purchase Order {1},Advarsel: Salg Order {0} findes allerede mod Kundens Indkøbsordre {1}
DocType: Terms and Conditions,"Standard Terms and Conditions that can be added to Sales and Purchases.

Examples:

1. Validity of the offer.
1. Payment Terms (In Advance, On Credit, part advance etc).
1. What is extra (or payable by the Customer).
1. Safety / usage warning.
1. Warranty if any.
1. Returns Policy.
1. Terms of shipping, if applicable.
1. Ways of addressing disputes, indemnity, liability, etc.
1. Address and Contact of your Company.","Standardvilkår og -betingelser, der kan føjes til salg og køb. Eksempler: 1. gyldighed for tilbuddet. 1. Betalingsbetingelser (på forhånd, på kredit, delvist på forhånd osv). 1. Hvad er ekstra (eller skal betales af kunden). 1. Sikkerhed / forbrugerinformation. 1. Garanti (hvis nogen). 1. Returpolitik. 1. Betingelser for skibsfart (hvis relevant). 1. Håndtering af tvister, erstatning, ansvar mv 1. Adresse og kontakt i din virksomhed."
DocType: Issue,Issue Type,Udstedelsestype
DocType: Attendance,Leave Type,Fraværstype
DocType: Purchase Invoice,Supplier Invoice Details,Leverandør fakturadetaljer
DocType: Agriculture Task,Ignore holidays,Ignorer ferie
apps/erpnext/erpnext/controllers/stock_controller.py +237,Expense / Difference account ({0}) must be a 'Profit or Loss' account,Udgifts- differencekonto ({0}) skal være en resultatskonto
DocType: Project,Copied From,Kopieret fra
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +265,Invoice already created for all billing hours,Faktura er allerede oprettet for alle faktureringstimer
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +177,Name error: {0},Navn fejl: {0}
DocType: Healthcare Service Unit Type,Item Details,Elementdetaljer
DocType: Cash Flow Mapping,Is Finance Cost,Er finansiering omkostninger
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +19,Attendance for employee {0} is already marked,Fremmøde til medarbejder {0} er allerede markeret
DocType: Packing Slip,If more than one package of the same type (for print),Hvis mere end én pakke af samme type (til udskrivning)
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +27,Please set default customer in Restaurant Settings,Indstil standardkunde i Restaurantindstillinger
,Salary Register,Løn Register
DocType: Warehouse,Parent Warehouse,Forældre Warehouse
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.js +41,Chart,Diagram
DocType: Subscription,Net Total,Netto i alt
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +527,Default BOM not found for Item {0} and Project {1},Standard BOM ikke fundet for Item {0} og Project {1}
apps/erpnext/erpnext/config/non_profit.py +74,Define various loan types,Definer forskellige låneformer
DocType: Bin,FCFS Rate,FCFS Rate
DocType: Bank Statement Transaction Invoice Item,Outstanding Amount,Udestående beløb
apps/erpnext/erpnext/templates/generators/bom.html +71,Time(in mins),Tid (i minutter)
DocType: Project Task,Working,Working
DocType: Stock Ledger Entry,Stock Queue (FIFO),Stock kø (FIFO)
apps/erpnext/erpnext/public/js/setup_wizard.js +128,Financial Year,Finansielt år
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +46,{0} does not belong to Company {1},{0} tilhører ikke firmaet {1}
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_period/supplier_scorecard_period.py +66,Could not solve criteria score function for {0}. Make sure the formula is valid.,"Kunne ikke løse kriteriernes scorefunktion for {0}. Sørg for, at formlen er gyldig."
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +137,Cost as on,Omkostninger som på
apps/erpnext/erpnext/hr/doctype/employee_loan_application/employee_loan_application.py +34,Repayment amount {} should be greater than monthly interest amount {},Tilbagebetalingsbeløbet {} skal være større end det månedlige rentebeløb {}
DocType: Healthcare Settings,Out Patient Settings,Ud patientindstillinger
DocType: Account,Round Off,Afrundninger
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +305,Quantity must be positive,Mængden skal være positiv
DocType: Material Request Plan Item,Requested Qty,Anmodet mængde
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +97,The fields From Shareholder and To Shareholder cannot be blank,Feltene fra aktionær og til aktionær kan ikke være tomme
DocType: Cashier Closing,Cashier Closing,Cashier Closing
DocType: Tax Rule,Use for Shopping Cart,Bruges til Indkøbskurv
apps/erpnext/erpnext/controllers/item_variant.py +101,Value {0} for Attribute {1} does not exist in the list of valid Item Attribute Values for Item {2},Værdi {0} for Attribut {1} findes ikke på listen over gyldige Item Attribut Værdier for Item {2}
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +81,Select Serial Numbers,Vælg serienumre
DocType: BOM Item,Scrap %,Skrot-%
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +46,"Charges will be distributed proportionately based on item qty or amount, as per your selection","Afgifter vil blive fordelt forholdsmæssigt baseret på post qty eller mængden, som pr dit valg"
DocType: Travel Request,Require Full Funding,Kræver Fuld finansiering
DocType: Maintenance Visit,Purposes,Formål
DocType: Stock Entry,MAT-STE-.YYYY.-,MAT-STE-.YYYY.-
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +110,Atleast one item should be entered with negative quantity in return document,Mindst ét element skal indtastes med negativt mængde gengæld dokument
apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +71,"Operation {0} longer than any available working hours in workstation {1}, break down the operation into multiple operations","Betjening {0} længere end alle tilgængelige arbejdstimer i arbejdsstation {1}, nedbryde driften i flere operationer"
DocType: Membership,Membership Status,Medlemskabsstatus
DocType: Travel Itinerary,Lodging Required,Indlogering påkrævet
,Requested,Anmodet
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +121,No Remarks,Ingen bemærkninger
DocType: Asset,In Maintenance,Ved vedligeholdelse
DocType: Amazon MWS Settings,Click this button to pull your Sales Order data from Amazon MWS.,Klik på denne knap for at trække dine salgsordre data fra Amazon MWS.
DocType: Vital Signs,Abdomen,Mave
DocType: Purchase Invoice,Overdue,Forfalden
DocType: Account,Stock Received But Not Billed,Stock Modtaget men ikke faktureret
apps/erpnext/erpnext/accounts/doctype/account/account.py +91,Root Account must be a group,Root Der skal være en gruppe
DocType: Drug Prescription,Drug Prescription,Lægemiddel recept
DocType: Loan,Repaid/Closed,Tilbagebetales / Lukket
DocType: Amazon MWS Settings,CA,CA
DocType: Item,Total Projected Qty,Den forventede samlede Antal
DocType: Monthly Distribution,Distribution Name,Distribution Name
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.js +56,Include UOM,Inkluder UOM
apps/erpnext/erpnext/stock/stock_ledger.py +482,"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","Værdiansættelsesrate ikke fundet for posten {0}, som er påkrævet for at foretage regnskabsposter for {1} {2}. Hvis varen handler som en nulværdieringsgrad i {1}, skal du nævne det i {1} Item-tabellen. Ellers skal du oprette en indgående aktietransaktion for varen eller nævne værdiansættelsesfrekvensen i vareposten og derefter forsøge at indsende / annullere denne post"
DocType: Course,Course Code,Kursuskode
apps/erpnext/erpnext/controllers/stock_controller.py +341,Quality Inspection required for Item {0},Kvalitetskontrol kræves for vare {0}
DocType: Location,Parent Location,Forældre Placering
DocType: POS Settings,Use POS in Offline Mode,Brug POS i offline-tilstand
DocType: Supplier Scorecard,Supplier Variables,Leverandørvariabler
apps/erpnext/erpnext/accounts/page/pos/pos.js +77,{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2},{0} er obligatorisk. Måske Valutaudvekslingsrekord er ikke oprettet til {1} til {2}
DocType: Quotation,Rate at which customer's currency is converted to company's base currency,"Hastighed, hvormed kundens valuta omregnes til virksomhedens basisvaluta"
DocType: Purchase Invoice Item,Net Rate (Company Currency),Nettosats (firmavaluta)
DocType: Salary Detail,Condition and Formula Help,Tilstand og formel Hjælp
apps/erpnext/erpnext/config/selling.py +105,Manage Territory Tree.,Administrer Område-træ.
DocType: Patient Service Unit,Patient Service Unit,Patient Service Unit
DocType: Bank Statement Transaction Invoice Item,Sales Invoice,Salgsfaktura
DocType: Journal Entry Account,Party Balance,Party Balance
DocType: Cash Flow Mapper,Section Subtotal,Sektion Subtotal
apps/erpnext/erpnext/accounts/page/pos/pos.js +500,Please select Apply Discount On,Vælg Anvend Rabat på
DocType: Stock Settings,Sample Retention Warehouse,Prøveopbevaringslager
DocType: Company,Default Receivable Account,Standard Tilgodehavende konto
DocType: Purchase Invoice,Deemed Export,Forsøgt eksport
DocType: Stock Entry,Material Transfer for Manufacture,Materiale Transfer til Fremstilling
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +20,Discount Percentage can be applied either against a Price List or for all Price List.,Rabat Procent kan anvendes enten mod en prisliste eller for alle prisliste.
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +432,Accounting Entry for Stock,Regnskab Punktet om Stock
DocType: Lab Test,LabTest Approver,LabTest Approver
apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py +49,You have already assessed for the assessment criteria {}.,Du har allerede vurderet for bedømmelseskriterierne {}.
DocType: Vehicle Service,Engine Oil,Motorolie
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1084,Work Orders Created: {0},Arbejdsordrer oprettet: {0}
DocType: Sales Invoice,Sales Team1,Salgs TEAM1
apps/erpnext/erpnext/stock/doctype/item/item.py +578,Item {0} does not exist,Element {0} eksisterer ikke
DocType: Sales Invoice,Customer Address,Kundeadresse
DocType: Loan,Loan Details,Lånedetaljer
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +62,Failed to setup post company fixtures,Kunne ikke opsætte postfirmaet inventar
DocType: Company,Default Inventory Account,Standard lagerkonto
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +193,The folio numbers are not matching,Folio numrene matcher ikke
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +304,Payment Request for {0},Betalingsanmodning om {0}
DocType: Item Barcode,Barcode Type,Stregkode Type
DocType: Antibiotic,Antibiotic Name,Antibiotikum Navn
apps/erpnext/erpnext/config/buying.py +43,Supplier Group master.,Leverandørgruppe mester.
DocType: Healthcare Service Unit,Occupancy Status,Beboelsesstatus
DocType: Purchase Invoice,Apply Additional Discount On,Påfør Yderligere Rabat på
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +66,Select Type...,Vælg type ...
apps/erpnext/erpnext/templates/pages/help.html +52,Your tickets,Dine billetter
DocType: Account,Root Type,Rodtype
DocType: Item,FIFO,FIFO
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +558,Close the POS,Luk POS
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +139,Row # {0}: Cannot return more than {1} for Item {2},Row # {0}: Kan ikke returnere mere end {1} for Item {2}
DocType: Item Group,Show this slideshow at the top of the page,Vis denne slideshow øverst på siden
DocType: BOM,Item UOM,Vareenhed
DocType: Sales Taxes and Charges,Tax Amount After Discount Amount (Company Currency),Skat Beløb Efter Discount Beløb (Company Valuta)
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +256,Target warehouse is mandatory for row {0},Target lageret er obligatorisk for rækken {0}
DocType: Cheque Print Template,Primary Settings,Primære indstillinger
DocType: Attendance Request,Work From Home,Arbejde hjemmefra
DocType: Purchase Invoice,Select Supplier Address,Vælg leverandør Adresse
apps/erpnext/erpnext/public/js/event.js +27,Add Employees,Tilføj medarbejdere
DocType: Purchase Invoice Item,Quality Inspection,Kvalitetskontrol
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +148,Extra Small,Extra Small
DocType: Company,Standard Template,Standardskabelon
DocType: Training Event,Theory,Teori
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +1103,Warning: Material Requested Qty is less than Minimum Order Qty,Advarsel: Anmodet materialemængde er mindre end minimum ordremængden
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +212,Account {0} is frozen,Konto {0} er spærret
DocType: Company,Legal Entity / Subsidiary with a separate Chart of Accounts belonging to the Organization.,Juridisk enhed / Datterselskab med en separat Kontoplan tilhører organisationen.
DocType: Payment Request,Mute Email,Mute Email
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +29,"Food, Beverage & Tobacco","Mad, drikke og tobak"
DocType: Account,Account Number,Kontonummer
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +794,Can only make payment against unbilled {0},Kan kun gøre betaling mod faktureret {0}
apps/erpnext/erpnext/controllers/selling_controller.py +114,Commission rate cannot be greater than 100,Provisionssats kan ikke være større end 100
DocType: Sales Invoice,Allocate Advances Automatically (FIFO),Fordel automatisk Advance (FIFO)
DocType: Volunteer,Volunteer,Frivillig
DocType: Buying Settings,Subcontract,Underleverance
apps/erpnext/erpnext/public/js/utils/party.js +167,Please enter {0} first,Indtast venligst {0} først
apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py +104,No replies from,Ingen svar fra
DocType: Work Order Operation,Actual End Time,Faktisk sluttid
DocType: Item,Manufacturer Part Number,Producentens varenummer
DocType: Taxable Salary Slab,Taxable Salary Slab,Skattepligtige lønplader
DocType: Work Order Operation,Estimated Time and Cost,Estimeret tid og omkostninger
DocType: Bin,Bin,Bin
DocType: Crop,Crop Name,Beskær Navn
apps/erpnext/erpnext/hub_node/api.py +54,Only users with {0} role can register on Marketplace,Kun brugere med {0} rolle kan registrere sig på Marketplace
DocType: SMS Log,No of Sent SMS,Antal afsendte SMS'er
DocType: Leave Application,HR-LAP-.YYYY.-,HR-LAP-.YYYY.-
apps/erpnext/erpnext/healthcare/doctype/inpatient_record/inpatient_record_dashboard.py +8,Appointments and Encounters,Udnævnelser og møder
DocType: Antibiotic,Healthcare Administrator,Sundhedsadministrator
apps/erpnext/erpnext/utilities/user_progress.py +47,Set a Target,Indstil et mål
DocType: Dosage Strength,Dosage Strength,Doseringsstyrke
DocType: Healthcare Practitioner,Inpatient Visit Charge,Inpatientbesøgsgebyr
DocType: Account,Expense Account,Udgiftskonto
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +49,Software,Software
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +155,Colour,Farve
DocType: Assessment Plan Criteria,Assessment Plan Criteria,Vurdering Plan Kriterier
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card_dashboard.py +8,Transactions,Transaktioner
apps/erpnext/erpnext/stock/doctype/batch/batch.py +123,Expiry date is mandatory for selected item,Udløbsdato er obligatorisk for den valgte vare
DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,Forhindre indkøbsordrer
apps/erpnext/erpnext/healthcare/setup.py +190,Susceptible,modtagelig
DocType: Patient Appointment,Scheduled,Planlagt
apps/erpnext/erpnext/config/buying.py +18,Request for quotation.,Anmodning om tilbud.
apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.js +13,"Please select Item where ""Is Stock Item"" is ""No"" and ""Is Sales Item"" is ""Yes"" and there is no other Product Bundle","Vælg venligst en vare, hvor ""Er lagervare"" er ""nej"" og ""Er salgsvare"" er ""Ja"", og der er ingen anden produktpakke"
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.js +148,Select Customer,Vælg kunde
DocType: Student Log,Academic,Akademisk
DocType: Patient,Personal and Social History,Personlig og social historie
apps/erpnext/erpnext/education/doctype/guardian/guardian.py +51,User {0} created,Bruger {0} oprettet
DocType: Fee Schedule,Fee Breakup for each student,Fee Breakup for hver elev
apps/erpnext/erpnext/controllers/accounts_controller.py +617,Total advance ({0}) against Order {1} cannot be greater than the Grand Total ({2}),Samlet forhånd ({0}) mod Order {1} kan ikke være større end Grand alt ({2})
DocType: Sales Partner,Select Monthly Distribution to unevenly distribute targets across months.,Vælg Månedlig Distribution til ujævnt distribuere mål på tværs måneder.
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js +88,Change Code,Skift kode
DocType: Purchase Invoice Item,Valuation Rate,Værdiansættelsesbeløb
DocType: Vehicle,Diesel,Diesel
apps/erpnext/erpnext/stock/get_item_details.py +546,Price List Currency not selected,Prisliste Valuta ikke valgt
DocType: Purchase Invoice,Availed ITC Cess,Benyttet ITC Cess
,Student Monthly Attendance Sheet,Student Månedlig Deltagelse Sheet
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +96,Shipping rule only applicable for Selling,Forsendelsesregel gælder kun for salg
apps/erpnext/erpnext/assets/doctype/asset/asset.py +219,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,Afskrivningsrække {0}: Næste afskrivningsdato kan ikke være før købsdato
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +30,Project Start Date,Sag startdato
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +26,Until,Indtil
DocType: Rename Tool,Rename Log,Omdøb log
apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py +27,Student Group or Course Schedule is mandatory,Elevgruppe eller kursusplan er obligatorisk
DocType: HR Settings,Maintain Billing Hours and Working Hours Same on Timesheet,Vedligehold faktureringstimer og arbejdstimer i samme tidskladde
DocType: Maintenance Visit Purpose,Against Document No,Mod dokument nr
DocType: BOM,Scrap,Skrot
apps/erpnext/erpnext/utilities/user_progress.py +217,Go to Instructors,Gå til instruktører
apps/erpnext/erpnext/config/selling.py +110,Manage Sales Partners.,Administrér forhandlere.
DocType: Quality Inspection,Inspection Type,Kontroltype
DocType: Fee Validity,Visited yet,Besøgt endnu
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +135,Warehouses with existing transaction can not be converted to group.,Lager med eksisterende transaktion kan ikke konverteres til gruppen.
DocType: Assessment Result Tool,Result HTML,resultat HTML
DocType: Selling Settings,How often should project and company be updated based on Sales Transactions.,Hvor ofte skal projektet og virksomheden opdateres baseret på salgstransaktioner.
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +35,Expires On,Udløber på
apps/erpnext/erpnext/utilities/activation.py +117,Add Students,Tilføj studerende
apps/erpnext/erpnext/hr/doctype/employee_tax_exemption_declaration/employee_tax_exemption_declaration.js +18,Please select {0},Vælg {0}
DocType: C-Form,C-Form No,C-Form Ingen
DocType: BOM,Exploded_items,Exploded_items
DocType: Delivery Stop,Distance,Afstand
apps/erpnext/erpnext/utilities/user_progress.py +139,List your products or services that you buy or sell.,"Skriv dine produkter eller tjenester, som du køber eller sælger."
DocType: Water Analysis,Storage Temperature,Stuetemperatur
DocType: Sales Order,SAL-ORD-.YYYY.-,SAL-ORD-.YYYY.-
DocType: Employee Attendance Tool,Unmarked Attendance,umærket Deltagelse
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +256,Creating Payment Entries......,Oprettelse af betalingsindlæg ......
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +100,Researcher,Forsker
DocType: Program Enrollment Tool Student,Program Enrollment Tool Student,Program Tilmelding Tool Student
apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.py +16,Start date should be less than end date for task {0},Startdatoen skal være mindre end slutdatoen for opgaven {0}
,Consolidated Financial Statement,Koncernregnskab
apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py +25,Name or Email is mandatory,Navn eller E-mail er obligatorisk
DocType: Instructor,Instructor Log,Instruktør Log
DocType: Clinical Procedure,Clinical Procedure,Klinisk procedure
DocType: Shopify Settings,Delivery Note Series,Serie til leveringskort
DocType: Purchase Order Item,Returned Qty,Returneret Antal
DocType: Student,Exit,Udgang
apps/erpnext/erpnext/accounts/doctype/account/account.py +163,Root Type is mandatory,Rodtypen er obligatorisk
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +30,Failed to install presets,Kan ikke installere forudindstillinger
DocType: Healthcare Service Unit Type,UOM Conversion in Hours,UOM Konvertering i timer
DocType: Contract,Signee Details,Signee Detaljer
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +44,"{0} currently has a {1} Supplier Scorecard standing, and RFQs to this supplier should be issued with caution.","{0} har for øjeblikket et {1} leverandør scorecard stående, og RFQs til denne leverandør skal udleveres med forsigtighed."
DocType: Certified Consultant,Non Profit Manager,Non Profit Manager
DocType: BOM,Total Cost(Company Currency),Totale omkostninger (firmavaluta)
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +398,Serial No {0} created,Serienummer {0} oprettet
DocType: Homepage,Company Description for website homepage,Firmabeskrivelse til hjemmesiden
DocType: Item Customer Detail,"For the convenience of customers, these codes can be used in print formats like Invoices and Delivery Notes","Af hensyn til kunderne, kan disse koder bruges i udskriftsformater ligesom fakturaer og følgesedler"
apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py +18,Suplier Name,suplier Navn
apps/erpnext/erpnext/accounts/report/financial_statements.py +177,Could not retrieve information for {0}.,Kunne ikke hente oplysninger for {0}.
apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +141,Opening Entry Journal,Åbning Entry Journal
DocType: Contract,Fulfilment Terms,Opfyldelsesbetingelser
DocType: Sales Invoice,Time Sheet List,Timeregistreringsoversigt
DocType: Employee,You can enter any date manually,Du kan indtaste et hvilket som helst tidspunkt manuelt
DocType: Healthcare Settings,Result Printed,Resultat trykt
DocType: Asset Category Account,Depreciation Expense Account,Afskrivninger udgiftskonto
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +191,Probationary Period,Prøvetid
DocType: Purchase Taxes and Charges Template,Is Inter State,Er inter stat
apps/erpnext/erpnext/config/hr.py +269,Shift Management,Shift Management
DocType: Customer Group,Only leaf nodes are allowed in transaction,Kun blade noder er tilladt i transaktionen
DocType: Project,Total Costing Amount (via Timesheets),Samlet Omkostningsbeløb (via tidsskemaer)
DocType: Department,Expense Approver,Udlægsgodkender
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +168,Row {0}: Advance against Customer must be credit,Række {0}: Advance mod Kunden skal være kredit
DocType: Project,Hourly,Hver time
apps/erpnext/erpnext/accounts/doctype/account/account.js +88,Non-Group to Group,Ikke-gruppe til gruppe
DocType: Employee,ERPNext User,ERPNæste bruger
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +58,Batch is mandatory in row {0},Parti er obligatorisk i række {0}
DocType: Purchase Receipt Item Supplied,Purchase Receipt Item Supplied,Købskvittering leveret vare
DocType: Amazon MWS Settings,Enable Scheduled Synch,Aktivér planlagt synkronisering
apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py +24,To Datetime,Til datotid
apps/erpnext/erpnext/config/selling.py +308,Logs for maintaining sms delivery status,Logs for opretholdelse sms leveringsstatus
DocType: Accounts Settings,Make Payment via Journal Entry,Foretag betaling via kassekladden
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +263,Printed On,Trykt On
DocType: Clinical Procedure Template,Clinical Procedure Template,Klinisk procedureskabelon
DocType: Item,Inspection Required before Delivery,Kontrol påkrævet før levering
DocType: Item,Inspection Required before Purchase,Kontrol påkrævet før køb
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +93,Pending Activities,Afventende aktiviteter
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test_list.js +41,Create Lab Test,Lav Lab Test
DocType: Patient Appointment,Reminded,mindet
apps/erpnext/erpnext/public/js/setup_wizard.js +126,View Chart of Accounts,Se oversigt over konti
DocType: Chapter Member,Chapter Member,Kapitel Medlem
DocType: Material Request Plan Item,Minimum Order Quantity,Minimumsordrenummer
apps/erpnext/erpnext/public/js/setup_wizard.js +106,Your Organization,Din organisation
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.py +84,"Skipping Leave Allocation for the following employees, as Leave Allocation records already exists against them. {0}","Overspringetildeling for følgende medarbejdere, da der allerede eksisterer rekordoverførselsregistre. {0}"
DocType: Fee Component,Fees Category,Gebyrer Kategori
apps/erpnext/erpnext/hr/doctype/employee/employee.py +151,Please enter relieving date.,Indtast lindre dato.
apps/erpnext/erpnext/controllers/trends.py +149,Amt,Amt
DocType: Travel Request,"Details of Sponsor (Name, Location)","Detaljer om sponsor (navn, sted)"
DocType: Supplier Scorecard,Notify Employee,Underrette medarbejder
DocType: Opportunity,Enter name of campaign if source of enquiry is campaign,"Indtast navnet på kampagne, hvis kilden undersøgelsesudvalg er kampagne"
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +38,Newspaper Publishers,Dagbladsudgivere
apps/erpnext/erpnext/hr/utils.py +154,Future dates not allowed,Fremtidige datoer ikke tilladt
apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +30,Select Fiscal Year,Vælg regnskabsår
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +119,Expected Delivery Date should be after Sales Order Date,Forventet leveringsdato skal være efter salgsordredato
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +43,Reorder Level,Genbestil Level
DocType: Company,Chart Of Accounts Template,Kontoplan Skabelon
DocType: Attendance,Attendance Date,Fremmødedato
apps/erpnext/erpnext/assets/doctype/asset/asset.py +80,Update stock must be enable for the purchase invoice {0},Opdateringslager skal aktiveres for købsfakturaen {0}
apps/erpnext/erpnext/stock/get_item_details.py +405,Item Price updated for {0} in Price List {1},Vareprisen opdateret for {0} i prisliste {1}
DocType: Salary Structure,Salary breakup based on Earning and Deduction.,Lønnen opdelt på tillæg og fradrag.
apps/erpnext/erpnext/accounts/doctype/account/account.py +135,Account with child nodes cannot be converted to ledger,Konto med barneknudepunkter kan ikke konverteres til finans
DocType: Purchase Invoice Item,Accepted Warehouse,Accepteret lager
DocType: Bank Reconciliation Detail,Posting Date,Bogføringsdato
DocType: Item,Valuation Method,Værdiansættelsesmetode
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js +30,One customer can be part of only single Loyalty Program.,En kunde kan kun indgå i et enkelt loyalitetsprogram.
apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +203,Mark Half Day,Mark Halvdags
DocType: Sales Invoice,Sales Team,Salgsteam
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +88,Duplicate entry,Duplicate entry
apps/erpnext/erpnext/accounts/doctype/bank_guarantee/bank_guarantee.py +19,Enter the name of the Beneficiary before submittting.,Indtast modtagerens navn før indsendelse.
DocType: Program Enrollment Tool,Get Students,Hent studerende
DocType: Serial No,Under Warranty,Under garanti
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +530,[Error],[Fejl]
DocType: Sales Order,In Words will be visible once you save the Sales Order.,"""I Ord"" vil være synlig, når du gemmer salgsordren."
,Employee Birthday,Medarbejder Fødselsdag
apps/erpnext/erpnext/assets/doctype/asset_repair/asset_repair.py +14,Please select Completion Date for Completed Repair,Vælg venligst Afslutningsdato for Afsluttet Reparation
DocType: Student Batch Attendance Tool,Student Batch Attendance Tool,Elevgruppe fremmødeværktøj
apps/erpnext/erpnext/controllers/status_updater.py +216,Limit Crossed,Grænse overskredet
apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.js +22,Scheduled Upto,Planlagt Upto
DocType: Woocommerce Settings,Secret,Hemmelighed
DocType: Company,Date of Establishment,Dato for etablering
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +55,Venture Capital,Venture Capital
apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +40,An academic term with this 'Academic Year' {0} and 'Term Name' {1} already exists. Please modify these entries and try again.,"En akademisk betegnelse for denne ""skoleår '{0} og"" betingelsesnavn' {1} findes allerede. Korrigér venligst og prøv igen."
DocType: UOM,Must be Whole Number,Skal være hele tal
DocType: Leave Control Panel,New Leaves Allocated (In Days),Nyt fravær tildelt (i dage)
DocType: Purchase Invoice,Invoice Copy,Faktura kopi
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +49,Serial No {0} does not exist,Serienummer {0} eksisterer ikke
DocType: Sales Invoice Item,Customer Warehouse (Optional),Kundelager (valgfrit)
DocType: Blanket Order Item,Blanket Order Item,Tæppe Bestillingsartikel
DocType: Pricing Rule,Discount Percentage,Discount Procent
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +51,Reserved for sub contracting,Reserveret til underentreprise
DocType: Payment Reconciliation Invoice,Invoice Number,Fakturanummer
DocType: Shopping Cart Settings,Orders,Ordrer
DocType: Travel Request,Event Details,Eventdetaljer
DocType: Department,Leave Approver,Fraværsgodkender
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +316,Please select a batch,Vælg venligst et parti
apps/erpnext/erpnext/config/hr.py +145,Travel and Expense Claim,Rejse- og udgiftskrav
DocType: Sales Invoice,Redemption Cost Center,Indløsningsomkostningscenter
DocType: QuickBooks Migrator,Scope,Anvendelsesområde
DocType: Assessment Group,Assessment Group Name,Assessment Group Name
DocType: Manufacturing Settings,Material Transferred for Manufacture,Materiale Overført til Fremstilling
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js +60,Add to Details,Tilføj til detaljer
DocType: Travel Itinerary,Taxi,Taxa
DocType: Shopify Settings,Last Sync Datetime,Sidste synkroniseringstidspunkt
DocType: Landed Cost Item,Receipt Document Type,Kvittering Dokumenttype
DocType: Daily Work Summary Settings,Select Companies,Vælg Virksomheder
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +225,Proposal/Price Quote,Forslag / pris citat
DocType: Antibiotic,Healthcare,Healthcare
DocType: Target Detail,Target Detail,Target Detail
apps/erpnext/erpnext/stock/doctype/item/item.js +67,Single Variant,Single Variant
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +51,All Jobs,Alle ansøgere
DocType: Sales Order,% of materials billed against this Sales Order,% af materialer faktureret mod denne salgsordre
DocType: Program Enrollment,Mode of Transportation,Transportform
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +65,Period Closing Entry,Periode Lukning indtastning
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +72,Select Department...,Vælg afdelingen ...
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +40,Cost Center with existing transactions can not be converted to group,Omkostningssted med eksisterende transaktioner kan ikke konverteres til gruppe
DocType: QuickBooks Migrator,Authorization URL,Tilladelseswebadresse
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +376,Amount {0} {1} {2} {3},Mængden {0} {1} {2} {3}
DocType: Account,Depreciation,Afskrivninger
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +103,The number of shares and the share numbers are inconsistent,Antallet af aktier og aktienumrene er inkonsekvente
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +50,Supplier(s),Leverandør (er)
DocType: Employee Attendance Tool,Employee Attendance Tool,Medarbejder Deltagerliste Værktøj
DocType: Guardian Student,Guardian Student,Guardian Student
DocType: Supplier,Credit Limit,Kreditgrænse
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +77,Avg. Selling Price List Rate,Gennemsnitlig. Salgsprisliste Pris
DocType: Loyalty Program Collection,Collection Factor (=1 LP),Samlingsfaktor (= 1 LP)
DocType: Additional Salary,Salary Component,Lønart
apps/erpnext/erpnext/accounts/utils.py +519,Payment Entries {0} are un-linked,Betalings Entries {0} er un-linked
DocType: GL Entry,Voucher No,Bilagsnr.
,Lead Owner Efficiency,Lederegenskaber Effektivitet
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py +65,"You can claim only an amount of {0}, the rest amount {1} should be in the application \
				as pro-rata component","Du kan kun kræve en mængde af {0}, resten mængde {1} skal være i applikationen \ som pro-rata-komponent"
DocType: Amazon MWS Settings,Customer Type,Kunde type
DocType: Compensatory Leave Request,Leave Allocation,Fraværstildeling
DocType: Payment Request,Recipient Message And Payment Details,Modtager Besked Og Betalingsoplysninger
DocType: Support Search Source,Source DocType,Kilde DocType
apps/erpnext/erpnext/templates/pages/help.html +60,Open a new ticket,Åbn en ny billet
DocType: Training Event,Trainer Email,Trainer Email
DocType: Driver,Transporter,Transporter
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +550,Material Requests {0} created,Materialeanmodning {0} oprettet
DocType: Restaurant Reservation,No of People,Ingen af mennesker
apps/erpnext/erpnext/config/selling.py +164,Template of terms or contract.,Skabelon til vilkår eller kontrakt.
DocType: Bank Account,Address and Contact,Adresse og kontaktperson
DocType: Vital Signs,Hyper,Hyper
DocType: Cheque Print Template,Is Account Payable,Er konto Betales
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +306,Stock cannot be updated against Purchase Receipt {0},Lager kan ikke opdateres mod købskvittering {0}
DocType: Support Settings,Auto close Issue after 7 days,Auto tæt Issue efter 7 dage
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +85,"Leave cannot be allocated before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}","Fravær kan ikke fordeles inden {0}, da fraværssaldoen allerede har været carry-fremsendt i fremtiden orlov tildeling rekord {1}"
apps/erpnext/erpnext/accounts/party.py +350,Note: Due / Reference Date exceeds allowed customer credit days by {0} day(s),Bemærk: forfalden / reference Dato overstiger tilladte kredit dage efter {0} dag (e)
apps/erpnext/erpnext/education/doctype/program/program.js +8,Student Applicant,Student Ansøger
DocType: Hub Tracked Item,Hub Tracked Item,Hub Tracked Item
DocType: Purchase Invoice,ORIGINAL FOR RECIPIENT,OPRINDELIGT FOR RECIPIENT
DocType: Asset Category Account,Accumulated Depreciation Account,Akkumuleret Afskrivninger konto
DocType: Certified Consultant,Discuss ID,Diskuter ID
DocType: Stock Settings,Freeze Stock Entries,Frys Stock Entries
DocType: Program Enrollment,Boarding Student,Boarding Student
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +81,Please enable Applicable on Booking Actual Expenses,Aktivér venligst ved bestilling af faktiske udgifter
DocType: Asset Finance Book,Expected Value After Useful Life,Forventet værdi efter forventet brugstid
DocType: Item,Reorder level based on Warehouse,Genbestil niveau baseret på Warehouse
DocType: Activity Cost,Billing Rate,Faktureringssats
,Qty to Deliver,Antal at levere
DocType: Amazon MWS Settings,Amazon will synch data updated after this date,Amazon vil synkronisere data opdateret efter denne dato
,Stock Analytics,Lageranalyser
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +543,Operations cannot be left blank,Operationer kan ikke være tomt
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.py +72,Lab Test(s) ,Lab Test (s)
DocType: Maintenance Visit Purpose,Against Document Detail No,Imod Dokument Detail Nej
apps/erpnext/erpnext/regional/__init__.py +11,Deletion is not permitted for country {0},Sletning er ikke tilladt for land {0}
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +111,Party Type is mandatory,Party Typen er obligatorisk
DocType: Quality Inspection,Outgoing,Udgående
DocType: Material Request,Requested For,Anmodet om
DocType: Quotation Item,Against Doctype,Mod DOCTYPE
apps/erpnext/erpnext/controllers/buying_controller.py +503,{0} {1} is cancelled or closed,{0} {1} er aflyst eller lukket
DocType: Asset,Calculate Depreciation,Beregn afskrivninger
DocType: Delivery Note,Track this Delivery Note against any Project,Spor denne følgeseddel mod en hvilken som helst sag
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +89,Net Cash from Investing,Netto kontant fra Investering
DocType: Work Order,Work-in-Progress Warehouse,Work-in-Progress Warehouse
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +116,Asset {0} must be submitted,Aktiv {0} skal godkendes
DocType: Fee Schedule Program,Total Students,Samlet Studerende
apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py +56,Attendance Record {0} exists against Student {1},Tilstedeværelse {0} eksisterer for studerende {1}
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +390,Reference #{0} dated {1},Henvisning # {0} dateret {1}
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +179,Depreciation Eliminated due to disposal of assets,Bortfaldne afskrivninger grundet afhændelse af aktiver
DocType: Employee Transfer,New Employee ID,New Employee ID
DocType: Loan,Member,Medlem
apps/erpnext/erpnext/templates/includes/cart/cart_address.html +15,Manage Addresses,Administrér adresser
DocType: Work Order Item,Work Order Item,Arbejdsordre
DocType: Pricing Rule,Item Code,Varenr.
DocType: Student,EDU-STU-.YYYY.-,EDU-STU-.YYYY.-
DocType: Serial No,Warranty / AMC Details,Garanti / AMC Detaljer
apps/erpnext/erpnext/education/doctype/student_group/student_group.js +119,Select students manually for the Activity based Group,Vælg studerende manuelt for aktivitetsbaseret gruppe
DocType: Journal Entry,User Remark,Brugerbemærkning
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +97,Optimizing routes.,Optimering af ruter.
DocType: Travel Itinerary,Non Diary,Ikke-dagbog
apps/erpnext/erpnext/hr/doctype/retention_bonus/retention_bonus.py +14,Cannot create Retention Bonus for left Employees,Kan ikke oprette tilbageholdelsesbonus for venstre medarbejdere
DocType: Lead,Market Segment,Markedssegment
DocType: Agriculture Analysis Criteria,Agriculture Manager,Landbrugschef
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +999,Paid Amount cannot be greater than total negative outstanding amount {0},Betalt beløb kan ikke være større end det samlede negative udestående beløb {0}
DocType: Supplier Scorecard Period,Variables,Variable
DocType: Employee Internal Work History,Employee Internal Work History,Medarbejder Intern Arbejde Historie
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +271,Closing (Dr),Lukning (dr)
DocType: Cheque Print Template,Cheque Size,Anvendes ikke
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +284,Serial No {0} not in stock,Serienummer {0} ikke er på lager
apps/erpnext/erpnext/config/selling.py +169,Tax template for selling transactions.,Beskatningsskabelon for salgstransaktioner.
DocType: Sales Invoice,Write Off Outstanding Amount,Skriv Off Udestående beløb
apps/erpnext/erpnext/hr/doctype/expense_claim_type/expense_claim_type.py +27,Account {0} does not match with Company {1},Konto {0} stemmer ikke overens med firma {1}
DocType: Education Settings,Current Academic Year,Nuværende skoleår
DocType: Stock Settings,Default Stock UOM,Standard lagerenhed
DocType: Asset,Number of Depreciations Booked,Antal Afskrivninger Reserveret
apps/erpnext/erpnext/public/js/pos/pos.html +71,Qty Total,Antal i alt
DocType: Landed Cost Item,Receipt Document,Kvittering dokument
DocType: Employee Education,School/University,Skole / Universitet
DocType: Sales Invoice Item,Available Qty at Warehouse,Tilgængeligt antal på lageret
apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +20,Billed Amount,Faktureret beløb
DocType: Share Transfer,(including),(inklusive)
DocType: Asset,Double Declining Balance,Dobbelt Faldende Balance
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +188,Closed order cannot be cancelled. Unclose to cancel.,Lukket ordre kan ikke annulleres. Unclose at annullere.
apps/erpnext/erpnext/config/hr.py +120,Payroll Setup,Lønningsopsætning
DocType: Amazon MWS Settings,Synch Products,Synch produkter
DocType: Loyalty Point Entry,Loyalty Program,Loyalitetsprogram
DocType: Student Guardian,Father,Far
apps/erpnext/erpnext/crm/report/lead_conversion_time/lead_conversion_time.py +59,Support Tickets,Support Billetter
apps/erpnext/erpnext/controllers/accounts_controller.py +703,'Update Stock' cannot be checked for fixed asset sale,'Opdater lager' kan ikke kontrolleres pga. salg af anlægsaktiver
DocType: Bank Reconciliation,Bank Reconciliation,Bank Afstemning
DocType: Attendance,On Leave,Fraværende
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +7,Get Updates,Modtag nyhedsbrev
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +97,{0} {1}: Account {2} does not belong to Company {3},{0} {1}: Konto {2} tilhører ikke firma {3}
apps/erpnext/erpnext/stock/doctype/item/item.js +452,Select at least one value from each of the attributes.,Vælg mindst en værdi fra hver af attributterne.
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +164,Material Request {0} is cancelled or stopped,Materialeanmodning {0} er annulleret eller stoppet
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +219,Dispatch State,Afsendelsesstat
apps/erpnext/erpnext/config/hr.py +399,Leave Management,Fraværsadministration
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +17,Groups,Grupper
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +51,Group by Account,Sortér efter konto
DocType: Purchase Invoice,Hold Invoice,Hold faktura
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js +37,Please select Employee,Vælg venligst Medarbejder
DocType: Sales Order,Fully Delivered,Fuldt Leveres
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +214,Lower Income,Lavere indkomst
DocType: Restaurant Order Entry,Current Order,Nuværende ordre
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +25,Number of serial nos and quantity must be the same,Antallet serienummer og mængde skal være ens
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +275,Source and target warehouse cannot be same for row {0},Kilde og mål lageret ikke kan være ens for rækken {0}
DocType: Account,Asset Received But Not Billed,Asset modtaget men ikke faktureret
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +244,"Difference Account must be a Asset/Liability type account, since this Stock Reconciliation is an Opening Entry","Differencebeløbet skal være af kontotypen Aktiv / Fordring, da denne lagerafstemning er en åbningsbalance"
apps/erpnext/erpnext/hr/doctype/loan/loan.py +116,Disbursed Amount cannot be greater than Loan Amount {0},Udbetalte beløb kan ikke være større end Lånebeløb {0}
apps/erpnext/erpnext/utilities/user_progress.py +176,Go to Programs,Gå til Programmer
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +212,Row {0}# Allocated amount {1} cannot be greater than unclaimed amount {2},Række {0} # Tildelt mængde {1} kan ikke være større end uanmeldt mængde {2}
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +91,Purchase Order number required for Item {0},Indkøbsordrenr. påkrævet for vare {0}
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +18,'From Date' must be after 'To Date','Fra dato' skal være efter 'Til dato'
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.js +32,No Staffing Plans found for this Designation,Ingen bemandingsplaner fundet for denne betegnelse
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1079,Batch {0} of Item {1} is disabled.,Batch {0} i vare {1} er deaktiveret.
DocType: Leave Policy Detail,Annual Allocation,Årlig tildeling
DocType: Travel Request,Address of Organizer,Arrangørens adresse
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +68,Select Healthcare Practitioner...,Vælg Healthcare Practitioner ...
DocType: Employee Boarding Activity,Applicable in the case of Employee Onboarding,Gælder for medarbejder ombordstigning
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +39,Cannot change status as student {0} is linked with student application {1},Kan ikke ændre status som studerende {0} er forbundet med student ansøgning {1}
DocType: Asset,Fully Depreciated,fuldt afskrevet
DocType: Item Barcode,UPC-A,UPC-A
,Stock Projected Qty,Stock Forventet Antal
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +516,Customer {0} does not belong to project {1},Kunden {0} hører ikke til sag {1}
DocType: Employee Attendance Tool,Marked Attendance HTML,Markant Deltagelse HTML
apps/erpnext/erpnext/utilities/activation.py +73,"Quotations are proposals, bids you have sent to your customers","Citater er forslag, bud, du har sendt til dine kunder"
DocType: Sales Invoice,Customer's Purchase Order,Kundens indkøbsordre
DocType: Clinical Procedure,Patient,Patient
apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +49,Bypass credit check at Sales Order ,Bypass kreditcheck på salgsordre
DocType: Employee Onboarding Activity,Employee Onboarding Activity,Medarbejder Onboarding Aktivitet
DocType: Location,Check if it is a hydroponic unit,Kontroller om det er en hydroponisk enhed
apps/erpnext/erpnext/config/stock.py +112,Serial No and Batch,Serienummer og parti
DocType: Warranty Claim,From Company,Fra firma
apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py +40,Sum of Scores of Assessment Criteria needs to be {0}.,Summen af Snesevis af Assessment Criteria skal være {0}.
apps/erpnext/erpnext/assets/doctype/asset/asset.py +207,Please set Number of Depreciations Booked,Venligst sæt Antal Afskrivninger Reserveret
DocType: Supplier Scorecard Period,Calculations,Beregninger
apps/erpnext/erpnext/public/js/stock_analytics.js +48,Value or Qty,Værdi eller mængde
DocType: Payment Terms Template,Payment Terms,Betalingsbetingelser
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +485,Productions Orders cannot be raised for:,Productions Ordrer kan ikke hæves til:
apps/erpnext/erpnext/utilities/user_progress.py +147,Minute,Minut
DocType: Purchase Invoice,Purchase Taxes and Charges,Indkøb Moms og afgifter
DocType: Chapter,Meetup Embed HTML,Meetup Embed HTML
DocType: Asset,Insured value,Forsikret værdi
apps/erpnext/erpnext/utilities/user_progress.py +121,Go to Suppliers,Gå til leverandører
DocType: POS Closing Voucher Taxes,POS Closing Voucher Taxes,POS Closing Voucher Skatter
,Qty to Receive,Antal til Modtag
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +564,"Start and end dates not in a valid Payroll Period, cannot calculate {0}.","Start og slut dato ikke i en gyldig lønseddel, kan ikke beregne {0}."
DocType: Leave Block List,Leave Block List Allowed,Tillad blokerede fraværsansøgninger
DocType: Grading Scale Interval,Grading Scale Interval,Karakterskala Interval
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +49,Expense Claim for Vehicle Log {0},Udlæg for kørebog {0}
DocType: Sales Invoice Item,Discount (%) on Price List Rate with Margin,Rabat (%) på prisliste med margen
DocType: Healthcare Service Unit Type,Rate / UOM,Rate / UOM
apps/erpnext/erpnext/patches/v7_0/create_warehouse_nestedset.py +59,All Warehouses,Alle lagre
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +1303,No {0} found for Inter Company Transactions.,Nej {0} fundet for Inter Company Transactions.
DocType: Travel Itinerary,Rented Car,Lejet bil
apps/erpnext/erpnext/public/js/hub/components/profile_dialog.js +15,About your Company,Om din virksomhed
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +144,Credit To account must be a Balance Sheet account,Kredit til konto skal være en balance konto
DocType: Donor,Donor,Donor
DocType: Global Defaults,Disable In Words,Deaktiver i ord
apps/erpnext/erpnext/stock/doctype/item/item.py +74,Item Code is mandatory because Item is not automatically numbered,"Varenr. er obligatorisk, fordi varen ikke nummereres automatisk"
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +102,Quotation {0} not of type {1},Tilbud {0} ikke af typen {1}
DocType: Maintenance Schedule Item,Maintenance Schedule Item,Vedligeholdelse Skema Vare
DocType: Sales Order,%  Delivered,% Leveret
apps/erpnext/erpnext/education/doctype/fees/fees.js +108,Please set the Email ID for the Student to send the Payment Request,Angiv e-mail-id til den studerende for at sende betalingsanmodningen
DocType: Patient,Medical History,Medicinsk historie
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +167,Bank Overdraft Account,Bank kassekredit
DocType: Patient,Patient ID,Patient-ID
DocType: Practitioner Schedule,Schedule Name,Planlægningsnavn
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.js +302,Sales Pipeline by Stage,Salgsledning efter trin
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js +49,Make Salary Slip,Opret lønseddel
DocType: Currency Exchange,For Buying,Til køb
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +897,Add All Suppliers,Tilføj alle leverandører
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +95,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Row # {0}: Allokeret beløb kan ikke være større end udestående beløb.
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +84,Browse BOM,Gennemse styklister
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +165,Secured Loans,Sikrede lån
DocType: Purchase Invoice,Edit Posting Date and Time,Redigér bogføringsdato og -tid
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +106,Please set Depreciation related Accounts in Asset Category {0} or Company {1},Venligst sæt Afskrivninger relaterede konti i Asset kategori {0} eller Company {1}
DocType: Lab Test Groups,Normal Range,Normal rækkevidde
DocType: Academic Term,Academic Year,Skoleår
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +79,Available Selling,Tilgængelig salg
DocType: Loyalty Point Entry Redemption,Loyalty Point Entry Redemption,Indfrielse af loyalitetspoint
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +179,Opening Balance Equity,Åbning Balance Egenkapital
DocType: Contract,CRM,CRM
DocType: Purchase Invoice,N,N
apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +175,Remaining,Resterende
DocType: Appraisal,Appraisal,Vurdering
DocType: Loan,Loan Account,Lånekonto
DocType: Purchase Invoice,GST Details,GST Detaljer
apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py +6,This is based on transactions against this Healthcare Practitioner.,Dette er baseret på transaktioner mod denne Healthcare Practitioner.
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +156,Email sent to supplier {0},E-mail sendt til leverandør {0}
DocType: Item,Default Sales Unit of Measure,Standard salgsforanstaltning
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +12,Academic Year: ,Akademi år:
DocType: Inpatient Record,Admission Schedule Date,Adgangskalender Dato
DocType: Subscription,Past Due Date,Forfaldsdato
apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py +19,Not allow to set alternative item for the item {0},Tillad ikke at indstille alternativt element til varen {0}
apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py +19,Date is repeated,Datoen er gentaget
apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +27,Authorized Signatory,Tegningsberettiget
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +65,Create Fees,Opret gebyrer
DocType: Project,Total Purchase Cost (via Purchase Invoice),Samlet anskaffelsespris (via købsfaktura)
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +549,Select Quantity,Vælg antal
DocType: Loyalty Point Entry,Loyalty Points,Loyalitetspoint
DocType: Customs Tariff Number,Customs Tariff Number,Toldtarif nummer
DocType: Patient Appointment,Patient Appointment,Patientaftale
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +34,Approving Role cannot be same as role the rule is Applicable To,Godkendelse Rolle kan ikke være det samme som rolle reglen gælder for
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +65,Unsubscribe from this Email Digest,Afmeld dette e-mail-nyhedsbrev
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +887,Get Suppliers By,Få leverandører af
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +187,{0} not found for Item {1},{0} ikke fundet for punkt {1}
apps/erpnext/erpnext/utilities/user_progress.py +197,Go to Courses,Gå til kurser
DocType: Accounts Settings,Show Inclusive Tax In Print,Vis inklusiv skat i tryk
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +17,"Bank Account, From Date and To Date are Mandatory","Bankkonto, Fra dato og til dato er obligatorisk"
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +29,Message Sent,Besked sendt
apps/erpnext/erpnext/accounts/doctype/account/account.py +105,Account with child nodes cannot be set as ledger,Konto med barn noder kan ikke indstilles som hovedbog
DocType: C-Form,II,II
DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,"Hastighed, hvormed Prisliste valuta omregnes til kundens basisvaluta"
DocType: Purchase Invoice Item,Net Amount (Company Currency),Nettobeløb (firmavaluta)
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +223,Total advance amount cannot be greater than total sanctioned amount,Samlet forskudsbeløb kan ikke være større end det samlede sanktionerede beløb
DocType: Salary Slip,Hour Rate,Timesats
DocType: Stock Settings,Item Naming By,Item Navngivning By
apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +46,Another Period Closing Entry {0} has been made after {1},En anden Periode Lukning indtastning {0} er blevet foretaget efter {1}
DocType: Work Order,Material Transferred for Manufacturing,Materiale Overført til Manufacturing
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +49,Account {0} does not exists,Konto {0} findes ikke
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1608,Select Loyalty Program,Vælg Loyalitetsprogram
DocType: Project,Project Type,Sagstype
apps/erpnext/erpnext/projects/doctype/task/task.py +157,Child Task exists for this Task. You can not delete this Task.,Børneopgave eksisterer for denne opgave. Du kan ikke slette denne opgave.
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +17,Either target qty or target amount is mandatory.,Enten target qty eller målbeløbet er obligatorisk.
apps/erpnext/erpnext/config/projects.py +56,Cost of various activities,Omkostninger ved forskellige aktiviteter
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +60,"Setting Events to {0}, since the Employee attached to the below Sales Persons does not have a User ID{1}","Sætter begivenheder til {0}, da den til medarbejderen tilknyttede salgsmedarbejder {1} ikke har et brugernavn"
DocType: Timesheet,Billing Details,Faktureringsoplysninger
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +163,Source and target warehouse must be different,Kilde og mål lager skal være forskellige
apps/erpnext/erpnext/erpnext_integrations/doctype/gocardless_settings/gocardless_settings.py +140,Payment Failed. Please check your GoCardless Account for more details,Betaling mislykkedes. Tjek venligst din GoCardless-konto for flere detaljer
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +101,Not allowed to update stock transactions older than {0},Ikke tilladt at opdatere lagertransaktioner ældre end {0}
DocType: BOM,Inspection Required,Inspection Nødvendig
DocType: Purchase Invoice Item,PR Detail,PR Detail
apps/erpnext/erpnext/accounts/doctype/bank_guarantee/bank_guarantee.py +17,Enter the Bank Guarantee Number before submittting.,Indtast bankgarantienummeret før indsendelse.
DocType: Driving License Category,Class,klasse
DocType: Sales Order,Fully Billed,Fuldt Billed
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +387,Work Order cannot be raised against a Item Template,Arbejdsordre kan ikke rejses imod en vare skabelon
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +101,Shipping rule only applicable for Buying,Forsendelsesregel gælder kun for køb
DocType: Vital Signs,BMI,BMI
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +20,Cash In Hand,Kassebeholdning
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +143,Delivery warehouse required for stock item {0},Levering lager kræves for lagervare {0}
DocType: Packing Slip,The gross weight of the package. Usually net weight + packaging material weight. (for print),Bruttovægt af pakken. Normalt nettovægt + emballagematerialevægt. (til udskrivning)
DocType: Assessment Plan,Program,Program
DocType: Accounts Settings,Users with this role are allowed to set frozen accounts and create / modify accounting entries against frozen accounts,Brugere med denne rolle får lov til at sætte indefrosne konti og oprette / ændre regnskabsposter mod indefrosne konti
DocType: Vital Signs,Cuts,Cuts
DocType: Serial No,Is Cancelled,Er Annulleret
DocType: Student Group,Group Based On,Gruppe baseret på
DocType: Journal Entry,Bill Date,Bill Dato
DocType: Healthcare Settings,Laboratory SMS Alerts,Laboratory SMS Alerts
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +20,"Service Item,Type,frequency and expense amount are required","Tjenesten Vare, type, frekvens og omkostninger beløb kræves"
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +45,"Even if there are multiple Pricing Rules with highest priority, then following internal priorities are applied:","Selv hvis der er flere Priser Regler med højeste prioritet, derefter følgende interne prioriteringer anvendt:"
DocType: Plant Analysis Criteria,Plant Analysis Criteria,Plant Analyse Kriterier
DocType: Cheque Print Template,Cheque Height,Anvendes ikke
DocType: Supplier,Supplier Details,Leverandør Detaljer
DocType: Setup Progress,Setup Progress,Setup Progress
DocType: Expense Claim,Approval Status,Godkendelsesstatus
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +35,From value must be less than to value in row {0},Fra værdi skal være mindre end at værdien i række {0}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +135,Wire Transfer,Bankoverførsel
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +93,Check all,Vælg alle
,Issued Items Against Work Order,Udstedte varer mod arbejdsordre
,BOM Stock Calculated,BOM lager Beregnet
DocType: Vehicle Log,Invoice Ref,Fakturareference
DocType: Company,Default Income Account,Standard Indkomst konto
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +39,Unclosed Fiscal Years Profit / Loss (Credit),Uafsluttede regnskabsår Profit / Loss (Credit)
DocType: Sales Invoice,Time Sheets,Tidsregistreringer
DocType: Healthcare Service Unit Type,Change In Item,Skift i vare
DocType: Payment Gateway Account,Default Payment Request Message,Standard Betaling Request Message
DocType: Retention Bonus,Bonus Amount,Bonusbeløb
DocType: Item Group,Check this if you want to show in website,"Markér dette, hvis du ønsker at vise det på hjemmesiden"
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +376,Balance ({0}),Balance ({0})
DocType: Loyalty Point Entry,Redeem Against,Indløse imod
apps/erpnext/erpnext/config/accounts.py +130,Banking and Payments,Bank- og betalinger
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.py +99,Please enter API Consumer Key,Indtast venligst API forbrugernøgle
,Welcome to ERPNext,Velkommen til ERPNext
apps/erpnext/erpnext/config/learn.py +102,Lead to Quotation,Emne til tilbud
apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +34,Email Reminders will be sent to all parties with email contacts,Email påmindelser vil blive sendt til alle parter med e-mail kontakter
DocType: Project,Twice Daily,To gange dagligt
DocType: Inpatient Record,A Negative,En negativ
apps/erpnext/erpnext/templates/includes/product_list.js +45,Nothing more to show.,Intet mere at vise.
DocType: Lead,From Customer,Fra kunde
apps/erpnext/erpnext/demo/setup/setup_data.py +340,Calls,Opkald
apps/erpnext/erpnext/utilities/user_progress.py +143,A Product,Et produkt
DocType: Employee Tax Exemption Declaration,Declarations,erklæringer
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +235,Batches,partier
apps/erpnext/erpnext/education/doctype/fee_structure/fee_structure.js +34,Make Fee Schedule,Lav gebyrplan
DocType: Purchase Order Item Supplied,Stock UOM,Lagerenhed
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +263,Purchase Order {0} is not submitted,Indkøbsordre {0} er ikke godkendt
DocType: Account,Expenses Included In Asset Valuation,Udgifter inkluderet i Asset Valuation
DocType: Vital Signs,Normal reference range for an adult is 16–20 breaths/minute (RCP 2012),Normalt referenceområde for en voksen er 16-20 vejrtrækninger / minut (RCP 2012)
DocType: Customs Tariff Number,Tariff Number,Tarif nummer
DocType: Work Order Item,Available Qty at WIP Warehouse,Tilgængelig antal på WIP Warehouse
apps/erpnext/erpnext/stock/doctype/item/item.js +41,Projected,Forventet
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +233,Serial No {0} does not belong to Warehouse {1},Serienummer {0} hører ikke til lager {1}
apps/erpnext/erpnext/controllers/status_updater.py +180,Note: System will not check over-delivery and over-booking for Item {0} as quantity or amount is 0,Bemærk: Systemet vil ikke kontrollere over-levering og over-booking for Item {0} som mængde eller beløb er 0
DocType: Notification Control,Quotation Message,Tilbudsbesked
DocType: Issue,Opening Date,Åbning Dato
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +89,Please save the patient first,Gem venligst patienten først
apps/erpnext/erpnext/education/api.py +80,Attendance has been marked successfully.,Deltagelse er mærket korrekt.
DocType: Program Enrollment,Public Transport,Offentlig transport
DocType: Delivery Note,GST Vehicle Type,GST-køretøjstype
DocType: Soil Texture,Silt Composition (%),Silt Sammensætning (%)
DocType: Journal Entry,Remark,Bemærkning
DocType: Healthcare Settings,Avoid Confirmation,Undgå bekræftelse
DocType: Purchase Receipt Item,Rate and Amount,Sats og Beløb
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +177,Account Type for {0} must be {1},Kontotype for {0} skal være {1}
apps/erpnext/erpnext/config/hr.py +34,Leaves and Holiday,Ferie og fravær
DocType: Education Settings,Current Academic Term,Nuværende akademisk betegnelse
DocType: Sales Order,Not Billed,Ikke faktureret
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +77,Both Warehouse must belong to same Company,Begge lagre skal høre til samme firma
DocType: Employee Grade,Default Leave Policy,Standard Afgangspolitik
DocType: Shopify Settings,Shop URL,Shop URL
apps/erpnext/erpnext/public/js/templates/contact_list.html +34,No contacts added yet.,Ingen kontakter tilføjet endnu.
DocType: Purchase Invoice Item,Landed Cost Voucher Amount,Landed Cost Voucher Beløb
,Item Balance (Simple),Varebalance (Enkel)
apps/erpnext/erpnext/config/accounts.py +19,Bills raised by Suppliers.,Regninger oprettet af leverandører.
DocType: POS Profile,Write Off Account,Skriv Off konto
DocType: Patient Appointment,Get prescribed procedures,Få foreskrevne procedurer
DocType: Sales Invoice,Redemption Account,Indløsningskonto
DocType: Purchase Invoice Item,Discount Amount,Rabatbeløb
DocType: Purchase Invoice,Return Against Purchase Invoice,Retur Against købsfaktura
DocType: Item,Warranty Period (in days),Garantiperiode (i dage)
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +56,Relation with Guardian1,Forholdet til Guardian1
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +879,Please select BOM against item {0},Vælg venligst BOM mod punkt {0}
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +18,Make Invoices,Lav fakturaer
DocType: Shopping Cart Settings,Show Stock Quantity,Vis lager Antal
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +77,Net Cash from Operations,Netto kontant fra drift
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +26,Item 4,Vare 4
DocType: Student Admission,Admission End Date,Optagelse Slutdato
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py +30,Sub-contracting,Underleverandører
DocType: Journal Entry Account,Journal Entry Account,Kassekladde konto
apps/erpnext/erpnext/education/doctype/academic_year/academic_year.js +3,Student Group,Elevgruppe
DocType: Shopping Cart Settings,Quotation Series,Tilbudsnummer
apps/erpnext/erpnext/setup/doctype/item_group/item_group.py +60,"An item exists with same name ({0}), please change the item group name or rename the item","En vare eksisterer med samme navn ({0}), og du bedes derfor ændre navnet på varegruppen eller omdøbe varen"
DocType: Soil Analysis Criteria,Soil Analysis Criteria,Kriterier for jordanalyse
apps/erpnext/erpnext/accounts/page/pos/pos.js +2052,Please select customer,Vælg venligst kunde
DocType: C-Form,I,jeg
DocType: Company,Asset Depreciation Cost Center,Asset Afskrivninger Omkostninger center
DocType: Production Plan Sales Order,Sales Order Date,Salgsordredato
DocType: Sales Invoice Item,Delivered Qty,Leveres Antal
DocType: Assessment Plan,Assessment Plan,Plan Assessment
DocType: Travel Request,Fully Sponsored,Fuldt sponsoreret
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +28,Reverse Journal Entry,Reverse Journal Entry
apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +90,Customer {0} is created.,Kunden {0} er oprettet.
DocType: Stock Settings,Limit Percent,Begrænsningsprocent
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +82, Currently no stock available in any warehouse,Der er i øjeblikket ingen lager på lageret
,Payment Period Based On Invoice Date,Betaling Periode Baseret på Fakturadato
DocType: Sample Collection,No. of print,Antal udskrifter
apps/erpnext/erpnext/hr/doctype/employee/employee.py +259,Birthday Reminder,Fødselsdag påmindelse
DocType: Hotel Room Reservation Item,Hotel Room Reservation Item,Hotel Room Reservation Item
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +59,Missing Currency Exchange Rates for {0},Manglende Valutakurser for {0}
DocType: Employee Health Insurance,Health Insurance Name,Navn på sygesikring
DocType: Assessment Plan,Examiner,Censor
DocType: Student,Siblings,Søskende
DocType: Journal Entry,Stock Entry,Lagerindtastning
DocType: Payment Entry,Payment References,Betalingsreferencer
DocType: Subscription Plan,"Number of intervals for the interval field e.g if Interval is 'Days' and Billing Interval Count is 3, invoices will be generated every 3 days","Antal intervaller for intervalfeltet, fx hvis Interval er &#39;Days&#39; og Billing Interval Count er 3, vil fakturaer blive genereret hver 3. dag"
DocType: Clinical Procedure Template,Allow Stock Consumption,Tillad lagerforbrug
DocType: Asset,Insurance Details,Forsikring Detaljer
DocType: Account,Payable,Betales
DocType: Share Balance,Share Type,Share Type
apps/erpnext/erpnext/hr/doctype/loan/loan.py +123,Please enter Repayment Periods,Indtast venligst Tilbagebetalingstid
apps/erpnext/erpnext/shopping_cart/cart.py +378,Debtors ({0}),Debitorer ({0})
DocType: Pricing Rule,Margin,Margen
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +57,New Customers,Nye kunder
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +72,Gross Profit %,Gross Profit%
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +90,Appointment {0} and Sales Invoice {1} cancelled,Udnævnelse {0} og salgsfaktura {1} annulleret
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.js +43,Opportunities by lead source,Muligheder ved hjælp af blykilde
DocType: Appraisal Goal,Weightage (%),Vægtning (%)
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +555,Change POS Profile,Skift POS-profil
DocType: Bank Reconciliation Detail,Clearance Date,Clearance Dato
DocType: Delivery Settings,Dispatch Notification Template,Dispatch Notification Template
apps/erpnext/erpnext/stock/doctype/item/item.py +742,"Asset is already exists against the item {0}, you cannot change the has serial no value","Akten eksisterer allerede imod elementet {0}, du kan ikke ændre den har seriel nrværdi"
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +10,Assessment Report,Vurderingsrapport
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +26,Get Employees,Få medarbejdere
apps/erpnext/erpnext/assets/doctype/asset/asset.py +72,Gross Purchase Amount is mandatory,Bruttokøbesummen er obligatorisk
apps/erpnext/erpnext/setup/doctype/company/company.js +115,Company name not same,Virksomhedens navn er ikke det samme
DocType: Lead,Address Desc,Adresse
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +114,Party is mandatory,Party er obligatorisk
DocType: Topic,Topic Name,Emnenavn
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +311,Please set default template for Leave Approval Notification in HR Settings.,Angiv standardskabelon for tilladelse til godkendelse af tilladelser i HR-indstillinger.
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +38,Atleast one of the Selling or Buying must be selected,Mindst en af salg eller køb skal vælges
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +308,Select an employee to get the employee advance.,Vælg en medarbejder for at få medarbejderen forskud.
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +56,Please select a valid Date,Vælg venligst en gyldig dato
apps/erpnext/erpnext/public/js/setup_wizard.js +36,Select the nature of your business.,Vælg arten af din virksomhed.
DocType: Lab Test Template,"Single for results which require only a single input, result UOM and normal value 
<br>
Compound for results which require multiple input fields with corresponding event names, result UOMs and normal values
<br>
Descriptive for tests which have multiple result components and corresponding result entry fields. 
<br>
Grouped for test templates which are a group of other test templates.
<br>
No Result for tests with no results. Also, no Lab Test is created. e.g.. Sub Tests for Grouped results.","Enkelt for resultater, der kun kræver en enkelt indgang, resultat UOM og normal værdi <br> Forbundet til resultater, der kræver flere indtastningsfelter med tilsvarende begivenhedsnavne, resultat UOM'er og normale værdier <br> Beskrivende for test, der har flere resultatkomponenter og tilsvarende resultatindtastningsfelter. <br> Grupperet til testskabeloner, som er en gruppe af andre testskabeloner. <br> Ingen resultat for test uden resultater. Derudover oprettes ingen Lab Test. f.eks. Underprøver for grupperede resultater."
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +87,Row #{0}: Duplicate entry in References {1} {2},Row # {0}: Duplicate entry i Referencer {1} {2}
apps/erpnext/erpnext/config/manufacturing.py +57,Where manufacturing operations are carried.,Hvor fremstillingsprocesser gennemføres.
apps/erpnext/erpnext/education/doctype/instructor/instructor.js +39,As Examiner,Som eksaminator
DocType: Company,Default Expense Claim Payable Account,Standardudgiftskrav Betalbar konto
DocType: Appointment Type,Default Duration,Standard varighed
DocType: BOM Explosion Item,Source Warehouse,Kildelager
DocType: Installation Note,Installation Date,Installation Dato
apps/erpnext/erpnext/accounts/doctype/shareholder/shareholder.js +30,Share Ledger,Del Ledger
apps/erpnext/erpnext/controllers/accounts_controller.py +677,Row #{0}: Asset {1} does not belong to company {2},Række # {0}: Aktiv {1} hører ikke til firma {2}
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +114,Sales Invoice {0} created,Salgsfaktura {0} oprettet
DocType: Employee,Confirmation Date,Bekræftet den
DocType: Inpatient Occupancy,Check Out,Check ud
DocType: C-Form,Total Invoiced Amount,Totalt faktureret beløb
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +51,Min Qty can not be greater than Max Qty,Min Antal kan ikke være større end Max Antal
DocType: Soil Texture,Silty Clay,Silty Clay
DocType: Account,Accumulated Depreciation,Akkumulerede afskrivninger
DocType: Supplier Scorecard Scoring Standing,Standing Name,Stående navn
DocType: Stock Entry,Customer or Supplier Details,Kunde- eller leverandørdetaljer
DocType: Payment Entry,ACC-PAY-.YYYY.-,ACC-PAY-.YYYY.-
DocType: Asset Value Adjustment,Current Asset Value,Aktuel aktivværdi
DocType: QuickBooks Migrator,Quickbooks Company ID,Quickbooks Company ID
DocType: Travel Request,Travel Funding,Rejsefinansiering
DocType: Loan Application,Required by Date,Kræves af Dato
DocType: Crop Cycle,A link to all the Locations in which the Crop is growing,"Et link til alle de steder, hvor afgrøden vokser"
DocType: Lead,Lead Owner,Emneejer
DocType: Production Plan,Sales Orders Detail,Salgsordrer Detail
DocType: Bin,Requested Quantity,Anmodet mængde
DocType: Fees,EDU-FEE-.YYYY.-,EDU-FEE-.YYYY.-
DocType: Patient,Marital Status,Civilstand
DocType: Stock Settings,Auto Material Request,Automatisk materialeanmodning
DocType: Woocommerce Settings,API consumer secret,API forbruger hemmelighed
DocType: Delivery Note Item,Available Batch Qty at From Warehouse,Tilgængeligt batch-antal fra lageret
DocType: Salary Slip,Gross Pay - Total Deduction - Loan Repayment,Bruttoløn - Fradrag i alt - Tilbagebetaling af lån
DocType: Bank Account,IBAN,IBAN
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +39,Current BOM and New BOM can not be same,Nuværende stykliste og ny stykliste må ikke være ens
apps/erpnext/erpnext/hr/report/salary_register/salary_register.py +47,Salary Slip ID,Lønseddel id
apps/erpnext/erpnext/hr/doctype/employee/employee.py +135,Date Of Retirement must be greater than Date of Joining,Pensioneringsdato skal være større end ansættelsesdato
apps/erpnext/erpnext/stock/doctype/item/item.js +70,Multiple Variants,Flere varianter
DocType: Sales Invoice,Against Income Account,Mod Indkomst konto
apps/erpnext/erpnext/controllers/website_list_for_contact.py +117,{0}% Delivered,{0}% Leveret
DocType: Subscription,Trial Period Start Date,Prøveperiode Startdato
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +106,Item {0}: Ordered qty {1} cannot be less than minimum order qty {2} (defined in Item).,Vare {0}: Bestilte qty {1} kan ikke være mindre end minimum ordreantal {2} (defineret i punkt).
DocType: Certification Application,Certified,Certificeret
DocType: Monthly Distribution Percentage,Monthly Distribution Percentage,Månedlig Distribution Procent
DocType: Daily Work Summary Group User,Daily Work Summary Group User,Daglig Arbejdsopsummering Gruppe Bruger
DocType: Territory,Territory Targets,Områdemål
DocType: Soil Analysis,Ca/Mg,Ca / Mg
DocType: Delivery Note,Transporter Info,Transporter Info
apps/erpnext/erpnext/accounts/utils.py +526,Please set default {0} in Company {1},Indstil standard {0} i Company {1}
DocType: Cheque Print Template,Starting position from top edge,Startposition fra overkanten
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +33,Same supplier has been entered multiple times,Samme leverandør er indtastet flere gange
apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.py +152,Gross Profit / Loss,Gross Profit / Loss
,Warehouse wise Item Balance Age and Value,Lagerbetydende varebalance Alder og værdi
DocType: Purchase Order Item Supplied,Purchase Order Item Supplied,Indkøbsordre leveret vare
apps/erpnext/erpnext/public/js/setup_wizard.js +94,Company Name cannot be Company,Firmaets navn kan ikke være Firma
apps/erpnext/erpnext/config/setup.py +27,Letter Heads for print templates.,Brevhoveder til udskriftsskabeloner.
apps/erpnext/erpnext/config/setup.py +32,Titles for print templates e.g. Proforma Invoice.,Tekster til udskriftsskabeloner fx Proforma-faktura.
DocType: Program Enrollment,Walking,gåture
DocType: Student Guardian,Student Guardian,Student Guardian
DocType: Member,Member Name,Medlems navn
DocType: Stock Settings,Use Naming Series,Brug navngivningsserie
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +231,Valuation type charges can not marked as Inclusive,Værdiansættelse typen omkostninger ikke er markeret som Inclusive
DocType: POS Profile,Update Stock,Opdatering Stock
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +100,Different UOM for items will lead to incorrect (Total) Net Weight value. Make sure that Net Weight of each item is in the same UOM.,"Forskellige UOM for elementer vil føre til forkert (Total) Vægt værdi. Sørg for, at Nettovægt for hvert punkt er i den samme UOM."
DocType: Certification Application,Payment Details,Betalingsoplysninger
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +41,BOM Rate,BOM Rate
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +249,"Stopped Work Order cannot be cancelled, Unstop it first to cancel","Stoppet Arbejdsordre kan ikke annulleres, Unstop det først for at annullere"
DocType: Asset,Journal Entry for Scrap,Kassekladde til skrot
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +83,Please pull items from Delivery Note,Træk varene fra følgeseddel
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +242,Row {0}: select the workstation against the operation {1},Række {0}: vælg arbejdsstationen imod operationen {1}
apps/erpnext/erpnext/accounts/utils.py +496,Journal Entries {0} are un-linked,Journaloptegnelser {0} er un-forbundet
apps/erpnext/erpnext/accounts/utils.py +825,{0} Number {1} already used in account {2},{0} Nummer {1} er allerede brugt i konto {2}
apps/erpnext/erpnext/config/crm.py +92,"Record of all communications of type email, phone, chat, visit, etc.","Registrering af al kommunikation af type e-mail, telefon, chat, besøg osv"
DocType: Supplier Scorecard Scoring Standing,Supplier Scorecard Scoring Standing,Leverandør Scorecard Scoring Standing
DocType: Manufacturer,Manufacturers used in Items,"Producenter, der anvendes i artikler"
apps/erpnext/erpnext/accounts/general_ledger.py +181,Please mention Round Off Cost Center in Company,Henvis afrunde omkostningssted i selskabet
DocType: Purchase Invoice,Terms,Betingelser
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js +10,Select Days,Vælg dage
DocType: Academic Term,Term Name,Betingelsesnavn
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +370,Credit ({0}),Kredit ({0})
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +503,Creating Salary Slips...,Oprettelse af lønlister ...
apps/erpnext/erpnext/hr/doctype/department/department.js +14,You cannot edit root node.,Du kan ikke redigere root node.
DocType: Buying Settings,Purchase Order Required,Indkøbsordre påkrævet
apps/erpnext/erpnext/public/js/projects/timer.js +5,Timer,Timer
,Item-wise Sales History,Vare-wise Sales History
DocType: Expense Claim,Total Sanctioned Amount,Total Sanktioneret Beløb
,Purchase Analytics,Indkøbsanalyser
DocType: Sales Invoice Item,Delivery Note Item,Følgeseddelvare
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +373,Current invoice {0} is missing,Nuværende faktura {0} mangler
DocType: Asset Maintenance Log,Task,Opgave
DocType: Purchase Taxes and Charges,Reference Row #,Henvisning Row #
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +76,Batch number is mandatory for Item {0},Partinummer er obligatorisk for vare {0}
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.js +22,This is a root sales person and cannot be edited.,Dette er en rod salg person og kan ikke redigeres.
DocType: Salary Component,"If selected, the value specified or calculated in this component will not contribute to the earnings or deductions. However, it's value can be referenced by other components that can be added or deducted. ","Hvis valgt, vil den værdi, der er angivet eller beregnet i denne komponent, ikke bidrage til indtjeningen eller fradrag. Men det er værdien kan henvises af andre komponenter, som kan tilføjes eller fratrækkes."
DocType: Asset Settings,Number of Days in Fiscal Year,Antal Dage i Skatteår
,Stock Ledger,Lagerkladde
apps/erpnext/erpnext/templates/includes/cart/cart_items.html +29,Rate: {0},Pris: {0}
DocType: Company,Exchange Gain / Loss Account,Exchange Gevinst / Tab konto
DocType: Amazon MWS Settings,MWS Credentials,MWS Credentials
apps/erpnext/erpnext/config/hr.py +7,Employee and Attendance,Medarbejder og fremmøde
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +123,Purpose must be one of {0},Formålet skal være en af {0}
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +99,Fill the form and save it,Udfyld skærmbilledet og gem det
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +26,Community Forum,Fællesskab Forum
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +52,Actual qty in stock,Faktisk antal på lager
DocType: Homepage,"URL for ""All Products""",URL til &quot;Alle produkter&quot;
DocType: Leave Application,Leave Balance Before Application,Fraværssaldo før anmodning
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +41,Send SMS,Send SMS
DocType: Supplier Scorecard Criteria,Max Score,Max score
DocType: Cheque Print Template,Width of amount in word,Bredde af beløb i ord
DocType: Company,Default Letter Head,Standard brevhoved
DocType: Purchase Order,Get Items from Open Material Requests,Hent varer fra åbne materialeanmodninger
DocType: Hotel Room Amenity,Billable,Faktureres
DocType: Lab Test Template,Standard Selling Rate,Standard salgspris
DocType: Account,Rate at which this tax is applied,"Hastighed, hvormed denne afgift anvendes"
DocType: Cash Flow Mapper,Section Name,Sektionens navn
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +92,Reorder Qty,Genbestil Antal
apps/erpnext/erpnext/assets/doctype/asset/asset.py +292,Depreciation Row {0}: Expected value after useful life must be greater than or equal to {1},Afskrivningsrække {0}: Forventet værdi efter brugstid skal være større end eller lig med {1}
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +55,Current Job Openings,Aktuelle ledige stillinger
DocType: Company,Stock Adjustment Account,Stock Justering konto
apps/erpnext/erpnext/public/js/payment/pos_payment.html +17,Write Off,Afskriv
DocType: Healthcare Service Unit,Allow Overlap,Tillad overlapning
DocType: Timesheet Detail,Operation ID,Operation ID
DocType: Employee,"System User (login) ID. If set, it will become default for all HR forms.","System Bruger (login) ID. Hvis sat, vil det blive standard for alle HR-formularer."
apps/erpnext/erpnext/assets/doctype/asset/asset.py +86,Enter depreciation details,Indtast afskrivningsoplysninger
apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +16,{0}: From {1},{0}: Fra {1}
apps/erpnext/erpnext/education/doctype/student_leave_application/student_leave_application.py +31,Leave application {0} already exists against the student {1},Forlad ansøgning {0} eksisterer allerede mod den studerende {1}
DocType: Task,depends_on,depends_on
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +78,Queued for updating latest price in all Bill of Materials. It may take a few minutes.,Kø for opdatering af seneste pris i alle Materialebevis. Det kan tage et par minutter.
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +26,Name of new Account. Note: Please don't create accounts for Customers and Suppliers,Navn på ny konto. Bemærk: Du må ikke oprette konti for kunder og leverandører
DocType: POS Profile,Display Items In Stock,Vis varer på lager
apps/erpnext/erpnext/config/setup.py +37,Country wise default Address Templates,Standard-adresseskabeloner sorteret efter lande
DocType: Payment Order,Payment Order Reference,Betalingsordre Reference
DocType: Water Analysis,Appearance,Udseende
DocType: HR Settings,Leave Status Notification Template,Meddelelsesskabelon for meddelelsesstatus
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +77,Avg. Buying Price List Rate,Gennemsnitlig. Pris for købsprisliste
DocType: Sales Order Item,Supplier delivers to Customer,Leverandøren leverer til Kunden
apps/erpnext/erpnext/config/non_profit.py +23,Member information.,Medlemsoplysninger.
DocType: Identification Document Type,Identification Document Type,Identifikationsdokumenttype
apps/erpnext/erpnext/utilities/bot.py +34,[{0}](#Form/Item/{0}) is out of stock,[{0}] (# Form / Vare / {0}) er udsolgt
apps/erpnext/erpnext/assets/doctype/asset/asset.js +87,Asset Maintenance,Asset Maintenance
,Sales Payment Summary,Salgsbetalingsoversigt
DocType: Restaurant,Restaurant,Restaurant
DocType: Woocommerce Settings,API consumer key,API forbrugernøgle
apps/erpnext/erpnext/accounts/party.py +353,Due / Reference Date cannot be after {0},Due / reference Dato kan ikke være efter {0}
apps/erpnext/erpnext/config/setup.py +51,Data Import and Export,Dataind- og udlæsning
DocType: Tax Withholding Category,Account Details,konto detaljer
DocType: Crop,Materials Required,Materialer krævet
apps/erpnext/erpnext/education/doctype/student_group/student_group.py +76,No students Found,Ingen studerende Fundet
DocType: Employee Tax Exemption Declaration,Monthly HRA Exemption,Månedlig HRA-fritagelse
DocType: Clinical Procedure,Medical Department,Medicinsk afdeling
DocType: Supplier Scorecard Scoring Criteria,Supplier Scorecard Scoring Criteria,Leverandør Scorecard Scoring Criteria
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +55,Invoice Posting Date,Faktura Bogføringsdato
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +25,Sell,Salg
DocType: Purchase Invoice,Rounded Total,Afrundet i alt
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js +91,Slots for {0} are not added to the schedule,Slots til {0} tilføjes ikke til skemaet
DocType: Product Bundle,List items that form the package.,"Vis varer, der er indeholdt i pakken."
apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.py +42,Not permitted. Please disable the Test Template,Ikke tilladt. Deaktiver venligst testskabelonen
DocType: Delivery Note,Distance (in km),Afstand (i km)
apps/erpnext/erpnext/accounts/doctype/monthly_distribution/monthly_distribution.py +26,Percentage Allocation should be equal to 100%,Procentdel fordeling bør være lig med 100%
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +611,Please select Posting Date before selecting Party,Vælg Bogføringsdato før du vælger Party
DocType: Program Enrollment,School House,School House
DocType: Serial No,Out of AMC,Ud af AMC
DocType: Opportunity,Opportunity Amount,Mulighedsbeløb
apps/erpnext/erpnext/assets/doctype/asset/asset.py +212,Number of Depreciations Booked cannot be greater than Total Number of Depreciations,Antal Afskrivninger Reserverede kan ikke være større end alt Antal Afskrivninger
DocType: Purchase Order,Order Confirmation Date,Ordrebekræftelsesdato
DocType: Driver,HR-DRI-.YYYY.-,HR-DRI-.YYYY.-
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +47,Make Maintenance Visit,Make Vedligeholdelse Besøg
DocType: Employee Transfer,Employee Transfer Details,Overførselsoplysninger for medarbejdere
apps/erpnext/erpnext/selling/doctype/customer/customer.py +263,Please contact to the user who have Sales Master Manager {0} role,"Kontakt venligst til den bruger, der har Sales Master manager {0} rolle"
DocType: Company,Default Cash Account,Standard Kontant konto
apps/erpnext/erpnext/config/accounts.py +40,Company (not Customer or Supplier) master.,Company (ikke kunde eller leverandør) herre.
apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +6,This is based on the attendance of this Student,Dette er baseret på deltagelse af denne Student
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +179,No Students in,Ingen studerende i
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +180,Add more items or open full form,Tilføj flere varer eller åben fulde form
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +224,Delivery Notes {0} must be cancelled before cancelling this Sales Order,"Følgesedler {0} skal annulleres, før den salgsordre annulleres"
apps/erpnext/erpnext/utilities/user_progress.py +259,Go to Users,Gå til Brugere
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +113,Paid amount + Write Off Amount can not be greater than Grand Total,Betalt beløb + Skriv Off Beløb kan ikke være større end beløb i alt
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +78,{0} is not a valid Batch Number for Item {1},{0} er ikke et gyldigt partinummer for vare {1}
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +198,Note: There is not enough leave balance for Leave Type {0},Bemærk: Der er ikke nok dage til rådighed til fraværstype {0}
apps/erpnext/erpnext/regional/india/utils.py +19,Invalid GSTIN or Enter NA for Unregistered,Ugyldig GSTIN eller Indtast NA for Uregistreret
DocType: Training Event,Seminar,Seminar
DocType: Program Enrollment Fee,Program Enrollment Fee,Program Tilmelding Gebyr
DocType: Item,Supplier Items,Leverandør Varer
DocType: Material Request,MAT-MR-.YYYY.-,MAT-MR-.YYYY.-
DocType: Opportunity,Opportunity Type,Salgsmulighedstype
DocType: Asset Movement,To Employee,Til medarbejder
DocType: Employee Transfer,New Company,Nyt firma
apps/erpnext/erpnext/setup/doctype/company/delete_company_transactions.py +19,Transactions can only be deleted by the creator of the Company,Transaktioner kan kun slettes af skaberen af selskabet
apps/erpnext/erpnext/accounts/general_ledger.py +21,Incorrect number of General Ledger Entries found. You might have selected a wrong Account in the transaction.,Forkert antal finansposter fundet. Du har muligvis valgt en forkert konto.
DocType: Employee,Prefered Contact Email,Foretrukket kontakt e-mail
DocType: Cheque Print Template,Cheque Width,Anvendes ikke
DocType: Selling Settings,Validate Selling Price for Item against Purchase Rate or Valuation Rate,Godkend salgspris for vare mod købspris eller værdiansættelsespris
DocType: Fee Schedule,Fee Schedule,Fee Schedule
DocType: Company,Create Chart Of Accounts Based On,Opret kontoplan baseret på
apps/erpnext/erpnext/hr/doctype/employee/employee.py +129,Date of Birth cannot be greater than today.,Fødselsdato kan ikke være større end i dag.
,Stock Ageing,Stock Ageing
DocType: Travel Request,"Partially Sponsored, Require Partial Funding","Delvist sponsoreret, kræves delfinansiering"
apps/erpnext/erpnext/education/doctype/student/student.py +40,Student {0} exist against student applicant {1},Student {0} findes mod studerende ansøger {1}
DocType: Purchase Invoice,Rounding Adjustment (Company Currency),Afrundingsjustering (Company Valuta)
apps/erpnext/erpnext/projects/doctype/task/task.js +39,Timesheet,Tidsregistrering
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +243,Batch: ,Parti:
DocType: Volunteer,Afternoon,Eftermiddag
DocType: Loyalty Program,Loyalty Program Help,Hjælp til loyalitetsprogram
apps/erpnext/erpnext/controllers/accounts_controller.py +315,{0} '{1}' is disabled,{0} &#39;{1}&#39; er deaktiveret
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +13,Set as Open,Sæt som Open
DocType: Cheque Print Template,Scanned Cheque,Anvendes ikke
DocType: Notification Control,Send automatic emails to Contacts on Submitting transactions.,Sende automatiske e-mails til Kontakter på Indsendelse transaktioner.
DocType: Timesheet,Total Billable Amount,Samlet faktureres Beløb
DocType: Customer,Credit Limit and Payment Terms,Kreditgrænse og betalingsbetingelser
DocType: Loyalty Program,Collection Rules,Indsamlingsregler
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +20,Item 3,Vare 3
apps/erpnext/erpnext/restaurant/doctype/restaurant/restaurant.js +6,Order Entry,Ordreindgang
DocType: Purchase Order,Customer Contact Email,Kundeservicekontakt e-mail
DocType: Warranty Claim,Item and Warranty Details,Item og garanti Detaljer
DocType: Chapter,Chapter Members,Kapitel Medlemmer
DocType: Sales Team,Contribution (%),Bidrag (%)
apps/erpnext/erpnext/controllers/accounts_controller.py +143,Note: Payment Entry will not be created since 'Cash or Bank Account' was not specified,Bemærk: Betaling indtastning vil ikke blive oprettet siden &#39;Kontant eller bank konto&#39; er ikke angivet
apps/erpnext/erpnext/projects/doctype/project/project.py +79,Project {0} already exists,Projekt {0} eksisterer allerede
DocType: Clinical Procedure,Nursing User,Sygeplejerske bruger
DocType: Employee Benefit Application,Payroll Period,Lønningsperiode
DocType: Plant Analysis,Plant Analysis Criterias,Plant Analyse Kriterier
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +239,Serial No {0} does not belong to Batch {1},Serienummer {0} tilhører ikke Batch {1}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +197,Responsibilities,Ansvar
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +125,Validity period of this quotation has ended.,Gyldighedsperioden for dette citat er afsluttet.
DocType: Expense Claim Account,Expense Claim Account,Udlægskonto
DocType: Account,Capital Work in Progress,Kapitalarbejde i fremskridt
DocType: Accounts Settings,Allow Stale Exchange Rates,Tillad forældede valutakurser
DocType: Sales Person,Sales Person Name,Salgsmedarbejdernavn
apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +54,Please enter atleast 1 invoice in the table,Indtast venligst mindst en faktura i tabellen
apps/erpnext/erpnext/utilities/user_progress.py +247,Add Users,Tilføj brugere
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.py +74,No Lab Test created,Ingen Lab Test oprettet
DocType: POS Item Group,Item Group,Varegruppe
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +19,Student Group: ,Studentgruppe:
DocType: Depreciation Schedule,Finance Book Id,Finans Bog ID
DocType: Item,Safety Stock,Minimum lagerbeholdning
DocType: Healthcare Settings,Healthcare Settings,Sundhedsindstillinger
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html +8,Total Allocated Leaves,Samlede tildelte blade
apps/erpnext/erpnext/projects/doctype/task/task.py +57,Progress % for a task cannot be more than 100.,Fremskridt-% for en opgave kan ikke være mere end 100.
DocType: Stock Reconciliation Item,Before reconciliation,Før forsoning
apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py +12,To {0},Til {0}
DocType: Purchase Invoice,Taxes and Charges Added (Company Currency),Skatter og Afgifter Tilføjet (Company Valuta)
apps/erpnext/erpnext/stock/doctype/item/item.py +507,Item Tax Row {0} must have account of type Tax or Income or Expense or Chargeable,"Varemoms række {0} skal have en konto med 
typen moms, indtægt, omkostning eller kan debiteres"
DocType: Sales Order,Partly Billed,Delvist faktureret
apps/erpnext/erpnext/assets/doctype/asset/asset.py +54,Item {0} must be a Fixed Asset Item,Vare {0} skal være en anlægsaktiv-vare
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +286,HSN,HSN
apps/erpnext/erpnext/stock/doctype/item/item.js +427,Make Variants,Lav variant
DocType: Item,Default BOM,Standard stykliste
DocType: Project,Total Billed Amount (via Sales Invoices),Samlet faktureret beløb (via salgsfakturaer)
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +138,Debit Note Amount,Debet Note Beløb
DocType: Project Update,Not Updated,Ikke opdateret
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +107,"There are inconsistencies between the rate, no of shares and the amount calculated","Der er uoverensstemmelser mellem kursen, antal aktier og det beregnede beløb"
apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py +39,You are not present all day(s) between compensatory leave request days,Du er ikke til stede hele dagen / dage mellem anmodninger om kompensationsorlov
apps/erpnext/erpnext/setup/doctype/company/company.js +109,Please re-type company name to confirm,Prøv venligst igen typen firmanavn for at bekræfte
apps/erpnext/erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.py +50,Total Outstanding Amt,Total Enestående Amt
DocType: Journal Entry,Printing Settings,Udskrivningsindstillinger
DocType: Employee Advance,Advance Account,Advance konto
DocType: Job Offer,Job Offer Terms,Jobtilbudsbetingelser
DocType: Sales Invoice,Include Payment (POS),Medtag betaling (Kassesystem)
DocType: Shopify Settings,eg: frappe.myshopify.com,fx: frappe.myshopify.com
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +324,Total Debit must be equal to Total Credit. The difference is {0},Debet og kredit stemmer ikke. Differencen er {0}
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +11,Automotive,Automotive
DocType: Vehicle,Insurance Company,Forsikringsselskab
DocType: Asset Category Account,Fixed Asset Account,Anlægsaktivkonto
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +442,Variable,Variabel
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.js +47,From Delivery Note,Fra følgeseddel
DocType: Chapter,Members,Medlemmer
DocType: Student,Student Email Address,Studerende e-mailadresse
DocType: Item,Hub Warehouse,Hub Lager
DocType: Cashier Closing,From Time,Fra Time
DocType: Hotel Settings,Hotel Settings,Hotelindstillinger
apps/erpnext/erpnext/public/js/pos/pos_bill_item.html +12,In Stock: ,På lager:
DocType: Notification Control,Custom Message,Tilpasset Message
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +33,Investment Banking,Investment Banking
DocType: Purchase Invoice,input,input
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +107,Cash or Bank Account is mandatory for making payment entry,Kontant eller bankkonto skal indtastes for post
DocType: Loyalty Program,Multiple Tier Program,Multiple Tier Program
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +54,Student Address,Studentadresse
DocType: Purchase Invoice,Price List Exchange Rate,Prisliste valutakurs
apps/erpnext/erpnext/patches/v11_0/rename_supplier_type_to_supplier_group.py +27,All Supplier Groups,Alle leverandørgrupper
DocType: Employee Boarding Activity,Required for Employee Creation,Påkrævet for medarbejderskabelse
apps/erpnext/erpnext/accounts/doctype/account/account.py +214,Account Number {0} already used in account {1},"Kontonummer {0}, der allerede er brugt i konto {1}"
DocType: GoCardless Mandate,Mandate,Mandat
DocType: POS Profile,POS Profile Name,POS-profilnavn
DocType: Hotel Room Reservation,Booked,Reserveret
DocType: Detected Disease,Tasks Created,Opgaver oprettet
DocType: Purchase Invoice Item,Rate,Sats
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +82,Intern,Intern
DocType: Delivery Stop,Address Name,Adresse Navn
DocType: Stock Entry,From BOM,Fra stykliste
DocType: Assessment Code,Assessment Code,Assessment Code
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +51,Basic,Grundlæggende
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +94,Stock transactions before {0} are frozen,Lagertransaktioner før {0} er frosset
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +219,Please click on 'Generate Schedule',Klik på &quot;Generer Schedule &#39;
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +154,Reference No is mandatory if you entered Reference Date,"Referencenummer er obligatorisk, hvis du har indtastet reference Dato"
DocType: Bank Reconciliation Detail,Payment Document,Betaling dokument
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py +37,Error evaluating the criteria formula,Fejl ved evaluering af kriterieformlen
apps/erpnext/erpnext/hr/doctype/employee/employee.py +132,Date of Joining must be greater than Date of Birth,Ansættelsesdato skal være større end fødselsdato
DocType: Subscription,Plans,Planer
DocType: Salary Slip,Salary Structure,Lønstruktur
DocType: Account,Bank,Bank
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +9,Airline,Flyselskab
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +886,Issue Material,Issue Materiale
apps/erpnext/erpnext/config/integrations.py +32,Connect Shopify with ERPNext,Tilslut Shopify med ERPNext
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1161,For Warehouse,Til lager
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +92,Delivery Notes {0} updated,Leveringsnotater {0} opdateret
DocType: Employee,Offer Date,Dato
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +35,Quotations,Tilbud
apps/erpnext/erpnext/accounts/page/pos/pos.js +742,You are in offline mode. You will not be able to reload until you have network.,"Du er i offline-tilstand. Du vil ikke være i stand til at genindlæse, indtil du har netværk igen."
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.js +90,Grant,Give
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +47,No Student Groups created.,Ingen elevgrupper oprettet.
DocType: Purchase Invoice Item,Serial No,Serienummer
apps/erpnext/erpnext/hr/doctype/loan/loan.py +129,Monthly Repayment Amount cannot be greater than Loan Amount,Månedlig tilbagebetaling beløb kan ikke være større end Lånebeløb
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +143,Please enter Maintaince Details first,Indtast venligst Maintaince Detaljer først
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +60,Row #{0}: Expected Delivery Date cannot be before Purchase Order Date,Række nr. {0}: Forventet leveringsdato kan ikke være før købsdato
DocType: Purchase Invoice,Print Language,Udskrivningssprog
DocType: Salary Slip,Total Working Hours,Arbejdstid i alt
DocType: Sales Invoice,Customer PO Details,Kunde PO Detaljer
DocType: Stock Entry,Including items for sub assemblies,Herunder elementer til sub forsamlinger
DocType: Opening Invoice Creation Tool Item,Temporary Opening Account,Midlertidig åbningskonto
apps/erpnext/erpnext/accounts/page/pos/pos.js +1979,Enter value must be positive,Indtast værdien skal være positiv
DocType: Asset,Finance Books,Finansbøger
DocType: Employee Tax Exemption Declaration Category,Employee Tax Exemption Declaration Category,Beskatningsgruppe for arbejdstagerbeskatning
apps/erpnext/erpnext/accounts/doctype/sales_invoice/pos.py +451,All Territories,Alle områder
apps/erpnext/erpnext/hr/utils.py +216,Please set leave policy for employee {0} in Employee / Grade record,Venligst indstil afgangspolitik for medarbejder {0} i medarbejder- / bedømmelsesrekord
apps/erpnext/erpnext/public/js/controllers/transaction.js +1472,Invalid Blanket Order for the selected Customer and Item,Ugyldig ordreordre for den valgte kunde og vare
apps/erpnext/erpnext/projects/doctype/task/task_tree.js +49,Add Multiple Tasks,Tilføj flere opgaver
DocType: Purchase Invoice,Items,Varer
apps/erpnext/erpnext/crm/doctype/contract/contract.py +38,End Date cannot be before Start Date.,Slutdato kan ikke være før startdato.
apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py +33,Student is already enrolled.,Student er allerede tilmeldt.
DocType: Fiscal Year,Year Name,År navn
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +323,There are more holidays than working days this month.,Der er flere helligdage end arbejdsdage i denne måned.
apps/erpnext/erpnext/controllers/buying_controller.py +772,Following items {0} are not marked as {1} item. You can enable them as {1} item from its Item master,Følgende elementer {0} er ikke markeret som {1} element. Du kan aktivere dem som {1} element fra dets Item master
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +108,PDC/LC Ref,PDC / LC Ref
DocType: Production Plan Item,Product Bundle Item,Produktpakkevare
DocType: Sales Partner,Sales Partner Name,Forhandlernavn
apps/erpnext/erpnext/hooks.py +148,Request for Quotations,Anmodning om tilbud
DocType: Payment Reconciliation,Maximum Invoice Amount,Maksimalt fakturabeløb
DocType: Normal Test Items,Normal Test Items,Normale testelementer
DocType: QuickBooks Migrator,Company Settings,Firmaindstillinger
DocType: Additional Salary,Overwrite Salary Structure Amount,Overskrive lønstruktursbeløb
DocType: Student Language,Student Language,Student Sprog
apps/erpnext/erpnext/config/selling.py +23,Customers,Kunder
DocType: Cash Flow Mapping,Is Working Capital,Er arbejdskapital
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +24,Order/Quot %,Ordre / Quot%
apps/erpnext/erpnext/config/healthcare.py +25,Record Patient Vitals,Optag Patient Vitals
DocType: Fee Schedule,Institution,Institution
DocType: Asset,Partially Depreciated,Delvist afskrevet
DocType: Issue,Opening Time,Åbning tid
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +97,From and To dates required,Fra og Til dato kræves
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +46,Securities & Commodity Exchanges,Værdipapirer og Commodity Exchanges
apps/erpnext/erpnext/stock/doctype/item/item.py +760,Default Unit of Measure for Variant '{0}' must be same as in Template '{1}',Standard måleenhed for Variant &#39;{0}&#39; skal være samme som i skabelon &#39;{1}&#39;
DocType: Shipping Rule,Calculate Based On,Beregn baseret på
DocType: Contract,Unfulfilled,uopfyldte
DocType: Delivery Note Item,From Warehouse,Fra lager
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +68,No employees for the mentioned criteria,Ingen ansatte for de nævnte kriterier
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1033,No Items with Bill of Materials to Manufacture,Ingen stykliste-varer at fremstille
DocType: Shopify Settings,Default Customer,Standardkunden
DocType: Sales Stage,Stage Name,Kunstnernavn
DocType: Warranty Claim,SER-WRN-.YYYY.-,SER-WRN-.YYYY.-
DocType: Assessment Plan,Supervisor Name,supervisor Navn
DocType: Healthcare Settings,Do not confirm if appointment is created for the same day,"Bekræft ikke, om en aftale er oprettet for samme dag"
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +267,Ship To State,Skib til stat
DocType: Program Enrollment Course,Program Enrollment Course,Tilmeldingskursusprogramm
apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner.py +59,User {0} is already assigned to Healthcare Practitioner {1},Bruger {0} er allerede tildelt Healthcare Practitioner {1}
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +187,Make Sample Retention Stock Entry,Foretag prøveindholdsbeholdning
DocType: Purchase Taxes and Charges,Valuation and Total,Værdiansættelse og Total
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +226,Negotiation/Review,Forhandling / anmeldelse
DocType: Leave Encashment,Encashment Amount,Indkøbsbeløb
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py +11,Scorecards,scorecards
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +159,Expired Batches,Udløbet Batcher
DocType: Employee,This will restrict user access to other employee records,Dette vil begrænse brugeradgang til andre medarbejderposter
DocType: Tax Rule,Shipping City,Forsendelse By
DocType: Delivery Note,Ship,Skib
DocType: Staffing Plan Detail,Current Openings,Nuværende åbninger
DocType: Notification Control,Customize the Notification,Tilpas Underretning
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +78,Cash Flow from Operations,Pengestrøm fra driften
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +316,CGST Amount,CGST beløb
DocType: Purchase Invoice,Shipping Rule,Forsendelseregel
DocType: Patient Relation,Spouse,Ægtefælle
DocType: Lab Test Groups,Add Test,Tilføj test
DocType: Manufacturer,Limited to 12 characters,Begrænset til 12 tegn
DocType: Journal Entry,Print Heading,Overskrift
apps/erpnext/erpnext/config/stock.py +149,Delivery Trip service tours to customers.,Leveringstur service ture til kunder.
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +57,Total cannot be zero,Samlede kan ikke være nul
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +16,'Days Since Last Order' must be greater than or equal to zero,'Dage siden sidste ordre' skal være større end eller lig med nul
DocType: Plant Analysis Criteria,Maximum Permissible Value,Maksimum tilladt værdi
DocType: Journal Entry Account,Employee Advance,Ansatte Advance
DocType: Payroll Entry,Payroll Frequency,Lønafregningsfrekvens
DocType: Lab Test Template,Sensitivity,Følsomhed
apps/erpnext/erpnext/erpnext_integrations/doctype/amazon_mws_settings/amazon_methods.py +132,Sync has been temporarily disabled because maximum retries have been exceeded,"Synkronisering er midlertidigt deaktiveret, fordi maksimale forsøg er overskredet"
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1015,Raw Material,Råmateriale
DocType: Leave Application,Follow via Email,Følg via e-mail
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +56,Plants and Machineries,Planter og Machineries
DocType: Purchase Taxes and Charges,Tax Amount After Discount Amount,Skat Beløb Efter Discount Beløb
DocType: Patient,Inpatient Status,Inpatient Status
DocType: Daily Work Summary Settings,Daily Work Summary Settings,Daglige Arbejde Resumé Indstillinger
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +1298,Selected Price List should have buying and selling fields checked.,Udvalgt prisliste skal have købs- og salgsfelter kontrolleret.
apps/erpnext/erpnext/controllers/buying_controller.py +693,Please enter Reqd by Date,Indtast venligst Reqd by Date
DocType: Payment Entry,Internal Transfer,Intern overførsel
DocType: Asset Maintenance,Maintenance Tasks,Vedligeholdelsesopgaver
apps/erpnext/erpnext/setup/doctype/territory/territory.py +19,Either target qty or target amount is mandatory,Enten target qty eller målbeløbet er obligatorisk
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +627,Please select Posting Date first,Vælg bogføringsdato først
apps/erpnext/erpnext/public/js/account_tree_grid.js +209,Opening Date should be before Closing Date,"Åbning Dato bør være, før Closing Dato"
DocType: Travel Itinerary,Flight,Flyvningen
DocType: Leave Control Panel,Carry Forward,Benyt fortsat fravær fra sidste regnskabsår
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +32,Cost Center with existing transactions can not be converted to ledger,Cost Center med eksisterende transaktioner kan ikke konverteres til finans
DocType: Budget,Applicable on booking actual expenses,Gældende ved booking faktiske udgifter
DocType: Department,Days for which Holidays are blocked for this department.,"Dage, for hvilke helligdage er blokeret for denne afdeling."
DocType: Amazon MWS Settings,ERPNext Integrations,ERPNext Integrations
DocType: Crop Cycle,Detected Disease,Opdaget sygdom
,Produced,Produceret
apps/erpnext/erpnext/hr/doctype/loan/loan.py +26,Repayment Start Date cannot be before Disbursement Date.,Tilbagebetaling Startdato kan ikke være før Udbetalingsdato.
DocType: Item,Item Code for Suppliers,Varenr. for leverandører
DocType: Issue,Raised By (Email),Oprettet af (e-mail)
DocType: Training Event,Trainer Name,Trainer Navn
DocType: Mode of Payment,General,Generelt
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +28,Last Communication,Sidste kommunikation
,TDS Payable Monthly,TDS betales månedligt
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +73,Queued for replacing the BOM. It may take a few minutes.,Kø for at erstatte BOM. Det kan tage et par minutter.
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +385,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',"Ikke kan fradrage, når kategorien er for &quot;Værdiansættelse&quot; eller &quot;Værdiansættelse og Total &#39;"
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +286,Serial Nos Required for Serialized Item {0},Serienummer påkrævet for serienummervare {0}
apps/erpnext/erpnext/config/accounts.py +140,Match Payments with Invoices,Match betalinger med fakturaer
DocType: Journal Entry,Bank Entry,Bank indtastning
DocType: Authorization Rule,Applicable To (Designation),Gælder for (Betegnelse)
,Profitability Analysis,Lønsomhedsanalyse
DocType: Fees,Student Email,Student Email
DocType: Supplier,Prevent POs,Forhindre PO&#39;er
DocType: Patient,"Allergies, Medical and Surgical History","Allergier, medicinsk og kirurgisk historie"
apps/erpnext/erpnext/templates/generators/item.html +96,Add to Cart,Føj til indkøbsvogn
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +197,Group By,Sortér efter
DocType: Guardian,Interests,Interesser
apps/erpnext/erpnext/config/accounts.py +266,Enable / disable currencies.,Aktivér / deaktivér valuta.
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +553,Could not submit some Salary Slips,Kunne ikke indsende nogle Lønslister
DocType: Exchange Rate Revaluation,Get Entries,Få indlæg
DocType: Production Plan,Get Material Request,Hent materialeanmodning
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +118,Postal Expenses,Portoudgifter
apps/erpnext/erpnext/selling/doctype/pos_closing_voucher/closing_voucher_details.html +8,Sales Summary,Salgsoversigt
apps/erpnext/erpnext/controllers/trends.py +19,Total(Amt),I alt (Amt)
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +26,Entertainment & Leisure,Entertainment &amp; Leisure
,Item Variant Details,Varevarianter Detaljer
DocType: Quality Inspection,Item Serial No,Serienummer til varer
DocType: Payment Request,Is a Subscription,Er en abonnement
apps/erpnext/erpnext/utilities/activation.py +135,Create Employee Records,Opret Medarbejder Records
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +97,Total Present,Samlet tilstede
DocType: Work Order,MFG-WO-.YYYY.-,MFG-WO-.YYYY.-
apps/erpnext/erpnext/config/accounts.py +83,Accounting Statements,Regnskabsoversigter
DocType: Drug Prescription,Hour,Time
DocType: Restaurant Order Entry,Last Sales Invoice,Sidste salgsfaktura
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +881,Please select Qty against item {0},Vælg venligst antal imod vare {0}
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +33,New Serial No cannot have Warehouse. Warehouse must be set by Stock Entry or Purchase Receipt,Nyt serienummer kan ikke have lager angivet. Lageret skal sættes ved lagerindtastning eller købskvittering
DocType: Lead,Lead Type,Emnetype
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +183,You are not authorized to approve leaves on Block Dates,Du er ikke autoriseret til at godkende fravær på blokerede dage
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +408,All these items have already been invoiced,Alle disse varer er allerede blevet faktureret
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +1024,Set New Release Date,Indstil ny udgivelsesdato
DocType: Company,Monthly Sales Target,Månedligt salgsmål
apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py +37,Can be approved by {0},Kan godkendes af {0}
DocType: Hotel Room,Hotel Room Type,Hotel Værelsestype
DocType: Leave Allocation,Leave Period,Forladelsesperiode
DocType: Item,Default Material Request Type,Standard materialeanmodningstype
DocType: Supplier Scorecard,Evaluation Period,Evalueringsperiode
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_list.js +13,Unknown,Ukendt
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1032,Work Order not created,Arbejdsordre er ikke oprettet
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py +36,"An amount of {0} already claimed for the component {1},\
						 set the amount equal or greater than {2}","En mængde på {0}, der allerede er påkrævet for komponenten {1}, \ indstil størrelsen lig med eller større end {2}"
DocType: Shipping Rule,Shipping Rule Conditions,Forsendelsesregelbetingelser
DocType: Purchase Invoice,Export Type,Eksporttype
DocType: Salary Slip Loan,Salary Slip Loan,Salary Slip Lån
DocType: BOM Update Tool,The new BOM after replacement,Den nye BOM efter udskiftning
,Point of Sale,Kassesystem
DocType: Payment Entry,Received Amount,modtaget Beløb
DocType: Patient,Widow,Enke
DocType: GST Settings,GSTIN Email Sent On,GSTIN Email Sent On
DocType: Program Enrollment,Pick/Drop by Guardian,Vælg / Drop af Guardian
DocType: Bank Account,SWIFT number,SWIFT nummer
DocType: Payment Entry,Party Name,Party Name
DocType: Employee Benefit Application,Benefits Applied,Fordele Anvendt
DocType: Crop,Planting UOM,Plantning af UOM
DocType: Account,Tax,Skat
apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py +45,Not Marked,Ikke Markeret
DocType: Contract,Signed,Underskrevet
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html +1,Opening Invoices Summary,Åbning af fakturaoversigt
DocType: Member,NPO-MEM-.YYYY.-,NPO-MEM-.YYYY.-
DocType: Education Settings,Education Manager,Uddannelsesleder
DocType: Crop Cycle,The minimum length between each plant in the field for optimum growth,Minimale længde mellem hver plante i marken for optimal vækst
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +153,"Batched Item {0} cannot be updated using Stock Reconciliation, instead use Stock Entry","Parti-vare {0} kan ikke opdateres ved hjælp af lagerafstemning, men brug lagerindtastning i stedet"
DocType: Quality Inspection,Report Date,Rapporteringsdato
DocType: Student,Middle Name,Mellemnavn
DocType: BOM,Routing,Routing
DocType: Serial No,Asset Details,Aktivoplysninger
DocType: Bank Statement Transaction Payment Item,Invoices,Fakturaer
DocType: Water Analysis,Type of Sample,Type prøve
DocType: Batch,Source Document Name,Kildedokumentnavn
DocType: Production Plan,Get Raw Materials For Production,Få råmaterialer til produktion
DocType: Job Opening,Job Title,Titel
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py +89,"{0} indicates that {1} will not provide a quotation, but all items \
					have been quoted. Updating the RFQ quote status.","{0} indikerer at {1} ikke giver et citat, men alle elementer \ er blevet citeret. Opdatering af RFQ citat status."
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1294,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,Maksimale prøver - {0} er allerede bevaret for Batch {1} og Item {2} i Batch {3}.
DocType: Manufacturing Settings,Update BOM Cost Automatically,Opdater BOM omkostninger automatisk
DocType: Lab Test,Test Name,Testnavn
DocType: Healthcare Settings,Clinical Procedure Consumable Item,Klinisk procedure forbrugsartikel
apps/erpnext/erpnext/utilities/activation.py +99,Create Users,Opret Brugere
apps/erpnext/erpnext/utilities/user_progress.py +147,Gram,Gram
apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +30,Subscriptions,Abonnementer
DocType: Supplier Scorecard,Per Month,Om måneden
DocType: Education Settings,Make Academic Term Mandatory,Gør faglig semester obligatorisk
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +414,Quantity to Manufacture must be greater than 0.,Mængde til Fremstilling skal være større end 0.
DocType: Asset Settings,Calculate Prorated Depreciation Schedule Based on Fiscal Year,Beregn Prorated Depreciation Schedule Baseret på Skatteår
apps/erpnext/erpnext/config/maintenance.py +17,Visit report for maintenance call.,Besøg rapport til vedligeholdelse opkald.
DocType: Stock Entry,Update Rate and Availability,Opdatér priser og tilgængelighed
DocType: Stock Settings,Percentage you are allowed to receive or deliver more against the quantity ordered. For example: If you have ordered 100 units. and your Allowance is 10% then you are allowed to receive 110 units.,"Procentdel, du får lov til at modtage eller levere mere mod den bestilte mængde. For eksempel: Hvis du har bestilt 100 enheder. og din Allowance er 10%, så du får lov til at modtage 110 enheder."
DocType: Loyalty Program,Customer Group,Kundegruppe
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +300,Row #{0}: Operation {1} is not completed for {2} qty of finished goods in Work Order # {3}. Please update operation status via Time Logs,Række nr. {0}: Drift {1} er ikke afsluttet for {2} Antal færdige varer i Arbejdsordre # {3}. Opdater operationsstatus via Time Logs
apps/erpnext/erpnext/stock/doctype/batch/batch.js +128,New Batch ID (Optional),Nyt partinr. (valgfri)
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +231,Expense account is mandatory for item {0},Udgiftskonto er obligatorisk for element {0}
DocType: BOM,Website Description,Hjemmesidebeskrivelse
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +101,Net Change in Equity,Nettoændring i Equity
apps/erpnext/erpnext/assets/doctype/asset/asset.py +300,Please cancel Purchase Invoice {0} first,Annullér købsfaktura {0} først
apps/erpnext/erpnext/healthcare/doctype/healthcare_service_unit_type/healthcare_service_unit_type.py +25,Not permitted. Please disable the Service Unit Type,Ikke tilladt. Deaktiver venligst serviceenhedstypen
apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py +43,"Email Address must be unique, already exists for {0}","E-mailadresse skal være unik, findes allerede for {0}"
DocType: Serial No,AMC Expiry Date,AMC Udløbsdato
DocType: Asset,Receipt,Kvittering
,Sales Register,Salgs Register
DocType: Daily Work Summary Group,Send Emails At,Send e-mails på
DocType: Quotation,Quotation Lost Reason,Tilbud afvist - årsag
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +383,Transaction reference no {0} dated {1},Transaktion henvisning ingen {0} dateret {1}
apps/erpnext/erpnext/setup/doctype/supplier_group/supplier_group.js +5,There is nothing to edit.,Der er intet at redigere.
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +542,Form View,Formularvisning
DocType: HR Settings,Expense Approver Mandatory In Expense Claim,Expense Approver Obligatorisk i Expense Claim
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +124,Summary for this month and pending activities,Resumé for denne måned og verserende aktiviteter
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.py +91,Please set Unrealized Exchange Gain/Loss Account in Company {0},Indstil Urealiseret Exchange Gain / Loss-konto i firma {0}
apps/erpnext/erpnext/utilities/user_progress.py +248,"Add users to your organization, other than yourself.","Tilføj brugere til din organisation, bortset fra dig selv."
DocType: Customer Group,Customer Group Name,Kundegruppenavn
apps/erpnext/erpnext/public/js/pos/pos.html +109,No Customers yet!,Ingen kunder endnu!
DocType: Healthcare Service Unit,Healthcare Service Unit,Sundhedsvæsen Service Unit
apps/erpnext/erpnext/public/js/financial_statements.js +58,Cash Flow Statement,Pengestrømsanalyse
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py +374,No material request created,Ingen væsentlig forespørgsel oprettet
apps/erpnext/erpnext/hr/doctype/employee_loan_application/employee_loan_application.py +23,Loan Amount cannot exceed Maximum Loan Amount of {0},Lånebeløb kan ikke overstige det maksimale lånebeløb på {0}
apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py +22,License,Licens
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +563,Please remove this Invoice {0} from C-Form {1},Fjern denne faktura {0} fra C-Form {1}
DocType: Leave Control Panel,Please select Carry Forward if you also want to include previous fiscal year's balance leaves to this fiscal year,"Vælg dette felt, hvis du også ønsker at inkludere foregående regnskabsår fraværssaldo til indeværende regnskabsår"
DocType: GL Entry,Against Voucher Type,Mod Bilagstype
DocType: Healthcare Practitioner,Phone (R),Telefon (R)
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js +104,Time slots added,Time slots tilføjet
DocType: Item,Attributes,Attributter
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js +36,Enable Template,Aktivér skabelon
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +256,Please enter Write Off Account,Indtast venligst Skriv Off konto
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +71,Last Order Date,Sidste ordredato
DocType: Salary Component,Is Payable,Er betales
DocType: Inpatient Record,B Negative,B Negativ
apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +25,Maintenance Status has to be Cancelled or Completed to Submit,Vedligeholdelsesstatus skal annulleres eller afsluttes for at indsende
DocType: Amazon MWS Settings,US,OS
DocType: Holiday List,Add Weekly Holidays,Tilføj ugentlige helligdage
DocType: Staffing Plan Detail,Vacancies,Ledige stillinger
DocType: Hotel Room,Hotel Room,Hotelværelse
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +57,Account {0} does not belongs to company {1},Konto {0} ikke hører til virksomheden {1}
DocType: Leave Type,Rounding,Afrunding
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +994,Serial Numbers in row {0} does not match with Delivery Note,Serienumre i række {0} stemmer ikke overens med Leveringsnotat
DocType: Employee Benefit Application,Dispensed Amount (Pro-rated),Dispensed Amount (Pro-rated)
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +36,"Then Pricing Rules are filtered out based on Customer, Customer Group, Territory, Supplier, Supplier Group, Campaign, Sales Partner etc.","Derefter filtreres prisreglerne ud fra kunde, kundegruppe, territorium, leverandør, leverandørgruppe, kampagne, salgspartner mv."
DocType: Student,Guardian Details,Guardian Detaljer
DocType: C-Form,C-Form,C-Form
DocType: Agriculture Task,Start Day,Start dag
DocType: Vehicle,Chassis No,Stelnummer
DocType: Payment Request,Initiated,Indledt
DocType: Production Plan Item,Planned Start Date,Planlagt startdato
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +649,Please select a BOM,Vælg venligst en BOM
DocType: Purchase Invoice,Availed ITC Integrated Tax,Benyttet ITC Integrated Tax
DocType: Purchase Order Item,Blanket Order Rate,Tæppe Ordre Rate
apps/erpnext/erpnext/hooks.py +164,Certification,Certificering
DocType: Bank Guarantee,Clauses and Conditions,Klausuler og betingelser
DocType: Serial No,Creation Document Type,Oprettet dokumenttype
DocType: Project Task,View Timesheet,Se tidsskema
DocType: Amazon MWS Settings,ES,ES
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.js +24,Make Journal Entry,Make Kassekladde
DocType: Leave Allocation,New Leaves Allocated,Nye fravær Allokeret
apps/erpnext/erpnext/controllers/trends.py +269,Project-wise data is not available for Quotation,Sagsdata er ikke tilgængelige for tilbuddet
apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +30,End on,Slut på
DocType: Project,Expected End Date,Forventet slutdato
DocType: Budget Account,Budget Amount,Budget Beløb
DocType: Donor,Donor Name,Donornavn
DocType: Journal Entry,Inter Company Journal Entry Reference,Inter Company Journal Entry Reference
DocType: Appraisal Template,Appraisal Template Title,Vurderingsskabelonnavn
apps/erpnext/erpnext/utilities/user_progress_utils.py +29,Commercial,Kommerciel
DocType: Patient,Alcohol Current Use,Alkohol Nuværende Brug
DocType: Employee Tax Exemption Proof Submission,House Rent Payment Amount,Husleje Betalingsbeløb
DocType: Student Admission Program,Student Admission Program,Studenter Adgangsprogram
DocType: Employee Tax Exemption Sub Category,Tax Exemption Category,Skattefritagelseskategori
DocType: Payment Entry,Account Paid To,Konto Betalt Til
DocType: Subscription Settings,Grace Period,Afdragsfri periode
DocType: Item Alternative,Alternative Item Name,Alternativt varenavn
apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.py +24,Parent Item {0} must not be a Stock Item,Overordnet bare {0} må ikke være en lagervare
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +164,Website Listing,Website liste
apps/erpnext/erpnext/config/selling.py +57,All Products or Services.,Alle produkter eller tjenesteydelser.
DocType: Email Digest,Open Quotations,Åben citat
DocType: Expense Claim,More Details,Flere detaljer
DocType: Supplier Quotation,Supplier Address,Leverandør Adresse
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +168,{0} Budget for Account {1} against {2} {3} is {4}. It will exceed by {5},{0} budget for konto {1} mod {2} {3} er {4}. Det vil overstige med {5}
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37,Out Qty,Out Antal
apps/erpnext/erpnext/buying/doctype/supplier/supplier.py +49,Series is mandatory,Nummerserien er obligatorisk
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +28,Financial Services,Financial Services
DocType: Student Sibling,Student ID,Studiekort
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +214,For Quantity must be greater than zero,For Mængde skal være større end nul
apps/erpnext/erpnext/config/projects.py +51,Types of activities for Time Logs,Typer af aktiviteter for Time Logs
DocType: Opening Invoice Creation Tool,Sales,Salg
DocType: Stock Entry Detail,Basic Amount,Grundbeløb
DocType: Training Event,Exam,Eksamen
apps/erpnext/erpnext/public/js/hub/hub_call.js +46,Marketplace Error,Markedspladsfejl
DocType: Complaint,Complaint,Klage
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +534,Warehouse required for stock Item {0},Lager kræves for lagervare {0}
DocType: Leave Allocation,Unused leaves,Ubrugte blade
apps/erpnext/erpnext/hr/doctype/loan/loan.js +83,Make Repayment Entry,Lav tilbagebetalingstildeling
apps/erpnext/erpnext/patches/v11_0/update_department_lft_rgt.py +10,All Departments,Alle afdelinger
DocType: Healthcare Service Unit,Vacant,Ledig
DocType: Patient,Alcohol Past Use,Alkohol tidligere brug
DocType: Fertilizer Content,Fertilizer Content,Gødning Indhold
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +248,Cr,Cr
DocType: Project Update,Problematic/Stuck,Problematisk / Stuck
DocType: Tax Rule,Billing State,Anvendes ikke
DocType: Share Transfer,Transfer,Overførsel
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +268,Work Order {0} must be cancelled before cancelling this Sales Order,"Arbejdsordren {0} skal annulleres, inden afbestillingen af denne salgsordre"
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +1008,Fetch exploded BOM (including sub-assemblies),Hent eksploderede BOM (herunder underenheder)
DocType: Authorization Rule,Applicable To (Employee),Gælder for (Medarbejder)
apps/erpnext/erpnext/controllers/accounts_controller.py +180,Due Date is mandatory,Forfaldsdato er obligatorisk
apps/erpnext/erpnext/controllers/item_variant.py +82,Increment for Attribute {0} cannot be 0,Tilvækst til Attribut {0} kan ikke være 0
DocType: Employee Benefit Claim,Benefit Type and Amount,Fordelstype og beløb
apps/erpnext/erpnext/hotels/report/hotel_room_occupancy/hotel_room_occupancy.py +19,Rooms Booked,Værelser Reserveret
apps/erpnext/erpnext/crm/doctype/lead/lead.py +57,Ends On date cannot be before Next Contact Date.,Slutter På dato kan ikke være før næste kontaktdato.
DocType: Journal Entry,Pay To / Recd From,Betal Til / RECD Fra
DocType: Naming Series,Setup Series,Opsætning af nummerserier
DocType: Payment Reconciliation,To Invoice Date,Til fakturadato
DocType: Bank Account,Contact HTML,Kontakt HTML
DocType: Support Settings,Support Portal,Support Portal
apps/erpnext/erpnext/healthcare/doctype/healthcare_settings/healthcare_settings.py +19,Registration fee can not be Zero,Registreringsgebyr kan ikke være nul
DocType: Disease,Treatment Period,Behandlingsperiode
DocType: Travel Itinerary,Travel Itinerary,Rejseplan
apps/erpnext/erpnext/education/api.py +336,Result already Submitted,Resultat allerede indsendt
apps/erpnext/erpnext/controllers/buying_controller.py +209,Reserved Warehouse is mandatory for Item {0} in Raw Materials supplied,Reserveret lager er obligatorisk for vare {0} i råvarer leveret
,Inactive Customers,Inaktive kunder
DocType: Student Admission Program,Maximum Age,Maksimal alder
apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +28,Please wait 3 days before resending the reminder.,Vent venligst 3 dage før genudsender påmindelsen.
DocType: Landed Cost Voucher,Purchase Receipts,Købskvitteringer
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +29,How Pricing Rule is applied?,Hvordan anvendes en prisfastsættelsesregel?
DocType: Stock Entry,Delivery Note No,Følgeseddelnr.
DocType: Cheque Print Template,Message to show,Besked for at vise
apps/erpnext/erpnext/public/js/setup_wizard.js +28,Retail,Retail
DocType: Student Attendance,Absent,Ikke-tilstede
DocType: Staffing Plan,Staffing Plan Detail,Bemandingsplandetaljer
DocType: Employee Promotion,Promotion Date,Kampagnedato
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +622,Product Bundle,Produktpakke
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +38,Unable to find score starting at {0}. You need to have standing scores covering 0 to 100,Kunne ikke finde nogen score fra {0}. Du skal have stående scoringer på mellem 0 og 100
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +244,Row {0}: Invalid reference {1},Række {0}: Ugyldig henvisning {1}
apps/erpnext/erpnext/assets/doctype/location/location_tree.js +23,New Location,Ny placering
DocType: Purchase Taxes and Charges Template,Purchase Taxes and Charges Template,Indkøb Moms- og afgiftsskabelon
DocType: Subscription,Current Invoice Start Date,Nuværende faktura startdato
DocType: Timesheet,TS-,TS
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +61,{0} {1}: Either debit or credit amount is required for {2},{0} {1}: Enten debet- eller kreditbeløb er påkrævet for {2}
DocType: GL Entry,Remarks,Bemærkninger
DocType: Hotel Room Amenity,Hotel Room Amenity,Hotel Værelsesfaciliteter
DocType: Budget,Action if Annual Budget Exceeded on MR,Handling hvis årligt budget oversteg MR
DocType: Payment Entry,Account Paid From,Konto Betalt Fra
DocType: Purchase Order Item Supplied,Raw Material Item Code,Råmateriale varenr.
DocType: Task,Parent Task,Forældreopgave
DocType: Journal Entry,Write Off Based On,Skriv Off baseret på
apps/erpnext/erpnext/utilities/activation.py +65,Make Lead,Opret emne
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +119,Print and Stationery,Print og papirvarer
DocType: Stock Settings,Show Barcode Field,Vis stregkodefelter
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +866,Send Supplier Emails,Send Leverandør Emails
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +165,"Salary already processed for period between {0} and {1}, Leave application period cannot be between this date range.","Løn allerede behandlet for perioden {0} til {1}, ferie ansøgningsperiode kan ikke være i dette datointerval."
DocType: Fiscal Year,Auto Created,Automatisk oprettet
apps/erpnext/erpnext/hr/doctype/employee_onboarding/employee_onboarding.py +19,Submit this to create the Employee record,Indsend dette for at oprette medarbejderposten
DocType: Item Default,Item Default,Element Standard
DocType: Chapter Member,Leave Reason,Forlad grunden
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +197,Invoice {0} no longer exists,Faktura {0} eksisterer ikke længere
DocType: Guardian Interest,Guardian Interest,Guardian Renter
DocType: Volunteer,Availability,tilgængelighed
apps/erpnext/erpnext/config/accounts.py +544,Setup default values for POS Invoices,Indstil standardværdier for POS-fakturaer
apps/erpnext/erpnext/config/hr.py +248,Training,Uddannelse
DocType: Project,Time to send,Tid til at sende
DocType: Timesheet,Employee Detail,Medarbejderoplysninger
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure/clinical_procedure.py +19,Set warehouse for Procedure {0} ,Sæt lager til procedure {0}
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +58,Guardian1 Email ID,Guardian1 Email ID
DocType: Lab Prescription,Test Code,Testkode
apps/erpnext/erpnext/config/website.py +11,Settings for website homepage,Indstillinger for hjemmesidens startside
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +895,{0} is on hold till {1},{0} er på vent indtil {1}
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +40,RFQs are not allowed for {0} due to a scorecard standing of {1},RFQ&#39;er er ikke tilladt for {0} på grund af et scorecard stående på {1}
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html +9,Used Leaves,Brugte blade
DocType: Job Offer,Awaiting Response,Afventer svar
DocType: Course Schedule,EDU-CSH-.YYYY.-,EDU-CSH-.YYYY.-
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +83,Above,Frem
DocType: Support Search Source,Link Options,Link muligheder
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1557,Total Amount {0},Samlede beløb {0}
apps/erpnext/erpnext/controllers/item_variant.py +323,Invalid attribute {0} {1},Ugyldig attribut {0} {1}
DocType: Supplier,Mention if non-standard payable account,Angiv hvis ikke-standard betalingskonto
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.py +25,Please select the assessment group other than 'All Assessment Groups',Vælg venligst vurderingsgruppen bortset fra &#39;Alle vurderingsgrupper&#39;
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +67,Row {0}: Cost center is required for an item {1},Række {0}: Omkostningscenter er påkrævet for en vare {1}
DocType: Training Event Employee,Optional,Valgfri
DocType: Salary Slip,Earning & Deduction,Tillæg & fradrag
DocType: Agriculture Analysis Criteria,Water Analysis,Vandanalyse
apps/erpnext/erpnext/stock/doctype/item/item.js +476,{0} variants created.,{0} varianter oprettet.
DocType: Amazon MWS Settings,Region,Region
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +36,Optional. This setting will be used to filter in various transactions.,Valgfri. Denne indstilling vil blive brugt til at filtrere i forskellige transaktioner.
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +111,Negative Valuation Rate is not allowed,Negative Værdiansættelses Rate er ikke tilladt
DocType: Holiday List,Weekly Off,Ugedag fri
apps/erpnext/erpnext/agriculture/doctype/crop_cycle/crop_cycle.js +7,Reload Linked Analysis,Genindlæs tilknyttet analyse
DocType: Fiscal Year,"For e.g. 2012, 2012-13","Til fx 2012, 2012-13"
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +99,Provisional Profit / Loss (Credit),Foreløbig Profit / Loss (Credit)
DocType: Sales Invoice,Return Against Sales Invoice,Retur mod salgsfaktura
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +32,Item 5,Vare 5
DocType: Serial No,Creation Time,Creation Time
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +62,Total Revenue,Omsætning i alt
DocType: Patient,Other Risk Factors,Andre risikofaktorer
DocType: Sales Invoice,Product Bundle Help,Produktpakkehjælp
,Monthly Attendance Sheet,Månedlig Deltagelse Sheet
apps/erpnext/erpnext/hr/report/employee_advance_summary/employee_advance_summary.py +15,No record found,Ingen post fundet
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +155,Cost of Scrapped Asset,Udgifter kasseret anlægsaktiv
apps/erpnext/erpnext/controllers/stock_controller.py +240,{0} {1}: Cost Center is mandatory for Item {2},{0} {1}: Omkostningssted er obligatorisk for vare {2}
DocType: Vehicle,Policy No,Politik Ingen
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +743,Get Items from Product Bundle,Hent varer fra produktpakke
DocType: Asset,Straight Line,Lineær afskrivning
DocType: Project User,Project User,Sagsbruger
apps/erpnext/erpnext/stock/doctype/batch/batch.js +72,Split,Dele
DocType: Employee Transfer,Re-allocate Leaves,Omfordele blade
DocType: GL Entry,Is Advance,Er Advance
apps/erpnext/erpnext/config/hr.py +202,Employee Lifecycle,Ansattes livscyklus
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +21,Attendance From Date and Attendance To Date is mandatory,Fremmøde fradato og Fremmøde tildato er obligatoriske
apps/erpnext/erpnext/controllers/buying_controller.py +196,Please enter 'Is Subcontracted' as Yes or No,Indtast &quot;underentreprise&quot; som Ja eller Nej
DocType: Item,Default Purchase Unit of Measure,Standardindkøbsenhed
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +29,Last Communication Date,Sidste kommunikationsdato
DocType: Clinical Procedure Item,Clinical Procedure Item,Klinisk procedurepost
DocType: Sales Team,Contact No.,Kontaktnr.
DocType: Bank Reconciliation,Payment Entries,Betalings Entries
apps/erpnext/erpnext/erpnext_integrations/doctype/shopify_settings/shopify_settings.py +33,Access token or Shopify URL missing,Adkomst token eller Shopify URL mangler
DocType: Location,Latitude,Breddegrad
DocType: Work Order,Scrap Warehouse,Skrotlager
DocType: Work Order,Check if material transfer entry is not required,"Kontroller, om materialetilførsel ikke er påkrævet"
DocType: Program Enrollment Tool,Get Students From,Hent studerende fra
apps/erpnext/erpnext/config/learn.py +263,Publish Items on Website,Vis varer på hjemmesiden
apps/erpnext/erpnext/utilities/activation.py +126,Group your students in batches,Opdel dine elever i grupper
DocType: Authorization Rule,Authorization Rule,Autorisation Rule
DocType: POS Profile,Offline POS Section,Offline POS-sektion
DocType: Sales Invoice,Terms and Conditions Details,Betingelsesdetaljer
apps/erpnext/erpnext/templates/generators/item.html +118,Specifications,Specifikationer
DocType: Sales Taxes and Charges Template,Sales Taxes and Charges Template,Salg Moms- og afgiftsskabelon
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +70,Total (Credit),I alt (kredit)
DocType: Repayment Schedule,Payment Date,Betalingsdato
apps/erpnext/erpnext/stock/doctype/batch/batch.js +122,New Batch Qty,Ny partimængde
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +10,Apparel & Accessories,Beklædning og tilbehør
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_period/supplier_scorecard_period.py +91,Could not solve weighted score function. Make sure the formula is valid.,"Kunne ikke løse vægtet scoringsfunktion. Sørg for, at formlen er gyldig."
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +186,Purchase Order Items not received on time,Indkøbsordre Varer ikke modtaget i tide
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +67,Number of Order,Antal Order
DocType: Item Group,HTML / Banner that will show on the top of product list.,"HTML / Banner, der vil vise på toppen af produktliste."
DocType: Shipping Rule,Specify conditions to calculate shipping amount,Angiv betingelser for at beregne forsendelsesmængden
DocType: Program Enrollment,Institute's Bus,Instituttets bus
DocType: Accounts Settings,Role Allowed to Set Frozen Accounts & Edit Frozen Entries,Rolle Tilladt til Indstil Frosne Konti og Rediger Frosne Entries
DocType: Supplier Scorecard Scoring Variable,Path,Sti
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +30,Cannot convert Cost Center to ledger as it has child nodes,"Kan ikke konvertere Cost Center til hovedbog, som det har barneknudepunkter"
DocType: Production Plan,Total Planned Qty,Samlet planlagt antal
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +83,Opening Value,åbning Value
DocType: Salary Component,Formula,Formel
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +59,Serial #,Serienummer
DocType: Lab Test Template,Lab Test Template,Lab Test Template
apps/erpnext/erpnext/setup/doctype/company/company.py +196,Sales Account,Salgskonto
DocType: Purchase Invoice Item,Total Weight,Totalvægt
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +101,Commission on Sales,Salgsprovisioner
DocType: Job Offer Term,Value / Description,/ Beskrivelse
apps/erpnext/erpnext/controllers/accounts_controller.py +706,"Row #{0}: Asset {1} cannot be submitted, it is already {2}","Row # {0}: Asset {1} kan ikke indsendes, er det allerede {2}"
DocType: Tax Rule,Billing Country,Faktureringsland
DocType: Purchase Order Item,Expected Delivery Date,Forventet leveringsdato
DocType: Restaurant Order Entry,Restaurant Order Entry,Restaurant Order Entry
apps/erpnext/erpnext/accounts/general_ledger.py +134,Debit and Credit not equal for {0} #{1}. Difference is {2}.,Debet og kredit ikke ens for {0} # {1}. Forskellen er {2}.
DocType: Clinical Procedure Item,Invoice Separately as Consumables,Faktura Separat som forbrugsstoffer
DocType: Budget,Control Action,Kontrol handling
DocType: Asset Maintenance Task,Assign To Name,Tildel til navn
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +105,Entertainment Expenses,Repræsentationsudgifter
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +98,Make Material Request,Opret materialeanmodning
apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html +20,Open Item {0},Åbent Item {0}
DocType: Asset Finance Book,Written Down Value,Skriftlig nedværdi
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +235,Sales Invoice {0} must be cancelled before cancelling this Sales Order,"Salgsfaktura {0} skal annulleres, før denne salgsordre annulleres"
DocType: Clinical Procedure,Age,Alder
DocType: Sales Invoice Timesheet,Billing Amount,Faktureret beløb
DocType: Cash Flow Mapping,Select Maximum Of 1,Vælg Maksimum 1
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +84,Invalid quantity specified for item {0}. Quantity should be greater than 0.,Ugyldig mængde angivet for element {0}. Mængde bør være større end 0.
DocType: Company,Default Employee Advance Account,Standardansatskonto
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1181,Search Item (Ctrl + i),Søgeelement (Ctrl + i)
DocType: C-Form,ACC-CF-.YYYY.-,ACC-CF-.YYYY.-
apps/erpnext/erpnext/accounts/doctype/account/account.py +171,Account with existing transaction can not be deleted,Konto med eksisterende transaktion kan ikke slettes
DocType: Vehicle,Last Carbon Check,Sidste synsdato
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +109,Legal Expenses,Advokatudgifter
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +147,Please select quantity on row ,Vælg venligst antal på række
apps/erpnext/erpnext/config/accounts.py +245,Make Opening Sales and Purchase Invoices,Gør åbning af salgs- og købsfakturaer
DocType: Purchase Invoice,Posting Time,Bogføringsdato og -tid
DocType: Timesheet,% Amount Billed,% Faktureret beløb
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +125,Telephone Expenses,Telefonudgifter
DocType: Sales Partner,Logo,Logo
DocType: Naming Series,Check this if you want to force the user to select a series before saving. There will be no default if you check this.,"Markér dette hvis du ønsker at tvinge brugeren til at vælge en serie før du gemmer. Der vil ikke være standard, hvis du markerer dette."
apps/erpnext/erpnext/stock/get_item_details.py +150,No Item with Serial No {0},Ingen vare med serienummer {0}
DocType: Email Digest,Open Notifications,Åbne Meddelelser
DocType: Payment Entry,Difference Amount (Company Currency),Differencebeløb (firmavaluta)
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +83,Direct Expenses,Direkte udgifter
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +60,New Customer Revenue,Omsætning nye kunder
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +126,Travel Expenses,Rejseudgifter
DocType: Maintenance Visit,Breakdown,Sammenbrud
DocType: Travel Itinerary,Vegetarian,Vegetarisk
DocType: Patient Encounter,Encounter Date,Encounter Date
apps/erpnext/erpnext/controllers/accounts_controller.py +907,Account: {0} with currency: {1} can not be selected,Konto: {0} med valuta: kan ikke vælges {1}
DocType: Bank Statement Transaction Settings Item,Bank Data,Bankdata
DocType: Purchase Receipt Item,Sample Quantity,Prøvekvantitet
DocType: Bank Guarantee,Name of Beneficiary,Navn på modtager
DocType: Manufacturing Settings,"Update BOM cost automatically via Scheduler, based on latest valuation rate / price list rate / last purchase rate of raw materials.","Opdater BOM omkostninger automatisk via Scheduler, baseret på seneste værdiansættelsesrate / prisliste sats / sidste købspris for råvarer."
DocType: Supplier,SUP-.YYYY.-,SUP-.YYYY.-
DocType: Bank Reconciliation Detail,Cheque Date,Anvendes ikke
apps/erpnext/erpnext/accounts/doctype/account/account.py +57,Account {0}: Parent account {1} does not belong to company: {2},Konto {0}: Forældre-konto {1} tilhører ikke virksomheden: {2}
apps/erpnext/erpnext/setup/doctype/company/company.js +126,Successfully deleted all transactions related to this company!,Succesfuld slettet alle transaktioner i forbindelse med dette selskab!
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +22,As on Date,Som på dato
DocType: Additional Salary,HR,HR
DocType: Program Enrollment,Enrollment Date,Tilmelding Dato
DocType: Healthcare Settings,Out Patient SMS Alerts,Out Patient SMS Alerts
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +78,Probation,Kriminalforsorgen
DocType: Program Enrollment Tool,New Academic Year,Nyt skoleår
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +866,Return / Credit Note,Retur / kreditnota
DocType: Stock Settings,Auto insert Price List rate if missing,"Auto insert Prisliste sats, hvis der mangler"
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +137,Total Paid Amount,Samlet indbetalt beløb
DocType: GST Settings,B2C Limit,B2C Limit
DocType: Job Card,Transferred Qty,Overført antal
apps/erpnext/erpnext/config/learn.py +11,Navigating,Navigering
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +141,Planning,Planlægning
DocType: Contract,Signee,Signee
DocType: Share Balance,Issued,Udstedt
DocType: Loan,Repayment Start Date,Tilbagebetaling Startdato
apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +14,Student Activity,Studentaktivitet
apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +80,Supplier Id,Leverandør id
DocType: Payment Request,Payment Gateway Details,Betaling Gateway Detaljer
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +290,Quantity should be greater than 0,Mængde bør være større end 0
DocType: Journal Entry,Cash Entry,indtastning af kontanter
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js +17,Child nodes can be only created under 'Group' type nodes,Child noder kan kun oprettes under &#39;koncernens typen noder
DocType: Attendance Request,Half Day Date,Halv dag dato
DocType: Academic Year,Academic Year Name,Skoleårsnavn
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +1182,{0} not allowed to transact with {1}. Please change the Company.,{0} må ikke transagere med {1}. Vær venlig at ændre selskabet.
DocType: Sales Partner,Contact Desc,Kontaktbeskrivelse
DocType: Email Digest,Send regular summary reports via Email.,Send regelmæssige sammenfattende rapporter via e-mail.
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +289,Please set default account in Expense Claim Type {0},Angiv standardkonto i udlægstype {0}
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html +11,Available Leaves,Tilgængelige blade
DocType: Assessment Result,Student Name,Elevnavn
DocType: Hub Tracked Item,Item Manager,Varechef
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +150,Payroll Payable,Udbetalt løn
DocType: Plant Analysis,Collection Datetime,Samling Datetime
DocType: Asset Repair,ACC-ASR-.YYYY.-,ACC-ASR-.YYYY.-
DocType: Work Order,Total Operating Cost,Samlede driftsomkostninger
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +172,Note: Item {0} entered multiple times,Bemærk: Varer {0} indtastet flere gange
apps/erpnext/erpnext/config/selling.py +41,All Contacts.,Alle kontakter.
DocType: Accounting Period,Closed Documents,Lukkede dokumenter
DocType: Healthcare Settings,Manage Appointment Invoice submit and cancel automatically for Patient Encounter,Administrer Aftalingsfaktura indsende og annullere automatisk for Patient Encounter
DocType: Patient Appointment,Referring Practitioner,Refererende praktiserende læge
apps/erpnext/erpnext/public/js/setup_wizard.js +71,Company Abbreviation,Firma-forkortelse
apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner.py +51,User {0} does not exist,Brugeren {0} eksisterer ikke
DocType: Payment Term,Day(s) after invoice date,Dag (er) efter faktura dato
apps/erpnext/erpnext/setup/doctype/company/company.js +34,Date of Commencement should be greater than Date of Incorporation,Dato for påbegyndelse skal være større end oprettelsesdato
DocType: Contract,Signed On,Logget på
DocType: Bank Account,Party Type,Party Type
DocType: Payment Schedule,Payment Schedule,Betalingsplan
DocType: Item Attribute Value,Abbreviation,Forkortelse
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +220,Payment Entry already exists,Betaling indtastning findes allerede
DocType: Subscription,Trial Period End Date,Prøveperiode Slutdato
apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py +36,Not authroized since {0} exceeds limits,Ikke authroized da {0} overskrider grænser
DocType: Serial No,Asset Status,Asset Status
DocType: Delivery Note,Over Dimensional Cargo (ODC),Over dimensionel last (ODC)
DocType: Restaurant Order Entry,Restaurant Table,Restaurantbord
DocType: Hotel Room,Hotel Manager,Hotelbestyrer
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +64,Set Tax Rule for shopping cart,Sæt momsregel for indkøbskurv
DocType: Purchase Invoice,Taxes and Charges Added,Skatter og Afgifter Tilføjet
apps/erpnext/erpnext/assets/doctype/asset/asset.py +223,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,Afskrivnings række {0}: Næste afskrivningsdato kan ikke være før tilgængelig dato
,Sales Funnel,Salgstragt
apps/erpnext/erpnext/setup/doctype/company/company.py +53,Abbreviation is mandatory,Forkortelsen er obligatorisk
DocType: Project,Task Progress,Opgave-fremskridt
apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html +7,Cart,Kurv
DocType: Certified Consultant,GitHub ID,GitHub ID
DocType: Staffing Plan,Total Estimated Budget,Samlet estimeret budget
,Qty to Transfer,Antal til Transfer
apps/erpnext/erpnext/config/selling.py +13,Quotes to Leads or Customers.,Tilbud til emner eller kunder.
DocType: Stock Settings,Role Allowed to edit frozen stock,Rolle Tilladt at redigere frosne lager
,Territory Target Variance Item Group-Wise,Områdemål Variance Item Group-Wise
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +108,All Customer Groups,Alle kundegrupper
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +155,Accumulated Monthly,Akkumuleret månedlig
DocType: Attendance Request,On Duty,På vagt
apps/erpnext/erpnext/controllers/accounts_controller.py +864,{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2}.,{0} er obligatorisk. Måske er valutaveksling record ikke lavet for {1} til {2}.
apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.py +51,Staffing Plan {0} already exist for designation {1},Bemanningsplan {0} findes allerede til betegnelse {1}
apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +46,Tax Template is mandatory.,Momsskabelon er obligatorisk.
apps/erpnext/erpnext/accounts/doctype/account/account.py +51,Account {0}: Parent account {1} does not exist,Konto {0}: Forældre-konto {1} findes ikke
DocType: POS Closing Voucher,Period Start Date,Periode Startdato
DocType: Purchase Invoice Item,Price List Rate (Company Currency),Prisliste Rate (Company Valuta)
DocType: Products Settings,Products Settings,Produkter Indstillinger
,Item Price Stock,Vare pris lager
apps/erpnext/erpnext/config/accounts.py +550,To make Customer based incentive schemes.,At lave kundebaserede incitamentsordninger.
DocType: Lab Prescription,Test Created,Test oprettet
DocType: Healthcare Settings,Custom Signature in Print,Brugerdefineret signatur i udskrivning
DocType: Account,Temporary,Midlertidig
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +127,Customer LPO No.,Kunde LPO nr.
DocType: Amazon MWS Settings,Market Place Account Group,Market Place Account Group
apps/erpnext/erpnext/accounts/doctype/payment_order/payment_order.js +14,Make Payment Entries,Foretag betalingsoplysninger
DocType: Program,Courses,Kurser
DocType: Monthly Distribution Percentage,Percentage Allocation,Procentvis fordeling
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +91,Secretary,Sekretær
apps/erpnext/erpnext/regional/india/utils.py +177,House rented dates required for exemption calculation,Hus lejede datoer kræves for fritagelse beregning
DocType: Global Defaults,"If disable, 'In Words' field will not be visible in any transaction","Hvis deaktivere, &#39;I Words&#39; område vil ikke være synlig i enhver transaktion"
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js +29,This action will stop future billing. Are you sure you want to cancel this subscription?,"Denne handling stopper fremtidig fakturering. Er du sikker på, at du vil annullere dette abonnement?"
DocType: Serial No,Distinct unit of an Item,Særskilt enhed af et element
DocType: Supplier Scorecard Criteria,Criteria Name,Kriterier Navn
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.js +406,Please set Company,Angiv venligst firma
DocType: Procedure Prescription,Procedure Created,Procedure oprettet
DocType: Pricing Rule,Buying,Køb
apps/erpnext/erpnext/config/agriculture.py +24,Diseases & Fertilizers,Sygdomme og gødninger
DocType: HR Settings,Employee Records to be created by,Medarbejdere skal oprettes af
DocType: Inpatient Record,AB Negative,AB Negativ
DocType: POS Profile,Apply Discount On,Påfør Rabat på
DocType: Member,Membership Type,Medlemskabstype
,Reqd By Date,Reqd Efter dato
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +147,Creditors,Kreditorer
DocType: Assessment Plan,Assessment Name,Vurdering Navn
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js +107,Show PDC in Print,Vis PDC i Print
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +95,Row # {0}: Serial No is mandatory,Række # {0}: serienummer er obligatorisk
DocType: Purchase Taxes and Charges,Item Wise Tax Detail,Item Wise Tax Detail
DocType: Employee Onboarding,Job Offer,Jobtilbud
apps/erpnext/erpnext/public/js/setup_wizard.js +71,Institute Abbreviation,Institut Forkortelse
,Item-wise Price List Rate,Item-wise Prisliste Rate
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1157,Supplier Quotation,Leverandørtilbud
DocType: Quotation,In Words will be visible once you save the Quotation.,"""I Ord"" vil være synlig, når du gemmer tilbuddet."
apps/erpnext/erpnext/utilities/transaction_base.py +169,Quantity ({0}) cannot be a fraction in row {1},Mængde ({0}) kan ikke være en brøkdel i række {1}
DocType: Contract,Unsigned,usigneret
DocType: Selling Settings,Each Transaction,Hver transaktion
apps/erpnext/erpnext/stock/doctype/item/item.py +523,Barcode {0} already used in Item {1},Stregkode {0} allerede brugt i vare {1}
apps/erpnext/erpnext/config/selling.py +86,Rules for adding shipping costs.,Regler for at tilføje forsendelsesomkostninger.
DocType: Hotel Room,Extra Bed Capacity,Ekstra seng kapacitet
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +72,Varaiance ,Varaiance
DocType: Item,Opening Stock,Åbning Stock
apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +20,Customer is required,Kunde skal angives
DocType: Lab Test,Result Date,Resultatdato
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +102,PDC/LC Date,PDC / LC Dato
DocType: Purchase Order,To Receive,At Modtage
DocType: Leave Period,Holiday List for Optional Leave,Ferieliste for valgfri ferie
apps/erpnext/erpnext/utilities/user_progress.py +252,user@example.com,user@example.com
DocType: Asset,Asset Owner,Asset Owner
DocType: Purchase Invoice,Reason For Putting On Hold,Årsag til at sætte på hold
DocType: Employee,Personal Email,Personlig e-mail
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +86,Total Variance,Samlet Varians
DocType: Accounts Settings,"If enabled, the system will post accounting entries for inventory automatically.","Hvis aktiveret, vil systemet sende bogføring for opgørelse automatisk."
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +15,Brokerage,Brokerage
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +264,Attendance for employee {0} is already marked for this day,Deltagelse for medarbejder {0} er allerede markeret for denne dag
DocType: Work Order Operation,"in Minutes
Updated via 'Time Log'",i minutter Opdateret via &#39;Time Log&#39;
DocType: Customer,From Lead,Fra Emne
DocType: Amazon MWS Settings,Synch Orders,Synkroniseringsordrer
apps/erpnext/erpnext/config/manufacturing.py +13,Orders released for production.,Ordrer frigivet til produktion.
apps/erpnext/erpnext/public/js/account_tree_grid.js +65,Select Fiscal Year...,Vælg regnskabsår ...
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +639,POS Profile required to make POS Entry,POS profil kræves for at gøre POS indtastning
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js +15,"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.","Loyalitetspoint beregnes ud fra det brugte udbytte (via salgsfakturaen), baseret på den nævnte indsamlingsfaktor."
DocType: Program Enrollment Tool,Enroll Students,Tilmeld Studerende
DocType: Company,HRA Settings,HRA-indstillinger
DocType: Employee Transfer,Transfer Date,Overførselsdato
DocType: Lab Test,Approved Date,Godkendt dato
apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py +21,Standard Selling,Standard salg
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +244,Atleast one warehouse is mandatory,Mindst ét lager skal angives
apps/erpnext/erpnext/healthcare/doctype/healthcare_service_unit_type/healthcare_service_unit_type.py +14,"Configure Item Fields like UOM, Item Group, Description and No of Hours.","Konfigurer produktfelter som UOM, varegruppe, beskrivelse og antal timer."
DocType: Certification Application,Certification Status,Certificeringsstatus
apps/erpnext/erpnext/public/js/hub/marketplace.js +44,Marketplace,Marketplace
DocType: Travel Itinerary,Travel Advance Required,Krav til rejseudvikling
DocType: Subscriber,Subscriber Name,Abonnentnavn
DocType: Serial No,Out of Warranty,Garanti udløbet
DocType: Bank Statement Transaction Settings Item,Mapped Data Type,Mapped Data Type
DocType: BOM Update Tool,Replace,Udskift
apps/erpnext/erpnext/templates/includes/product_list.js +42,No products found.,Ingen produkter fundet.
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +396,{0} against Sales Invoice {1},{0} mod salgsfaktura {1}
DocType: Antibiotic,Laboratory User,Laboratoriebruger
DocType: Request for Quotation Item,Project Name,Sagsnavn
DocType: Customer,Mention if non-standard receivable account,"Nævne, hvis ikke-standard tilgodehavende konto"
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py +63,Please add the remaining benefits {0} to any of the existing component,Tilføj venligst de resterende fordele {0} til en eksisterende komponent
DocType: Journal Entry Account,If Income or Expense,Hvis indtægter og omkostninger
DocType: Bank Statement Transaction Entry,Matching Invoices,Matchende fakturaer
DocType: Work Order,Required Items,Nødvendige varer
DocType: Stock Ledger Entry,Stock Value Difference,Stock Value Forskel
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +63,Item Row {0}: {1} {2} does not exist in above '{1}' table,Vare række {0}: {1} {2} findes ikke i ovenstående &#39;{1}&#39; tabel
apps/erpnext/erpnext/config/learn.py +229,Human Resource,Menneskelige Ressourcer
DocType: Payment Reconciliation Payment,Payment Reconciliation Payment,Betaling Afstemning Betaling
DocType: Disease,Treatment Task,Behandlingstjeneste
DocType: Payment Order Reference,Bank Account Details,Bankkontooplysninger
DocType: Purchase Order Item,Blanket Order,Tæppeordre
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +39,Tax Assets,Skatteaktiver
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +631,Production Order has been {0},Produktionsordre har været {0}
apps/erpnext/erpnext/regional/india/utils.py +186,House rent paid days overlap with {0},Husleje betalte dage overlapper med {0}
DocType: BOM Item,BOM No,Styklistenr.
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +192,Journal Entry {0} does not have account {1} or already matched against other voucher,Kassekladde {0} har ikke konto {1} eller allerede matchet mod andre kupon
DocType: Item,Moving Average,Glidende gennemsnit
DocType: BOM Update Tool,The BOM which will be replaced,Den stykliste som vil blive erstattet
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +47,Electronic Equipments,Elektronisk udstyr
DocType: Asset,Maintenance Required,Vedligeholdelse kræves
DocType: Account,Debit,Debet
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +63,Leaves must be allocated in multiples of 0.5,"Fravær skal angives i multipla af 0,5"
DocType: Work Order,Operation Cost,Operation Cost
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +223,Identifying Decision Makers,Identificerende beslutningstagere
apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +47,Outstanding Amt,Enestående Amt
DocType: Sales Person,Set targets Item Group-wise for this Sales Person.,Fastsatte mål Item Group-wise for denne Sales Person.
DocType: Stock Settings,Freeze Stocks Older Than [Days],Frys Stocks Ældre end [dage]
DocType: Payment Request,Payment Ordered,Betaling Bestilt
DocType: Asset Maintenance Team,Maintenance Team Name,Vedligeholdelsesnavn
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +42,"If two or more Pricing Rules are found based on the above conditions, Priority is applied. Priority is a number between 0 to 20 while default value is zero (blank). Higher number means it will take precedence if there are multiple Pricing Rules with same conditions.","Hvis to eller flere Priser Regler er fundet på grundlag af de ovennævnte betingelser, er Priority anvendt. Prioritet er et tal mellem 0 og 20, mens Standardværdien er nul (blank). Højere antal betyder, at det vil have forrang, hvis der er flere Priser Regler med samme betingelser."
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +197,Customer is mandatory if 'Opportunity From' is selected as Customer,"Kunde er obligatorisk, hvis &#39;Mulighed Fra&#39; er valgt som kunde"
apps/erpnext/erpnext/controllers/trends.py +36,Fiscal Year: {0} does not exists,Fiscal År: {0} ikke eksisterer
DocType: Currency Exchange,To Currency,Til Valuta
DocType: Leave Block List,Allow the following users to approve Leave Applications for block days.,Tillad følgende brugere til at godkende fraværsansøgninger på blokerede dage.
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +30,Lifecycle,Livscyklus
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +142,Make BOM,Lav BOM
apps/erpnext/erpnext/controllers/selling_controller.py +161,Selling rate for item {0} is lower than its {1}. Selling rate should be atleast {2},Salgsprisen for vare {0} er lavere end dens {1}. Salgsprisen skal være mindst {2}
DocType: Subscription,Taxes,Moms
DocType: Purchase Invoice,capital goods,kapitalgoder
DocType: Purchase Invoice Item,Weight Per Unit,Vægt pr. Enhed
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +363,Paid and Not Delivered,Betalt og ikke leveret
DocType: QuickBooks Migrator,Default Cost Center,Standard omkostningssted
apps/erpnext/erpnext/config/stock.py +7,Stock Transactions,Lagertransaktioner
DocType: Budget,Budget Accounts,Budget Regnskab
DocType: Employee,Internal Work History,Intern Arbejde Historie
DocType: Bank Statement Transaction Entry,New Transactions,Nye Transaktioner
DocType: Depreciation Schedule,Accumulated Depreciation Amount,Akkumuleret Afskrivninger Beløb
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +42,Private Equity,Private Equity
DocType: Supplier Scorecard Variable,Supplier Scorecard Variable,Leverandør Scorecard Variable
apps/erpnext/erpnext/assets/doctype/asset/asset.py +75,Please create purchase receipt or purchase invoice for the item {0},Opret venligst købskvittering eller købsfaktura for varen {0}
DocType: Employee Advance,Due Advance Amount,Forfaldne beløb
DocType: Maintenance Visit,Customer Feedback,Kundefeedback
DocType: Account,Expense,Udlæg
apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.js +48,Score cannot be greater than Maximum Score,Score kan ikke være større end maksimal score
DocType: Support Search Source,Source Type,Kilde Type
apps/erpnext/erpnext/utilities/user_progress.py +129,Customers and Suppliers,Kunder og Leverandører
DocType: Item Attribute,From Range,Fra Range
DocType: BOM,Set rate of sub-assembly item based on BOM,Indstil sats for underenhedspost baseret på BOM
DocType: Inpatient Occupancy,Invoiced,faktureret
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +179,Syntax error in formula or condition: {0},Syntaks fejl i formel eller tilstand: {0}
DocType: Daily Work Summary Settings Company,Daily Work Summary Settings Company,Daglige arbejde Resumé Indstillinger Firma
apps/erpnext/erpnext/stock/utils.py +149,Item {0} ignored since it is not a stock item,"Vare {0} ignoreres, da det ikke er en lagervare"
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +23,"To not apply Pricing Rule in a particular transaction, all applicable Pricing Rules should be disabled.","Hvis du ikke vil anvende Prisfastsættelse Regel i en bestemt transaktion, bør alle gældende Priser Regler deaktiveres."
DocType: Payment Term,Day(s) after the end of the invoice month,Dag (er) efter faktura månedens afslutning
DocType: Assessment Group,Parent Assessment Group,Parent Group Assessment
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +54,Jobs,Stillinger
,Sales Order Trends,Salgsordre Trends
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +51,The 'From Package No.' field must neither be empty nor it's value less than 1.,Fra pakke nr. feltet må hverken være tomt eller det er mindre end 1.
DocType: Employee,Held On,Held On
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order_calendar.js +36,Production Item,Produktion Vare
,Employee Information,Medarbejder Information
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +242,Healthcare Practitioner not available on {0},Sundhedspleje er ikke tilgængelig på {0}
DocType: Stock Entry Detail,Additional Cost,Yderligere omkostning
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +57,"Can not filter based on Voucher No, if grouped by Voucher",Kan ikke filtrere baseret på bilagsnr. hvis der sorteres efter Bilagstype
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +975,Make Supplier Quotation,Opret Leverandørtilbud
DocType: Quality Inspection,Incoming,Indgående
apps/erpnext/erpnext/setup/doctype/company/company.js +90,Default tax templates for sales and purchase are created.,Standard skat skabeloner til salg og køb oprettes.
apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.py +44,Assessment Result record {0} already exists.,Vurdering Resultatoptegnelsen {0} eksisterer allerede.
DocType: Item,"Example: ABCD.#####. If series is set and Batch No is not mentioned in transactions, then automatic batch number will be created based on this series. If you always want to explicitly mention Batch No for this item, leave this blank. Note: this setting will take priority over the Naming Series Prefix in Stock Settings.","Eksempel: ABCD. #####. Hvis serier er indstillet og Batch nr ikke er nævnt i transaktioner, oprettes automatisk batchnummer baseret på denne serie. Hvis du altid vil udtrykkeligt nævne Batch nr for dette emne, skal du lade dette være tomt. Bemærk: Denne indstilling vil have prioritet i forhold til Naming Series Prefix i lagerindstillinger."
DocType: BOM,Materials Required (Exploded),Nødvendige materialer (Sprængskitse)
DocType: Contract,Party User,Party bruger
apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py +60,Please set Company filter blank if Group By is 'Company',"Indstil Firmafilter blankt, hvis Group By er &#39;Company&#39;"
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +68,Posting Date cannot be future date,Bogføringsdato kan ikke være en fremtidig dato
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +100,Row # {0}: Serial No {1} does not match with {2} {3},Række # {0}: serienummer {1} matcher ikke med {2} {3}
DocType: Stock Entry,Target Warehouse Address,Mållagerhusadresse
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +64,Casual Leave,Casual Leave
DocType: Agriculture Task,End Day,Slutdagen
DocType: Batch,Batch ID,Parti-id
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +386,Note: {0},Bemærk: {0}
,Delivery Note Trends,Følgeseddel Tendenser
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +120,This Week's Summary,Denne uges oversigt
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py +24,In Stock Qty,På lager Antal
,Daily Work Summary Replies,Daglige Arbejdsoversigt Svar
DocType: Delivery Trip,Calculate Estimated Arrival Times,Beregn Anslåede ankomsttider
apps/erpnext/erpnext/accounts/general_ledger.py +113,Account: {0} can only be updated via Stock Transactions,Konto: {0} kan kun opdateres via Lagertransaktioner
DocType: Student Group Creation Tool,Get Courses,Hent kurser
DocType: Shopify Settings,Webhooks,Webhooks
DocType: Bank Account,Party,Selskab
DocType: Healthcare Settings,Patient Name,Patientnavn
DocType: Variant Field,Variant Field,Variant Field
apps/erpnext/erpnext/assets/doctype/asset/asset.js +370,Target Location,Målsted
DocType: Sales Order,Delivery Date,Leveringsdato
DocType: Opportunity,Opportunity Date,Salgsmulighedsdato
DocType: Employee,Health Insurance Provider,Sundhedsforsikringsselskabet
DocType: Products Settings,Show Availability Status,Vis tilgængelighed Status
DocType: Purchase Receipt,Return Against Purchase Receipt,Retur mod købskvittering
DocType: Water Analysis,Person Responsible,Person Ansvarlig
DocType: Request for Quotation Item,Request for Quotation Item,Anmodning om tilbud Varer
DocType: Purchase Order,To Bill,Til Bill
DocType: Material Request,% Ordered,% Bestilt
DocType: Education Settings,"For Course based Student Group, the Course will be validated for every Student from the enrolled Courses in Program Enrollment.",For kursusbaseret studentegruppe vil kurset blive valideret for hver elev fra de tilmeldte kurser i programtilmelding.
DocType: Employee Grade,Employee Grade,Medarbejderklasse
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +81,Piecework,Akkordarbejde
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +68,Avg. Buying Rate,Gns. købssats
DocType: Share Balance,From No,Fra nr
DocType: Task,Actual Time (in Hours),Faktisk tid (i timer)
DocType: Employee,History In Company,Historie I Company
DocType: Customer,Customer Primary Address,Kunde primære adresse
apps/erpnext/erpnext/config/learn.py +107,Newsletters,Nyhedsbreve
apps/erpnext/erpnext/accounts/report/tds_payable_monthly/tds_payable_monthly.py +175,Reference No.,Referencenummer.
DocType: Drug Prescription,Description/Strength,Beskrivelse / Strength
DocType: Bank Statement Transaction Entry,Create New Payment/Journal Entry,Opret ny betaling / journal indtastning
DocType: Certification Application,Certification Application,Certificeringsansøgning
DocType: Leave Type,Is Optional Leave,Er Valgfri Forladelse
DocType: Share Balance,Is Company,Er virksomhed
DocType: Stock Ledger Entry,Stock Ledger Entry,Lagerpost
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +190,{0} on Half day Leave on {1},{0} på halv dag forladt på {1}
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +87,Same item has been entered multiple times,Samme vare er blevet indtastet flere gange
DocType: Department,Leave Block List,Blokér fraværsansøgninger
DocType: Purchase Invoice,Tax ID,CVR-nr.
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +198,Item {0} is not setup for Serial Nos. Column must be blank,Vare {0} er ikke opsat til serienumre. Kolonnen skal være tom
DocType: Accounts Settings,Accounts Settings,Kontoindstillinger
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +11,Approve,Godkende
DocType: Loyalty Program,Customer Territory,Kundeområde
DocType: Email Digest,Sales Orders to Deliver,Salgsordrer til levering
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +28,"Number of new Account, it will be included in the account name as a prefix","Antal nye konti, det vil blive inkluderet i kontonavnet som et præfiks"
DocType: Maintenance Team Member,Team Member,Medarbejder
apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js +151,No Result to submit,Intet resultat at indsende
DocType: Customer,Sales Partner and Commission,Forhandler og provision
DocType: Loan,Rate of Interest (%) / Year,Rente (%) / år
,Project Quantity,Sagsmængde
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +79,"Total {0} for all items is zero, may be you should change 'Distribute Charges Based On'","I alt {0} for alle punkter er nul, kan være du skal ændre &quot;Fordel afgifter baseret på &#39;"
apps/erpnext/erpnext/hr/utils.py +152,To date can not be less than from date,Til dato kan ikke være mindre end fra dato
DocType: Opportunity,To Discuss,Samtaleemne
apps/erpnext/erpnext/stock/stock_ledger.py +382,{0} units of {1} needed in {2} to complete this transaction.,{0} enheder af {1} skal bruges i {2} at fuldføre denne transaktion.
DocType: Loan Type,Rate of Interest (%) Yearly,Rente (%) Årlig
DocType: Support Settings,Forum URL,Forum-URL
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +75,Temporary Accounts,Midlertidige konti
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +40,Source Location is required for the asset {0},Kildens placering er påkrævet for aktivet {0}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +159,Black,Sort
DocType: BOM Explosion Item,BOM Explosion Item,BOM Explosion Vare
DocType: Shareholder,Contact List,Kontakt liste
DocType: Account,Auditor,Revisor
DocType: Project,Frequency To Collect Progress,Frekvens for at indsamle fremskridt
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +254,{0} items produced,{0} varer produceret
apps/erpnext/erpnext/utilities/user_progress.py +58,Learn More,Lær mere
DocType: Cheque Print Template,Distance from top edge,Afstand fra overkanten
DocType: POS Closing Voucher Invoices,Quantity of Items,Mængde af varer
apps/erpnext/erpnext/stock/get_item_details.py +521,Price List {0} is disabled or does not exist,Prisliste {0} er deaktiveret eller findes ikke
DocType: Purchase Invoice,Return,Retur
DocType: Pricing Rule,Disable,Deaktiver
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +184,Mode of payment is required to make a payment,Betalingsmåde er forpligtet til at foretage en betaling
DocType: Project Task,Pending Review,Afventende anmeldelse
apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +14,"Edit in full page for more options like assets, serial nos, batches etc.","Rediger på fuld side for flere muligheder som aktiver, serienummer, partier osv."
DocType: Leave Type,Maximum Continuous Days Applicable,Maksimale kontinuerlige dage gældende
apps/erpnext/erpnext/education/doctype/student_group/student_group.py +41,{0} - {1} is not enrolled in the Batch {2},{0} - {1} er ikke indskrevet i batch {2}
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +118,"Asset {0} cannot be scrapped, as it is already {1}","Anlægsaktiv {0} kan ikke kasseres, da det allerede er {1}"
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +93,Cheques Required,Checks påkrævet
DocType: Task,Total Expense Claim (via Expense Claim),Udlæg ialt (via Udlæg)
apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +177,Mark Absent,Markér ikke-tilstede
DocType: Job Applicant Source,Job Applicant Source,Job Ansøger Kilde
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +328,IGST Amount,IGST Beløb
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +41,Failed to setup company,Kunne ikke opsætte firmaet
DocType: Asset Repair,Asset Repair,Asset Repair
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +155,Row {0}: Currency of the BOM #{1} should be equal to the selected currency {2},Række {0}: Valuta af BOM # {1} skal være lig med den valgte valuta {2}
DocType: Journal Entry Account,Exchange Rate,Vekselkurs
DocType: Patient,Additional information regarding the patient,Yderligere oplysninger om patienten
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +657,Sales Order {0} is not submitted,Salgsordre {0} er ikke godkendt
DocType: Homepage,Tag Line,tag Linje
DocType: Fee Component,Fee Component,Gebyr Component
apps/erpnext/erpnext/config/hr.py +286,Fleet Management,Firmabiler
apps/erpnext/erpnext/config/agriculture.py +7,Crops & Lands,Afgrøder og lande
DocType: Cheque Print Template,Regular,Fast
DocType: Fertilizer,Density (if liquid),Tæthed (hvis væske)
apps/erpnext/erpnext/education/doctype/course/course.py +20,Total Weightage of all Assessment Criteria must be 100%,Samlet vægtning af alle vurderingskriterier skal være 100%
DocType: Purchase Order Item,Last Purchase Rate,Sidste købsværdi
DocType: Account,Asset,Anlægsaktiv
DocType: Project Task,Task ID,Opgave-id
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +84,Stock cannot exist for Item {0} since has variants,Stock kan ikke eksistere for Item {0} da har varianter
DocType: Healthcare Practitioner,Mobile,Mobil
,Sales Person-wise Transaction Summary,SalgsPerson Transaktion Totaler
DocType: Training Event,Contact Number,Kontaktnummer
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +74,Warehouse {0} does not exist,Lager {0} eksisterer ikke
DocType: Cashier Closing,Custody,Forældremyndighed
DocType: Employee Tax Exemption Proof Submission Detail,Employee Tax Exemption Proof Submission Detail,Beskatningsfrihed for medarbejderskattefritagelse
DocType: Monthly Distribution,Monthly Distribution Percentages,Månedlige Distribution Procenter
apps/erpnext/erpnext/stock/doctype/batch/batch.py +115,The selected item cannot have Batch,Den valgte vare kan ikke have parti
DocType: Delivery Note,% of materials delivered against this Delivery Note,% af materialer leveret mod denne følgeseddel
DocType: Asset Maintenance Log,Has Certificate,Har certifikat
DocType: Project,Customer Details,Kunde Detaljer
DocType: Asset,Check if Asset requires Preventive Maintenance or Calibration,"Kontroller, om aktivet kræver forebyggende vedligeholdelse eller kalibrering"
apps/erpnext/erpnext/public/js/setup_wizard.js +87,Company Abbreviation cannot have more than 5 characters,Virksomhedsforkortelse kan ikke have mere end 5 tegn
DocType: Employee,Reports to,Rapporter til
,Unpaid Expense Claim,Ubetalt udlæg
DocType: Payment Entry,Paid Amount,Betalt beløb
apps/erpnext/erpnext/utilities/user_progress.py +158,Explore Sales Cycle,Udforsk salgscyklus
DocType: Assessment Plan,Supervisor,Tilsynsførende
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +934,Retention Stock Entry,Retention Stock Entry
,Available Stock for Packing Items,Tilgængelig Stock til Emballerings- Varer
DocType: Item Variant,Item Variant,Varevariant
,Work Order Stock Report,Arbejdsordre lagerrapport
DocType: Purchase Receipt,Auto Repeat Detail,Automatisk gentag detaljer
DocType: Assessment Result Tool,Assessment Result Tool,Assessment Resultat Tool
apps/erpnext/erpnext/education/doctype/instructor/instructor.js +45,As Supervisor,Som Supervisor
DocType: Leave Policy Detail,Leave Policy Detail,Forlad politikoplysninger
DocType: BOM Scrap Item,BOM Scrap Item,Stykliste skrotvare
apps/erpnext/erpnext/accounts/page/pos/pos.js +906,Submitted orders can not be deleted,Godkendte ordrer kan ikke slettes
apps/erpnext/erpnext/accounts/doctype/account/account.py +121,"Account balance already in Debit, you are not allowed to set 'Balance Must Be' as 'Credit'",Konto balance er debit. Du har ikke lov til at ændre 'Balancetype' til 'kredit'
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +391,Quality Management,Kvalitetssikring
apps/erpnext/erpnext/assets/doctype/asset/asset.py +52,Item {0} has been disabled,Vare {0} er blevet deaktiveret
DocType: Project,Total Billable Amount (via Timesheets),Samlet fakturerbart beløb (via timesheets)
DocType: Agriculture Task,Previous Business Day,Tidligere Erhvervsdag
DocType: Loan,Repay Fixed Amount per Period,Tilbagebetale fast beløb pr Periode
DocType: Employee,Health Insurance No,Sygesikring nr
DocType: Employee Tax Exemption Proof Submission,Tax Exemption Proofs,Skattefritagelse bevis
apps/erpnext/erpnext/buying/utils.py +47,Please enter quantity for Item {0},Indtast mængde for vare {0}
apps/erpnext/erpnext/regional/report/hsn_wise_summary_of_outward_supplies/hsn_wise_summary_of_outward_supplies.py +78,Total Taxable Amount,Samlet skattepligtigt beløb
DocType: Employee External Work History,Employee External Work History,Medarbejder Ekstern Work History
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +691,Job card {0} created,Jobkort {0} oprettet
DocType: Opening Invoice Creation Tool,Purchase,Indkøb
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37,Balance Qty,Balance Antal
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +20,Goals cannot be empty,Mål kan ikke være tom
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.js +18,Enrolling students,Tilmelding til studerende
DocType: Item Group,Parent Item Group,Overordnet varegruppe
DocType: Appointment Type,Appointment Type,Udnævnelsestype
apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +21,{0} for {1},{0} for {1}
DocType: Healthcare Settings,Valid number of days,Gyldigt antal dage
apps/erpnext/erpnext/setup/doctype/company/company.js +59,Cost Centers,Omkostningssteder
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js +19,Restart Subscription,Genstart abonnement
DocType: Linked Plant Analysis,Linked Plant Analysis,Linked Plant Analysis
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +358,Transporter ID,Transporter ID
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +222,Value Proposition,Værdiforslag
DocType: Purchase Receipt,Rate at which supplier's currency is converted to company's base currency,"Hastighed, hvormed leverandørens valuta omregnes til virksomhedens basisvaluta"
DocType: Purchase Invoice Item,Service End Date,Service Slutdato
apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +36,Row #{0}: Timings conflicts with row {1},Row # {0}: tider konflikter med rækken {1}
DocType: Purchase Invoice Item,Allow Zero Valuation Rate,Tillad nulværdi
DocType: Bank Guarantee,Receiving,Modtagelse
DocType: Training Event Employee,Invited,inviteret
apps/erpnext/erpnext/config/accounts.py +276,Setup Gateway accounts.,Opsætning Gateway konti.
DocType: Employee,Employment Type,Beskæftigelsestype
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +43,Fixed Assets,Anlægsaktiver
DocType: Payment Entry,Set Exchange Gain / Loss,Sæt Exchange Gevinst / Tab
,GST Purchase Register,GST købsregistrering
,Cash Flow,Pengestrøm
DocType: Shareholder,ACC-SH-.YYYY.-,ACC-SH-.YYYY.-
apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +25,Combined invoice portion must equal 100%,Kombineret faktura del skal svare til 100%
DocType: Item Default,Default Expense Account,Standard udgiftskonto
DocType: GST Account,CGST Account,CGST-konto
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +53,Student Email ID,Student Email ID
DocType: Employee,Notice (days),Varsel (dage)
DocType: POS Closing Voucher Invoices,POS Closing Voucher Invoices,POS Closing Voucher Fakturaer
DocType: Tax Rule,Sales Tax Template,Salg Momsskabelon
DocType: Employee Benefit Application Detail,Pay Against Benefit Claim,Betal mod fordele
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +21,Update Cost Center Number,Opdater Cost Center Number
apps/erpnext/erpnext/accounts/page/pos/pos.js +2524,Select items to save the invoice,Vælg elementer for at gemme fakturaen
DocType: Employee,Encashment Date,Indløsningsdato
DocType: Training Event,Internet,Internet
DocType: Special Test Template,Special Test Template,Special Test Skabelon
DocType: Account,Stock Adjustment,Stock Justering
apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +34,Default Activity Cost exists for Activity Type - {0},Standard Aktivitets Omkostninger findes for Aktivitets Type - {0}
DocType: Work Order,Planned Operating Cost,Planlagte driftsomkostninger
DocType: Academic Term,Term Start Date,Betingelser startdato
apps/erpnext/erpnext/config/accounts.py +440,List of all share transactions,Liste over alle aktietransaktioner
DocType: Supplier,Is Transporter,Er Transporter
DocType: Shopify Settings,Import Sales Invoice from Shopify if Payment is marked,Import salgsfaktura fra Shopify hvis Betaling er markeret
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +18,Opp Count,Opp Count
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +218,Both Trial Period Start Date and Trial Period End Date must be set,Begge prøveperiode Startdato og prøveperiode Slutdato skal indstilles
apps/erpnext/erpnext/accounts/report/share_balance/share_balance.py +52,Average Rate,Gennemsnitlig sats
apps/erpnext/erpnext/controllers/accounts_controller.py +808,Total Payment Amount in Payment Schedule must be equal to Grand / Rounded Total,Samlet betalingsbeløb i betalingsplan skal svare til Grand / Rounded Total
DocType: Subscription Plan Detail,Plan,Plan
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +34,Bank Statement balance as per General Ledger,Kontoudskrift balance pr Finans
DocType: Job Applicant,Applicant Name,Ansøgernavn
DocType: Authorization Rule,Customer / Item Name,Kunde / Varenavn
DocType: Product Bundle,"Aggregate group of **Items** into another **Item**. This is useful if you are bundling a certain **Items** into a package and you maintain stock of the packed **Items** and not the aggregate **Item**. 

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

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

Note: BOM = Bill of Materials","Samlede gruppe af ** varer ** samlet i en  anden **vare**. Dette er nyttigt, hvis du vil sammenføre et bestemt antal **varer** i en pakke, og du kan bevare en status over de pakkede **varer** og ikke den samlede **vare**. Pakken **vare** vil have ""Er lagervarer"" som ""Nej"" og ""Er salgsvare"" som ""Ja"". For eksempel: Hvis du sælger Laptops og Rygsække separat og har en særlig pris, hvis kunden køber begge, så vil Laptop + Rygsæk vil være en ny Produktpakke-vare."
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +42,Serial No is mandatory for Item {0},Serienummer er obligatorisk for vare {0}
DocType: Item Variant Attribute,Attribute,Attribut
DocType: Staffing Plan Detail,Current Count,Nuværende Grev
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +43,Please specify from/to range,Angiv fra / til spænder
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +28,Opening {0} Invoice created,Åbning {0} Faktura oprettet
DocType: Serial No,Under AMC,Under AMC
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +55,Item valuation rate is recalculated considering landed cost voucher amount,Item værdiansættelse sats genberegnes overvejer landede omkostninger kupon beløb
apps/erpnext/erpnext/config/selling.py +153,Default settings for selling transactions.,Standardindstillinger for salgstransaktioner.
DocType: Guardian,Guardian Of ,Guardian Of
DocType: Grading Scale Interval,Threshold,Grænseværdi
DocType: BOM Update Tool,Current BOM,Aktuel stykliste
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html +32,Balance (Dr - Cr),Balance (Dr - Cr)
apps/erpnext/erpnext/public/js/utils.js +56,Add Serial No,Tilføj serienummer
DocType: Work Order Item,Available Qty at Source Warehouse,Tilgængelig mængde på Source Warehouse
apps/erpnext/erpnext/config/support.py +22,Warranty,Garanti
DocType: Purchase Invoice,Debit Note Issued,Debit Note Udstedt
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +60,Filter based on Cost Center is only applicable if Budget Against is selected as Cost Center,"Filter baseret på Omkostningscenter er kun gældende, hvis Budget Against er valgt som Omkostningscenter"
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1182,"Search by item code, serial number, batch no or barcode","Søg efter varenummer, serienummer, batchnummer eller stregkode"
DocType: Work Order,Warehouses,Lagre
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +19,{0} asset cannot be transferred,{0} aktiv kan ikke overføres
DocType: Hotel Room Pricing,Hotel Room Pricing,Hotel værelsespriser
apps/erpnext/erpnext/healthcare/doctype/inpatient_record/inpatient_record.py +121,"Can not mark Inpatient Record Discharged, there are Unbilled Invoices {0}","Kan ikke markere Inpatient Record Discharged, der er Unbilled Fakturaer {0}"
DocType: Subscription,Days Until Due,Dage indtil forfaldsdato
apps/erpnext/erpnext/stock/doctype/item/item.js +82,This Item is a Variant of {0} (Template).,Denne vare er en variant af {0} (skabelon).
DocType: Workstation,per hour,per time
DocType: Blanket Order,Purchasing,Indkøb
DocType: Announcement,Announcement,Bekendtgørelse
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +130,Customer LPO,Kunde LPO
DocType: Education Settings,"For Batch based Student Group, the Student Batch will be validated for every Student from the Program Enrollment.",For Batch-baserede Studentegruppe bliver Student Batch Valideret for hver Student fra Programindskrivningen.
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +51,Warehouse can not be deleted as stock ledger entry exists for this warehouse.,"Lager kan ikke slettes, da der eksisterer lagerposter for dette lager."
apps/erpnext/erpnext/public/js/setup_wizard.js +25,Distribution,Distribution
DocType: Journal Entry Account,Loan,Lån
DocType: Expense Claim Advance,Expense Claim Advance,Udgiftskrav Advance
DocType: Lab Test,Report Preference,Rapportindstilling
apps/erpnext/erpnext/config/non_profit.py +43,Volunteer information.,Frivillig information.
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +96,Project Manager,Projektleder
,Quoted Item Comparison,Sammenligning Citeret Vare
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +34,Overlap in scoring between {0} and {1},Overlappe i scoring mellem {0} og {1}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +387,Dispatch,Dispatch
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +75,Max discount allowed for item: {0} is {1}%,Maksimal rabat tilladt for vare: {0} er {1}%
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +191,Net Asset value as on,Indre værdi som på
DocType: Crop,Produce,Fremstille
DocType: Hotel Settings,Default Taxes and Charges,Standard Skatter og Afgifter
DocType: Account,Receivable,Tilgodehavende
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +325,Row #{0}: Not allowed to change Supplier as Purchase Order already exists,"Række # {0}: Ikke tilladt at skifte leverandør, da indkøbsordre allerede findes"
DocType: Stock Entry,Material Consumption for Manufacture,Materialeforbrug til fremstilling
DocType: Item Alternative,Alternative Item Code,Alternativ varekode
DocType: Accounts Settings,Role that is allowed to submit transactions that exceed credit limits set.,"Rolle, som får lov til at indsende transaktioner, der overstiger kredit grænser."
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1068,Select Items to Manufacture,Vælg varer til Produktion
DocType: Delivery Stop,Delivery Stop,Leveringsstop
apps/erpnext/erpnext/accounts/page/pos/pos.js +974,"Master data syncing, it might take some time","Master data synkronisering, kan det tage nogen tid"
DocType: Item,Material Issue,Materiale Issue
DocType: Employee Education,Qualification,Kvalifikation
DocType: Item Price,Item Price,Varepris
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +48,Soap & Detergent,Sæbe &amp; Vaskemiddel
DocType: BOM,Show Items,Vis elementer
apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.py +30,From Time cannot be greater than To Time.,Fra Tiden kan ikke være større end til anden.
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +125,Do you want to notify all the customers by email?,Vil du anmelde alle kunderne via e-mail?
DocType: Subscription Plan,Billing Interval,Faktureringsinterval
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +36,Motion Picture & Video,Motion Picture &amp; Video
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js +5,Ordered,Bestilt
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.py +76,Actual start date and actual end date is mandatory,Faktisk startdato og faktisk slutdato er obligatorisk
DocType: Salary Detail,Component,Lønart
apps/erpnext/erpnext/assets/doctype/asset_category/asset_category.py +16,Row {0}: {1} must be greater than 0,Række {0}: {1} skal være større end 0
DocType: Assessment Criteria,Assessment Criteria Group,Vurderingskriterier Group
DocType: Healthcare Settings,Patient Name By,Patientnavn By
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +224,Accrual Journal Entry for salaries from {0} to {1},Periodiseringsjournalen Entry for løn fra {0} til {1}
DocType: Sales Invoice Item,Enable Deferred Revenue,Aktivér udskudt indtjening
apps/erpnext/erpnext/assets/doctype/asset/asset.py +202,Opening Accumulated Depreciation must be less than equal to {0},Åbning Akkumuleret Afskrivning skal være mindre end lig med {0}
DocType: Warehouse,Warehouse Name,Lagernavn
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.py +20,Actual start date must be less than actual end date,Faktisk startdato skal være mindre end den faktiske slutdato
DocType: Naming Series,Select Transaction,Vælg Transaktion
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +30,Please enter Approving Role or Approving User,Indtast Godkendelse Rolle eller godkender Bruger
DocType: Journal Entry,Write Off Entry,Skriv Off indtastning
DocType: BOM,Rate Of Materials Based On,Rate Of materialer baseret på
DocType: Education Settings,"If enabled, field Academic Term will be Mandatory in Program Enrollment Tool.","Hvis aktiveret, vil feltet Akademisk Term være obligatorisk i Programindskrivningsværktøjet."
apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +21,Support Analtyics,Support Analtyics
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +103,Uncheck all,Fravælg alle
DocType: POS Profile,Terms and Conditions,Betingelser
DocType: Asset,Booked Fixed Asset,Reserveret Fixed Asset
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +49,To Date should be within the Fiscal Year. Assuming To Date = {0},Til dato bør være inden regnskabsåret. Antages Til dato = {0}
DocType: Employee,"Here you can maintain height, weight, allergies, medical concerns etc","Her kan du vedligeholde højde, vægt, allergier, medicinske problemer osv"
DocType: Leave Block List,Applies to Company,Gælder for hele firmaet
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +222,Cannot cancel because submitted Stock Entry {0} exists,"Kan ikke annullere, for en godkendt lagerindtastning {0} eksisterer"
DocType: Loan,Disbursement Date,Udbetaling Dato
DocType: BOM Update Tool,Update latest price in all BOMs,Opdater seneste pris i alle BOM&#39;er
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +24,Medical Record,Medicinsk post
DocType: Vehicle,Vehicle,Køretøj
DocType: Purchase Invoice,In Words,I Words
apps/erpnext/erpnext/accounts/doctype/bank_guarantee/bank_guarantee.py +21,Enter the name of the bank or lending institution before submittting.,Indtast navnet på banken eller låneinstitutionen før indsendelse.
apps/erpnext/erpnext/hr/doctype/training_result/training_result.py +15,{0} must be submitted,{0} skal indsendes
DocType: POS Profile,Item Groups,Varegrupper
DocType: Sales Order Item,For Production,For Produktion
DocType: Payment Request,payment_url,payment_url
DocType: Exchange Rate Revaluation Account,Balance In Account Currency,Balance i kontovaluta
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +188,Please add a Temporary Opening account in Chart of Accounts,Tilføj venligst en midlertidig åbningskonto i kontoplan
DocType: Customer,Customer Primary Contact,Kunde primær kontakt
DocType: Project Task,View Task,Vis opgave
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +22,Opp/Lead %,Opp / Lead%
DocType: Bank Guarantee,Bank Account Info,Bankkontooplysninger
DocType: Bank Guarantee,Bank Guarantee Type,Bankgaranti Type
DocType: Payment Schedule,Invoice Portion,Fakturaafdeling
,Asset Depreciations and Balances,Asset Afskrivninger og Vægte
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +372,Amount {0} {1} transferred from {2} to {3},Mængden {0} {1} overført fra {2} til {3}
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +200,{0} does not have a Healthcare Practitioner Schedule. Add it in Healthcare Practitioner master,{0} har ikke en Healthcare Practitioner Schedule. Tilføj det i Healthcare Practitioner master
DocType: Sales Invoice,Get Advances Received,Få forskud
DocType: Email Digest,Add/Remove Recipients,Tilføj / fjern modtagere
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.js +19,"To set this Fiscal Year as Default, click on 'Set as Default'","For at indstille dette regnskabsår som standard, skal du klikke på &#39;Vælg som standard&#39;"
apps/erpnext/erpnext/accounts/report/tds_computation_summary/tds_computation_summary.py +130,Amount of TDS Deducted,Mængden af TDS fratrukket
DocType: Production Plan,Include Subcontracted Items,Inkluder underleverancer
apps/erpnext/erpnext/projects/doctype/project/project.py +281,Join,Tilslutte
apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +81,Shortage Qty,Mangel Antal
apps/erpnext/erpnext/stock/doctype/item/item.py +792,Item variant {0} exists with same attributes,Vare variant {0} eksisterer med samme attributter
DocType: Loan,Repay from Salary,Tilbagebetale fra Løn
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +405,Requesting payment against {0} {1} for amount {2},Anmodning betaling mod {0} {1} for beløb {2}
DocType: Additional Salary,Salary Slip,Lønseddel
DocType: Lead,Lost Quotation,Lost Citat
apps/erpnext/erpnext/utilities/user_progress.py +221,Student Batches,Studerendepartier
DocType: Pricing Rule,Margin Rate or Amount,Margin sats eller beløb
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +48,'To Date' is required,&#39;Til dato&#39; er nødvendig
DocType: Packing Slip,"Generate packing slips for packages to be delivered. Used to notify package number, package contents and its weight.","Generer pakkesedler til pakker, der skal leveres. Pakkesedlen indeholder pakkenummer, pakkens indhold og dens vægt."
apps/erpnext/erpnext/projects/doctype/project/project.py +90,Task weight cannot be negative,Opgavevægt kan ikke være negativ
DocType: Sales Invoice Item,Sales Order Item,Salgsordrevare
DocType: Salary Slip,Payment Days,Betalingsdage
DocType: Stock Settings,Convert Item Description to Clean HTML,Konverter varebeskrivelse for at rydde HTML
DocType: Patient,Dormant,hvilende
DocType: Payroll Entry,Deduct Tax For Unclaimed Employee Benefits,Fradragsafgift for uopkrævede medarbejderfordele
DocType: Salary Slip,Total Interest Amount,Samlet rentebeløb
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +125,Warehouses with child nodes cannot be converted to ledger,Lager med referencer kan ikke konverteres til finans
DocType: BOM,Manage cost of operations,Administrer udgifter til operationer
DocType: Accounts Settings,Stale Days,Forældede dage
DocType: Travel Itinerary,Arrival Datetime,Ankomst Datetime
DocType: Notification Control,"When any of the checked transactions are ""Submitted"", an email pop-up automatically opened to send an email to the associated ""Contact"" in that transaction, with the transaction as an attachment. The user may or may not send the email.","Når nogen af de kontrollerede transaktioner er &quot;Indsendt&quot;, en e-pop-up automatisk åbnet til at sende en e-mail til den tilknyttede &quot;Kontakt&quot; i denne transaktion, med transaktionen som en vedhæftet fil. Brugeren kan eller ikke kan sende e-mailen."
DocType: Tax Rule,Billing Zipcode,Fakturering Postnummer
DocType: Attendance,HR-ATT-.YYYY.-,HR-ATT-.YYYY.-
apps/erpnext/erpnext/config/setup.py +14,Global Settings,Globale indstillinger
DocType: Crop,Row Spacing UOM,Rækkevidde UOM
DocType: Assessment Result Detail,Assessment Result Detail,Vurdering Resultat Detail
DocType: Employee Education,Employee Education,Medarbejder Uddannelse
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +53,Duplicate item group found in the item group table,Samme varegruppe findes to gange i varegruppetabellen
apps/erpnext/erpnext/public/js/controllers/transaction.js +1247,It is needed to fetch Item Details.,Det er nødvendigt at hente Elementdetaljer.
DocType: Fertilizer,Fertilizer Name,Gødning Navn
DocType: Salary Slip,Net Pay,Nettoløn
DocType: Cash Flow Mapping Accounts,Account,Konto
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +222,Serial No {0} has already been received,Serienummer {0} er allerede blevet modtaget
,Requested Items To Be Transferred,"Anmodet Varer, der skal overføres"
DocType: Expense Claim,Vehicle Log,Kørebog
DocType: Budget,Action if Accumulated Monthly Budget Exceeded on Actual,Handling hvis akkumuleret månedlig budget oversteg faktisk
DocType: Salary Component,Create Separate Payment Entry Against Benefit Claim,Opret særskilt betalingsindgang mod fordringsanmodning
DocType: Vital Signs,Presence of a fever (temp &gt; 38.5 °C/101.3 °F or sustained temp &gt; 38 °C/100.4 °F),"Tilstedeværelse af feber (temp&gt; 38,5 ° C eller vedvarende temperatur&gt; 38 ° C / 100,4 ° F)"
DocType: Customer,Sales Team Details,Salgs Team Detaljer
apps/erpnext/erpnext/accounts/page/pos/pos.js +1366,Delete permanently?,Slet permanent?
DocType: Expense Claim,Total Claimed Amount,Total krævede beløb
apps/erpnext/erpnext/config/crm.py +17,Potential opportunities for selling.,Potentielle muligheder for at sælge.
DocType: Shareholder,Folio no.,Folio nr.
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +251,Invalid {0},Ugyldig {0}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +68,Sick Leave,Sygefravær
DocType: Email Digest,Email Digest,E-mail nyhedsbrev
DocType: Delivery Note,Billing Address Name,Faktureringsadressenavn
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +22,Department Stores,Varehuse
,Item Delivery Date,Leveringsdato for vare
DocType: Selling Settings,Sales Update Frequency,Salgsopdateringsfrekvens
DocType: Production Plan,Material Requested,Materiale krævet
DocType: Warehouse,PIN,PIN
DocType: Bin,Reserved Qty for sub contract,Reserveret antal til underentreprise
DocType: Patient Service Unit,Patinet Service Unit,Patinet Service Unit
DocType: Sales Invoice,Base Change Amount (Company Currency),Base ændring beløb (Company Currency)
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +310,No accounting entries for the following warehouses,Ingen bogføring for følgende lagre
apps/erpnext/erpnext/projects/doctype/project/project.js +98,Save the document first.,Gem dokumentet først.
apps/erpnext/erpnext/shopping_cart/cart.py +74,Only {0} in stock for item {1},Kun {0} på lager til vare {1}
DocType: Account,Chargeable,Gebyr
DocType: Company,Change Abbreviation,Skift Forkortelse
DocType: Contract,Fulfilment Details,Opfyldelse Detaljer
apps/erpnext/erpnext/templates/pages/integrations/gocardless_checkout.py +68,Pay {0} {1},Betal {0} {1}
DocType: Employee Onboarding,Activities,Aktiviteter
DocType: Expense Claim Detail,Expense Date,Udlægsdato
DocType: Item,No of Months,Antal måneder
DocType: Item,Max Discount (%),Maksimal rabat (%)
apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +30,Credit Days cannot be a negative number,Kreditdage kan ikke være et negativt tal
DocType: Purchase Invoice Item,Service Stop Date,Service Stop Date
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +70,Last Order Amount,Sidste ordrebeløb
DocType: Cash Flow Mapper,e.g Adjustments for:,fx justeringer for:
apps/erpnext/erpnext/stock/doctype/item/item.py +304," {0} Retain Sample is based on batch, please check Has Batch No to retain sample of item","{0} Behold prøve er baseret på batch, bedes du tjekke Har batch nr for at bevare prøveeksempel"
DocType: Task,Is Milestone,Er Milestone
DocType: Certification Application,Yet to appear,Endnu at dukke op
DocType: Delivery Stop,Email Sent To,E-mail til
DocType: Job Card Item,Job Card Item,Jobkort vare
DocType: Accounts Settings,Allow Cost Center In Entry of Balance Sheet Account,Tillad omkostningscenter ved indtastning af Balance Konto
apps/erpnext/erpnext/accounts/doctype/account/account.js +102,Merge with Existing Account,Flet sammen med eksisterende konto
DocType: Budget,Warn,Advar
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +992,All items have already been transferred for this Work Order.,Alle elementer er allerede overført til denne Arbejdsordre.
DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","Alle andre bemærkninger, bemærkelsesværdigt indsats, skal gå i registrene."
DocType: Asset Maintenance,Manufacturing User,Produktionsbruger
DocType: Purchase Invoice,Raw Materials Supplied,Leverede råvarer
DocType: Subscription Plan,Payment Plan,Betalingsplan
DocType: Shopping Cart Settings,Enable purchase of items via the website,Aktivér køb af varer via hjemmesiden
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +296,Currency of the price list {0} must be {1} or {2},Valuta på prislisten {0} skal være {1} eller {2}
apps/erpnext/erpnext/config/accounts.py +561,Subscription Management,Abonnement Management
DocType: Appraisal,Appraisal Template,Vurderingsskabelon
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +255,To Pin Code,At pin kode
DocType: Soil Texture,Ternary Plot,Ternary Plot
DocType: Amazon MWS Settings,Check this to enable a scheduled Daily synchronization routine via scheduler,Marker dette for at aktivere en planlagt daglig synkroniseringsrutine via tidsplanlægger
DocType: Item Group,Item Classification,Item Klassifikation
DocType: Driver,License Number,Licens nummer
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +94,Business Development Manager,Business Development Manager
DocType: Maintenance Visit Purpose,Maintenance Visit Purpose,Formål med vedligeholdelsesbesøg
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +19,Invoice Patient Registration,Faktura Patientregistrering
DocType: Crop,Period,Periode
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.js +27,General Ledger,Finansbogholderi
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js +16,To Fiscal Year,Til regnskabsår
apps/erpnext/erpnext/selling/doctype/campaign/campaign.js +10,View Leads,Se emner
DocType: Program Enrollment Tool,New Program,nyt Program
DocType: Item Attribute Value,Attribute Value,Attribut Værdi
DocType: POS Closing Voucher Details,Expected Amount,Forventet beløb
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test_list.js +16,Create Multiple,Opret flere
,Itemwise Recommended Reorder Level,Itemwise Anbefalet genbestillings Level
apps/erpnext/erpnext/hr/utils.py +212,Employee {0} of grade {1} have no default leave policy,Medarbejder {0} i lønklasse {1} har ingen standardlovspolitik
DocType: Salary Detail,Salary Detail,Løn Detail
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1103,Please select {0} first,Vælg {0} først
apps/erpnext/erpnext/public/js/hub/marketplace.js +176,Added {0} users,Tilføjet {0} brugere
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js +21,"In the case of multi-tier program, Customers will be auto assigned to the concerned tier as per their spent","I tilfælde af multi-tier program, vil kunder automatisk blive tildelt den pågældende tier som per deres brugt"
DocType: Appointment Type,Physician,Læge
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1076,Batch {0} of Item {1} has expired.,Batch {0} af varer {1} er udløbet.
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment_dashboard.py +11,Consultations,Høringer
apps/erpnext/erpnext/manufacturing/report/bom_variance_report/bom_variance_report.py +36,Finished Good,Færdig godt
apps/erpnext/erpnext/stock/doctype/item_price/item_price.py +56,"Item Price appears multiple times based on Price List, Supplier/Customer, Currency, Item, UOM, Qty and Dates.","Varepris vises flere gange baseret på prisliste, leverandør / kunde, valuta, vare, uom, antal og datoer."
DocType: Sales Invoice,Commission,Provision
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +203,{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0} ({1}) kan ikke være større end den planlagte mængde ({2}) i Work Order {3}
DocType: Certification Application,Name of Applicant,Ansøgerens navn
apps/erpnext/erpnext/config/manufacturing.py +27,Time Sheet for manufacturing.,Tidsregistrering til Produktion.
apps/erpnext/erpnext/templates/pages/cart.html +37,Subtotal,Subtotal
apps/erpnext/erpnext/stock/doctype/item/item.py +731,Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,Kan ikke ændre Variantegenskaber efter aktiehandel. Du bliver nødt til at lave en ny vare til at gøre dette.
apps/erpnext/erpnext/config/integrations.py +18,GoCardless SEPA Mandate,GoCardless SEPA Mandat
DocType: Healthcare Practitioner,Charges,Afgifter
DocType: Production Plan,Get Items For Work Order,Få varer til arbejdsordre
DocType: Salary Detail,Default Amount,Standard Mængde
DocType: Lab Test Template,Descriptive,Beskrivende
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +96,Warehouse not found in the system,Lager ikke fundet i systemet
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +123,This Month's Summary,Denne måneds Summary
DocType: Quality Inspection Reading,Quality Inspection Reading,Kvalitetskontrol-aflæsning
apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +26,`Freeze Stocks Older Than` should be smaller than %d days.,`Frys lager ældre end` skal være mindre end %d dage.
DocType: Tax Rule,Purchase Tax Template,Indkøb Momsskabelon
apps/erpnext/erpnext/utilities/user_progress.py +48,Set a sales goal you'd like to achieve for your company.,"Indstil et salgsmål, du gerne vil opnå for din virksomhed."
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1553,Healthcare Services,Sundhedsydelser
,Project wise Stock Tracking,Opfølgning på lager sorteret efter sager
DocType: GST HSN Code,Regional,Regional
apps/erpnext/erpnext/config/healthcare.py +50,Laboratory,Laboratorium
DocType: UOM Category,UOM Category,UOM kategori
DocType: Clinical Procedure Item,Actual Qty (at source/target),Faktiske Antal (ved kilden / mål)
DocType: Item Customer Detail,Ref Code,Ref Code
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +75,Customer Group is Required in POS Profile,Kundegruppe er påkrævet i POS-profil
DocType: HR Settings,Payroll Settings,Lønindstillinger
apps/erpnext/erpnext/config/accounts.py +142,Match non-linked Invoices and Payments.,Match ikke-forbundne fakturaer og betalinger.
DocType: POS Settings,POS Settings,POS-indstillinger
apps/erpnext/erpnext/templates/pages/cart.html +16,Place Order,Angiv bestilling
DocType: Email Digest,New Purchase Orders,Nye indkøbsordrer
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +26,Root cannot have a parent cost center,Root kan ikke have en forælder cost center
apps/erpnext/erpnext/public/js/stock_analytics.js +54,Select Brand...,Vælg varemærke ...
apps/erpnext/erpnext/public/js/setup_wizard.js +32,Non Profit (beta),Ikke-profit (beta)
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +167,Accumulated Depreciation as on,Akkumulerede afskrivninger som på
DocType: Employee Tax Exemption Category,Employee Tax Exemption Category,Skattefritagelseskategori for ansatte
DocType: Sales Invoice,C-Form Applicable,C-anvendelig
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +419,Operation Time must be greater than 0 for Operation {0},Driftstid skal være større end 0 til drift {0}
DocType: Support Search Source,Post Route String,Post Rute String
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +105,Warehouse is mandatory,Lager er obligatorisk
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +72,Failed to create website,Kunne ikke oprette websted
DocType: Soil Analysis,Mg/K,Mg / K
DocType: UOM Conversion Detail,UOM Conversion Detail,UOM Konvertering Detail
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +989,Retention Stock Entry already created or Sample Quantity not provided,Retention Stock Entry allerede oprettet eller Sample Mængde ikke angivet
DocType: Program,Program Abbreviation,Program Forkortelse
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +407,Production Order cannot be raised against a Item Template,Produktionsordre kan ikke rejses mod en Vare skabelon
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +52,Charges are updated in Purchase Receipt against each item,Afgifter er opdateret i købskvitteringen for hver enkelt vare
DocType: Warranty Claim,Resolved By,Løst af
apps/erpnext/erpnext/healthcare/doctype/patient_encounter/patient_encounter.js +32,Schedule Discharge,Planlægningsudladning
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +42,Cheques and Deposits incorrectly cleared,Anvendes ikke
apps/erpnext/erpnext/accounts/doctype/account/account.py +53,Account {0}: You can not assign itself as parent account,Konto {0}: Konto kan ikke samtidig være forældre-konto
DocType: Purchase Invoice Item,Price List Rate,Prisliste Rate
apps/erpnext/erpnext/utilities/activation.py +72,Create customer quotes,Opret tilbud til kunder
apps/erpnext/erpnext/public/js/controllers/transaction.js +885,Service Stop Date cannot be after Service End Date,Service Stop Date kan ikke være efter Service Slutdato
DocType: Item,"Show ""In Stock"" or ""Not in Stock"" based on stock available in this warehouse.",Vis &quot;På lager&quot; eller &quot;Ikke på lager&quot; baseret på lager til rådighed i dette lager.
apps/erpnext/erpnext/config/manufacturing.py +38,Bill of Materials (BOM),Styklister
DocType: Item,Average time taken by the supplier to deliver,Gennemsnitlig tid taget af leverandøren til at levere
DocType: Travel Itinerary,Check-in Date,Check-in dato
DocType: Sample Collection,Collected By,Indsamlet af
apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.js +25,Assessment Result,Vurdering Resultat
DocType: Hotel Room Package,Hotel Room Package,Hotelværelsepakke
DocType: Employee Transfer,Employee Transfer,Medarbejderoverførsel
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +13,Hours,Timer
DocType: Project,Expected Start Date,Forventet startdato
DocType: Purchase Invoice,04-Correction in Invoice,04-korrektion i fakturaen
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1041,Work Order already created for all items with BOM,Arbejdsordre allerede oprettet for alle varer med BOM
DocType: Payment Request,Party Details,Fest Detaljer
apps/erpnext/erpnext/stock/doctype/item/item.js +62,Variant Details Report,Variant Details Report
DocType: Setup Progress Action,Setup Progress Action,Setup Progress Action
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +48,Buying Price List,Købsprisliste
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +49,Remove item if charges is not applicable to that item,"Fjern element, hvis afgifter ikke finder anvendelse på denne post"
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js +9,Cancel Subscription,Annuller abonnement
apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +21,Please select Maintenance Status as Completed or remove Completion Date,Vælg venligst Vedligeholdelsesstatus som Afsluttet eller fjern Afslutningsdato
DocType: Supplier,Default Payment Terms Template,Standard betalingsbetingelser skabelon
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +40,Transaction currency must be same as Payment Gateway currency,Transaktion valuta skal være samme som Payment Gateway valuta
DocType: Payment Entry,Receive,Modtag
DocType: Employee Benefit Application Detail,Earning Component,Earning Component
apps/erpnext/erpnext/templates/pages/rfq.html +75,Quotations: ,Tilbud:
DocType: Contract,Partially Fulfilled,Delvis opfyldt
DocType: Maintenance Visit,Fully Completed,Fuldt Afsluttet
apps/erpnext/erpnext/projects/doctype/project/project_list.js +6,{0}% Complete,{0}% Fuldført
DocType: Employee,Educational Qualification,Uddannelseskvalifikation
DocType: Workstation,Operating Costs,Driftsomkostninger
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +487,Currency for {0} must be {1},Valuta for {0} skal være {1}
DocType: Asset,Disposal Date,Salgsdato
DocType: Daily Work Summary Settings,"Emails will be sent to all Active Employees of the company at the given hour, if they do not have holiday. Summary of responses will be sent at midnight.","E-mails vil blive sendt til alle aktive medarbejdere i selskabet ved den givne time, hvis de ikke har ferie. Sammenfatning af svarene vil blive sendt ved midnat."
DocType: Employee Leave Approver,Employee Leave Approver,Medarbejder Leave Godkender
apps/erpnext/erpnext/stock/doctype/item/item.py +541,Row {0}: An Reorder entry already exists for this warehouse {1},Række {0}: En Genbestil indgang findes allerede for dette lager {1}
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +99,"Cannot declare as lost, because Quotation has been made.","Kan ikke erklæres tabt, fordi tilbud er afgivet."
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +68,CWIP Account,CWIP-konto
apps/erpnext/erpnext/hr/doctype/training_event/training_event.js +16,Training Feedback,Træning Feedback
apps/erpnext/erpnext/config/accounts.py +184,Tax Withholding rates to be applied on transactions.,"Skat tilbageholdelsessatser, der skal anvendes på transaktioner."
DocType: Supplier Scorecard Criteria,Supplier Scorecard Criteria,Leverandør Scorecard Criteria
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +149,Please select Start Date and End Date for Item {0},Vælg Start og slutdato for Item {0}
DocType: Maintenance Schedule,MAT-MSH-.YYYY.-,MAT-MSH-.YYYY.-
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +55,Course is mandatory in row {0},Kursus er obligatorisk i række {0}
apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.js +16,To date cannot be before from date,Til dato kan ikke være før fra dato
DocType: Supplier Quotation Item,Prevdoc DocType,Prevdoc DocType
DocType: Cash Flow Mapper,Section Footer,Sektion Footer
apps/erpnext/erpnext/stock/doctype/item/item.js +359,Add / Edit Prices,Tilføj / rediger priser
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.py +19,Employee Promotion cannot be submitted before Promotion Date ,Medarbejderfremme kan ikke indsendes før Kampagnedato
DocType: Batch,Parent Batch,Overordnet parti
DocType: Cheque Print Template,Cheque Print Template,Anvendes ikke
DocType: Salary Component,Is Flexible Benefit,Er fleksibel fordel
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +85,Chart of Cost Centers,Diagram af omkostningssteder
DocType: Subscription Settings,Number of days after invoice date has elapsed before canceling subscription or marking subscription as unpaid,"Antal dage efter fakturadato er udløbet, før abonnement eller markeringsabonnement ophæves som ubetalt"
DocType: Clinical Procedure Template,Sample Collection,Prøveopsamling
,Requested Items To Be Ordered,Anmodet Varer skal bestilles
DocType: Price List,Price List Name,Prislistenavn
DocType: Delivery Stop,Dispatch Information,Dispatch Information
DocType: Blanket Order,Manufacturing,Produktion
,Ordered Items To Be Delivered,"Bestilte varer, der skal leveres"
DocType: Account,Income,Indtægter
DocType: Industry Type,Industry Type,Branchekode
apps/erpnext/erpnext/templates/includes/cart.js +150,Something went wrong!,Noget gik galt!
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +174,Warning: Leave application contains following block dates,Advarsel: Fraværsansøgningen indeholder følgende blokerede dage
DocType: Bank Statement Settings,Transaction Data Mapping,Transaktionsdata Kortlægning
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +280,Sales Invoice {0} has already been submitted,Salgsfaktura {0} er allerede blevet godkendt
DocType: Salary Component,Is Tax Applicable,Er skat gældende
DocType: Supplier Scorecard Scoring Criteria,Score,score
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +25,Fiscal Year {0} does not exist,Regnskabsår {0} findes ikke
DocType: Asset Maintenance Log,Completion Date,Afslutning Dato
DocType: Purchase Invoice Item,Amount (Company Currency),Beløb (firmavaluta)
DocType: Agriculture Analysis Criteria,Agriculture User,Landbruger Bruger
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +38,Valid till date cannot be before transaction date,Gyldig til dato kan ikke være før transaktionsdato
apps/erpnext/erpnext/stock/stock_ledger.py +386,{0} units of {1} needed in {2} on {3} {4} for {5} to complete this transaction.,{0} enheder af {1} skal bruges i {2} på {3} {4} til {5} for at gennemføre denne transaktion.
DocType: Fee Schedule,Student Category,Studerendekategori
DocType: Announcement,Student,Studerende
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure/clinical_procedure.js +98,Stock quantity to start procedure is not available in the warehouse. Do you want to record a Stock Transfer,Lagerkvantitet til startprocedure er ikke tilgængelig på lageret. Ønsker du at optage en lageroverførsel
DocType: Shipping Rule,Shipping Rule Type,Forsendelsesregel Type
apps/erpnext/erpnext/utilities/user_progress.py +239,Go to Rooms,Gå til værelser
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +259,"Company, Payment Account, From Date and To Date is mandatory","Firma, Betalingskonto, Fra dato og til dato er obligatorisk"
DocType: Company,Budget Detail,Budget Detail
apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +79,Please enter message before sending,"Indtast venligst en meddelelse, før du sender"
DocType: Purchase Invoice,DUPLICATE FOR SUPPLIER,DUPLIKATE FOR LEVERANDØR
DocType: Asset,Custodian,kontoførende
apps/erpnext/erpnext/config/accounts.py +543,Point-of-Sale Profile,Kassesystemprofil
apps/erpnext/erpnext/agriculture/doctype/soil_texture/soil_texture.py +25,{0} should be a value between 0 and 100,{0} skal være en værdi mellem 0 og 100
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +323,Payment of {0} from {1} to {2},Betaling af {0} fra {1} til {2}
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +166,Unsecured Loans,Usikrede lån
DocType: Cost Center,Cost Center Name,Omkostningsstednavn
DocType: Student,B+,B +
DocType: HR Settings,Max working hours against Timesheet,Max arbejdstid mod Timesheet
DocType: Maintenance Schedule Detail,Scheduled Date,Planlagt dato
apps/erpnext/erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.py +34,Total Paid Amt,Total Betalt Amt
DocType: SMS Center,Messages greater than 160 characters will be split into multiple messages,Beskeder større end 160 tegn vil blive opdelt i flere meddelelser
DocType: Purchase Receipt Item,Received and Accepted,Modtaget og accepteret
,GST Itemised Sales Register,GST Itemized Sales Register
DocType: Staffing Plan,Staffing Plan Details,Bemandingsplandetaljer
DocType: Soil Texture,Silt Loam,Silt Loam
,Serial No Service Contract Expiry,Serienummer Servicekontrakt-udløb
DocType: Employee Health Insurance,Employee Health Insurance,Medarbejdernes sygesikring
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +331,You cannot credit and debit same account at the same time,Du kan ikke kreditere og debitere samme konto på samme tid
DocType: Vital Signs,Adults' pulse rate is anywhere between 50 and 80 beats per minute.,Voksne pulsrate er overalt mellem 50 og 80 slag per minut.
DocType: Naming Series,Help HTML,Hjælp HTML
DocType: Student Group Creation Tool,Student Group Creation Tool,Værktøj til dannelse af elevgrupper
DocType: Item,Variant Based On,Variant Based On
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +53,Total weightage assigned should be 100%. It is {0},Samlet weightage tildelt skulle være 100%. Det er {0}
DocType: Loyalty Point Entry,Loyalty Program Tier,Loyalitetsprogram Tier
apps/erpnext/erpnext/utilities/user_progress.py +109,Your Suppliers,Dine Leverandører
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +80,Cannot set as Lost as Sales Order is made.,Kan ikke indstilles som Lost som Sales Order er foretaget.
DocType: Request for Quotation Item,Supplier Part No,Leverandør varenummer
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +395,Cannot deduct when category is for 'Valuation' or 'Vaulation and Total',Kan ikke fratrække når kategori er for &quot;Værdiansættelse&quot; eller &quot;Vaulation og Total &#39;
apps/erpnext/erpnext/public/js/hub/components/reviews.js +2,Anonymous,Anonym
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +379,Received From,Modtaget fra
DocType: Lead,Converted,Konverteret
DocType: Item,Has Serial No,Har serienummer
DocType: Employee,Date of Issue,Udstedt den
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +252,"As per the Buying Settings if Purchase Reciept Required == 'YES', then for creating Purchase Invoice, user need to create Purchase Receipt first for item {0}","I henhold til købsindstillingerne, hvis købsmodtagelse er påkrævet == &#39;JA&#39; og derefter for at oprette købsfaktura, skal brugeren først oprette købsmodtagelse for vare {0}"
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +173,Row #{0}: Set Supplier for item {1},Række # {0}: Indstil Leverandør for vare {1}
DocType: Global Defaults,Default Distance Unit,Standard Distance Unit
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +127,Row {0}: Hours value must be greater than zero.,Række {0}: Timer værdi skal være større end nul.
apps/erpnext/erpnext/stock/doctype/item/item.py +224,Website Image {0} attached to Item {1} cannot be found,Website Billede {0} er knyttet til Vare {1} kan ikke findes
DocType: Issue,Content Type,Indholdstype
DocType: Asset,Assets,Aktiver
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +17,Computer,Computer
DocType: Item,List this Item in multiple groups on the website.,Liste denne vare i flere grupper på hjemmesiden.
DocType: Subscription,Current Invoice End Date,Nuværende faktura Slutdato
DocType: Payment Term,Due Date Based On,Forfaldsdato baseret på
apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +82,Please set default customer group and territory in Selling Settings,Angiv standard kundegruppe og område i Sælgerindstillinger
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +215,{0} {1} does not exist,{0} {1} findes ikke
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +355,Please check Multi Currency option to allow accounts with other currency,Kontroller venligst Multi Valuta indstilling for at tillade konti med anden valuta
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +88,Item: {0} does not exist in the system,Item: {0} findes ikke i systemet
apps/erpnext/erpnext/accounts/doctype/account/account.py +113,You are not authorized to set Frozen value,Du er ikke autoriseret til at fastsætte Frozen værdi
DocType: Payment Reconciliation,Get Unreconciled Entries,Hent ikke-afstemte poster
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +35,Employee {0} is on Leave on {1},Medarbejder {0} er på ferie på {1}
apps/erpnext/erpnext/hr/doctype/loan/loan.py +159,No repayments selected for Journal Entry,Ingen tilbagebetalinger valgt til Journal Entry
DocType: Payment Reconciliation,From Invoice Date,Fra fakturadato
DocType: Loan,Disbursed,udbetalt
DocType: Healthcare Settings,Laboratory Settings,Laboratorieindstillinger
DocType: Clinical Procedure,Service Unit,Serviceenhed
apps/erpnext/erpnext/buying/report/quoted_item_comparison/quoted_item_comparison.js +97,Successfully Set Supplier,Vellykket Indstil Leverandør
DocType: Leave Encashment,Leave Encashment,Udbetal fravær
apps/erpnext/erpnext/public/js/setup_wizard.js +114,What does it do?,Hvad gør det?
apps/erpnext/erpnext/agriculture/doctype/crop_cycle/crop_cycle.py +47,Tasks have been created for managing the {0} disease (on row {1}),Opgaver er oprettet til styring af {0} sygdommen (på række {1})
DocType: Crop,Byproducts,biprodukter
apps/erpnext/erpnext/stock/doctype/batch/batch.js +84,To Warehouse,Til lager
apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +26,All Student Admissions,Alle Student Indlæggelser
,Average Commission Rate,Gennemsnitlig provisionssats
DocType: Share Balance,No of Shares,Antal Aktier
DocType: Taxable Salary Slab,To Amount,Til beløb
apps/erpnext/erpnext/stock/doctype/item/item.py +479,'Has Serial No' can not be 'Yes' for non-stock item,'Har serienummer' kan ikke være 'Ja' for ikke-lagerførte vare
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +59,Select Status,Vælg Status
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +44,Attendance can not be marked for future dates,Fremmøde kan ikke markeres for fremtidige datoer
DocType: Support Search Source,Post Description Key,Indlæg Beskrivelse Nøgle
DocType: Pricing Rule,Pricing Rule Help,Hjælp til prisfastsættelsesregel
DocType: School House,House Name,Husnavn
DocType: Fee Schedule,Total Amount per Student,Samlede beløb pr. Studerende
DocType: Opportunity,Sales Stage,Salgstrin
DocType: Purchase Taxes and Charges,Account Head,Konto hoved
DocType: Company,HRA Component,HRA komponent
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +119,Electrical,Elektrisk
apps/erpnext/erpnext/utilities/activation.py +100,Add the rest of your organization as your users. You can also add invite Customers to your portal by adding them from Contacts,Tilsæt resten af din organisation som dine brugere. Du kan også tilføje invitere kunder til din portal ved at tilføje dem fra Kontakter
DocType: Stock Entry,Total Value Difference (Out - In),Samlet værdi (difference udgående - indgående)
DocType: Grant Application,Requested Amount,Ønsket beløb
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +380,Row {0}: Exchange Rate is mandatory,Række {0}: Valutakursen er obligatorisk
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +46,User ID not set for Employee {0},Bruger-id ikke indstillet til Medarbejder {0}
DocType: Vehicle,Vehicle Value,Køretøjsværdi
DocType: Crop Cycle,Detected Diseases,Opdagede sygdomme
DocType: Stock Entry,Default Source Warehouse,Standardkildelager
DocType: Item,Customer Code,Kundekode
DocType: Asset Maintenance Task,Last Completion Date,Sidste sluttidspunkt
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +72,Days Since Last Order,Dage siden sidste ordre
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +437,Debit To account must be a Balance Sheet account,Debit-Til konto skal være en balance konto
DocType: Asset,Naming Series,Navngivningsnummerserie
DocType: Vital Signs,Coated,coated
apps/erpnext/erpnext/assets/doctype/asset/asset.py +190,Row {0}: Expected Value After Useful Life must be less than Gross Purchase Amount,Række {0}: Forventet værdi efter brugbart liv skal være mindre end brutto købsbeløb
DocType: GoCardless Settings,GoCardless Settings,GoCardless Indstillinger
DocType: Leave Block List,Leave Block List Name,Blokering af fraværsansøgninger
DocType: Certified Consultant,Certification Validity,Certificering Gyldighed
apps/erpnext/erpnext/hr/doctype/vehicle/vehicle.py +14,Insurance Start date should be less than Insurance End date,Forsikring Startdato skal være mindre end Forsikring Slutdato
DocType: Shopping Cart Settings,Display Settings,Skærmindstillinger
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +33,Stock Assets,Lageraktiver
DocType: Restaurant,Active Menu,Aktiv Menu
DocType: Target Detail,Target Qty,Target Antal
apps/erpnext/erpnext/hr/doctype/loan/loan.py +37,Against Loan: {0},Mod lån: {0}
DocType: Shopping Cart Settings,Checkout Settings,Kassen Indstillinger
DocType: Student Attendance,Present,Tilstede
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +37,Delivery Note {0} must not be submitted,Følgeseddel {0} må ikke godkendes
DocType: Notification Control,Sales Invoice Message,Salgfakturabesked
apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +27,Closing Account {0} must be of type Liability / Equity,Lukningskonto {0} skal være af typen Passiver / Egenkapital
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +407,Salary Slip of employee {0} already created for time sheet {1},Medarbejder {0} lønseddel er allerede overført til tidsregistreringskladde {1}
DocType: Vehicle Log,Odometer,kilometertæller
DocType: Production Plan Item,Ordered Qty,Bestilt antal
apps/erpnext/erpnext/stock/doctype/item/item.py +822,Item {0} is disabled,Vare {0} er deaktiveret
DocType: Stock Settings,Stock Frozen Upto,Stock Frozen Op
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +1021,BOM does not contain any stock item,Stykliste indeholder ikke nogen lagervarer
DocType: Chapter,Chapter Head,Kapitel Hoved
DocType: Payment Term,Month(s) after the end of the invoice month,Måned (e) efter afslutningen af faktura måned
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +66,Salary Structure should have flexible benefit component(s) to dispense benefit amount,Lønstruktur skal have fleksible fordelskomponenter til at uddele ydelsesbeløb
apps/erpnext/erpnext/config/projects.py +24,Project activity / task.,Sagsaktivitet / opgave.
DocType: Vital Signs,Very Coated,Meget belagt
DocType: Salary Component,Only Tax Impact (Cannot Claim But Part of Taxable Income),Kun skattepåvirkning (kan ikke kræve en del af skattepligtig indkomst)
DocType: Vehicle Log,Refuelling Details,Brændstofpåfyldningsdetaljer
apps/erpnext/erpnext/agriculture/doctype/water_analysis/water_analysis.py +25,Lab result datetime cannot be before testing datetime,Lab resultatet datetime kan ikke være før testen datetime
DocType: POS Profile,Allow user to edit Discount,Tillad brugeren at redigere rabat
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +65,Get customers from,Få kunder fra
DocType: Purchase Invoice Item,Include Exploded Items,Inkluder eksploderede elementer
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +46,"Buying must be checked, if Applicable For is selected as {0}","Indkøb skal kontrolleres, om nødvendigt er valgt som {0}"
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +40,Discount must be less than 100,Rabat skal være mindre end 100
DocType: Shipping Rule,Restrict to Countries,Begræns til lande
DocType: Shopify Settings,Shared secret,Delt hemmelighed
DocType: Amazon MWS Settings,Synch Taxes and Charges,Synch Skatter og afgifter
DocType: Purchase Invoice,Write Off Amount (Company Currency),Skriv Off Beløb (Company Valuta)
DocType: Sales Invoice Timesheet,Billing Hours,Fakturerede timer
DocType: Project,Total Sales Amount (via Sales Order),Samlet Salgsbeløb (via salgsordre)
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +529,Default BOM for {0} not found,Standard stykliste for {0} blev ikke fundet
apps/erpnext/erpnext/stock/doctype/item/item.py +545,Row #{0}: Please set reorder quantity,Række # {0}: Venligst sæt genbestille mængde
apps/erpnext/erpnext/public/js/pos/pos.html +20,Tap items to add them here,Tryk på elementer for at tilføje dem her
DocType: Fees,Program Enrollment,Program Tilmelding
DocType: Share Transfer,To Folio No,Til Folio nr
DocType: Landed Cost Voucher,Landed Cost Voucher,Landed Cost Voucher
apps/erpnext/erpnext/public/js/queries.js +39,Please set {0},Indstil {0}
apps/erpnext/erpnext/education/doctype/student_group/student_group.py +37,{0} - {1} is inactive student,{0} - {1} er inaktiv studerende
DocType: Employee,Health Details,Sundhedsdetaljer
DocType: Leave Encashment,Encashable days,Encashable dage
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +30,To create a Payment Request reference document is required,For at oprette en betalingsanmodning kræves referencedokument
DocType: Soil Texture,Sandy Clay,Sandy Clay
DocType: Grant Application,Assessment  Manager,Vurderingsleder
DocType: Payment Entry,Allocate Payment Amount,Tildel Betaling Beløb
DocType: Subscription Plan,Subscription Plan,Abonnementsplan
DocType: Employee External Work History,Salary,Løn
DocType: Serial No,Delivery Document Type,Levering Dokumenttype
DocType: Sales Order,Partly Delivered,Delvist leveret
DocType: Item Variant Settings,Do not update variants on save,Opdater ikke varianter ved at gemme
DocType: Email Digest,Receivables,Tilgodehavender
DocType: Lead Source,Lead Source,Lead Source
DocType: Customer,Additional information regarding the customer.,Yderligere oplysninger om kunden.
DocType: Quality Inspection Reading,Reading 5,Reading 5
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +237,"{0} {1} is associated with {2}, but Party Account is {3}","{0} {1} er forbundet med {2}, men Party Account er {3}"
DocType: Bank Statement Settings Item,Bank Header,Bankoverskrift
apps/erpnext/erpnext/healthcare/doctype/sample_collection/sample_collection.js +7,View Lab Tests,Se labtest
DocType: Hub Users,Hub Users,Hub-brugere
DocType: Purchase Invoice,Y,Y
DocType: Maintenance Visit,Maintenance Date,Vedligeholdelsesdato
DocType: Purchase Invoice Item,Rejected Serial No,Afvist serienummer
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +82,Year start date or end date is overlapping with {0}. To avoid please set company,År startdato eller slutdato overlapper med {0}. For at undgå du indstille selskab
apps/erpnext/erpnext/selling/doctype/customer/customer.py +137,Please mention the Lead Name in Lead {0},Angiv Lead Name in Lead {0}
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +156,Start date should be less than end date for Item {0},Start dato bør være mindre end slutdato for Item {0}
DocType: Item,"Example: ABCD.#####
If series is set and Serial No is not mentioned in transactions, then automatic serial number will be created based on this series. If you always want to explicitly mention Serial Nos for this item. leave this blank.","Eksempel:. ABCD ##### Hvis nummerserien er indstillet, og serienummeret ikke fremkommer i transaktionerne, så vil serienummeret automatisk blive oprettet på grundlag af denne nummerserie. Hvis du altid ønsker, eksplicit at angive serienumre for denne vare, skal du lade dette felt være blankt."
DocType: Upload Attendance,Upload Attendance,Indlæs fremmøde
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +648,BOM and Manufacturing Quantity are required,Stykliste and produceret mængde skal angives
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +35,Ageing Range 2,Ageing Range 2
DocType: SG Creation Tool Course,Max Strength,Max Strength
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +29,Installing presets,Installation af forudindstillinger
DocType: Fee Schedule,EDU-FSH-.YYYY.-,EDU-FSH-.YYYY.-
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +113,No Delivery Note selected for Customer {},Ingen leveringskort valgt til kunden {}
apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py +17,Employee {0} has no maximum benefit amount,Medarbejder {0} har ingen maksimal ydelsesbeløb
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1211,Select Items based on Delivery Date,Vælg varer baseret på Leveringsdato
DocType: Grant Application,Has any past Grant Record,Har nogen tidligere Grant Record
,Sales Analytics,Salgsanalyser
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +127,Available {0},Tilgængelige {0}
,Prospects Engaged But Not Converted,Udsigter Engageret men ikke konverteret
DocType: Manufacturing Settings,Manufacturing Settings,Produktion Indstillinger
apps/erpnext/erpnext/config/setup.py +56,Setting up Email,Opsætning af E-mail
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +57,Guardian1 Mobile No,Formynder 1 mobiltelefonnr.
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +135,Please enter default currency in Company Master,Indtast standardvaluta i Firma-masteren
DocType: Stock Entry Detail,Stock Entry Detail,Lagerindtastningsdetaljer
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +117,Daily Reminders,Daglige påmindelser
apps/erpnext/erpnext/templates/pages/help.html +56,See all open tickets,Se alle åbne billetter
apps/erpnext/erpnext/healthcare/doctype/healthcare_service_unit/healthcare_service_unit.js +21,Healthcare Service Unit Tree,Healthcare Service Unit Tree
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +273,Product,Produkt
DocType: Products Settings,Home Page is Products,Home Page er Produkter
,Asset Depreciation Ledger,Asset Afskrivninger Ledger
DocType: Salary Structure,Leave Encashment Amount Per Day,Forlad Encashment Amount Per Day
DocType: Loyalty Program Collection,For how much spent = 1 Loyalty Point,For hvor meget brugt = 1 Loyalitetspoint
apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +97,Tax Rule Conflicts with {0},Momsregel konflikter med {0}
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +25,New Account Name,Ny Kontonavn
DocType: Purchase Invoice Item,Raw Materials Supplied Cost,Raw Materials Leveres Cost
DocType: Selling Settings,Settings for Selling Module,Indstillinger for salgsmodul
DocType: Hotel Room Reservation,Hotel Room Reservation,Hotelværelse Reservation
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +388,Customer Service,Kundeservice
DocType: BOM,Thumbnail,Thumbnail
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +383,No contacts with email IDs found.,Ingen kontakter med e-mail-id&#39;er fundet.
DocType: Item Customer Detail,Item Customer Detail,Item Customer Detail
DocType: Notification Control,Prompt for Email on Submission of,Spørg til Email på Indsendelse af
apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py +36,Maximum benefit amount of employee {0} exceeds {1},Maksimal ydelsesbeløb for medarbejderen {0} overstiger {1}
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +102,Total allocated leaves are more than days in the period,Samlede fordelte blade er mere end dage i perioden
DocType: Linked Soil Analysis,Linked Soil Analysis,Linked Soil Analysis
DocType: Pricing Rule,Percentage,Procent
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +70,Item {0} must be a stock Item,Vare {0} skal være en lagervare
DocType: Manufacturing Settings,Default Work In Progress Warehouse,Standard varer-i-arbejde-lager
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js +83,"Schedules for {0} overlaps, do you want to proceed after skiping overlaped slots ?","Skemaer for {0} overlapninger, vil du fortsætte efter at have oversat overlapte slots?"
apps/erpnext/erpnext/config/accounts.py +256,Default settings for accounting transactions.,Standardindstillinger regnskabsmæssige transaktioner.
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.js +8,Grant Leaves,Grant Leaves
DocType: Restaurant,Default Tax Template,Standard skat skabelon
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +71,{0} Students have been enrolled,{0} Studerende er blevet tilmeldt
DocType: Fees,Student Details,Studentoplysninger
DocType: Purchase Invoice Item,Stock Qty,Antal på lager
DocType: Contract,Requires Fulfilment,Kræver Opfyldelse
DocType: QuickBooks Migrator,Default Shipping Account,Standard fragtkonto
DocType: Loan,Repayment Period in Months,Tilbagebetaling Periode i måneder
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +26,Error: Not a valid id?,Fejl: Ikke et gyldigt id?
DocType: Naming Series,Update Series Number,Opdatering Series Number
DocType: Account,Equity,Egenkapital
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +79,{0} {1}: 'Profit and Loss' type account {2} not allowed in Opening Entry,{0} {1}: konto {2} af typen Resultatopgørelse må ikke angives i Åbningsbalancen
DocType: Job Offer,Printing Details,Udskrivningsindstillinger
DocType: Task,Closing Date,Closing Dato
DocType: Sales Order Item,Produced Quantity,Produceret Mængde
DocType: Item Price,Quantity  that must be bought or sold per UOM,"Mængde, der skal købes eller sælges pr. UOM"
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +89,Engineer,Ingeniør
DocType: Employee Tax Exemption Category,Max Amount,Maks. Beløb
DocType: Journal Entry,Total Amount Currency,Samlet beløb Valuta
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +38,Search Sub Assemblies,Søg Sub Assemblies
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +200,Item Code required at Row No {0},Varenr. kræves på rækkenr. {0}
DocType: GST Account,SGST Account,SGST-konto
apps/erpnext/erpnext/utilities/user_progress.py +154,Go to Items,Gå til varer
DocType: Sales Partner,Partner Type,Partnertype
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +72,Actual,Faktiske
DocType: Restaurant Menu,Restaurant Manager,Restaurantchef
DocType: Authorization Rule,Customerwise Discount,Customerwise Discount
apps/erpnext/erpnext/config/projects.py +46,Timesheet for tasks.,Timeseddel til opgaver.
DocType: Purchase Invoice,Against Expense Account,Mod udgiftskonto
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +287,Installation Note {0} has already been submitted,Installation Bemærk {0} er allerede blevet indsendt
DocType: Bank Reconciliation,Get Payment Entries,Hent betalingsposter
DocType: Quotation Item,Against Docname,Mod Docname
DocType: SMS Center,All Employee (Active),Alle medarbejdere (aktive)
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +9,View Now,Se nu
DocType: BOM,Raw Material Cost,Råmaterialeomkostninger
DocType: Woocommerce Settings,Woocommerce Server URL,Webadresse for WoCommerce Server
DocType: Item Reorder,Re-Order Level,Re-Order Level
DocType: Shopify Tax Account,Shopify Tax/Shipping Title,Shopify Skat / Fragt Titel
apps/erpnext/erpnext/projects/doctype/project/project.js +54,Gantt Chart,Gantt-diagram
DocType: Crop Cycle,Cycle Type,Cykeltype
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +77,Part-time,Deltid
DocType: Employee,Applicable Holiday List,Gældende helligdagskalender
DocType: Employee,Cheque,Anvendes ikke
DocType: Training Event,Employee Emails,Medarbejder Emails
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +67,Series Updated,Nummerserien opdateret
apps/erpnext/erpnext/accounts/doctype/account/account.py +166,Report Type is mandatory,Kontotype er obligatorisk
DocType: Item,Serial Number Series,Serienummer-nummerserie
apps/erpnext/erpnext/buying/utils.py +68,Warehouse is mandatory for stock Item {0} in row {1},Lager er obligatorisk for lagervare {0} i række {1}
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +45,Retail & Wholesale,Detail &amp; Wholesale
DocType: Issue,First Responded On,Først svarede den
DocType: Website Item Group,Cross Listing of Item in multiple groups,Cross Notering af Item i flere grupper
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +90,Fiscal Year Start Date and Fiscal Year End Date are already set in Fiscal Year {0},Regnskabsår Start Dato og Skatteårsafslutning Dato allerede sat i regnskabsåret {0}
DocType: Projects Settings,Ignore User Time Overlap,Ignorér overlapning af brugertid
DocType: Accounting Period,Accounting Period,Regnskabsperiode
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +113,Clearance Date updated,Clearance Dato opdateret
apps/erpnext/erpnext/stock/doctype/batch/batch.js +146,Split Batch,Opdel parti
DocType: Stock Settings,Batch Identification,Batchidentifikation
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +132,Successfully Reconciled,Succesfuld Afstemt
DocType: Request for Quotation Supplier,Download PDF,Download PDF
DocType: Work Order,Planned End Date,Planlagt slutdato
DocType: Shareholder,Hidden list maintaining the list of contacts linked to Shareholder,"Skjult liste vedligeholdelse af listen over kontakter, der er knyttet til Aktionær"
DocType: Exchange Rate Revaluation Account,Current Exchange Rate,Aktuel valutakurs
DocType: Item,"Sales, Purchase, Accounting Defaults","Salg, køb, regnskabsstandarder"
apps/erpnext/erpnext/config/non_profit.py +63,Donor Type information.,Donor Type oplysninger.
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +192,{0} on Leave on {1},{0} på forladt på {1}
apps/erpnext/erpnext/assets/doctype/asset/asset.py +60,Available for use date is required,Tilgængelig til brug dato er påkrævet
DocType: Request for Quotation,Supplier Detail,Leverandør Detail
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +181,Error in formula or condition: {0},Fejl i formel eller betingelse: {0}
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +119,Invoiced Amount,Faktureret beløb
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +47,Criteria weights must add up to 100%,Kriterier vægt skal tilføje op til 100%
apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.js +7,Attendance,Fremmøde
apps/erpnext/erpnext/public/js/pos/pos.html +115,Stock Items,Lagervarer
DocType: Sales Invoice,Update Billed Amount in Sales Order,Opdater billedbeløb i salgsordre
DocType: BOM,Materials,Materialer
DocType: Leave Block List,"If not checked, the list will have to be added to each Department where it has to be applied.","Hvis ikke afkrydset, skal hver afdeling vælges, hvor det skal anvendes."
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +689,Posting date and posting time is mandatory,Bogføringsdato og -tid er obligatorisk
apps/erpnext/erpnext/config/buying.py +76,Tax template for buying transactions.,Momsskabelon til købstransaktioner.
,Item Prices,Varepriser
DocType: Purchase Order,In Words will be visible once you save the Purchase Order.,"""I Ord"" vil være synlig, når du gemmer indkøbsordren."
DocType: Holiday List,Add to Holidays,Tilføj til helligdage
DocType: Woocommerce Settings,Endpoint,Endpoint
DocType: Period Closing Voucher,Period Closing Voucher,Periode Lukning Voucher
DocType: Patient Encounter,Review Details,Gennemgå detaljer
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +186,The shareholder does not belong to this company,Aktionæren tilhører ikke dette selskab
DocType: Dosage Form,Dosage Form,Doseringsformular
apps/erpnext/erpnext/config/selling.py +67,Price List master.,Master-Prisliste.
DocType: Task,Review Date,Anmeldelse Dato
DocType: BOM,Allow Alternative Item,Tillad alternativ vare
DocType: Company,Series for Asset Depreciation Entry (Journal Entry),Serie for Asset Depreciation Entry (Journal Entry)
DocType: Membership,Member Since,Medlem siden
DocType: Purchase Invoice,Advance Payments,Forudbetalinger
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1754,Please select Healthcare Service,Vælg venligst Healthcare Service
DocType: Purchase Taxes and Charges,On Net Total,On Net Total
apps/erpnext/erpnext/controllers/item_variant.py +92,Value for Attribute {0} must be within the range of {1} to {2} in the increments of {3} for Item {4},Værdi for Egenskab {0} skal være inden for området af {1} og {2} i intervaller af {3} til konto {4}
DocType: Restaurant Reservation,Waitlisted,venteliste
DocType: Employee Tax Exemption Declaration Category,Exemption Category,Fritagelseskategori
apps/erpnext/erpnext/accounts/doctype/account/account.py +131,Currency can not be changed after making entries using some other currency,Valuta kan ikke ændres efter at poster ved hjælp af nogle anden valuta
DocType: Shipping Rule,Fixed,Fast
DocType: Vehicle Service,Clutch Plate,clutch Plate
DocType: Company,Round Off Account,Afrundningskonto
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +100,Administrative Expenses,Administrationsomkostninger
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +18,Consulting,Rådgivning
DocType: Subscription Plan,Based on price list,Baseret på prisliste
DocType: Customer Group,Parent Customer Group,Overordnet kundegruppe
DocType: Vehicle Service,Change,Ændring
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +898,Subscription,Abonnement
DocType: Purchase Invoice,Contact Email,Kontakt e-mail
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +11,Fee Creation Pending,Gebyr oprettelse afventer
DocType: Appraisal Goal,Score Earned,Score tjent
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +199,Notice Period,Opsigelsesperiode
DocType: Asset Category,Asset Category Name,Asset Kategori Navn
apps/erpnext/erpnext/setup/doctype/territory/territory.js +13,This is a root territory and cannot be edited.,Dette er et overordnet område og kan ikke redigeres.
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js +5,New Sales Person Name,Navn på ny salgsmedarbejder
DocType: Packing Slip,Gross Weight UOM,Bruttovægtenhed
DocType: Employee Transfer,Create New Employee Id,Opret nyt medarbejder-id
apps/erpnext/erpnext/public/js/hub/components/item_publish_dialog.js +26,Set Details,Indstil detaljer
DocType: Travel Itinerary,Travel From,Rejse fra
DocType: Asset Maintenance Task,Preventive Maintenance,Forebyggende vedligeholdelse
DocType: Delivery Note Item,Against Sales Invoice,Mod salgsfaktura
DocType: Purchase Invoice,07-Others,07-Andre
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +158,Please enter serial numbers for serialized item ,Indtast serienumre for serialiseret vare
DocType: Bin,Reserved Qty for Production,Reserveret Antal for Produktion
DocType: Student Group Creation Tool,Leave unchecked if you don't want to consider batch while making course based groups. ,"Markér ikke, hvis du ikke vil overveje batch mens du laver kursusbaserede grupper."
DocType: Asset,Frequency of Depreciation (Months),Hyppigheden af afskrivninger (måneder)
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +542,Credit Account,Kreditkonto
DocType: Landed Cost Item,Landed Cost Item,Landed Cost Vare
apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.js +58,Show zero values,Vis nulværdier
DocType: BOM,Quantity of item obtained after manufacturing / repacking from given quantities of raw materials,Mængde post opnået efter fremstilling / ompakning fra givne mængde råvarer
DocType: Lab Test,Test Group,Testgruppe
DocType: Payment Reconciliation,Receivable / Payable Account,Tilgodehavende / Betales konto
DocType: Delivery Note Item,Against Sales Order Item,Mod Sales Order Item
DocType: Company,Company Logo,Firma Logo
apps/erpnext/erpnext/stock/doctype/item/item.py +787,Please specify Attribute Value for attribute {0},Angiv Attribut Værdi for attribut {0}
DocType: QuickBooks Migrator,Default Warehouse,Standard-lager
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +55,Budget cannot be assigned against Group Account {0},Budget kan ikke tildeles mod Group konto {0}
DocType: Shopping Cart Settings,Show Price,Vis pris
DocType: Healthcare Settings,Patient Registration,Patientregistrering
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +24,Please enter parent cost center,Indtast overordnet omkostningssted
DocType: Delivery Note,Print Without Amount,Print uden Beløb
apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +92,Depreciation Date,Afskrivningsdato
,Work Orders in Progress,Arbejdsordrer i gang
DocType: Issue,Support Team,Supportteam
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +36,Expiry (In Days),Udløb (i dage)
DocType: Appraisal,Total Score (Out of 5),Samlet score (ud af 5)
DocType: Student Attendance Tool,Batch,Parti
DocType: Support Search Source,Query Route String,Query Route String
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1173,Update rate as per last purchase,Opdateringshastighed pr. Sidste køb
DocType: Donor,Donor Type,Donor Type
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +710,Auto repeat document updated,Automatisk gentag dokument opdateret
apps/erpnext/erpnext/stock/doctype/item/item.js +29,Balance,Balance
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +66,Please select the Company,Vælg venligst firmaet
DocType: Job Card,Job Card,Jobkort
DocType: Room,Seating Capacity,Seating Capacity
DocType: Issue,ISS-,ISS-
DocType: Lab Test Groups,Lab Test Groups,Lab Test Grupper
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.py +151,Party Type and Party is mandatory for {0} account,Party Type og Party er obligatorisk for {0} konto
DocType: Project,Total Expense Claim (via Expense Claims),Udlæg ialt (via Udlæg)
DocType: GST Settings,GST Summary,GST Sammendrag
apps/erpnext/erpnext/hr/doctype/daily_work_summary_group/daily_work_summary_group.py +16,Please enable default incoming account before creating Daily Work Summary Group,"Aktivér standard indgående konto, før du opretter Daglig Arbejdsopsamlingsgruppe"
DocType: Assessment Result,Total Score,Samlet score
DocType: Crop Cycle,ISO 8601 standard,ISO 8601 standard
DocType: Journal Entry,Debit Note,Debitnota
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1517,You can only redeem max {0} points in this order.,Du kan kun indløse maksimalt {0} point i denne ordre.
DocType: Expense Claim,HR-EXP-.YYYY.-,HR-EXP-.YYYY.-
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.py +102,Please enter API Consumer Secret,Indtast venligst API Consumer Secret
DocType: Stock Entry,As per Stock UOM,pr. lagerenhed
apps/erpnext/erpnext/stock/doctype/batch/batch_list.js +7,Not Expired,Ikke udløbet
DocType: Student Log,Achievement,Præstation
DocType: Asset,Insurer,Forsikringsgiver
DocType: Batch,Source Document Type,Kilde dokumenttype
apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +24,Following course schedules were created,Følgende kursusplaner blev oprettet
DocType: Employee Onboarding,Employee Onboarding,Medarbejder Onboarding
DocType: Journal Entry,Total Debit,Samlet debet
DocType: Travel Request Costing,Sponsored Amount,Sponsoreret beløb
DocType: Manufacturing Settings,Default Finished Goods Warehouse,Standard færdigvarer Warehouse
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +380,Please select Patient,Vælg venligst Patient
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +74,Sales Person,Salgsmedarbejder
DocType: Hotel Room Package,Amenities,Faciliteter
DocType: QuickBooks Migrator,Undeposited Funds Account,Undeposited Funds Account
apps/erpnext/erpnext/config/accounts.py +201,Budget and Cost Center,Budget og Omkostningssted
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +65,Multiple default mode of payment is not allowed,Flere standard betalingsmåder er ikke tilladt
DocType: Sales Invoice,Loyalty Points Redemption,Loyalitetspoint Indfrielse
,Appointment Analytics,Aftale Analytics
DocType: Vehicle Service,Half Yearly,Halvårlig
DocType: Lead,Blog Subscriber,Blog Subscriber
DocType: Guardian,Alternate Number,Alternativ Number
DocType: Assessment Plan Criteria,Maximum Score,Maksimal score
apps/erpnext/erpnext/config/setup.py +83,Create rules to restrict transactions based on values.,Oprette regler til at begrænse transaktioner baseret på værdier.
DocType: Cash Flow Mapping Accounts,Cash Flow Mapping Accounts,Cash Flow Mapping Accounts
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +49, Group Roll No,Gruppe Roll nr
DocType: Batch,Manufacturing Date,Fremstillingsdato
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +9,Fee Creation Failed,Fee Creation mislykkedes
DocType: Opening Invoice Creation Tool,Create Missing Party,Opret manglende parti
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +85,Total Budget,Samlet budget
DocType: Student Group Creation Tool,Leave blank if you make students groups per year,"Lad feltet stå tomt, hvis du laver elevergrupper hvert år"
DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Hvis markeret, Total nej. af Arbejdsdage vil omfatte helligdage, og dette vil reducere værdien af Løn Per Day"
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js +25,"Apps using current key won't be able to access, are you sure?","Apps, der bruger den nuværende nøgle, vil ikke kunne få adgang til, er du sikker?"
DocType: Subscription Settings,Prorate,prorate
DocType: Purchase Invoice,Total Advance,Samlet Advance
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js +78,Change Template Code,Skift skabelonkode
apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +23,The Term End Date cannot be earlier than the Term Start Date. Please correct the dates and try again.,Betingelsernes slutdato kan ikke være tidligere end betingelsernes startdato. Ret venligst datoerne og prøv igen.
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +19,Quot Count,Citeringsantal
DocType: Bank Statement Transaction Entry,Bank Statement,Kontoudtog
DocType: Employee Benefit Claim,Max Amount Eligible,Maksimumsbeløb berettiget
,BOM Stock Report,BOM Stock Rapport
DocType: Stock Reconciliation Item,Quantity Difference,Mængdeforskel
DocType: Opportunity Item,Basic Rate,Grundlæggende Rate
DocType: GL Entry,Credit Amount,Kreditbeløb
DocType: Cheque Print Template,Signatory Position,undertegnende holdning
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +184,Set as Lost,Sæt som Lost
DocType: Timesheet,Total Billable Hours,Total fakturerbare timer
DocType: Subscription,Number of days that the subscriber has to pay invoices generated by this subscription,"Antal dage, som abonnenten skal betale fakturaer genereret af dette abonnement"
DocType: Employee Benefit Application Detail,Employee Benefit Application Detail,Ansøgningsbidrag Ansøgnings detaljer
apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +4,Payment Receipt Note,Betalingskvittering
apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +6,This is based on transactions against this Customer. See timeline below for details,Dette er baseret på transaktioner for denne kunde. Se tidslinje nedenfor for detaljer
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +162,Row {0}: Allocated amount {1} must be less than or equals to Payment Entry amount {2},Række {0}: Allokeret beløb {1} skal være mindre end eller lig med Payment indtastning beløb {2}
DocType: Program Enrollment Tool,New Academic Term,Ny akademisk term
,Course wise Assessment Report,Kursusbaseret vurderingsrapport
DocType: Purchase Invoice,Availed ITC State/UT Tax,Udnyttet ITC Stat / UT Skat
DocType: Tax Rule,Tax Rule,Momsregel
DocType: Selling Settings,Maintain Same Rate Throughout Sales Cycle,Oprethold Samme Rate Gennem Sales Cycle
apps/erpnext/erpnext/hub_node/api.py +49,Please login as another user to register on Marketplace,Log venligst ind som en anden bruger for at registrere dig på Marketplace
DocType: Manufacturing Settings,Plan time logs outside Workstation Working Hours.,Planlæg tid logs uden Workstation arbejdstid.
apps/erpnext/erpnext/public/js/pos/pos.html +98,Customers in Queue,Kunder i kø
DocType: Driver,Issuing Date,Udstedelsesdato
DocType: Procedure Prescription,Appointment Booked,Udnævnelse Reserveret
DocType: Student,Nationality,Nationalitet
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +108,Submit this Work Order for further processing.,Send denne arbejdsordre til videre behandling.
,Items To Be Requested,Varer til bestilling
DocType: Company,Company Info,Firmainformation
apps/erpnext/erpnext/accounts/page/pos/pos.js +1399,Select or add new customer,Vælg eller tilføj ny kunde
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +177,Cost center is required to book an expense claim,Omkostningssted er forpligtet til at bestille et udlæg
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +9,Application of Funds (Assets),Anvendelse af midler (Aktiver)
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +6,This is based on the attendance of this Employee,Dette er baseret på deltagelse af denne Medarbejder
DocType: Payment Request,Payment Request Type,Betalingsanmodning Type
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +113,Mark Attendance,Mark Attendance
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +536,Debit Account,Debetkonto
DocType: Fiscal Year,Year Start Date,År Startdato
DocType: Additional Salary,Employee Name,Medarbejdernavn
DocType: Restaurant Order Entry Item,Restaurant Order Entry Item,Restaurant Bestillingsartikel
DocType: Purchase Invoice,Rounded Total (Company Currency),Afrundet i alt (firmavaluta)
apps/erpnext/erpnext/accounts/doctype/account/account.py +103,Cannot covert to Group because Account Type is selected.,"Kan ikke skjult til gruppen, fordi Kontotype er valgt."
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +276,{0} {1} has been modified. Please refresh.,{0} {1} er blevet ændret. Venligst opdater.
DocType: Leave Block List,Stop users from making Leave Applications on following days.,Stop brugere fra at oprette fraværsansøgninger for de følgende dage.
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js +24,"If unlimited expiry for the Loyalty Points, keep the Expiry Duration empty or 0.","Hvis ubegrænset udløb for loyalitetspoint, skal du holde udløbsperioden tom eller 0."
DocType: Asset Maintenance Team,Maintenance Team Members,Vedligeholdelse Team Medlemmer
DocType: Loyalty Point Entry,Purchase Amount,Indkøbsbeløb
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +251,"Cannot deliver Serial No {0} of item {1} as it is reserved \
											to fullfill Sales Order {2}","Kan ikke aflevere serienummer {0} af punkt {1}, da det er reserveret \ for at fuldfylde salgsordre {2}"
DocType: Quotation,SAL-QTN-.YYYY.-,SAL-QTN-.YYYY.-
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +261,Supplier Quotation {0} created,Leverandørtilbud {0} oprettet
apps/erpnext/erpnext/accounts/report/financial_statements.py +106,End Year cannot be before Start Year,Slutår kan ikke være før startår
DocType: Employee Benefit Application,Employee Benefits,Personalegoder
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +269,Packed quantity must equal quantity for Item {0} in row {1},Pakket mængde skal være lig mængde for vare {0} i række {1}
DocType: Work Order,Manufactured Qty,Fremstillet mængde
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +79,The shares don't exist with the {0},Aktierne findes ikke med {0}
DocType: Sales Partner Type,Sales Partner Type,Salgspartartype
DocType: Shopify Webhook Detail,Webhook ID,Webhook ID
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +64,Invoice Created,Faktura er oprettet
DocType: Asset,Out of Order,Virker ikke
DocType: Purchase Receipt Item,Accepted Quantity,Mængde
DocType: Projects Settings,Ignore Workstation Time Overlap,Ignorer arbejdstidens overlapning
apps/erpnext/erpnext/hr/doctype/employee/employee.py +302,Please set a default Holiday List for Employee {0} or Company {1},Angiv en standard helligdagskalender for medarbejder {0} eller firma {1}
apps/erpnext/erpnext/accounts/party.py +30,{0}: {1} does not exists,{0}: {1} eksisterer ikke
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +78,Select Batch Numbers,Vælg batchnumre
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +231,To GSTIN,Til GSTIN
apps/erpnext/erpnext/config/accounts.py +14,Bills raised to Customers.,Regninger sendt til kunder.
DocType: Healthcare Settings,Invoice Appointments Automatically,Fakturaaftaler automatisk
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26,Project Id,Sags-id
DocType: Salary Component,Variable Based On Taxable Salary,Variabel baseret på skattepligtig løn
DocType: Company,Basic Component,Grundlæggende komponent
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +578,Row No {0}: Amount cannot be greater than Pending Amount against Expense Claim {1}. Pending Amount is {2},Rækkenr. {0}: Beløb kan ikke være større end Udestående Beløb overfor Udlæg {1}. Udestående Beløb er {2}
DocType: Patient Service Unit,Medical Administrator,Medicinsk administrator
DocType: Assessment Plan,Schedule,Køreplan
DocType: Account,Parent Account,Parent Konto
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +297,Available,Tilgængelig
DocType: Quality Inspection Reading,Reading 3,Reading 3
DocType: Stock Entry,Source Warehouse Address,Source Warehouse Address
DocType: GL Entry,Voucher Type,Bilagstype
DocType: Amazon MWS Settings,Max Retry Limit,Max Retry Limit
apps/erpnext/erpnext/accounts/page/pos/pos.js +1731,Price List not found or disabled,Prisliste ikke fundet eller deaktiveret
DocType: Student Applicant,Approved,Godkendt
apps/erpnext/erpnext/public/js/pos/pos_selected_item.html +15,Price,Pris
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +349,Employee relieved on {0} must be set as 'Left',Medarbejder lettet på {0} skal indstilles som &quot;Left&quot;
DocType: Marketplace Settings,Last Sync On,Sidste synkronisering
DocType: Guardian,Guardian,Guardian
apps/erpnext/erpnext/support/doctype/issue/issue.js +48,All communications including and above this shall be moved into the new Issue,Alle meddelelser inklusive og over dette skal flyttes til det nye udgave
DocType: Salary Detail,Tax on additional salary,Skat af ekstra løn
DocType: Item Alternative,Item Alternative,Vare Alternativ
DocType: Healthcare Settings,Default income accounts to be used if not set in Healthcare Practitioner to book Appointment charges.,"Standardindkomstkonti, der skal bruges, hvis det ikke er fastsat i Healthcare Practitioner at bestille Aftaleomkostninger."
DocType: Opening Invoice Creation Tool,Create missing customer or supplier.,Opret manglende kunde eller leverandør.
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +42,Appraisal {0} created for Employee {1} in the given date range,Vurdering {0} dannet for medarbejder {1} i det givne datointerval
DocType: Academic Term,Education,Uddannelse
DocType: Payroll Entry,Salary Slips Created,Lønningslisterne er oprettet
DocType: Inpatient Record,Expected Discharge,Forventet udledning
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +594,Del,Slet
DocType: Selling Settings,Campaign Naming By,Kampagne Navngivning Af
DocType: Employee,Current Address Is,Nuværende adresse er
apps/erpnext/erpnext/utilities/user_progress.py +51,Monthly Sales Target (,Månedligt salgsmål (
apps/erpnext/erpnext/templates/includes/projects/project_tasks.html +9,modified,modificeret
DocType: Travel Request,Identification Document Number,Identifikationsdokumentnummer
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +41,"Optional. Sets company's default currency, if not specified.","Valgfri. Sætter virksomhedens standard valuta, hvis ikke angivet."
DocType: Sales Invoice,Customer GSTIN,Kunde GSTIN
DocType: Crop Cycle,List of diseases detected on the field. When selected it'll automatically add a list of tasks to deal with the disease ,"Liste over sygdomme opdaget på marken. Når den er valgt, tilføjer den automatisk en liste over opgaver for at håndtere sygdommen"
apps/erpnext/erpnext/healthcare/doctype/healthcare_service_unit/healthcare_service_unit.js +30,This is a root healthcare service unit and cannot be edited.,Dette er en root sundheds service enhed og kan ikke redigeres.
DocType: Asset Repair,Repair Status,Reparation Status
apps/erpnext/erpnext/public/js/event.js +31,Add Sales Partners,Tilføj salgspartnere
apps/erpnext/erpnext/config/accounts.py +45,Accounting journal entries.,Regnskab journaloptegnelser.
DocType: Travel Request,Travel Request,Rejseforespørgsel
DocType: Delivery Note Item,Available Qty at From Warehouse,Tilgængeligt antal fra vores lager
apps/erpnext/erpnext/hr/doctype/department_approver/department_approver.py +17,Please select Employee Record first.,Vælg Medarbejder Record først.
apps/erpnext/erpnext/hr/doctype/attendance_request/attendance_request.py +52,Attendance not submitted for {0} as it is a Holiday.,Tilstedeværelse er ikke indsendt til {0} som det er en ferie.
DocType: POS Profile,Account for Change Amount,Konto for returbeløb
DocType: QuickBooks Migrator,Connecting to QuickBooks,Tilslutning til QuickBooks
DocType: Exchange Rate Revaluation,Total Gain/Loss,Total gevinst / tab
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +1175,Invalid Company for Inter Company Invoice.,Invalid Company for Inter Company Invoice.
DocType: Purchase Invoice,input service,input service
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +249,Row {0}: Party / Account does not match with {1} / {2} in {3} {4},Række {0}: Party / Konto matcher ikke med {1} / {2} i {3} {4}
DocType: Employee Promotion,Employee Promotion,Medarbejderfremmende
DocType: Maintenance Team Member,Maintenance Team Member,Vedligeholdelse Teammedlem
DocType: Agriculture Analysis Criteria,Soil Analysis,Jordanalyse
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +16,Course Code: ,Kursuskode:
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +241,Please enter Expense Account,Indtast venligst udgiftskonto
DocType: Account,Stock,Lager
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1128,"Row #{0}: Reference Document Type must be one of Purchase Order, Purchase Invoice or Journal Entry","Row # {0}: referencedokument Type skal være en af indkøbsordre, købsfaktura eller Kassekladde"
DocType: Employee,Current Address,Nuværende adresse
DocType: Item,"If item is a variant of another item then description, image, pricing, taxes etc will be set from the template unless explicitly specified","Hvis varen er en variant af et andet element derefter beskrivelse, billede, prissætning, skatter mv vil blive fastsat fra skabelonen medmindre det udtrykkeligt er angivet"
DocType: Serial No,Purchase / Manufacture Details,Indkøbs- og produktionsdetaljer
DocType: Assessment Group,Assessment Group,Gruppe Assessment
apps/erpnext/erpnext/config/stock.py +332,Batch Inventory,Partilager
DocType: Supplier,GST Transporter ID,GST Transporter ID
DocType: Procedure Prescription,Procedure Name,Procedure Navn
DocType: Employee,Contract End Date,Kontrakt Slutdato
DocType: Amazon MWS Settings,Seller ID,Sælger ID
DocType: Sales Order,Track this Sales Order against any Project,Spor denne salgsordre mod enhver sag
DocType: Bank Statement Transaction Entry,Bank Statement Transaction Entry,Kontoudskrift Transaktion
DocType: Sales Invoice Item,Discount and Margin,Rabat og Margin
DocType: Lab Test,Prescription,Recept
DocType: Company,Default Deferred Revenue Account,Standard udskudt indtjeningskonto
DocType: Project,Second Email,Anden Email
DocType: Budget,Action if Annual Budget Exceeded on Actual,Handling hvis årligt budget oversteg på faktisk
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +129,Not Available,Ikke tilgængelig
DocType: Pricing Rule,Min Qty,Minimum mængde
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js +41,Disable Template,Deaktiver skabelon
DocType: Bank Statement Transaction Invoice Item,Transaction Date,Transaktionsdato
DocType: Production Plan Item,Planned Qty,Planlagt mængde
DocType: Company,Date of Incorporation,Oprindelsesdato
apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +121,Total Tax,Moms i alt
apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.py +40,Last Purchase Price,Sidste købspris
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +284,For Quantity (Manufactured Qty) is mandatory,For Mængde (Fremstillet Antal) er obligatorisk
DocType: Stock Entry,Default Target Warehouse,Standard Target Warehouse
DocType: Purchase Invoice,Net Total (Company Currency),Netto i alt (firmavaluta)
DocType: Delivery Note,Air,Luft
apps/erpnext/erpnext/education/doctype/academic_year/academic_year.py +14,The Year End Date cannot be earlier than the Year Start Date. Please correct the dates and try again.,Året Slutdato kan ikke være tidligere end året startdato. Ret de datoer og prøv igen.
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +277,{0} is not in Optional Holiday List,{0} er ikke i valgfri ferieliste
DocType: Notification Control,Purchase Receipt Message,Købskvittering meddelelse
DocType: Amazon MWS Settings,JP,JP
DocType: BOM,Scrap Items,Skrotvarer
DocType: Job Card,Actual Start Date,Faktisk startdato
DocType: Sales Order,% of materials delivered against this Sales Order,% Af materialer leveret mod denne Sales Order
apps/erpnext/erpnext/config/manufacturing.py +18,Generate Material Requests (MRP) and Work Orders.,Generer materialeanmodninger (MRP) og arbejdsordrer.
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +62,Set default mode of payment,Indstil standard betalingsform
DocType: Grant Application,Withdrawn,Trukket tilbage
DocType: Support Search Source,Support Search Source,Support Søg kilde
DocType: Project,Gross Margin %,Gross Margin%
DocType: BOM,With Operations,Med Operations
DocType: Support Search Source,Post Route Key List,Post rute nøgle liste
apps/erpnext/erpnext/accounts/party.py +288,Accounting entries have already been made in currency {0} for company {1}. Please select a receivable or payable account with currency {0}.,Regnskabsposteringer er allerede foretaget i valuta {0} for virksomheden {1}. Vælg tilgodehavendets eller gældens konto med valuta {0}.
DocType: Asset,Is Existing Asset,Er eksisterende aktiv
DocType: Salary Component,Statistical Component,Statistisk komponent
DocType: Warranty Claim,If different than customer address,Hvis anderledes end kundeadresse
DocType: Purchase Invoice,Without Payment of Tax,Uden betaling af skat
DocType: BOM Operation,BOM Operation,BOM Operation
apps/erpnext/erpnext/config/stock.py +144,Fulfilment,Opfyldelse
DocType: Purchase Taxes and Charges,On Previous Row Amount,På Forrige Row Beløb
DocType: Item,Has Expiry Date,Har udløbsdato
apps/erpnext/erpnext/assets/doctype/asset/asset.js +367,Transfer Asset,Transfer Asset
DocType: POS Profile,POS Profile,Kassesystemprofil
DocType: Training Event,Event Name,begivenhed Navn
DocType: Healthcare Practitioner,Phone (Office),Telefon (kontor)
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +21,"Cannot Submit, Employees left to mark attendance","Kan ikke indsende, Medarbejdere tilbage for at markere deltagelse"
DocType: Inpatient Record,Admission,Adgang
apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +29,Admissions for {0},Indlæggelser for {0}
apps/erpnext/erpnext/config/accounts.py +225,"Seasonality for setting budgets, targets etc.","Sæsonudsving til indstilling budgetter, mål etc."
DocType: Supplier Scorecard Scoring Variable,Variable Name,Variabelt navn
apps/erpnext/erpnext/stock/get_item_details.py +163,"Item {0} is a template, please select one of its variants","Vare {0} er en skabelon, skal du vælge en af dens varianter"
DocType: Purchase Invoice Item,Deferred Expense,Udskudt Udgift
apps/erpnext/erpnext/hr/doctype/salary_structure_assignment/salary_structure_assignment.py +26,From Date {0} cannot be before employee's joining Date {1},Fra dato {0} kan ikke være før medarbejderens tilmeldingsdato {1}
DocType: Asset,Asset Category,Asset Kategori
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +39,Net pay cannot be negative,Nettoløn kan ikke være negativ
DocType: Purchase Order,Advance Paid,Forudbetalt
DocType: Manufacturing Settings,Overproduction Percentage For Sales Order,Overproduktionsprocent for salgsordre
DocType: Item,Item Tax,Varemoms
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +951,Material to Supplier,Materiale til leverandøren
DocType: Soil Texture,Loamy Sand,Loamy Sand
DocType: Production Plan,Material Request Planning,Materialeforespørgselsplanlægning
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +708,Excise Invoice,Skattestyrelsen Faktura
apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py +16,Treshold {0}% appears more than once,Grænsen {0}% forekommer mere end én gang
DocType: Expense Claim,Employees Email Id,Medarbejdere Email Id
DocType: Employee Attendance Tool,Marked Attendance,Markant Deltagelse
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +145,Current Liabilities,Kortfristede forpligtelser
apps/erpnext/erpnext/public/js/projects/timer.js +138,Timer exceeded the given hours.,Timeren oversteg de angivne timer.
apps/erpnext/erpnext/config/selling.py +303,Send mass SMS to your contacts,Send masse-SMS til dine kontakter
DocType: Inpatient Record,A Positive,En positiv
DocType: Program,Program Name,Programnavn
DocType: Purchase Taxes and Charges,Consider Tax or Charge for,Overvej Skat eller Gebyr for
DocType: Driver,Driving License Category,Kørekort kategori
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +57,Actual Qty is mandatory,Faktiske Antal er obligatorisk
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +89,"{0} currently has a {1} Supplier Scorecard standing, and Purchase Orders to this supplier should be issued with caution.","{0} har for øjeblikket en {1} leverandør scorecard stående, og købsordrer til denne leverandør bør udstedes med forsigtighed."
DocType: Asset Maintenance Team,Asset Maintenance Team,Asset Maintenance Team
apps/erpnext/erpnext/setup/default_success_action.py +13,{0} has been submitted successfully,{0} er blevet indsendt succesfuldt
DocType: Loan,Loan Type,Lånetype
DocType: Scheduling Tool,Scheduling Tool,Planlægning Tool
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +133,Credit Card,Kreditkort
DocType: BOM,Item to be manufactured or repacked,"Element, der skal fremstilles eller forarbejdes"
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +766,Syntax error in condition: {0},Syntaksfejl i tilstand: {0}
DocType: Fee Structure,EDU-FST-.YYYY.-,EDU-FST-.YYYY.-
DocType: Employee Education,Major/Optional Subjects,Større / Valgfag
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +121,Please Set Supplier Group in Buying Settings.,Angiv leverandørgruppe i købsindstillinger.
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +63,"Total flexible benefit component amount {0} should not be less \
				than max benefits {1}",Samlet beløb for fleksibel fordel komponent {0} bør ikke være mindre end maksimale fordele {1}
DocType: Sales Invoice Item,Drop Ship,Drop Ship
DocType: Driver,Suspended,Suspenderet
DocType: Training Event,Attendees,Deltagere
DocType: Employee,"Here you can maintain family details like name and occupation of parent, spouse and children","Her kan du opretholde familiens detaljer såsom navn og beskæftigelse af forældre, ægtefælle og børn"
DocType: Academic Term,Term End Date,Betingelser slutdato
DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),Skatter og Afgifter Fratrukket (Company Valuta)
DocType: Item Group,General Settings,Generelle indstillinger
apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py +23,From Currency and To Currency cannot be same,Fra Valuta og Til valuta ikke kan være samme
DocType: Taxable Salary Slab,Percent Deduction,Procent Fradrag
DocType: Stock Entry,Repack,Pak om
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +6,You must Save the form before proceeding,"Du skal gemme formularen, før du fortsætter"
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +125,Please select the Company first,Vælg venligst firmaet først
DocType: Item Attribute,Numeric Values,Numeriske værdier
apps/erpnext/erpnext/public/js/setup_wizard.js +56,Attach Logo,Vedhæft Logo
apps/erpnext/erpnext/stock/doctype/batch/batch.js +51,Stock Levels,lagrene
DocType: Customer,Commission Rate,Provisionssats
apps/erpnext/erpnext/accounts/doctype/bank_statement_transaction_entry/bank_statement_transaction_entry.py +241,Successfully created payment entries,Vellykket oprettet betalingsposter
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +187,Created {0} scorecards for {1} between: ,Oprettet {0} scorecards for {1} mellem:
apps/erpnext/erpnext/stock/doctype/item/item.js +590,Make Variant,Opret Variant
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +156,"Payment Type must be one of Receive, Pay and Internal Transfer","Betaling Type skal være en af Modtag, Pay og Intern Transfer"
DocType: Travel Itinerary,Preferred Area for Lodging,Foretrukne område for overnatning
apps/erpnext/erpnext/config/selling.py +184,Analytics,Analyser
apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html +25,Cart is Empty,Indkøbskurv er tom
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +430,"Item {0} has no Serial No. Only serilialized items \
						can have delivery based on Serial No",Vare {0} har ingen serienummer. Kun seriliserede artikler \ kan have levering baseret på serienummer
DocType: Vehicle,Model,Model
DocType: Work Order,Actual Operating Cost,Faktiske driftsomkostninger
DocType: Payment Entry,Cheque/Reference No,Anvendes ikke
DocType: Soil Texture,Clay Loam,Clay Loam
apps/erpnext/erpnext/accounts/doctype/account/account.py +88,Root cannot be edited.,Root kan ikke redigeres.
DocType: Item,Units of Measure,Måleenheder
DocType: Employee Tax Exemption Declaration,Rented in Metro City,Udlejes i Metro City
DocType: Supplier,Default Tax Withholding Config,Standard Skat tilbageholdende Config
DocType: Manufacturing Settings,Allow Production on Holidays,Tillad produktion på helligdage
DocType: Sales Invoice,Customer's Purchase Order Date,Kundens indkøbsordredato
DocType: Production Plan,MFG-PP-.YYYY.-,MFG-PP-.YYYY.-
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +173,Capital Stock,Capital Stock
DocType: Asset,Default Finance Book,Standard Finance Book
DocType: Shopping Cart Settings,Show Public Attachments,Vis offentlige vedhæftede filer
apps/erpnext/erpnext/public/js/hub/components/item_publish_dialog.js +3,Edit Publishing Details,Rediger udgivelsesoplysninger
DocType: Packing Slip,Package Weight Details,Pakkevægtdetaljer
DocType: Leave Type,Is Compensatory,Er kompenserende
DocType: Restaurant Reservation,Reservation Time,Reservationstid
DocType: Payment Gateway Account,Payment Gateway Account,Betaling Gateway konto
DocType: Shopping Cart Settings,After payment completion redirect user to selected page.,Efter betaling afslutning omdirigere brugeren til valgte side.
DocType: Company,Existing Company,Eksisterende firma
DocType: Healthcare Settings,Result Emailed,Resultat sendt
apps/erpnext/erpnext/controllers/buying_controller.py +101,"Tax Category has been changed to ""Total"" because all the Items are non-stock items","Skatkategori er blevet ændret til &quot;Total&quot;, fordi alle genstande er ikke-lagerartikler"
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.py +35,To date can not be equal or less than from date,Til dato kan ikke være lige eller mindre end fra dato
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js +118,Nothing to change,Intet at ændre
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +104,Please select a csv file,Vælg en CSV-fil
DocType: Holiday List,Total Holidays,Samlede helligdage
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +123,Missing email template for dispatch. Please set one in Delivery Settings.,Manglende email skabelon til afsendelse. Indstil venligst en i Leveringsindstillinger.
DocType: Student Leave Application,Mark as Present,Markér som tilstede
DocType: Supplier Scorecard,Indicator Color,Indikator Farve
DocType: Purchase Order,To Receive and Bill,Til at modtage og Bill
apps/erpnext/erpnext/controllers/buying_controller.py +691,Row #{0}: Reqd by Date cannot be before Transaction Date,Row # {0}: Reqd by Date kan ikke være før Transaktionsdato
apps/erpnext/erpnext/templates/pages/home.html +14,Featured Products,Fremhævede varer
apps/erpnext/erpnext/assets/doctype/asset/asset.js +384,Select Serial No,Vælg serienummer
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +99,Designer,Designer
apps/erpnext/erpnext/config/selling.py +163,Terms and Conditions Template,Skabelon til vilkår og betingelser
DocType: Delivery Trip,Delivery Details,Levering Detaljer
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +618,Cost Center is required in row {0} in Taxes table for type {1},Omkostningssted kræves i række {0} i Skattetabellen for type {1}
DocType: Program,Program Code,programkode
DocType: Terms and Conditions,Terms and Conditions Help,Hjælp til vilkår og betingelser
,Item-wise Purchase Register,Vare-wise Purchase Tilmeld
DocType: Loyalty Point Entry,Expiry Date,Udløbsdato
DocType: Healthcare Settings,Employee name and designation in print,Ansattes navn og betegnelse i print
,accounts-browser,konti-browser
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +381,Please select Category first,Vælg kategori først
apps/erpnext/erpnext/config/projects.py +13,Project master.,Sags-master.
apps/erpnext/erpnext/controllers/status_updater.py +215,"To allow over-billing or over-ordering, update ""Allowance"" in Stock Settings or the Item.","For at tillade overfakturering eller overbestilling, skal du opdatere ""Allowance"" i lager- eller vareindstillingerne."
DocType: Contract,Contract Terms,Kontraktvilkår
DocType: Global Defaults,Do not show any symbol like $ etc next to currencies.,Vis ikke valutasymbol (fx. $) ved siden af valutaen.
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py +89,Maximum benefit amount of component {0} exceeds {1},Maksimumbeløbet for komponent {0} overstiger {1}
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +526, (Half Day),(Halv dag)
DocType: Payment Term,Credit Days,Kreditdage
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +140,Please select Patient to get Lab Tests,Vælg patienten for at få labtest
apps/erpnext/erpnext/utilities/activation.py +128,Make Student Batch,Masseopret elever
DocType: BOM Explosion Item,Allow Transfer for Manufacture,Tillad Overførsel til Fremstilling
DocType: Leave Type,Is Carry Forward,Er fortsat fravær fra sidste regnskabsår
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +997,Get Items from BOM,Hent varer fra stykliste
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41,Lead Time Days,Lead Time dage
DocType: Cash Flow Mapping,Is Income Tax Expense,Er indkomstskat udgift
apps/erpnext/erpnext/patches/v11_0/add_default_dispatch_notification_template.py +19,Your order is out for delivery!,Din ordre er ude for levering!
apps/erpnext/erpnext/controllers/accounts_controller.py +693,Row #{0}: Posting Date must be same as purchase date {1} of asset {2},Række # {0}: Bogføringsdato skal være den samme som købsdatoen {1} af aktivet {2}
DocType: Program Enrollment,Check this if the Student is residing at the Institute's Hostel.,"Tjek dette, hvis den studerende er bosiddende på instituttets Hostel."
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +125,Please enter Sales Orders in the above table,Indtast salgsordrer i ovenstående tabel
,Stock Summary,Stock Summary
apps/erpnext/erpnext/config/assets.py +62,Transfer an asset from one warehouse to another,Overfør et aktiv fra et lager til et andet
DocType: Vehicle,Petrol,Benzin
DocType: Employee Benefit Application,Remaining Benefits (Yearly),Resterende fordele (årlig)
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +873,Bill of Materials,Styklister
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +137,Row {0}: Party Type and Party is required for Receivable / Payable account {1},Række {0}: Party Type og part er nødvendig for Tilgodehavende / Betales konto {1}
DocType: Employee,Leave Policy,Forlad politik
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +865,Update Items,Opdater elementer
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +94,Ref Date,Ref Dato
DocType: Employee,Reason for Leaving,Årsag til Leaving
DocType: BOM Operation,Operating Cost(Company Currency),Driftsomkostninger (Company Valuta)
DocType: Loan Application,Rate of Interest,Rentesats
DocType: Expense Claim Detail,Sanctioned Amount,Sanktioneret Beløb
DocType: Item,Shelf Life In Days,Holdbarhed i dage
DocType: GL Entry,Is Opening,Er Åbning
DocType: Department,Expense Approvers,Cost Approves
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +228,Row {0}: Debit entry can not be linked with a {1},Række {0}: Debit indgang ikke kan knyttes med en {1}
DocType: Journal Entry,Subscription Section,Abonnementsafdeling
apps/erpnext/erpnext/accounts/doctype/account/account.py +238,Account {0} does not exist,Konto {0} findes ikke
DocType: Training Event,Training Program,Træningsprogram
DocType: Account,Cash,Kontanter
DocType: Employee,Short biography for website and other publications.,Kort biografi for hjemmesiden og andre publikationer.
