DocType: Employee,Salary Mode,Løn-tilstand
DocType: Patient,Divorced,Skilt
apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +96,Items already synced,Varer allerede synkroniseret
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/setup/setup_wizard/industry_type.py +19,Consumer Products,Forbrugerprodukter
DocType: Purchase Receipt,Subscription Detail,Abonnementsdetaljer
DocType: Supplier Scorecard,Notify Supplier,Underret Leverandør
DocType: Item,Customer Items,Kundevarer
DocType: Project,Costing and Billing,Omkostningsberegning og fakturering
apps/erpnext/erpnext/accounts/doctype/account/account.py +52,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/config/setup.py +88,Email Notifications,E-mail-meddelelser
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +26,Evaluation,Evaluering
DocType: Item,Default Unit of Measure,Standard Måleenhed
DocType: SMS Center,All Sales Partner Contact,Alle forhandlerkontakter
DocType: Employee,Leave Approvers,Fraværsgodkendere
DocType: Sales Partner,Dealer,Forhandler
DocType: Consultation,Investigations,Undersøgelser
DocType: Employee,Rented,Lejet
DocType: Purchase Order,PO-,IO-
DocType: POS Profile,Applicable for User,Gældende for bruger
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +196,"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/accounts/doctype/asset/asset.js +231,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/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +37,Currency is required for Price List {0},Valuta er nødvendig for prisliste {0}
DocType: Sales Taxes and Charges Template,* Will be calculated in the transaction.,* Vil blive beregnet i transaktionen.
DocType: Purchase Order,Customer Contact,Kundeservicekontakt
DocType: Patient Appointment,Check availability,Tjek tilgængelighed
DocType: Job Applicant,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
apps/erpnext/erpnext/hub_node/page/hub/hub_body.html +18,No more results.,Ikke flere resultater.
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +34,Legal,Juridisk
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +174,Actual type tax cannot be included in Item rate in row {0},"Faktiske type skat, kan ikke indgå i vare sats i række {0}"
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: Purchase Order,% Billed,% Faktureret
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +43,Exchange Rate must be same as {0} {1} ({2}),Vekselkurs skal være det samme som {0} {1} ({2})
DocType: Sales Invoice,Customer Name,Kundennavn
DocType: Vehicle,Natural Gas,Naturgas
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +132,Bank account cannot be named as {0},Bankkonto kan ikke blive navngivet som {0}
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 +196,Outstanding for {0} cannot be less than zero ({1}),Enestående for {0} kan ikke være mindre end nul ({1})
apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +357,There are no submitted Salary Slips to process.,Der er ikke indgivet lønlister til behandling.
DocType: Manufacturing Settings,Default 10 mins,Standard 10 min
DocType: Leave Type,Leave Type Name,Fraværstypenavn
apps/erpnext/erpnext/templates/pages/projects.js +62,Show open,Vis åben
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +151,Series Updated Successfully,Nummerserien opdateret
apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html +18,Checkout,bestilling
apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +175,Accural Journal Entry Submitted,Accural Kassekladde Indsendt
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 +65,Expected End Date can not be less than Expected Start Date,Forventet slutdato kan ikke være mindre end forventet startdato
apps/erpnext/erpnext/utilities/transaction_base.py +110,Row #{0}: Rate must be same as {1}: {2} ({3} / {4}) ,Row # {0}: Pris skal være samme som {1}: {2} ({3} / {4})
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +282,New Leave Application,Ny fraværsanmodning
,Batch Item Expiry Status,Partivare-udløbsstatus
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +180,Bank Draft,Bank Draft
DocType: Mode of Payment Account,Mode of Payment Account,Betalingsmådekonto
DocType: Consultation,Consultation,Konsultation
apps/erpnext/erpnext/stock/doctype/item/item.js +56,Show Variants,Vis varianter
DocType: Academic Term,Academic Term,Akademisk betegnelse
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py +14,Material,Materiale
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +670,Quantity,Mængde
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +546,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 +154,Loans (Liabilities),Lån (passiver)
DocType: Employee Education,Year of Passing,År for Passing
DocType: Item,Country of Origin,Oprindelsesland
apps/erpnext/erpnext/templates/includes/product_page.js +24,In Stock,På lager
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +46,Open Issues,Åbne spørgsmål
DocType: Production Plan Item,Production Plan Item,Produktion Plan Vare
apps/erpnext/erpnext/hr/doctype/employee/employee.py +144,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/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: Lab Prescription,Lab Prescription,Lab Prescription
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 +887,Serial Number: {0} is already referenced in Sales Invoice: {1},Serienummer: {0} er allerede refereret i salgsfaktura: {1}
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +824,Invoice,Faktura
DocType: Maintenance Schedule Item,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
apps/erpnext/erpnext/setup/setup_wizard/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 +225,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 +75,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 +157,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 +78,Row #{0}: Payment document is required to complete the trasaction,Row # {0}: Betaling dokument er nødvendig for at fuldføre trasaction
DocType: Production Order Operation,Work In Progress,Varer i arbejde
apps/erpnext/erpnext/schools/report/absent_student_report/absent_student_report.py +13,Please select date,Vælg venligst dato
DocType: Employee,Holiday List,Helligdagskalender
apps/erpnext/erpnext/schools/doctype/instructor/instructor.py +15,Please setup Instructor Naming System in School &gt; School Settings,Opsæt venligst instruktørens navngivningssystem i skolen&gt; skoleindstillinger
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +123,Accountant,Revisor
DocType: Patient,Tobacco Current Use,Tobaks nuværende anvendelse
DocType: Cost Center,Stock User,Lagerbruger
DocType: Company,Phone No,Telefonnr.
apps/erpnext/erpnext/schools/doctype/course_scheduling_tool/course_scheduling_tool.py +50,Course Schedules created:,Kursusskema oprettet:
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +182,New {0}: #{1},Ny {0}: # {1}
,Sales Partners Commission,Forhandlerprovision
DocType: Purchase Invoice,Rounding Adjustment,Afrundingsjustering
apps/erpnext/erpnext/setup/doctype/company/company.py +45,Abbreviation cannot have more than 5 characters,Forkortelse kan ikke have mere end 5 tegn
DocType: Physician Schedule Time Slot,Physician Schedule Time Slot,Læge Schedule Time Slot
DocType: Payment Request,Payment Request,Betalingsanmodning
DocType: Asset,Value After Depreciation,Værdi efter afskrivninger
DocType: Employee,O+,O +
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt_dashboard.py +18,Related,Relaterede
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +43,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
DocType: Subscription,Repeat on Day,Gentag på dagen
apps/erpnext/erpnext/accounts/doctype/account/account.js +41,This is a root account and cannot be edited.,Dette er en rod-konto og kan ikke redigeres.
DocType: Sales Invoice,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: 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/accounts/utils.py +73,{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/utilities/user_progress.py +125,Kg,Kg
DocType: Student Log,Log,Log
apps/erpnext/erpnext/config/hr.py +45,Opening for a Job.,Rekruttering
apps/erpnext/erpnext/schools/doctype/assessment_result_tool/assessment_result_tool.js +146,{0} Result submittted,{0} Resultat indsendt
DocType: Item Attribute,Increment,Tilvækst
apps/erpnext/erpnext/utilities/page/leaderboard/leaderboard.js +61,Timespan,Tidsperiode
apps/erpnext/erpnext/public/js/stock_analytics.js +61,Select Warehouse...,Vælg lager ...
apps/erpnext/erpnext/setup/setup_wizard/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 +44,Not permitted for {0},Ikke tilladt for {0}
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +568,Get items from,Hent varer fra
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +456,Stock cannot be updated against Delivery Note {0},Lager kan ikke opdateres mod følgeseddel {0}
apps/erpnext/erpnext/templates/pages/home.py +25,Product {0},Produkt {0}
apps/erpnext/erpnext/templates/generators/item_group.html +43,No items listed,Ingen emner opført
DocType: Payment Reconciliation,Reconcile,Forene
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +30,Grocery,Købmand
DocType: Quality Inspection Reading,Reading 1,Læsning 1
DocType: Process Payroll,Make Bank Entry,Make Bank indtastning
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +40,Pension Funds,Pensionskasser
apps/erpnext/erpnext/accounts/doctype/asset/asset.py +88,Next Depreciation Date cannot be before Purchase Date,Næste afskrivningsdato kan ikke være før købsdatoen
DocType: Consultation,Consultation Date,Høringsdato
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 / Target tværs måneder, hvis du har sæsonudsving i din virksomhed."
apps/erpnext/erpnext/accounts/page/pos/pos.js +1750,Not items found,Ikke varer fundet
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +181,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 +110,"e.g. ""Primary School"" or ""University""",fx &quot;Primary School&quot; eller &quot;University&quot;
apps/erpnext/erpnext/config/stock.py +32,Stock Reports,Stock Rapporter
DocType: Warehouse,Warehouse Detail,Lagerinformation
apps/erpnext/erpnext/selling/doctype/customer/customer.py +164,Credit limit has been crossed for customer {0} {1}/{2},Credit grænsen er krydset for kunde {0} {1} / {2}
apps/erpnext/erpnext/schools/doctype/academic_term/academic_term.py +33,The Term End Date cannot be later than the Year End Date of the Academic Year to which the term is linked (Academic Year {}). Please correct the dates and try again.,"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 +468,"""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: Vehicle Service,Brake Oil,Bremse Oil
DocType: Tax Rule,Tax Type,Skat Type
apps/erpnext/erpnext/controllers/taxes_and_totals.py +555,Taxable Amount,Skattepligtigt beløb
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +160,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: BOM,Item Image (if not slideshow),Varebillede (hvis ikke lysbilledshow)
apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.py +20,An Customer exists with same name,En Kunde eksisterer med samme navn
DocType: Production Order Operation,(Hour Rate / 60) * Actual Operation Time,(Timesats / 60) * TidsforbrugIMinutter
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1055,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 +913,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 +38,The holiday on {0} is not between From Date and To Date,Ferien på {0} er ikke mellem Fra dato og Til dato
DocType: Student Log,Student Log,Student Log
DocType: Quality Inspection,Get Specification Details,Hent specifikationer
apps/erpnext/erpnext/config/buying.py +165,Templates of supplier standings.,Skabeloner af leverandørplaceringer.
DocType: Lead,Interested,Interesseret
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +171,Opening,Åbning
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +28,From {0} to {1},Fra {0} til {1}
DocType: Item,Copy From Item Group,Kopier fra varegruppe
DocType: Journal Entry,Opening Entry,Åbningsbalance
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +25,Account Pay Only,Konto Pay Kun
DocType: Employee 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 +141,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: Academic Term,Schools,Skoler
DocType: School Settings,Validate Batch for Students in Student Group,Valider batch for studerende i studentegruppe
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +35,No leave record found for employee {0} for {1},Ingen orlov rekord fundet for medarbejderen {0} for {1}
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 +358,Please select Company first,Vælg venligst firma først
DocType: Employee Education,Under Graduate,Under Graduate
apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.js +27,Target On,Target On
DocType: BOM,Total Cost,Omkostninger i alt
DocType: Journal Entry Account,Employee Loan,Medarbejderlån
apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.js +108,Activity Log:,Aktivitet Log:
DocType: Fee Schedule,Send Payment Request Email,Send betalingsanmodning e-mail
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +250,Item {0} does not exist in the system or has expired,Vare {0} findes ikke i systemet eller er udløbet
apps/erpnext/erpnext/setup/setup_wizard/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/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 +234,"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
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +51,Duplicate customer group found in the cutomer group table,Doppelt kundegruppe forefindes i Kundegruppetabellen
apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +31,Supplier Type / Supplier,Leverandørtype / leverandør
DocType: Naming Series,Prefix,Præfiks
apps/erpnext/erpnext/hr/email_alert/training_scheduled/training_scheduled.html +7,Event Location,Event Location
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +64,Consumable,Forbrugsmaterialer
DocType: Employee,B-,B-
DocType: Upload Attendance,Import Log,Import-log
DocType: Production Planning Tool,Pull Material Request of type Manufacture based on the above criteria,Hent materialeanmodning af typen Fremstilling på grundlag af de ovennævnte kriterier
DocType: Training Result Employee,Grade,Grad
DocType: Sales Invoice Item,Delivered By Supplier,Leveret af Leverandøren
DocType: SMS Center,All Contact,Alle Kontakt
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +901,Production Order already created for all items with BOM,Produktionsordre allerede skabt for alle poster med BOM
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +220,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 +357,{0} {1} is frozen,{0} {1} er frosset
apps/erpnext/erpnext/setup/doctype/company/company.py +136,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 +80,Stock Expenses,Stock Udgifter
apps/erpnext/erpnext/stock/doctype/batch/batch.js +91,Select Target Warehouse,Vælg Target Warehouse
apps/erpnext/erpnext/hr/doctype/employee/employee.js +80,Please enter Preferred Contact Email,Indtast foretrukket kontakt e-mail
DocType: Program Enrollment,School Bus,Skolebus
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
apps/erpnext/erpnext/schools/doctype/student_attendance_tool/student_attendance_tool.js +135,"Do you want to update attendance?<br>Present: {0}\
					<br>Absent: {1}",Ønsker du at opdatere fremmøde? <br> Present: {0} \ <br> Fraværende: {1}
apps/erpnext/erpnext/controllers/buying_controller.py +325,Accepted + Rejected Qty must be equal to Received quantity for Item {0},Accepteret + Afvist skal være lig med Modtaget mængde for vare {0}
DocType: Request for Quotation,RFQ-,AT-
DocType: Item,Supply Raw Materials for Purchase,Supply råstoffer til Indkøb
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +149,At least one mode of payment is required for POS invoice.,Mindst én form for betaling er nødvendig for POS faktura.
DocType: Products Settings,Show Products as a List,Vis produkterne på en liste
DocType: Upload Attendance,"Download the Template, fill appropriate data and attach the modified file.
All dates and employee combination in the selected period will come in the template, with existing attendance records","Download skabelon, fylde relevante data og vedhæfte den ændrede fil. Alle datoer og medarbejder kombination i den valgte periode vil komme i skabelonen, med eksisterende fremmøde optegnelser"
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +482,Item {0} is not active or end of life has been reached,Vare {0} er ikke aktiv eller slutningen af livet er nået
apps/erpnext/erpnext/utilities/user_progress.py +169,Example: Basic Mathematics,Eksempel: Grundlæggende Matematik
apps/erpnext/erpnext/controllers/accounts_controller.py +657,"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"
apps/erpnext/erpnext/config/hr.py +214,Settings for HR Module,Indstillinger for HR modul
DocType: SMS Center,SMS Center,SMS-center
DocType: Sales Invoice,Change Amount,ændring beløb
DocType: BOM Update Tool,New BOM,Ny stykliste
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +117,Please enter Delivery Date,Indtast venligst Leveringsdato
DocType: Depreciation Schedule,Make Depreciation Entry,Foretag Afskrivninger indtastning
DocType: Appraisal Template Goal,KRA,KRA
DocType: Lead,Request Type,Anmodningstype
apps/erpnext/erpnext/hr/doctype/offer_letter/offer_letter.js +17,Make Employee,Opret medarbejder
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +14,Broadcasting,Broadcasting
apps/erpnext/erpnext/utilities/user_progress.py +206,Add Rooms,Tilføj værelser
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +187,Execution,Udførelse
apps/erpnext/erpnext/config/manufacturing.py +62,Details of the operations carried out.,Oplysninger om de gennemførte transaktioner.
DocType: Serial No,Maintenance Status,Vedligeholdelsesstatus
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 Betales 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: Drug Prescription,Interval,Interval
DocType: Customer,Individual,Privatperson
DocType: Interest,Academics User,akademikere Bruger
DocType: Cheque Print Template,Amount In Figure,Beløb I figur
DocType: Employee 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: POS Profile,Customer Groups,Kundegrupper
apps/erpnext/erpnext/public/js/financial_statements.js +51,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: Physician 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
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 (%)
DocType: Offer Letter,Select Terms and Conditions,Vælg betingelser
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +60,Out Value,Out Value
DocType: Production Planning Tool,Sales Orders,Salgsordrer
DocType: Purchase Taxes and Charges,Valuation,Værdiansættelse
,Purchase Order Trends,Indkøbsordre Trends
apps/erpnext/erpnext/utilities/user_progress.py +75,Go to Customers,Gå til kunder
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
apps/erpnext/erpnext/config/hr.py +81,Allocate leaves for the year.,Afsætte blade for året.
DocType: SG Creation Tool Course,SG Creation Tool Course,SG Creation Tool Course
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +236,Insufficient Stock,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 Guarantee,Bank Account,Bankkonto
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;
DocType: Employee,Create User,Opret bruger
DocType: Selling Settings,Default Territory,Standardområde
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +53,Television,Fjernsyn
DocType: Production Order Operation,Updated via 'Time Log',Opdateret via &#39;Time Log&#39;
apps/erpnext/erpnext/controllers/taxes_and_totals.py +427,Advance amount cannot be greater than {0} {1},Advance beløb kan ikke være større end {0} {1}
DocType: Naming Series,Series List for this Transaction,Serie Liste for denne transaktion
DocType: Company,Enable Perpetual Inventory,Aktiver evigt lager
DocType: Company,Default Payroll Payable Account,Standard Payroll Betales konto
apps/erpnext/erpnext/schools/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: Supplier Scorecard,Criteria Setup,Kriterier opsætning
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +179,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: Sales Partner,Reseller,Forhandler
DocType: Codification Table,Medical Code,Medicinsk kode
DocType: Production Planning Tool,"If checked, Will include non-stock items in the Material Requests.","Hvis markeret, vil ikke-lagervarer i materialeanmodningerne blive medtaget."
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +24,Please enter Company,Indtast firma
DocType: Delivery Note Item,Against Sales Invoice Item,Mod salgsfakturavarer
,Production Orders in Progress,Igangværende produktionsordrer
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +39,Net Cash from Financing,Netto kontant fra Finansiering
apps/erpnext/erpnext/accounts/page/pos/pos.js +2329,"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
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +105,Add Item,Tilføj vare
DocType: Lab Test,Custom Result,Brugerdefineret resultat
apps/erpnext/erpnext/utilities/user_progress.py +71,Contact Name,Kontaktnavn
DocType: Course Assessment Criteria,Course Assessment Criteria,Kriterier for kursusvurdering
DocType: Process Payroll,Creates salary slip for above mentioned criteria.,Opretter lønseddel i henhold til ovennævnte kriterier.
DocType: POS Customer Group,POS Customer Group,Kassesystem-kundegruppe
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/schools/report/course_wise_assessment_report/course_wise_assessment_report.html +11,Assessment Plan: ,Vurderingsplan:
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: 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
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +385,Net Pay cannot be less than 0,Nettoløn kan ikke være mindre end 0
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +224,Only the selected Leave Approver can submit this Leave Application,Kun den valgte fraværsgodkender kan godkende denne fraværsansøgning
apps/erpnext/erpnext/hr/doctype/employee/employee.py +116,Relieving Date must be greater than Date of Joining,Fratrædelsesdato skal være større end ansættelsesdato
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +228,Leaves per Year,Fravær pr. år
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +130,Row {0}: Please check 'Is Advance' against Account {1} if this is an advance entry.,"Række {0}: Tjek venligst &quot;Er Advance &#39;mod konto {1}, hvis dette er et forskud post."
apps/erpnext/erpnext/stock/utils.py +212,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 +126,Litre,liter
DocType: Task,Total Costing Amount (via Time Sheet),Totale omkostninger (via tidsregistrering)
DocType: Item Website Specification,Item Website Specification,Varebeskrivelse til hjemmesiden
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +477,Leave Blocked,Fravær blokeret
apps/erpnext/erpnext/stock/doctype/item/item.py +691,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 +88,Bank Entries,Bank Entries
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +119,Annual,Årligt
DocType: Stock Reconciliation Item,Stock Reconciliation Item,Lagerafstemningsvare
DocType: Stock Entry,Sales Invoice No,Salgsfakturanr.
DocType: Material Request Item,Min Order Qty,Min prisen evt
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 +189,People who teach at your organisation,"Mennesker, der underviser i din organisation"
DocType: Purchase Invoice,The unique id for tracking all recurring invoices. It is generated on submit.,Den unikke id til at spore alle tilbagevendende fakturaer. Det genereres på send.
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +131,Software Developer,Software Developer
DocType: Item,Minimum Order Qty,Minimum Antal
DocType: Pricing Rule,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 +711,Item {0} is cancelled,Vare {0} er aflyst
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +903,Material Request,Materialeanmodning
DocType: Bank Reconciliation,Update Clearance Date,Opdatering Clearance Dato
DocType: Item,Purchase Details,Indkøbsdetaljer
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +357,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: Patient Relation,Relation,Relation
DocType: Shipping Rule,Worldwide Shipping,Levering til hele verden
DocType: Patient Relation,Mother,Mor
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/schools/doctype/fees/fees.py +79,Payment request {0} created,Betalingsanmodning {0} oprettet
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: Healthcare Settings,Create documents for sample collection,Opret dokumenter til prøveindsamling
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +276,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}
DocType: Supplier,Address HTML,Adresse HTML
DocType: Lead,Mobile No.,Mobiltelefonnr.
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 +146,Please select Charge Type first,Vælg Charge Type først
DocType: Student Group Student,Student Group Student,Elev i elevgruppe
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41,Latest,Seneste
DocType: Vehicle Service,Inspection,Kontrol
DocType: Supplier Scorecard Scoring Standing,Max Grade,Max Grade
DocType: Email Digest,New Quotations,Nye tilbud
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: Employee,The first Leave Approver in the list will be set as the default Leave Approver,"Den første fraværsgodkender i listen, vil blive markeret som standard-fraværsgodkender"
DocType: Tax Rule,Shipping County,Anvendes ikke
apps/erpnext/erpnext/config/desktop.py +158,Learn,Hjælp
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 +663,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.
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: Vehicle,Fleet Manager,Fleet manager
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +517,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 +80,Wrong Password,Forkert adgangskode
DocType: Item,Variant Of,Variant af
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +367,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
DocType: Physician,Time per Appointment,Tid pr. Ansættelse
apps/erpnext/erpnext/projects/doctype/task/task.py +99,Circular Reference Error,Cirkulær reference Fejl
DocType: Appointment Type,Is Inpatient,Er sygeplejerske
apps/erpnext/erpnext/schools/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 / Warehouse / {2})
DocType: Lead,Industry,Branche
DocType: Employee,Job Profile,Stillingsprofil
DocType: BOM Item,Rate & Amount,Pris &amp; Beløb
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +88,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Venligst opsæt nummereringsserier for Tilstedeværelse via Opsætning&gt; Nummereringsserie
apps/erpnext/erpnext/setup/doctype/company/company_dashboard.py +6,This is based on transactions against this Company. See timeline below for details,Dette er baseret på transaktioner mod denne virksomhed. Se tidslinjen nedenfor for detaljer
DocType: Stock Settings,Notify by Email on creation of automatic Material Request,Give besked på e-mail om oprettelse af automatiske materialeanmodninger
DocType: Journal Entry,Multi Currency,Multi Valuta
DocType: Payment Reconciliation Invoice,Invoice Type,Fakturatype
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +51,Customer &gt; Customer Group &gt; Territory,Kunde&gt; Kundegruppe&gt; Territorium
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +865,Delivery Note,Følgeseddel
DocType: Consultation,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 +131,Cost of Sold Asset,Udgifter Solgt Asset
apps/erpnext/erpnext/accounts/utils.py +345,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."
apps/erpnext/erpnext/stock/doctype/item/item.py +437,{0} entered twice in Item Tax,{0} indtastet to gange i varemoms
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +114,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 +81,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/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +85,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
apps/erpnext/erpnext/config/accounts.py +27,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 +55,This Item is a Template and cannot be used in transactions. Item attributes will be copied over into the variants unless 'No Copy' is set,"Dette element er en skabelon, og kan ikke anvendes i transaktioner. Item attributter kopieres over i varianterne medmindre &#39;Ingen Copy &quot;er indstillet"
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +69,Total Order Considered,Samlet Order Anses
apps/erpnext/erpnext/config/hr.py +234,"Employee designation (e.g. CEO, Director etc.).","Medarbejderbetegnelse (fx CEO, direktør osv.)"
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 +558,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}
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +189,[Urgent] Error while creating recurring %s for %s,[Urgent] Fejl under oprettelse af tilbagevendende% s for% s
DocType: Item Tax,Tax Rate,Skat
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +59,{0} already allocated for Employee {1} for period {2} to {3},{0} allerede afsat til Medarbejder {1} for perioden {2} til {3}
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +870,Select Item,Vælg Item
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +140,Purchase Invoice {0} is already submitted,Købsfaktura {0} er allerede godkendt
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +91,Row # {0}: Batch No must be same as {1} {2},Række # {0}: Partinr. skal være det samme som {1} {2}
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +52,Convert to non-Group,Konverter til ikke-Group
apps/erpnext/erpnext/config/stock.py +127,Batch (lot) of an Item.,Batch (parti) af en vare.
DocType: C-Form Invoice Detail,Invoice Date,Fakturadato
DocType: GL Entry,Debit Amount,Debetbeløb
apps/erpnext/erpnext/accounts/party.py +246,There can only be 1 Account per Company in {0} {1},Der kan kun være 1 konto pr. firma i {0} {1}
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +402,Please see attachment,Se venligst vedhæftede fil
DocType: Purchase Order,% Received,% Modtaget
apps/erpnext/erpnext/schools/doctype/student_group_creation_tool/student_group_creation_tool.js +3,Create Student Groups,Opret Elevgrupper
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +23,Setup Already Complete!!,Opsætning Allerede Complete !!
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +24,Credit Note Amount,Kredit Note Beløb
DocType: Setup Progress Action,Action Document,Handlingsdokument
,Finished Goods,Færdigvarer
DocType: Delivery Note,Instructions,Instruktioner
DocType: Quality Inspection,Inspected By,Kontrolleret af
DocType: Maintenance Visit,Maintenance Type,Vedligeholdelsestype
apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +40,{0} - {1} is not enrolled in the Course {2},{0} - {1} er ikke tilmeldt kurset {2}
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +48,Item Code &gt; Item Group &gt; Brand,Varenummer&gt; Varegruppe&gt; Mærke
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/templates/pages/demo.html +47,ERPNext Demo,ERPNext Demo
apps/erpnext/erpnext/public/js/utils/item_selector.js +12,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
apps/erpnext/erpnext/config/hr.py +116,"Earnings, Deductions and other Salary components","Tillæg, fradrag og andre lønarter"
DocType: Packed Item,Packed Item,Pakket vare
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/schools/doctype/program_enrollment_tool/program_enrollment_tool.py +14,Mandatory field - Get Students From,Obligatorisk felt - Få studerende fra
DocType: Program Enrollment,Enrolled courses,Indskrevne kurser
DocType: Currency Exchange,Currency Exchange,Valutaveksling
DocType: Asset,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
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 +1531,Create a new Customer,Opret ny kunde
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +59,"If multiple Pricing Rules continue to prevail, users are asked to set Priority manually to resolve conflict.","Hvis flere 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
DocType: Course Scheduling Tool,Rechedule,Rechedule
DocType: Landed Cost Item,Applicable Charges,Gældende gebyrer
DocType: Workstation,Consumable Cost,Forbrugsmaterialer Cost
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +220,{0} ({1}) must have role 'Leave Approver',"{0} ({1}), skal have rollen 'Godkendelse af fravær'"
DocType: Purchase Receipt,Vehicle Date,Køretøj dato
DocType: Student Log,Medical,Medicinsk
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +177,Reason for losing,Tabsårsag
apps/erpnext/erpnext/crm/doctype/lead/lead.py +41,Lead Owner cannot be same as the Lead,Emneejer kan ikke være den samme som emnet
apps/erpnext/erpnext/accounts/utils.py +351,Allocated amount can not greater than unadjusted amount,Allokeret beløb kan ikke større end ikke-justerede beløb
DocType: Announcement,Receiver,Modtager
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 +32,Opportunities,Salgsmuligheder
DocType: Lab Test Template,Single,Enkeltværelse
DocType: Salary Slip,Total Loan Repayment,Samlet lån til tilbagebetaling
DocType: Account,Cost of Goods Sold,Vareforbrug
DocType: Purchase Invoice,Yearly,Årlig
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +228,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 +70,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 +209,Classrooms/ Laboratories etc where lectures can be scheduled.,Klasseværelser / Laboratorier osv hvor foredrag kan planlægges.
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +46,Please enter company name first,Indtast venligst firmanavn først
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: Account,Is Group,Er en kontogruppe
DocType: Email Digest,Pending Purchase Orders,Afventende indkøbsordrer
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
DocType: Vehicle Service,Oil Change,Olieskift
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.'
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +142,Non Profit,Non Profit
DocType: Production Order,Not Started,Ikke igangsat
DocType: Lead,Channel Partner,Channel Partner
DocType: Account,Old Parent,Gammel Parent
apps/erpnext/erpnext/schools/doctype/program_enrollment_tool/program_enrollment_tool.py +18,Mandatory field - Academic Year,Obligatorisk felt - skoleår
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/hr/doctype/expense_claim/expense_claim.py +157,Please set default payable account for the company {0},Indtast venligst standardbetalt konto for virksomheden {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 +653,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
apps/erpnext/erpnext/config/hr.py +70,Holiday master.,Ferie mester.
DocType: Request for Quotation Item,Required Date,Forfaldsdato
DocType: Delivery Note,Billing Address,Faktureringsadresse
DocType: BOM,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
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +48,Total Qty,Antal i alt
apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +62,Guardian2 Email ID,Guardian2 Email ID
DocType: Item,Show in Website (Variant),Vis på hjemmesiden (Variant)
DocType: Employee,Health Concerns,Sundhedsmæssige betænkeligheder
DocType: Process Payroll,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 +29,Securities and Deposits,Værdipapirer og Indlån
apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +44,"Can't change valuation method, as there are transactions against some items which does not have it's own valuation method","Kan ikke ændre værdiansættelsesmetode, da der er transaktioner mod nogle poster, der ikke har egen værdiansættelsesmetode"
apps/erpnext/erpnext/config/healthcare.py +133,Test Sample Master.,Test Prøve Master.
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +82,Total leaves allocated is mandatory,Tildelt fravær allokeret i alt er obligatorisk
DocType: Patient,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 +111,Pending activities for today,Afventende aktiviteter for i dag
apps/erpnext/erpnext/config/hr.py +24,Attendance record.,Fremmøde rekord.
DocType: Salary Structure,Salary Component for timesheet based payroll.,Lønart til tidsregistering
DocType: Sales Order Item,Used for Production Plan,Bruges til Produktionsplan
DocType: Employee Loan,Total Payment,Samlet betaling
DocType: Manufacturing Settings,Time Between Operations (in mins),Time Between Operations (i minutter)
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +134,{0} {1} is cancelled so the action cannot be completed,"{0} {1} er 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
DocType: Patient,Allergies,allergier
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +30,The selected BOMs are not for the same item,De valgte styklister er ikke for den samme vare
DocType: Supplier Scorecard Standing,Notify Other,Underret Andet
DocType: Vital Signs,Blood Pressure (systolic),Blodtryk (systolisk)
DocType: Pricing Rule,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 +64,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.
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py +21,Enough Parts to Build,Nok Dele til Build
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +128,Direct Income,Direkte indkomst
DocType: Patient Appointment,Date TIme,Dato Tid
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +36,"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/install_fixtures.py +126,Administrative Officer,Kontorfuldmægtig
apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +21,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 +342,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 +46,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 +434,Please enter Warehouse for which Material Request will be raised,Indtast venligst lager for hvilket materialeanmodning vil blive rejst
DocType: Production Order,Additional Operating Cost,Yderligere driftsomkostninger
DocType: Lab Test Template,Lab Routine,Lab Rutine
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +20,Cosmetics,Kosmetik
apps/erpnext/erpnext/stock/doctype/item/item.py +534,"To merge, following properties must be same for both items","At fusionere, skal følgende egenskaber være ens for begge poster"
DocType: Shipping Rule,Net Weight,Nettovægt
DocType: Employee,Emergency Phone,Emergency Phone
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 +159,Student Application,Student ansøgning
apps/erpnext/erpnext/schools/doctype/grading_scale/grading_scale.py +20,Please define grade for Threshold 0%,Angiv venligst lønklasse for Tærskel 0%
DocType: Sales Order,To Deliver,Til at levere
DocType: Purchase Invoice Item,Item,Vare
apps/erpnext/erpnext/accounts/page/pos/pos.js +2501,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: Account,Profit and Loss,Resultatopgørelse
DocType: Patient,Risk Factors,Risikofaktorer
DocType: Patient,Occupational Hazards and Environmental Factors,Arbejdsfarer og miljøfaktorer
DocType: Vital Signs,Respiratory rate,Respirationsfrekvens
apps/erpnext/erpnext/config/stock.py +330,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/config/projects.py +23,Define Project type.,Definer projekttype.
DocType: Supplier Scorecard,Weighting Function,Vægtningsfunktion
DocType: Physician,OP Consulting Charge,OP Consulting Charge
apps/erpnext/erpnext/utilities/user_progress.py +25,Setup your ,Opsæt din
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 +62,Account {0} does not belong to company: {1},Konto {0} tilhører ikke virksomheden: {1}
apps/erpnext/erpnext/setup/doctype/company/company.py +51,Abbreviation already used for another company,Forkortelse allerede brugt til et andet selskab
DocType: Selling Settings,Default Customer Group,Standard kundegruppe
DocType: Global Defaults,"If disable, 'Rounded Total' field will not be visible in any transaction","Hvis deaktivere, &#39;Afrundet Total&#39; felt, vil ikke være synlig i enhver transaktion"
DocType: BOM,Operating Cost,Driftsomkostninger
DocType: Sales Order Item,Gross Profit,Gross Profit
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +49,Increment cannot be 0,Tilvækst kan ikke være 0
DocType: Production Planning Tool,Material Requirement,Material Requirement
DocType: Company,Delete Company Transactions,Slet Company Transaktioner
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +345,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
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +158,"Cannot delete Serial No {0}, as it is used in stock transactions","Kan ikke slette serienummer {0}, eftersom det bruges på lagertransaktioner"
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +246,Closing (Cr),Lukning (Cr)
apps/erpnext/erpnext/hr/email_alert/training_feedback/training_feedback.html +1,Hello,Hej
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +105,Move Item,Flyt vare
DocType: Serial No,Warranty Period (Days),Garantiperiode (dage)
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 +361,{0} {1} is not active,{0} {1} er ikke aktiv
apps/erpnext/erpnext/config/accounts.py +285,Setup cheque dimensions for printing,Anvendes ikke
DocType: Salary Slip,Salary Slip Timesheet,Lønseddel Timeseddel
apps/erpnext/erpnext/controllers/buying_controller.py +157,Supplier Warehouse mandatory for sub-contracted Purchase Receipt,Leverandør Warehouse obligatorisk for underentreprise købskvittering
DocType: Pricing Rule,Valid From,Gyldig fra
DocType: Sales Invoice,Total Commission,Samlet provision
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
apps/erpnext/erpnext/stock/doctype/item/item.py +131,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 +142,No records found in the Invoice table,Ingen poster i faktureringstabellen
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js +17,Please select Company and Party Type first,Vælg Company og Party Type først
apps/erpnext/erpnext/config/accounts.py +301,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 +162,"Sorry, Serial Nos cannot be merged","Beklager, serienumre kan ikke blive slået sammen"
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +63,Territory is Required in POS Profile,Område er påkrævet i POS-profil
DocType: Supplier,Prevent RFQs,Forebygg RFQs
apps/erpnext/erpnext/utilities/activation.py +83,Make Sales Order,Opret salgsordre
DocType: Project Task,Project Task,Sagsopgave
,Lead Id,Emne-Id
DocType: C-Form Invoice Detail,Grand Total,Beløb i alt
DocType: Training Event,Course,Kursus
DocType: Timesheet,Payslip,Lønseddel
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: C-Form,IV,IV
apps/erpnext/erpnext/templates/pages/order.html +76,Delivered: {0},Leveret: {0}
DocType: Expense Claim,Payable Account,Betales konto
DocType: Payment Entry,Type of Payment,Betalingsmåde
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/stock/doctype/delivery_note/delivery_note.js +804,Sales Return,Salg Return
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +96,Note: Total allocated leaves {0} shouldn't be less than already approved leaves {1} for the period,Bemærk: I alt tildelt blade {0} bør ikke være mindre end allerede godkendte blade {1} for perioden
,Total Stock Summary,Samlet lageroversigt
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
DocType: Lead,Middle Income,Midterste indkomst
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +218,Opening (Cr),Åbning (Cr)
apps/erpnext/erpnext/stock/doctype/item/item.py +817,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 +349,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: 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.
DocType: Repayment Schedule,Principal Amount,hovedstol
DocType: Employee Loan Application,Total Payable Interest,Samlet Betales Renter
apps/erpnext/erpnext/schools/doctype/fee_schedule/fee_schedule.js +59,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 +118,Reference No & Reference Date is required for {0},Referencenummer &amp; Reference Dato er nødvendig for {0}
DocType: Process Payroll,Select Payment Account to make Bank Entry,Vælg Betalingskonto til bankbetalingerne
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/config/healthcare.py +118,Prescription Period,Receptperiode
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +186,Proposal Writing,Forslag Skrivning
DocType: Payment Entry Deduction,Payment Entry Deduction,Betaling indtastning Fradrag
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +35,Another Sales Person {0} exists with the same Employee id,En anden salgsmedarbejder {0} eksisterer med samme Medarbejder-id
DocType: Production Planning Tool,"If checked, raw materials for items that are sub-contracted will be included in the Material Requests","Hvis markeret, vil råmaterialer til varer, der er i underentreprise indgå i materialeanmodningerne"
apps/erpnext/erpnext/config/healthcare.py +61,Masters,Masters
DocType: Assessment Plan,Maximum Assessment Score,Maksimal Score Assessment
apps/erpnext/erpnext/config/accounts.py +146,Update Bank Transaction Dates,Opdatering Bank transaktionstidspunkterne
apps/erpnext/erpnext/config/projects.py +35,Time Tracking,Tidsregistrering
DocType: Purchase Invoice,DUPLICATE FOR TRANSPORTER,DUPLICERER FOR TRANSPORTØR
DocType: Fiscal Year Company,Fiscal Year Company,Fiscal År Company
DocType: Packing Slip Item,DN Detail,DN Detail
DocType: Training Event,Conference,Konference
DocType: Timesheet,Billed,Billed
DocType: Batch,Batch Description,Partibeskrivelse
apps/erpnext/erpnext/schools/doctype/student_group_creation_tool/student_group_creation_tool.js +12,Creating student groups,Oprettelse af elevgrupper
apps/erpnext/erpnext/accounts/utils.py +723,"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
DocType: Sales Invoice,Sales Taxes and Charges,Salg Moms og afgifter
DocType: Employee,Organization Profile,Organisationsprofil
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 +101,Automatically triggers the feedback request based on conditions.,udløser automatisk feedback anmodning baseret på betingelser.
DocType: Employee,Reason for Resignation,Årsag til Udmeldelse
apps/erpnext/erpnext/config/hr.py +147,Template for performance appraisals.,Skabelon til præstationsvurderinger.
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 +83,{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/accounts/doctype/asset_movement/asset_movement.py +21,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 +36,"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."
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +24,Net Change in Inventory,Netto Ændring i Inventory
apps/erpnext/erpnext/config/hr.py +157,Employee Loan Management,Medarbejder Lån Management
DocType: Employee,Passport Number,Pasnummer
apps/erpnext/erpnext/schools/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/install_fixtures.py +120,Manager,Leder
DocType: Payment Entry,Payment From / To,Betaling fra/til
apps/erpnext/erpnext/selling/doctype/customer/customer.py +127,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/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: Installation Note,IN-,I-
DocType: Production Order Operation,In minutes,I minutter
DocType: Issue,Resolution Date,Løsningsdato
DocType: Lab Test Template,Compound,Forbindelse
DocType: Student Batch Name,Batch Name,Partinavn
DocType: Fee Validity,Max number of visit,Maks antal besøg
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +319,Timesheet created:,Timeseddel oprettet:
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +907,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/schools/doctype/student_applicant/student_applicant.js +24,Enroll,Indskrive
DocType: GST Settings,GST Settings,GST-indstillinger
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 +56,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 +47,Delivered Amount,Leveres Beløb
DocType: Supplier,Fixed Days,Faste dage
apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +14,Lab Tests,Lab Tests
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.
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +43,Publishing,Udgivning
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 +157,{0}: {1} not found in Invoice Details table,{0}: {1} blev ikke fundet i Invoice Detaljer tabel
DocType: Company,Round Off Cost Center,Afrundningsomkostningssted
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +227,Maintenance Visit {0} must be cancelled before cancelling this Sales Order,"Vedligeholdelsesbesøg {0} skal annulleres, før den denne salgordre annulleres"
DocType: Item,Material Transfer,Materiale Transfer
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 +211,Opening (Dr),Åbning (dr)
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +39,Posting timestamp must be after {0},Udstationering tidsstempel skal være efter {0}
apps/erpnext/erpnext/config/accounts.py +39,To make recurring documents,At lave tilbagevendende dokumenter
,GST Itemised Purchase Register,GST Itemized Purchase Register
DocType: Employee Loan,Total Interest Payable,Samlet Renteudgifter
DocType: Landed Cost Taxes and Charges,Landed Cost Taxes and Charges,Landede Cost Skatter og Afgifter
DocType: Production Order Operation,Actual Start Time,Faktisk starttid
DocType: BOM Operation,Operation Time,Operation Time
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +285,Finish,Slutte
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +395,Base,Grundlag
DocType: Timesheet,Total Billed Hours,Total Billed Timer
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1187,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: Purchase Invoice,Quarterly,Kvartalsvis
DocType: Lab Test Template,Grouped,grupperet
DocType: Selling Settings,Delivery Note Required,Følgeseddel er påkrævet
DocType: Bank Guarantee,Bank Guarantee Number,Bankgaranti nummer
DocType: Assessment Criteria,Assessment Criteria,vurderingskriterier
DocType: BOM Item,Basic Rate (Company Currency),Basissats (firmavaluta)
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å
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +84,Please enter item details,Indtast venligst varedetaljer
DocType: Interest,Interest,Interesse
apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +10,Pre Sales,Pre-Sale
DocType: Purchase Receipt,Other Details,Andre detaljer
apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +18,Suplier,suplier
DocType: Lab Test,Test Template,Test skabelon
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/install_fixtures.py +105,Marketing,Marketing
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +290,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 +545,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 +377,Preview Salary Slip,Lønseddel kladde
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +54,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
DocType: Hub Settings,Seller City,Sælger By
,Absent Student Report,Ikke-tilstede studerende rapport
DocType: Email Digest,Next email will be sent on:,Næste email vil blive sendt på:
DocType: Offer Letter Term,Offer Letter Term,Ansættelsesvilkår
DocType: Supplier Scorecard,Per Week,Per uge
apps/erpnext/erpnext/stock/doctype/item/item.py +632,Item has variants.,Vare har varianter.
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/schools/doctype/fee_schedule/fee_schedule.js +41,Fee records will be created in the background. In case of any error the error message will be updated in the Schedule.,Gebyroptegnelser oprettes i baggrunden. I tilfælde af en fejl vil fejlmeddelelsen blive opdateret i skemaet.
apps/erpnext/erpnext/accounts/doctype/account/account.py +26,Company {0} does not exist,Firma {0} findes ikke
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +37,{0} has fee validity till {1},{0} har gebyrgyldighed indtil {1}
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +57,Tree Type,Tree Type
DocType: BOM Explosion Item,Qty Consumed Per Unit,Antal Consumed Per Unit
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/schools/doctype/student_group/student_group.py +23,Please select Program,Vælg venligst Program
DocType: Project,Estimated Cost,Anslåede omkostninger
DocType: Purchase Order,Link to material requests,Link til materialeanmodninger
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +7,Aerospace,Aerospace
DocType: Journal Entry,Credit Card Entry,Credit Card indtastning
apps/erpnext/erpnext/config/accounts.py +57,Company and Accounts,Firma og regnskab
apps/erpnext/erpnext/config/healthcare.py +108,Appointment Type Master,Udnævnelsestype Master
apps/erpnext/erpnext/config/stock.py +22,Goods received from Suppliers.,Varer modtaget fra leverandører.
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +58,In Value,I Value
DocType: Lead,Campaign Name,Kampagne Navn
DocType: Selling Settings,Close Opportunity After Days,Luk salgsmulighed efter dage
,Reserved,Reserveret
DocType: Purchase Order,Supply Raw Materials,Supply råmaterialer
DocType: Purchase Invoice,The date on which next invoice will be generated. It is generated on submit.,"Datoen, hvor den næste faktura vil blive dannet. Den dannes ved godkendelsen."
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 +94,{0} is not a stock Item,{0} er ikke en lagervare
apps/erpnext/erpnext/hr/email_alert/training_feedback/training_feedback.html +6,Please share your feedback to the training by clicking on 'Training Feedback' and then 'New',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
DocType: Payment Entry,Received Amount (Company Currency),Modtaget beløb (firmavaluta)
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +174,Lead must be set if Opportunity is made from Lead,"""Er emne"" skal markeres, hvis salgsmulighed er lavet fra emne"
apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +29,Please select weekly off day,Vælg ugentlig fridag
DocType: Patient,O Negative,O Negativ
DocType: Production 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 +96,Account with existing transaction cannot be converted to ledger,Konto med eksisterende transaktion kan ikke konverteres til finans
DocType: Delivery Note,Customer's Purchase Order No,Kundens Indkøbsordre Nej
DocType: Budget,Budget Against,Budget Against
DocType: Employee,Cell Number,Mobiltelefonnr.
apps/erpnext/erpnext/stock/reorder_item.py +177,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 +152,You can not enter current voucher in 'Against Journal Entry' column,"Du kan ikke indtaste det aktuelle bilag i ""Mod Kassekladde 'kolonne"
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +50,Reserved for manufacturing,Reserveret til fremstilling
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +25,Energy,Energi
DocType: Opportunity,Opportunity From,Salgsmulighed fra
apps/erpnext/erpnext/config/hr.py +98,Monthly salary statement.,Månedlige lønseddel.
apps/erpnext/erpnext/utilities/user_progress.py +23,Add Company,Tilføj firma
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +875,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}.
DocType: BOM,Website Specifications,Website Specifikationer
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +59,{0} is an invalid email address in 'Recipients',{0} er en ugyldig e-mail-adresse i &#39;Modtagere&#39;
DocType: Special Test Items,Particulars,Oplysninger
apps/erpnext/erpnext/config/healthcare.py +143,Antibiotic.,Antibiotikum.
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +24,{0}: From {0} of type {1},{0}: Fra {0} af typen {1}
DocType: Warranty Claim,CI-,Cl-
apps/erpnext/erpnext/controllers/buying_controller.py +291,Row {0}: Conversion Factor is mandatory,Række {0}: konverteringsfaktor er obligatorisk
DocType: Employee,A+,A +
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +326,"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}"
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +495,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"
DocType: Opportunity,Maintenance,Vedligeholdelse
DocType: Item Attribute Value,Item Attribute Value,Item Attribut Værdi
apps/erpnext/erpnext/config/selling.py +158,Sales campaigns.,Salgskampagner.
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +109,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: Bank Guarantee,Project,Sag
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: 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/physician_schedule/physician_schedule.js +26,Add Timeslots,Tilføj Timeslots
apps/erpnext/erpnext/accounts/doctype/asset/depreciation.py +138,Asset scrapped via Journal Entry {0},Anlægsasset er kasseret via finanspost {0}
DocType: Employee Loan,Interest Income Account,Renter Indkomst konto
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +13,Biotechnology,Bioteknologi
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +109,Office Maintenance Expenses,Kontorholdudgifter
apps/erpnext/erpnext/utilities/user_progress.py +51,Go to ,Gå til
apps/erpnext/erpnext/config/learn.py +47,Setting up Email Account,Opsætning Email-konto
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.js +114,Please enter Item first,Indtast vare først
DocType: Account,Liability,Passiver
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +186,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}.
DocType: Company,Default Cost of Goods Sold Account,Standard vareforbrug konto
apps/erpnext/erpnext/stock/get_item_details.py +310,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 +205,Warning: Invalid Attachment {0},Advarsel: ugyldig vedhæftet fil {0}
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +755,No Permission,Ingen tilladelse
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 +50,"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 +48,'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 +125,Nos,Nos
DocType: Item,Items with higher weightage will be shown higher,Elementer med højere weightage vises højere
DocType: Bank Reconciliation Detail,Bank Reconciliation Detail,Bank Afstemning Detail
apps/erpnext/erpnext/controllers/accounts_controller.py +549,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: Subscription,Stopped,Stoppet
DocType: Item,If subcontracted to a vendor,Hvis underentreprise til en sælger
apps/erpnext/erpnext/schools/doctype/student_group/student_group.js +111,Student Group is already updated.,Studentgruppen er allerede opdateret.
DocType: SMS Center,All Customer Contact,Alle kundekontakter
apps/erpnext/erpnext/config/stock.py +158,Upload stock balance via csv.,Upload lager balance via csv.
DocType: Warehouse,Tree Details,Tree Detaljer
DocType: Training Event,Event Status,begivenhed status
,Support Analytics,Supportanalyser
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +352,"If you have any questions, please get back to us.","Hvis du har spørgsmål, er du velkommen til at kontakte os."
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 +111,{0} {1}: Cost Center {2} does not belong to Company {3},{0} {1}: omkostningssted {2} tilhører ikke firma {3}
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +88,{0} {1}: Account {2} cannot be a Group,{0} {1}: Konto {2} kan ikke være en gruppe
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +63,Item Row {idx}: {doctype} {docname} does not exist in above '{doctype}' table,Item Row {IDX}: {doctype} {DOCNAME} findes ikke i ovenstående &#39;{doctype}&#39; tabel
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +289,Timesheet {0} is already completed or cancelled,Tidsregistreringskladde {0} er allerede afsluttet eller annulleret
apps/erpnext/erpnext/templates/pages/projects.html +42,No tasks,Ingen opgaver
DocType: Purchase Invoice,"The day of the month on which auto invoice will be generated e.g. 05, 28 etc","Den dag i den måned, hvor auto faktura vil blive genereret f.eks 05, 28 osv"
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 +49,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 +338,C-Form records,C-Form optegnelser
apps/erpnext/erpnext/config/selling.py +311,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 +354,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: Setup Progress Action,Action Doctype,Handling Doctype
,Production Order Stock Report,Produktionsordre Stock Report
apps/erpnext/erpnext/config/healthcare.py +148,Sensitivity Naming.,Følsomhedsnavngivning.
DocType: HR Settings,Retirement Age,Pensionsalder
DocType: Bin,Moving Average Rate,Glidende gennemsnit Rate
DocType: Production Planning Tool,Select Items,Vælg varer
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +372,{0} against Bill {1} dated {2},{0} mod regning {1} dateret {2}
apps/erpnext/erpnext/utilities/user_progress.py +24,Setup Institution,Opsætningsinstitution
DocType: Program Enrollment,Vehicle/Bus Number,Køretøj / busnummer
apps/erpnext/erpnext/schools/doctype/course/course.js +17,Course Schedule,Kursusskema
DocType: Request for Quotation Supplier,Quote Status,Citat Status
DocType: Maintenance Visit,Completion Status,Afslutning status
DocType: HR Settings,Enter retirement age in years,Indtast pensionsalderen i år
apps/erpnext/erpnext/accounts/doctype/asset/asset.js +263,Target Warehouse,Target Warehouse
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +108,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: Stock Entry,STE-,Ste-
DocType: Upload Attendance,Import Attendance,Importér fremmøde
apps/erpnext/erpnext/public/js/pos/pos.html +115,All Item Groups,Alle varegrupper
DocType: Process Payroll,Activity Log,Activity Log
apps/erpnext/erpnext/accounts/report/profit_and_loss_statement/profit_and_loss_statement.py +39,Net Profit / Loss,Nettoresultat
apps/erpnext/erpnext/config/setup.py +89,Automatically compose message on submission of transactions.,Automatisk skrive besked på indsendelse af transaktioner.
DocType: Production 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: 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
apps/erpnext/erpnext/stock/doctype/item/item.js +355,Item Variant {0} already exists with same attributes,Item Variant {0} findes allerede med samme attributter
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +115,'Opening','Åbner'
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +130,Open To Do,Åbn Opgaver
DocType: Notification Control,Delivery Note Message,Følgeseddelmeddelelse
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: Process Payroll,Bimonthly,Hver anden måned
DocType: Vehicle Service,Brake Pad,Bremseklods
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +115,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
DocType: Pricing Rule,Price or Discount,Pris eller rabat
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +91,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: Production Planning Tool,Only Obtain Raw Materials,Kun Opnå råstoffer
apps/erpnext/erpnext/config/hr.py +142,Performance appraisal.,Præstationsvurdering.
apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +96,"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"
apps/erpnext/erpnext/controllers/accounts_controller.py +347,"Payment Entry {0} is linked against Order {1}, check if it should be pulled as advance in this invoice.","Betaling indtastning {0} er forbundet mod Order {1}, kontrollere, om det skal trækkes forhånd i denne faktura."
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 +321,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 +119,"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: Hub Settings,Publish Pricing,Offentliggøre Pricing
DocType: Notification Control,Expense Claim Rejected Message,Udlæg afvist besked
,Available Qty,Tilgængelig Antal
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: Salary Slip,Working Days,Arbejdsdage
DocType: Serial No,Incoming Rate,Indgående sats
DocType: Packing Slip,Gross Weight,Bruttovægt
apps/erpnext/erpnext/public/js/setup_wizard.js +103,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
DocType: Job Applicant,Hold,Hold
DocType: Employee,Date of Joining,Ansættelsesdato
DocType: Naming Series,Update Series,Opdatering Series
DocType: Supplier Quotation,Is Subcontracted,Underentreprise
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 +817,Purchase Receipt,Købskvittering
,Received Items To Be Billed,Modtagne varer skal faktureres
apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +173,Submitted Salary Slips,Godkendte lønsedler
apps/erpnext/erpnext/config/accounts.py +311,Currency exchange rate master.,Valutakursen mester.
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +198,Reference Doctype must be one of {0},Henvisning Doctype skal være en af {0}
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +302,Unable to find Time Slot in the next {0} days for Operation {1},Kan ikke finde Time Slot i de næste {0} dage til Operation {1}
DocType: Production 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 +575,BOM {0} must be active,Stykliste {0} skal være aktiv
DocType: Journal Entry,Depreciation Entry,Afskrivninger indtastning
apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +36,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"
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +213,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
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +123,Warehouses with existing transaction can not be converted to ledger.,Lager med eksisterende transaktioner kan ikke konverteres til Finans.
DocType: Bank Reconciliation,Total Amount,Samlet beløb
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +32,Internet Publishing,Internet Publishing
DocType: Prescription Duration,Number,Nummer
DocType: Medical Code,Medical Code Standard,Medical Code Standard
DocType: Production Planning Tool,Production Orders,Produktionsordrer
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +62,Balance Value,Balance Value
DocType: Lab Test,Lab Technician,Laboratorie tekniker
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +38,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/hub_node/doctype/hub_settings/hub_settings.py +69,Publish to sync items,Udgive synkronisere emner
DocType: Bank Reconciliation,Account Currency,Konto Valuta
DocType: Lab Test,Sample ID,Prøve ID
apps/erpnext/erpnext/accounts/general_ledger.py +165,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 +49,Employee {0} is not active or does not exist,Medarbejder {0} er ikke aktiv eller findes ikke
DocType: Fee Structure,Components,Lønarter
apps/erpnext/erpnext/accounts/doctype/asset/asset.py +251,Please enter Asset Category in Item {0},Indtast Asset kategori i Item {0}
apps/erpnext/erpnext/stock/doctype/item/item.py +627,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 +928,Cannot {0} {1} {2} without any negative outstanding invoice,Kan ikke {0} {1} {2} uden nogen negativ udestående faktura
DocType: Purchase Invoice Advance,Purchase Invoice Advance,Købsfaktura Advance
DocType: Hub Settings,Sync Now,Synkroniser nu
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +199,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 +254,Define budget for a financial year.,Definer budget for et regnskabsår.
DocType: Mode of Payment Account,Default Bank / Cash account will be automatically updated in POS Invoice when this mode is selected.,"Standard Bank / Kontant-konto vil automatisk blive opdateret i POS faktura, når denne tilstand er valgt."
DocType: Lead,LEAD-,EMNE-
DocType: Employee,Permanent Address Is,Fast adresse
DocType: Production Order Operation,Operation completed for how many finished goods?,Operation afsluttet for hvor mange færdigvarer?
apps/erpnext/erpnext/public/js/setup_wizard.js +47,The Brand,Varemærket
DocType: Employee,Exit Interview Details,Exit Interview Detaljer
DocType: Item,Is Purchase Item,Er Indkøbsvare
DocType: Asset,Purchase Invoice,Købsfaktura
DocType: Stock Ledger Entry,Voucher Detail No,Voucher Detail Nej
apps/erpnext/erpnext/accounts/page/pos/pos.js +759,New Sales Invoice,Nye salgsfaktura
DocType: Stock Entry,Total Outgoing Value,Samlet værdi udgående
DocType: Physician,Appointments,Udnævnelser
apps/erpnext/erpnext/public/js/account_tree_grid.js +224,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
apps/erpnext/erpnext/accounts/page/pos/pos.js +772,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."
DocType: Salary Slip,Total in words,I alt i ord
DocType: Material Request Item,Lead Time Date,Leveringstid Dato
DocType: Guardian,Guardian Name,Guardian Navn
DocType: Cheque Print Template,Has Print Format,Har Print Format
DocType: Employee Loan,Sanctioned,sanktioneret
apps/erpnext/erpnext/accounts/page/pos/pos.js +73, is mandatory. Maybe Currency Exchange record is not created for ,er obligatorisk. Måske Valutaveksling rekord er ikke skabt til
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +112,Row #{0}: Please specify Serial No for Item {1},Række # {0}: Angiv serienummer for vare {1}
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +622,"For 'Product Bundle' items, Warehouse, Serial No and Batch No will be considered from the 'Packing List' table. If Warehouse and Batch No are same for all packing items for any 'Product Bundle' item, those values can be entered in the main Item table, values will be copied to 'Packing List' table.","For 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: Job Opening,Publish on website,Udgiv på hjemmesiden
apps/erpnext/erpnext/config/stock.py +17,Shipments to customers.,Forsendelser til kunder.
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +641,Supplier Invoice Date cannot be greater than Posting Date,Leverandørfakturadato kan ikke være større end bogføringsdatoen
DocType: Purchase Invoice Item,Purchase Order Item,Indkøbsordre vare
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +132,Indirect Income,Indirekte Indkomst
DocType: Student Attendance Tool,Student Attendance Tool,Student Deltagelse Tool
DocType: Cheque Print Template,Date Settings,Datoindstillinger
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +48,Variance,Varians
,Company Name,Firmaets navn
DocType: SMS Center,Total Message(s),Besked (er) i alt
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +868,Select Item for Transfer,Vælg Item for Transfer
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: 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/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 +132,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/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.
DocType: BOM,Raw Material Cost(Company Currency),Råmaterialeomkostninger (firmavaluta)
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +732,All items have already been transferred for this Production Order.,Alle varer er allerede blevet overført til denne produktionsordre.
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +87,Row # {0}: Rate cannot be greater than the rate used in {1} {2},"Row # {0}: Prisen kan ikke være større end den sats, der anvendes i {1} {2}"
apps/erpnext/erpnext/utilities/user_progress.py +126,Meter,Måler
DocType: Workstation,Electricity Cost,Elektricitetsomkostninger
DocType: HR Settings,Don't send Employee Birthday Reminders,Send ikke medarbejderfødselsdags- påmindelser
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 +48,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/accounts/doctype/asset/asset.py +85,Next Depreciation Date is entered as past date,Næste afskrivningsdato er indtastet som tidligere dato
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +204,White,Hvid
DocType: SMS Center,All Lead (Open),Alle emner (åbne)
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +231,Row {0}: Qty not available for {4} in warehouse {1} at posting time of the entry ({2} {3}),Række {0}: Antal ikke tilgængelig for {4} i lageret {1} på udstationering tid af posten ({2} {3})
DocType: Purchase Invoice,Get Advances Paid,Få forskud
DocType: Item,Automatically Create New Batch,Opret automatisk et nyt parti
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +782,Make ,Opret
DocType: Student Admission,Admission Start Date,Optagelse Startdato
DocType: Journal Entry,Total Amount in Words,Samlet beløb i Words
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +7,There was an error. One probable reason could be that you haven't saved the form. Please contact support@erpnext.com if the problem persists.,"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 +157,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 +467,Please enter Account for Change Amount,Indtast konto for returbeløb
DocType: Student Batch Name,Student Batch Name,Elevgruppenavn
DocType: Consultation,Doctor,Læge
DocType: Holiday List,Holiday List Name,Helligdagskalendernavn
DocType: Repayment Schedule,Balance Loan Amount,Balance Lånebeløb
apps/erpnext/erpnext/schools/doctype/course_scheduling_tool/course_scheduling_tool.js +13,Schedule Course,Kursusskema
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +224,Stock Options,Aktieoptioner
DocType: Journal Entry Account,Expense Claim,Udlæg
apps/erpnext/erpnext/accounts/doctype/asset/asset.js +245,Do you really want to restore this scrapped asset?,Vil du virkelig gendanne dette kasserede anlægsaktiv?
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +349,Qty for {0},Antal for {0}
DocType: Leave Application,Leave Application,Ansøg om fravær
DocType: Patient,Patient Relation,Patientrelation
apps/erpnext/erpnext/config/hr.py +80,Leave Allocation Tool,Fraværstildelingsværktøj
DocType: Leave Block List,Leave Block List Dates,Fraværsblokeringsdatoer
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
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 +71,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.py +650,Attribute table is mandatory,Attributtabellen er obligatorisk
DocType: Production Planning Tool,Get Sales Orders,Hent salgsordrer
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +67,{0} can not be negative,{0} kan ikke være negativ
DocType: Training Event,Self-Study,Selvstudie
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +384,Discount,Rabat
DocType: Asset,Total Number of Depreciations,Samlet antal afskrivninger
DocType: Sales Invoice Item,Rate With Margin,Vurder med margen
DocType: Workstation,Wages,Løn
DocType: Task,Urgent,Hurtigst muligt
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +157,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 +556,Please select a field to edit from numpad,Vælg venligst et felt for at redigere fra numpad
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
DocType: Item,Manufacturer,Producent
DocType: Landed Cost Item,Purchase Receipt Item,Købskvittering vare
DocType: Purchase Receipt,PREC-RET-,PREC-Retsinformation
DocType: POS Profile,Sales Invoice Payment,Salgsfakturabetaling
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 +72,Selling Amount,Salgsbeløb
DocType: Repayment Schedule,Interest Amount,Renter Beløb
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +109,You are the Expense Approver for this record. Please Update the 'Status' and Save,"Du er udlægsgodkender til denne oplysning. Opdater ""Status"" og gem"
DocType: Serial No,Creation Document No,Oprettet med dok.-nr.
DocType: Issue,Issue,Issue
apps/erpnext/erpnext/healthcare/doctype/consultation/consultation_dashboard.py +11,Records,Records
DocType: Asset,Scrapped,Skrottet
apps/erpnext/erpnext/config/stock.py +200,"Attributes for Item Variants. e.g Size, Color etc.","Attributter for varer Varianter. f.eks størrelse, farve etc."
DocType: Purchase Invoice,Returns,Retur
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order_calendar.js +42,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 +35,Recruitment,Rekruttering
DocType: Lead,Organization Name,Organisationens navn
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"""
DocType: Employee,A-,EN-
DocType: Production Planning Tool,Include non-stock items,Medtag ikke-lagervarer
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +117,Sales Expenses,Salgsomkostninger
DocType: Consultation,Diagnosis,Diagnose
apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py +18,Standard Buying,Standard Buying
DocType: GL Entry,Against,Imod
DocType: Item,Default Selling Cost Center,Standard salgsomkostningssted
DocType: Sales Partner,Implementation Partner,Implementering Partner
apps/erpnext/erpnext/accounts/page/pos/pos.js +1621,ZIP Code,Postnummer
apps/erpnext/erpnext/controllers/selling_controller.py +270,Sales Order {0} is {1},Salgsordre {0} er {1}
DocType: Opportunity,Contact Info,Kontaktinformation
apps/erpnext/erpnext/config/stock.py +315,Making Stock Entries,Making Stock Angivelser
DocType: Packing Slip,Net Weight UOM,Nettovægt vægtenhed
DocType: Item,Default Supplier,Standard Leverandør
DocType: Manufacturing Settings,Over Production Allowance Percentage,Over Produktion GODTGØRELSESPROCENT
DocType: Employee Loan,Repayment Schedule,tilbagebetaling Schedule
DocType: Shipping Rule Condition,Shipping Rule Condition,Forsendelsesregelbetingelse
DocType: Holiday List,Get Weekly Off Dates,Hent ugentlige fridage til kalenderen
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +33,End Date can not be less than Start Date,Slutdato kan ikke være mindre end Startdato
DocType: Sales Person,Select company name first.,Vælg firmanavn først.
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 +24,To {0} | {1} {2},Til {0} | {1} {2}
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +40,Average Age,Gennemsnitlig alder
DocType: School Settings,Attendance Freeze Date,Tilmelding senest d.
apps/erpnext/erpnext/utilities/user_progress.py +89,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 +31,View All Products,Se alle produkter
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +20,Minimum Lead Age (Days),Mindste levealder (dage)
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +57,All BOMs,Alle styklister
DocType: Patient,Default Currency,Standardvaluta
DocType: Expense Claim,From Employee,Fra Medarbejder
apps/erpnext/erpnext/controllers/accounts_controller.py +407,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: 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 +92,Invalid Attribute,Ugyldig Attribut
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +229,{0} {1} must be submitted,{0} {1} skal godkendes
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +146,Quantity must be less than or equal to {0},Antal skal være mindre end eller lig med {0}
DocType: SMS Center,Total Characters,Total tegn
apps/erpnext/erpnext/controllers/buying_controller.py +161,Please select BOM in BOM field for Item {0},Vælg BOM i BOM vilkår for Item {0}
DocType: C-Form Invoice Detail,C-Form Invoice Detail,C-Form Faktura Detail
DocType: Payment Reconciliation Invoice,Payment Reconciliation Invoice,Betalingsafstemningsfaktura
apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +42,Contribution %,Bidrag%
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +212,"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}"
DocType: Company,Company registration numbers for your reference. Tax numbers etc.,Firma registreringsnumre til din reference. Skat numre etc.
DocType: Sales Partner,Distributor,Distributør
DocType: Shopping Cart Shipping Rule,Shopping Cart Shipping Rule,Indkøbskurv forsendelsesregler
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +233,Production Order {0} must be cancelled before cancelling this Sales Order,"Produktionsordre {0} skal annulleres, før den annullerer denne Sales Order"
apps/erpnext/erpnext/public/js/controllers/transaction.js +68,Please set 'Apply Additional Discount On',Venligst sæt &#39;Anvend Ekstra Rabat på&#39;
,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 +210,Project Collaboration Invitation,Invitation til sagssamarbejde
DocType: Salary Slip,Deductions,Fradrag
DocType: Leave Allocation,LAL/,LAL /
DocType: Setup Progress Action,Action Name,Handlingsnavn
apps/erpnext/erpnext/public/js/financial_statements.js +75,Start Year,Startår
apps/erpnext/erpnext/regional/india/utils.py +24,First 2 digits of GSTIN should match with State number {0},De første 2 cifre i GSTIN skal svare til statens nummer {0}
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
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +346,Capacity Planning Error,Kapacitetsplanlægningsfejl
,Trial Balance for Party,Trial Balance til Party
DocType: Lead,Consultant,Konsulent
DocType: Salary Slip,Earnings,Indtjening
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +391,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 +550,Nothing to request,Intet at anmode om
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +34,Another Budget record '{0}' already exists against {1} '{2}' for fiscal year {3},En anden Budget rekord &#39;{0}&#39; findes allerede mod {1} &#39;{2}&#39; for regnskabsåret {3}
apps/erpnext/erpnext/projects/doctype/task/task.py +40,'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/install_fixtures.py +113,Management,Ledelse
DocType: Cheque Print Template,Payer Settings,payer Indstillinger
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: Purchase Invoice,Is Return,Er Return
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +79,Caution,Advarsel
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +787,Return / Debit Note,Retur / debetnota
DocType: Price List Country,Price List Country,Prislisteland
DocType: Item,UOMs,Enheder
apps/erpnext/erpnext/stock/utils.py +205,{0} valid serial nos for Item {1},{0} gyldige serienumre for vare {1}
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +57,Item Code cannot be changed for Serial No.,Varenr. kan ikke ændres for Serienummer
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +26,POS Profile {0} already created for user: {1} and company {2},POS Profil {0} allerede oprettet for bruger: {1} og selskab {2}
DocType: Sales Invoice Item,UOM Conversion Factor,UOM Conversion Factor
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +23,Please enter Item Code to get Batch Number,Indtast venligst varenr. for at få partinr.
DocType: Stock Settings,Default Item Group,Standard varegruppe
DocType: Employee Loan,Partially Disbursed,Delvist udbetalt
apps/erpnext/erpnext/config/buying.py +38,Supplier database.,Leverandør database.
DocType: Account,Balance Sheet,Balance
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +701,Cost Center For Item with Item Code ',Omkostningssted for vare med varenr. '
DocType: Fee Validity,Valid Till,Gyldig til
apps/erpnext/erpnext/accounts/page/pos/pos.js +2462,"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 +28,"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
apps/erpnext/erpnext/stock/doctype/batch/batch.js +85,Stock Entry {0} created,Lagerindtastning {0} oprettet
apps/erpnext/erpnext/controllers/buying_controller.py +297,Row #{0}: Rejected Qty can not be entered in Purchase Return,Row # {0}: Afvist Antal kan ikke indtastes i Indkøb Return
,Purchase Order Items To Be Billed,Indkøbsordre varer til fakturering
DocType: Purchase Invoice Item,Net Rate,Nettosats
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +131,Please select a customer,Vælg venligst en kunde
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
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +8,Item 1,Vare 1
DocType: Holiday,Holiday,Holiday
DocType: Support Settings,Close Issue After Days,Luk Issue efter dage
DocType: Leave Control Panel,Leave blank if considered for all branches,Lad feltet stå tomt hvis det skal gælde for alle filialer
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: Payment Reconciliation,Unreconciled Payment Details,Ikke-afstemte Betalingsoplysninger
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 Order,Group same items,Gruppe samme elementer
DocType: Global Defaults,Disable Rounded Total,Deaktiver Afrundet Total
DocType: Employee Loan Application,Repayment Info,tilbagebetaling Info
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +448,'Entries' cannot be empty,'Indlæg' kan ikke være tomt
apps/erpnext/erpnext/utilities/transaction_base.py +81,Duplicate row {0} with same {1},Duplikér række {0} med samme {1}
,Trial Balance,Trial Balance
apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +449,Fiscal Year {0} not found,Regnskabsår {0} blev ikke fundet
apps/erpnext/erpnext/config/hr.py +296,Setting up Employees,Opsætning af Medarbejdere
DocType: Sales Order,SO-,SO-
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +153,Please select prefix first,Vælg venligst præfiks først
DocType: Employee,O-,O-
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +185,Research,Forskning
DocType: Maintenance Visit Purpose,Work Done,Arbejdet udført
apps/erpnext/erpnext/controllers/item_variant.py +33,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/accounts/doctype/asset/asset.py +45,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
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41,Earliest,Tidligste
apps/erpnext/erpnext/stock/doctype/item/item.py +508,"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"
apps/erpnext/erpnext/schools/report/absent_student_report/absent_student_report.py +52,Student Mobile No.,Studerende mobiltelefonnr.
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +379,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
,Budget Variance Report,Budget Variance Report
DocType: Salary Slip,Gross Pay,Bruttoløn
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +118,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 +166,Dividends Paid,Betalt udbytte
apps/erpnext/erpnext/buying/doctype/supplier/supplier.js +36,Accounting Ledger,Regnskab Ledger
DocType: Stock Reconciliation,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 +172,Retained Earnings,Overført overskud
DocType: Vehicle Log,Service Detail,service Detail
DocType: BOM,Item Description,Varebeskrivelse
DocType: Student Sibling,Student Sibling,Student Søskende
DocType: Purchase Invoice,Is Recurring,Er Tilbagevendende
DocType: Purchase Invoice,Supplied Items,Medfølgende varer
DocType: Student,STUD.,STUD.
DocType: Production Order,Qty To Manufacture,Antal at producere
DocType: Email Digest,New Income,Ny Indkomst
DocType: School Settings,School Settings,Skoleindstillinger
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/buying/doctype/request_for_quotation/request_for_quotation.py +51,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 +72,Temporary Opening,Midlertidig åbning
,Employee Leave Balance,Medarbejder Leave Balance
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +147,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 +178,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 +148,Example: Masters in Computer Science,Eksempel: Masters i Computer Science
DocType: Purchase Invoice,Rejected Warehouse,Afvist lager
DocType: GL Entry,Against Voucher,Modbilag
DocType: Item,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/accounts/page/pos/pos.js +74, to ,til
DocType: Supplier Quotation Item,Lead Time in days,Gennemsnitlig leveringstid i dage
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +58,Accounts Payable Summary,Kreditorer Resumé
apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +337,Payment of salary from {0} to {1},Udbetaling af løn fra {0} til {1}
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +213,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 +70,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/setup/doctype/company/company.py +222,"Sorry, companies cannot be merged","Beklager, kan virksomhederne ikke slås sammen"
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +151,Lab Test Prescriptions,Lab Test Prescriptions
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +167,"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/install_fixtures.py +193,Small,Lille
DocType: Employee,Employee Number,Medarbejdernr.
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +65,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: Supplier,SUPP-,SUPP-
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
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +97,Contract,Kontrakt
DocType: Email Digest,Add Quote,Tilføj tilbud
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +869,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 +92,Indirect Expenses,Indirekte udgifter
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +83,Row {0}: Qty is mandatory,Række {0}: Antal er obligatorisk
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +8,Agriculture,Landbrug
apps/erpnext/erpnext/accounts/page/pos/pos.js +764,Sync Master Data,Sync Master Data
apps/erpnext/erpnext/utilities/user_progress.py +117,Your Products or Services,Dine produkter eller tjenester
DocType: Special Test Items,Special Test Items,Særlige testelementer
DocType: Mode of Payment,Mode of Payment,Betalingsmåde
apps/erpnext/erpnext/stock/doctype/item/item.py +179,Website Image should be a public file or website URL,Website Billede bør være en offentlig fil eller webadresse
DocType: Student Applicant,AP,AP
DocType: Purchase Invoice Item,BOM,Stykliste
apps/erpnext/erpnext/setup/doctype/item_group/item_group.js +37,This is a root item group and cannot be edited.,Dette er en rod-varegruppe og kan ikke redigeres.
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: Purchase Invoice,Recurring Type,Tilbagevendende Type
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +410,"{0}: Employee email not found, hence email not sent","{0}: Medarbejderens e-mail er ikke fundet, og derfor er e-mailen ikke sendt"
DocType: Item,Foreign Trade Details,Udenrigshandel Detaljer
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/healthcare/doctype/patient_appointment/patient_appointment.js +67,Please select Physician and Date,Vælg venligst læge og dato
DocType: Student Group Student,Group Roll Number,Gruppe Roll nummer
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +145,"For {0}, only credit accounts can be linked against another debit entry",For {0} kan kun kredit konti knyttes mod en anden debet post
apps/erpnext/erpnext/projects/doctype/project/project.py +73,Total of all task weights should be 1. Please adjust weights of all Project tasks accordingly,Totalen for vægtningen af alle opgaver skal være 1. Juster vægten af alle sagsopgaver i overensstemmelse hermed
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +577,Delivery Note {0} is not submitted,Følgeseddel {0} er ikke godkendt
apps/erpnext/erpnext/stock/get_item_details.py +151,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 +43,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/production_order/production_order.js +215,Please set the Item Code first,Indstil varenummeret først
DocType: Hub Settings,Seller Website,Sælger Website
DocType: Item,ITEM-,VARE-
apps/erpnext/erpnext/controllers/selling_controller.py +150,Total allocated percentage for sales team should be 100,Samlede fordelte procentdel for salgsteam bør være 100
DocType: Sales Invoice Item,Edit Description,Rediger beskrivelse
DocType: Antibiotic,Antibiotic,Antibiotikum
,Team Updates,Team opdateringer
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +885,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/schools/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}"
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 +47,"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: Authorization Rule,Transaction,Transaktion
DocType: Patient Appointment,Duration,Varighed
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +27,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/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)
apps/erpnext/erpnext/stock/utils.py +200,Serial number {0} entered more than once,Serienummer {0} indtastet mere end én gang
DocType: Depreciation Schedule,Journal Entry,Kassekladde
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +140,{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/manufacturing/doctype/bom/bom.py +581,BOM {0} does not belong to Item {1},Stykliste {0} hører ikke til vare {1}
DocType: Sales Partner,Target Distribution,Target Distribution
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)"
DocType: Quality Inspection Reading,Reading 8,Reading 8
DocType: Sales Partner,Agent,Agent
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/install_fixtures.py +150,Hardware,Hardware
DocType: Sales Order,Recurring Upto,tilbagevendende Op
DocType: Prescription Dosage,Prescription Dosage,Receptpligtig dosering
DocType: Attendance,HR Manager,HR-chef
apps/erpnext/erpnext/accounts/party.py +175,Please select a Company,Vælg firma
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +88,Privilege Leave,Privilege Forlad
DocType: Purchase Invoice,Supplier Invoice Date,Leverandør fakturadato
apps/erpnext/erpnext/templates/includes/product_page.js +18,per,om
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +90,You need to enable Shopping Cart,Du skal aktivere Indkøbskurven
DocType: Payment Entry,Writeoff,Skrive af
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
,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: Purchase Taxes and Charges,Add or Deduct,Tilføje eller fratrække
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +82,Overlapping conditions found between:,Overlappende betingelser fundet mellem:
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +187,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 +326,Food,Mad
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +51,Ageing Range 3,Ageing Range 3
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/schools/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
,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 +60,Warehouse cannot be changed for Serial No.,Lager kan ikke ændres for serienummeret
DocType: Authorization Rule,Average Discount,Gennemsnitlig rabat
DocType: Purchase Invoice Item,UOM,Enhed
DocType: Rename Tool,Utilities,Forsyningsvirksomheder
DocType: Purchase Invoice Item,Accounting,Regnskab
DocType: Employee,EMP/,MA/
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +113,Please select batches for batched item ,Vælg venligst batches for batched item
DocType: Asset,Depreciation Schedules,Afskrivninger Tidsplaner
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +89,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 +27,From {0} | {1} {2},Fra {0} | {1} {2}
DocType: Production Order Operation,Operation Description,Operation Beskrivelse
DocType: Item,Will also apply to variants,Vil også gælde for varianter
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +34,Cannot change Fiscal Year Start Date and Fiscal Year End Date once the Fiscal Year is saved.,Kan ikke æ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: Physician,Contacts and Address,Kontakter og adresse
DocType: Purchase Invoice,Contact Person,Kontaktperson
apps/erpnext/erpnext/projects/doctype/task/task.py +37,'Expected Start Date' can not be greater than 'Expected End Date','Forventet startdato' kan ikke være større end 'Forventet slutdato '
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: Item,Maintain Stock,Vedligehold lageret
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +212,Stock Entries already created for Production Order ,Stock Entries allerede skabt til produktionsordre
DocType: Employee,Prefered Email,foretrukket Email
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +33,Net Change in Fixed Asset,Nettoændring i anlægsaktiver
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 +663,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/production_order/production_order.js +350,Max: {0},Max: {0}
apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py +24,From Datetime,Fra datotid
DocType: Email Digest,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 +193,"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 +73,Buying Amount,Køb Beløb
DocType: Sales Invoice,Shipping Address Name,Leveringsadressenavn
apps/erpnext/erpnext/accounts/doctype/account/account.js +58,Chart of Accounts,Kontoplan
DocType: Material Request,Terms and Conditions Content,Vilkår og -betingelsesindhold
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +555,cannot be greater than 100,må ikke være større end 100
apps/erpnext/erpnext/stock/doctype/item/item.py +702,Item {0} is not a stock Item,Vare {0} er ikke en lagervare
DocType: Maintenance Visit,Unscheduled,Uplanlagt
DocType: Employee,Owned,Ejet
DocType: Salary Detail,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
apps/erpnext/erpnext/stock/doctype/batch/batch.py +114,"Row #{0}: The batch {1} has only {2} qty. Please select another batch which has {3} qty available or split the row into multiple rows, to deliver/issue from multiple batches","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: Vehicle,License Plate,Nummerplade
DocType: Appraisal,Goals,Mål
DocType: Warranty Claim,Warranty / AMC Status,Garanti / AMC status
,Accounts Browser,Konti Browser
DocType: Payment Entry Reference,Payment Entry Reference,Betalingspost reference
DocType: GL Entry,GL Entry,GL indtastning
DocType: HR Settings,Employee Settings,Medarbejderindstillinger
,Batch-Wise Balance History,Historik sorteret pr. parti
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/install_fixtures.py +101,Apprentice,Lærling
DocType: Purchase Invoice,Company GSTIN,Firma GSTIN
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +103,Negative Quantity is not allowed,Negative 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
DocType: Supplier Scorecard Period,SSC-,SSC-
apps/erpnext/erpnext/hr/doctype/employee/employee.py +154,Employee cannot report to himself.,Medarbejder kan ikke referere til sig selv.
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 +238,Accounting Entry for {0}: {1} can only be made in currency: {2},Regnskab Punktet om {0}: {1} kan kun foretages i valuta: {2}
DocType: Job Opening,"Job profile, qualifications required etc.","Stillingsprofil, kvalifikationskrav mv."
DocType: Journal Entry Account,Account Balance,Kontosaldo
apps/erpnext/erpnext/config/accounts.py +191,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)
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +60,Show unclosed fiscal year's P&L balances,Vis uafsluttede finanspolitiske års P &amp; L balancer
DocType: Lab Test Template,Collection Details,Indsamlingsdetaljer
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.py +294,"select cp.name, cp.test_code, cp.parent, cp.invoice, ct.physician, ct.consultation_date from tabConsultation ct,
	`tabLab Prescription` cp where ct.patient='{0}' and cp.parent=ct.name and cp.test_created=0","vælg cp.name, cp.test_code, cp.parent, cp.invoice, ct.physician, ct.consultation_date fra tabConsultation ct, `tabLab Prescription` cp hvor ct.patient = &#39;{0}&#39; og cp.parent = ct. navn og cp.test_created = 0"
DocType: Shipping Rule,Shipping Account,Forsendelse konto
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +92,{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: Quality Inspection,Readings,Aflæsninger
DocType: Stock Entry,Total Additional Costs,Yderligere omkostninger i alt
DocType: Course Schedule,SH,SH
DocType: BOM,Scrap Material Cost(Company Currency),Skrot materialeomkostninger (firmavaluta)
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +62,Sub Assemblies,Sub forsamlinger
DocType: Asset,Asset Name,Aktivnavn
DocType: Project,Task Weight,Opgavevægtning
DocType: Shipping Rule Condition,To Value,Til Value
DocType: Asset Movement,Stock Manager,Stock manager
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +144,Source warehouse is mandatory for row {0},Kilde lageret er obligatorisk for rækken {0}
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +809,Packing Slip,Pakkeseddel
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +110,Office Rent,Kontorleje
apps/erpnext/erpnext/config/setup.py +111,Setup SMS gateway settings,Opsætning SMS gateway-indstillinger
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +60,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/install_fixtures.py +121,Analyst,Analytiker
DocType: Item,Inventory,Inventory
DocType: Item,Sales Details,Salg Detaljer
DocType: Quality Inspection,QI-,QI-
DocType: Opportunity,With Items,Med varer
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37,In Qty,I Antal
DocType: School 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/install_fixtures.py +143,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
apps/erpnext/erpnext/public/js/setup_wizard.js +60,Institute Name,Institut Navn
apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +117,Please enter repayment Amount,Indtast tilbagebetaling Beløb
apps/erpnext/erpnext/config/stock.py +305,Item Variants,Item Varianter
DocType: Company,Services,Tjenester
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 +1017,Select Possible Supplier,Vælg Mulig leverandør
DocType: Sales Invoice,Source,Kilde
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 +237,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 +145,No records found in the Payment table,Ingen resultater i Payment tabellen
apps/erpnext/erpnext/schools/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 +286,Packing Slip(s) cancelled,Pakkeseddel (ler) annulleret
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +31,Cash Flow from Investing,Pengestrømme fra investeringsaktiviteter
DocType: Program Course,Program Course,Kursusprogram
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +99,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 +27,Taken,Taget
DocType: Student,Date of Leaving,Dato for Leaving
DocType: Pricing Rule,For Price List,For prisliste
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +27,Executive Search,Executive Search
apps/erpnext/erpnext/utilities/activation.py +63,Create Leads,Opret emner
DocType: Maintenance Schedule,Schedules,Tidsplaner
DocType: Purchase Invoice Item,Net Amount,Nettobeløb
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +143,{0} {1} has not been submitted so the action cannot be completed,"{0} {1} er ikke 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: Purchase Invoice,Additional Discount Amount (Company Currency),Ekstra rabatbeløb (firmavaluta)
DocType: Supplier Scorecard,Supplier Scorecard,Leverandør Scorecard
apps/erpnext/erpnext/accounts/doctype/account/account.js +21,Please create new account from Chart of Accounts.,Opret ny konto fra kontoplanen.
,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 +50,"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: Landed Cost Voucher,Landed Cost Help,Landed Cost Hjælp
DocType: Purchase Invoice,Select Shipping Address,Vælg leveringsadresse
DocType: Leave Block List,Block Holidays on important days.,Blokér ferie på vigtige dage.
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js +71,Accounts Receivable Summary,Debitor Resumé
DocType: Employee Loan,Monthly Repayment Amount,Månedlige ydelse Beløb
apps/erpnext/erpnext/hr/doctype/employee/employee.py +191,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
DocType: GST HSN Code,HSN Code,HSN kode
apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +43,Contribution Amount,Bidrag Beløb
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."
DocType: Expense Claim,EXP,UDL
apps/erpnext/erpnext/config/stock.py +205,Brand master.,Varemærke-master.
apps/erpnext/erpnext/schools/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: Healthcare Settings,Manage Sample Collection,Administrer prøveudtagning
DocType: Program Enrollment Tool,Program Enrollments,program Tilmeldingsaftaler
DocType: Patient,Tobacco Past Use,Tidligere brug af tobak
DocType: Sales Invoice Item,Brand Name,Varemærkenavn
DocType: Purchase Receipt,Transporter Details,Transporter Detaljer
apps/erpnext/erpnext/healthcare/doctype/physician/physician.py +55,User {0} is already assigned to Physician {1},Bruger {0} er allerede tildelt Læger {1}
apps/erpnext/erpnext/accounts/page/pos/pos.js +2646,Default warehouse is required for selected item,Standardlageret er påkrævet for den valgte vare
apps/erpnext/erpnext/utilities/user_progress.py +125,Box,Kasse
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1014,Possible Supplier,mulig leverandør
DocType: Budget,Monthly Distribution,Månedlig Distribution
apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +68,Receiver List is empty. Please create Receiver List,Modtager List er tom. Opret Modtager liste
apps/erpnext/erpnext/public/js/setup_wizard.js +29,Healthcare (beta),Sundhedspleje (beta)
DocType: Production Plan Sales Order,Production Plan Sales Order,Produktion Plan kundeordre
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/schools/doctype/student_group/student_group.py +53,Duplicate roll number for student {0},Dupliceringsrulle nummer for studerende {0}
DocType: Budget,Action if Annual Budget Exceeded,Action hvis årlige budgetplan overskredet
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 +80,Row # {0}: Returned Item {1} does not exists in {2} {3},Row # {0}: returnerede vare {1} ikke eksisterer i {2} {3}
DocType: Purchase Receipt,PREC-,PREC-
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +16,Bank Accounts,Bankkonti
,Bank Reconciliation Statement,Bank Saldoopgørelsen
DocType: Consultation,Medical Coding,Medicinsk kodning
DocType: Healthcare Settings,Reminder Message,Påmindelsesmeddelelse
,Lead Name,Emnenavn
,POS,Kassesystem
DocType: C-Form,III,III
apps/erpnext/erpnext/config/stock.py +310,Opening Stock Balance,Åbning Stock Balance
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/stock/doctype/stock_entry/stock_entry.py +368,Not allowed to tranfer more {0} than {1} against Purchase Order {2},Ikke tilladt at overføre mere {0} end {1} mod indkøbsordre {2}
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 +40,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 +555,Manufacturing Quantity is mandatory,Produktionmængde er obligatorisk
DocType: Employee 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/config/hr.py +127,Claims for company expense.,Krav om selskabets regning.
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/accounts/doctype/bank_reconciliation/bank_reconciliation.py +81,Row #{0}: Clearance date {1} cannot be before Cheque Date {2},Anvendes ikke {0} {1} {2}
DocType: Company,Default Holiday List,Standard helligdagskalender
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +190,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 +145,Stock Liabilities,Stock Passiver
DocType: Purchase Invoice,Supplier Warehouse,Leverandør Warehouse
DocType: Opportunity,Contact Mobile No,Kontakt mobiltelefonnr.
,Material Requests for which Supplier Quotations are not created,Materialeanmodninger under hvilke leverandørtilbud ikke er oprettet
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 +141,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."
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +20,Resend Payment Email,Gensend Betaling E-mail
apps/erpnext/erpnext/templates/pages/projects.html +27,New task,Ny opgave
DocType: Consultation,Appointment,Aftale
apps/erpnext/erpnext/utilities/activation.py +74,Make Quotation,Opret tilbud
apps/erpnext/erpnext/config/selling.py +216,Other Reports,Andre rapporter
DocType: Dependent Task,Dependent Task,Afhængig opgave
apps/erpnext/erpnext/stock/doctype/item/item.py +403,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 +208,Leave of type {0} cannot be longer than {1},Fravær af typen {0} må ikke vare længere end {1}
DocType: Manufacturing Settings,Try planning operations for X days in advance.,Prøv at planlægge operationer for X dage i forvejen.
DocType: HR Settings,Stop Birthday Reminders,Stop Fødselsdag Påmindelser
apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +250,Please set Default Payroll Payable Account in Company {0},Venligst sæt Standard Payroll Betales konto i Company {0}
DocType: SMS Center,Receiver List,Modtageroversigt
apps/erpnext/erpnext/accounts/page/pos/pos.js +1092,Search Item,Søg Vare
DocType: Patient Appointment,Referring Physician,Refererende læge
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +46,Consumed Amount,Forbrugt Mængde
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +98,Net Change in Cash,Nettoændring i kontanter
DocType: Assessment Plan,Grading Scale,karakterbekendtgørelsen
apps/erpnext/erpnext/stock/doctype/item/item.py +398,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 +607,Already completed,Allerede afsluttet
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +33,Stock In Hand,Stock i hånden
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +29,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: Physician,Hospital,Sygehus
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +353,Quantity must not be more than {0},Antal må ikke være mere end {0}
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +117,Previous Financial Year is not closed,Foregående regnskabsår er ikke lukket
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +46,Age (Days),Alder (dage)
DocType: Quotation Item,Quotation Item,Tilbudt vare
DocType: Customer,Customer POS Id,Kundens POS-id
DocType: Account,Account Name,Kontonavn
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +40,From Date cannot be greater than To Date,Fra dato ikke kan være større end til dato
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +198,Serial No {0} quantity {1} cannot be a fraction,Serienummer {0} mængde {1} kan ikke være en brøkdel
apps/erpnext/erpnext/config/buying.py +43,Supplier Type master.,Leverandørtype-master.
DocType: Purchase Order Item,Supplier Part Number,Leverandør Part Number
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +105,Conversion rate cannot be 0 or 1,Omregningskurs kan ikke være 0 eller 1
DocType: Sales Invoice,Reference Document,referencedokument
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +213,{0} {1} is cancelled or stopped,{0} {1} er aflyst eller stoppet
DocType: Accounts Settings,Credit Controller,Credit Controller
DocType: Delivery Note,Vehicle Dispatch Date,Køretøj Dispatch Dato
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 +234,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."
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 +18,Reserved Qty,Reserveret mængde
DocType: Party Account,Party Account,Party Account
apps/erpnext/erpnext/config/setup.py +122,Human Resources,Medarbejdere
DocType: Lead,Upper Income,Upper Indkomst
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +41,Reject,Afvise
DocType: Journal Entry Account,Debit in Company Currency,Debet (firmavaluta)
DocType: BOM Item,BOM Item,Styklistevarer
DocType: Appraisal,For Employee,Til medarbejder
apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.js +49,Make Disbursement Entry,Make Udbetaling indtastning
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +138,Row {0}: Advance against Supplier must be debit,Række {0}: Advance mod Leverandøren skal debitere
DocType: Company,Default Values,Standardværdier
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +61,{frequency} Digest,{Frequency} Digest
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/accounts/doctype/purchase_invoice/purchase_invoice.py +87,Against Supplier Invoice {0} dated {1},Imod Leverandør Faktura {0} dateret {1}
DocType: Customer,Default Price List,Standardprisliste
apps/erpnext/erpnext/accounts/doctype/asset/asset.py +244,Asset Movement record {0} created,Asset Movement rekord {0} skabt
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: Journal Entry,Entry Type,Posttype
apps/erpnext/erpnext/schools/report/course_wise_assessment_report/course_wise_assessment_report.py +44,No assessment plan linked with this assessment group,Ingen vurderingsplan knyttet til denne vurderingsgruppe
,Customer Credit Balance,Customer Credit Balance
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +23,Net Change in Accounts Payable,Netto Ændring i Kreditor
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 +148,Update bank payment dates with journals.,Opdatér bankbetalingsdatoerne med kladderne.
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +21,Pricing,Priser
DocType: Quotation,Term Details,Betingelsesdetaljer
DocType: Project,Total Sales Cost (via Sales Order),Samlet salgsomkostninger (via salgsordre)
apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +29,Cannot enroll more than {0} students for this student group.,Kan ikke tilmelde mere end {0} studerende til denne elevgruppe.
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +17,Lead Count,Lead Count
apps/erpnext/erpnext/accounts/doctype/asset_category/asset_category.py +15,{0} must be greater than 0,{0} skal være større end 0
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 +64,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/schools/doctype/program_enrollment_tool/program_enrollment_tool.py +16,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: Salary Slip,Loan repayment,Tilbagebetaling af lån
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
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: 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: Maintenance Visit,Partially Completed,Delvist afsluttet
DocType: Leave Type,Include holidays within leaves as leaves,Medtag helligdage indenfor fraværsperioden som fravær
DocType: Sales Invoice,Packed Items,Pakkede varer
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 +65,'Total','I alt'
DocType: Shopping Cart Settings,Enable Shopping Cart,Aktiver Indkøbskurv
DocType: Employee,Permanent Address,Permanent adresse
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +260,"Advance paid against {0} {1} cannot be greater \
						than Grand Total {2}",Forskud mod {0} {1} kan ikke være større \ end Grand alt {2}
DocType: Patient,Medication,Medicin
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: Territory,Territory Manager,Områdechef
DocType: Packed Item,To Warehouse (Optional),Til lager (valgfrit)
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/industry_type.py +39,Online Auctions,Online Auktioner
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +98,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 +67,View in Cart,Se i indkøbskurven
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +103,Marketing Expenses,Markedsføringsomkostninger
,Item Shortage Report,Item Mangel Rapport
apps/erpnext/erpnext/stock/doctype/item/item.js +271,"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
apps/erpnext/erpnext/accounts/doctype/asset/asset.py +68,Next Depreciation Date is mandatory for new asset,Næste afskrivningsdato er obligatorisk for nye aktiver
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: Drug Prescription,Dosage by time interval,Dosering efter tidsinterval
,Student Fee Collection,Student afgiftsopkrævning
apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +23,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/accounts/doctype/purchase_invoice/purchase_invoice.py +160,Warehouse required at Row No {0},Lager kræves på rækkenr. {0}
apps/erpnext/erpnext/public/js/setup_wizard.js +135,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
DocType: Material Request,Transferred,overført
DocType: Vehicle,Doors,Døre
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +208,ERPNext Setup Complete!,ERPNext opsætning er afsluttet !
DocType: Healthcare Settings,Collect Fee for Patient Registration,Indsamle gebyr for patientregistrering
DocType: Course Assessment Criteria,Weightage,Vægtning
DocType: Purchase Invoice,Tax Breakup,Skatteafbrydelse
DocType: Packing Slip,PS-,PS
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +67,{0} {1}: Cost Center is required for 'Profit and Loss' account {2}. Please set up a default Cost Center for the Company.,{0} {1}: omkostningssted er påkrævet for resultatopgørelsekonto {2}. Opret venligst et standard omkostningssted for firmaet.
apps/erpnext/erpnext/selling/doctype/customer/customer.py +118,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
apps/erpnext/erpnext/public/js/templates/contact_list.html +37,New Contact,Ny kontakt
DocType: Territory,Parent Territory,Overordnet område
DocType: Sales Invoice,Place of Supply,Leveringssted
DocType: Quality Inspection Reading,Reading 2,Reading 2
DocType: Stock Entry,Material Receipt,Materiale Kvittering
DocType: Homepage,Products,Produkter
DocType: Announcement,Instructor,Instruktør
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js +61,Select Item (optional),Vælg emne (valgfrit)
DocType: Fee Schedule Student Group,Fee Schedule Student Group,Fee Schedule Student Group
DocType: Employee,AB+,AB +
DocType: Item,"If this item has variants, then it cannot be selected in sales orders etc.","Hvis denne vare har varianter, så det kan ikke vælges i salgsordrer mv"
DocType: Lead,Next Contact By,Næste kontakt af
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +305,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: Quotation,Order Type,Bestil Type
DocType: Purchase Invoice,Notification Email Address,Meddelelse E-mailadresse
,Item-wise Sales Register,Vare-wise Sales Register
DocType: Asset,Gross Purchase Amount,Bruttokøbesum
apps/erpnext/erpnext/utilities/user_progress.py +36,Opening Balances,Åbning af saldi
DocType: Asset,Depreciation Method,Afskrivningsmetode
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +57,Offline,Offline
DocType: Purchase Taxes and Charges,Is this Tax included in Basic Rate?,Er denne Tax inkluderet i Basic Rate?
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +56,Total Target,Samlet Target
DocType: Job Applicant,Applicant for a Job,Ansøger
DocType: Production Plan Material Request,Production Plan Material Request,Produktionsplan-Materialeanmodning
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +235,No Production Orders created,Ingen produktionsordrer oprettet
DocType: Stock Reconciliation,Reconciliation JSON,Afstemning JSON
apps/erpnext/erpnext/accounts/report/financial_statements.html +3,Too many columns. Export the report and print it using a spreadsheet application.,For mange kolonner. Udlæs rapporten og udskriv den ved hjælp af et regnearksprogram.
DocType: Purchase Invoice Item,Batch No,Partinr.
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
apps/erpnext/erpnext/schools/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 +201,Main,Hoved
apps/erpnext/erpnext/stock/doctype/item/item.js +60,Variant,Variant
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 +417,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 +1084,Make Purchase Order,Opret indkøbsordre
DocType: SMS Center,Send To,Send til
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +152,There is not enough leave balance for Leave Type {0},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
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +177,Work-in-Progress Warehouse is required before Submit,"Work-in-Progress Warehouse er nødvendig, før Indsend"
apps/erpnext/erpnext/config/hr.py +40,Applicant for a Job.,Ansøger.
DocType: Purchase Order Item,Warehouse and Reference,Lager og reference
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/schools/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 +250,Against Journal Entry {0} does not have any unmatched {1} entry,Mod Kassekladde {0} har ikke nogen uovertruffen {1} indgang
apps/erpnext/erpnext/config/hr.py +137,Appraisals,Medarbejdervurderinger
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +205,Duplicate Serial No entered for Item {0},Doppelte serienumre er indtastet for vare {0}
DocType: Shipping Rule Condition,A condition for a Shipping Rule,Betingelse for en forsendelsesregel
apps/erpnext/erpnext/hr/doctype/employee/employee.py +161,Please enter ,Kom ind
apps/erpnext/erpnext/controllers/accounts_controller.py +423,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Buying Settings","Kan ikke overfakturere for vare {0} i række {1} for mere end {2}. For at tillade over-fakturering, skal du ændre i Indkøbsindstillinger"
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +212,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)
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 +578,BOM {0} must be submitted,Stykliste {0} skal godkendes
DocType: Authorization Control,Authorization Control,Authorization Kontrol
apps/erpnext/erpnext/controllers/buying_controller.py +308,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 +782,Payment,Betaling
apps/erpnext/erpnext/controllers/stock_controller.py +92,"Warehouse {0} is not linked to any account, please mention the account in  the warehouse record or set default inventory account in company {1}.","Lager {0} er ikke knyttet til 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: Production Order Operation,Actual Time and Cost,Aktuel leveringstid og omkostninger
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +54,Material Request of maximum {0} can be made for Item {1} against Sales Order {2},Materialeanmodning af maksimum {0} kan oprettes for vare {1} mod salgsordre {2}
DocType: Course,Course Abbreviation,Kursusforkortelse
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/accounts/doctype/asset/asset.py +160,"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 +29,Employee {0} on Half day on {1},Medarbejder {0} på halv tid den {1}
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +42,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: Quotation Item,Actual Qty,Faktiske Antal
DocType: Sales Invoice Item,References,Referencer
DocType: Quality Inspection Reading,Reading 10,Reading 10
DocType: Hub Settings,Hub Node,Hub Node
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +78,You have entered duplicate items. Please rectify and try again.,"Du har indtastet dubletter. Venligst rette, og prøv igen."
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +125,Associate,Associate
DocType: Asset Movement,Asset Movement,Asset Movement
apps/erpnext/erpnext/accounts/page/pos/pos.js +2180,New Cart,Ny kurv
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: SMS Center,Create Receiver List,Opret Modtager liste
DocType: Vehicle,Wheels,Hjul
DocType: Packing Slip,To Package No.,Til pakkenr.
DocType: Patient Relation,Family,Familie
DocType: Production Planning Tool,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/industry_type.py +52,Telecommunications,Telekommunikation
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)"
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +36,Make Payment Entry,Indtast indbetaling
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +126,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/print_format/payment_receipt_voucher/payment_receipt_voucher.html +23,For,For
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +150,Can refer row only if the charge type is 'On Previous Row Amount' or 'Previous Row Total',"Kan 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
apps/erpnext/erpnext/config/accounts.py +249,Tree of financial Cost Centers.,Tree of finansielle omkostningssteder.
DocType: Serial No,Delivery Document No,Levering dokument nr
apps/erpnext/erpnext/accounts/doctype/asset/depreciation.py +190,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/stock/doctype/item_price/item_price.py +33,Item {0} appears multiple times in Price List {1},Vare {0} forekommer flere gange i prisliste {1}
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +40,"Selling must be checked, if Applicable For is selected as {0}","Selling 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
DocType: Manufacturing Settings,Disables creation of time logs against Production Orders. Operations shall not be tracked against Production Order,Deaktiverer skabelse af tid logfiler mod produktionsordrer. Operationer må ikke spores mod produktionsordre
DocType: Student,Student Mobile Number,Studerende mobiltelefonnr.
DocType: Item,Has Variants,Har Varianter
apps/erpnext/erpnext/templates/emails/training_event.html +11,Update Response,Opdater svar
apps/erpnext/erpnext/public/js/utils.js +222,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 +25,Batch ID is mandatory,Parti-id er obligatorisk
DocType: Sales Person,Parent Sales Person,Parent Sales Person
DocType: Purchase Invoice,Recurring Invoice,Tilbagevendende Faktura
DocType: Patient Appointment,Patient Age,Patientalder
apps/erpnext/erpnext/config/learn.py +263,Managing Projects,Håndtering af sager
DocType: Supplier,Supplier of Goods or Services.,Leverandør af varer eller tjenesteydelser.
DocType: Budget,Fiscal Year,Regnskabsår
DocType: Healthcare Settings,Default receivable accounts to be used if not set in Patient to book Consultation charges.,"Standardfordelbare konti, der skal bruges, hvis de ikke er indstillet til patienten for at bestille konsultationsafgifter."
DocType: Vehicle Log,Fuel Price,Brændstofpris
DocType: Budget,Budget,Budget
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +35,Set Open,Sæt Åbn
apps/erpnext/erpnext/stock/doctype/item/item.py +234,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 +50,"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/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
apps/erpnext/erpnext/selling/page/sales_analytics/sales_analytics.js +66,Territory / Customer,Område / kunde
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +44,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 +166,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 +21,Item Group Tree,Varegruppetræ
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +69,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"
apps/erpnext/erpnext/schools/doctype/academic_term/academic_term.py +30,The Term Start Date cannot be earlier than the Year Start Date of the Academic Year to which the term is linked (Academic Year {}). Please correct the dates and try again.,"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."
DocType: Guardian,Guardian Interests,Guardian Interesser
DocType: Naming Series,Current Value,Aktuel værdi
apps/erpnext/erpnext/controllers/accounts_controller.py +240,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: School 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 +233,{0} created,{0} oprettet
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 +373,Amount {0} {1} deducted against {2},Mængden {0} {1} trækkes mod {2}
DocType: Employee,Salary Information,Løn Information
DocType: Sales Person,Name and Employee ID,Navn og medarbejdernr.
apps/erpnext/erpnext/accounts/party.py +303,Due Date cannot be before Posting Date,Forfaldsdato kan ikke være før bogføringsdatoen
DocType: Website Item Group,Website Item Group,Hjemmeside-varegruppe
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +150,Duties and Taxes,Skatter og afgifter
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +356,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: Purchase Order Item,Material Request Item,Materialeanmodningsvare
apps/erpnext/erpnext/config/selling.py +75,Tree of Item Groups.,Varegruppetræer
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +160,Cannot refer row number greater than or equal to current row number for this Charge type,Kan ikke 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
,Open Production Orders,Åbne produktionsordrer
DocType: Sales Invoice Payment,Base Amount (Company Currency),Base Beløb (Company Currency)
DocType: Payment Reconciliation Payment,Reference Row,henvisning Row
DocType: Installation Note,Installation Time,Installation Time
DocType: Sales Invoice,Accounting Details,Regnskabsdetaljer
apps/erpnext/erpnext/setup/doctype/company/company.js +84,Delete all the Transactions for this Company,Slette alle transaktioner for denne Company
DocType: Patient,O Positive,O Positive
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +190,Row #{0}: Operation {1} is not completed for {2} qty of finished goods in Production Order # {3}. Please update operation status via Time Logs,Row # {0}: Operation {1} er ikke afsluttet for {2} qty af færdigvarer i produktionsordre # {3}. Du opdatere driftsstatus via Time Logs
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +68,Investments,Investeringer
DocType: Issue,Resolution Details,Løsningsdetaljer
apps/erpnext/erpnext/hr/doctype/leave_type/leave_type.js +3,Allocations,Tildelinger af fravær
DocType: Item Quality Inspection Parameter,Acceptance Criteria,Acceptkriterier
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +163,Please enter Material Requests in the above table,Indtast materialeanmodninger i ovenstående tabel
DocType: Item Attribute,Attribute Name,Attribut Navn
DocType: BOM,Show In Website,Vis på hjemmesiden
DocType: Shopping Cart Settings,Show Quantity in Website,Vis Mængde i Website
DocType: Employee 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)
,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/config/projects.py +30,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
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +98,Available slots,Tilgængelige slots
DocType: C-Form Invoice Detail,Invoice No,Fakturanr.
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +350,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 +100,"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 +229,Customer Addresses And Contacts,Kundeadresser og kontakter
,Campaign Efficiency,Kampagneeffektivitet
DocType: Discussion,Discussion,Diskussion
DocType: Payment Entry,Transaction ID,Transaktions-ID
DocType: Patient,Surgical History,Kirurgisk historie
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 +333,Please set the Date Of Joining for employee {0},Angiv ansættelsesdatoen for medarbejder {0}
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
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +175,{0} ({1}) must have role 'Expense Approver',"{0} ({1}), skal have rollen 'Udlægsgodkender'"
apps/erpnext/erpnext/utilities/user_progress.py +125,Pair,Par
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +908,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 +71,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
DocType: Item,Has Batch No,Har partinr.
apps/erpnext/erpnext/public/js/utils.js +96,Annual Billing: {0},Årlig fakturering: {0}
apps/erpnext/erpnext/config/accounts.py +208,Goods and Services Tax (GST India),Varer og tjenesteydelser Skat (GST Indien)
DocType: Delivery Note,Excise Page Number,Excise Sidetal
apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.js +157,"Company, From Date and To Date is mandatory","Company, Fra dato og Til dato er obligatorisk"
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +33,Get from Consultation,Få fra Høring
DocType: Asset,Purchase Date,Købsdato
DocType: Employee,Personal Details,Personlige oplysninger
apps/erpnext/erpnext/accounts/doctype/asset/depreciation.py +192,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)
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +368,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 +159,Item Group not mentioned in item master for item {0},Varegruppe ikke er nævnt i vare-masteren for vare {0}
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +357,Debit To account must be a Receivable account,Debit-Til konto skal være et tilgodehavende konto
DocType: Shipping Rule Condition,Shipping Amount,Forsendelsesmængde
DocType: Supplier Scorecard Period,Period Score,Periode score
apps/erpnext/erpnext/utilities/user_progress.py +61,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: Purchase Invoice Item,Conversion Factor,Konverteringsfaktor
DocType: Purchase Order,Delivered,Leveret
,Vehicle Expenses,Køretøjsudgifter
DocType: Serial No,Invoice Details,Faktura detaljer
apps/erpnext/erpnext/accounts/doctype/asset/asset.py +155,Expected value after useful life must be greater than or equal to {0},Forventet værdi efter brugstid skal være større end eller lig med {0}
DocType: Purchase Invoice,SEZ,SEZ
DocType: Purchase Receipt,Vehicle Number,Køretøjsnummer
DocType: Purchase Invoice,The date on which recurring invoice will be stop,"Den dato, hvor tilbagevendende faktura vil blive stoppe"
DocType: Employee Loan,Loan Amount,Lånebeløb
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 +424,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 +98,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: Journal Entry,Accounts Receivable,Tilgodehavender
,Supplier-Wise Sales Analytics,Salgsanalyser pr. leverandør
DocType: Salary Structure,Select employees for current Salary Structure,Vælg medarbejdere til denne lønstruktur
DocType: Sales Invoice,Company Address Name,Virksomhedens adresse navn
DocType: Production 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å
apps/erpnext/erpnext/hooks.py +131,Timesheets,Tidsregistreringskladder
DocType: HR Settings,HR Settings,HR-indstillinger
DocType: Salary Slip,net pay info,nettoløn info
DocType: Lab Test Template,This value is updated in the Default Sales Price List.,Denne værdi opdateres i standard salgsprislisten.
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +111,Expense Claim is pending approval. Only the Expense Approver can update status.,Udlæg afventer godkendelse. Kun Udlægs-godkenderen kan opdatere status.
DocType: Email Digest,New Expenses,Nye udgifter
DocType: Purchase Invoice,Additional Discount Amount,Ekstra rabatbeløb
DocType: Consultation,Patient Details,Patientdetaljer
DocType: Patient,B Positive,B positiv
apps/erpnext/erpnext/controllers/accounts_controller.py +531,"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 +288,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 +62,Group to Non-Group,Gruppe til ikke-Group
apps/erpnext/erpnext/setup/setup_wizard/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 +56,Total Actual,Samlede faktiske
DocType: Lab Test UOM,Test UOM,Test UOM
DocType: Student Siblings,Student Siblings,Student Søskende
apps/erpnext/erpnext/utilities/user_progress.py +125,Unit,Enhed
apps/erpnext/erpnext/stock/get_item_details.py +141,Please specify Company,Angiv venligst firma
,Customer Acquisition and Loyalty,Kundetilgang og -loyalitet
DocType: Purchase Invoice,Warehouse where you are maintaining stock of rejected items,"Lager, hvor du vedligeholder lager af afviste varer"
DocType: Production Order,Skip Material Transfer,Spring over overførsel af materiale
apps/erpnext/erpnext/setup/utils.py +109,Unable to find exchange rate for {0} to {1} for key date {2}. Please create a Currency Exchange record manually,Kan ikke 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 +37,Expense Claims,Udlæg
DocType: Issue,Support,Support
,BOM Search,BOM Søg
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +189,Closing (Opening + Totals),Lukning (Åbning + Totals)
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
DocType: Email Digest,Pending Sales Orders,Afventende salgsordrer
apps/erpnext/erpnext/controllers/accounts_controller.py +279,Account {0} is invalid. Account Currency must be {1},Konto {0} er ugyldig. Konto Valuta skal være {1}
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 +1039,"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: Salary Component,Deduction,Fradrag
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +115,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 +297,Item Price added for {0} in Price List {1},Varepris tilføjet for {0} i prisliste {1}
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js +8,Please enter Employee Id of this sales person,Indtast venligst Medarbejder Id dette salg person
DocType: Territory,Classification of Customers by region,Klassifikation af kunder efter region
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +57,Difference Amount must be zero,Differencebeløb skal være nul
DocType: Project,Gross Margin,Gross Margin
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +53,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/buying/doctype/supplier_quotation/supplier_quotation.js +764,Quotation,Tilbud
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +957,Cannot set a received RFQ to No Quote,Kan ikke indstille en modtaget RFQ til No Quote
DocType: Quotation,QTN-,T-
DocType: Salary Slip,Total Deduction,Fradrag i alt
,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 +195,Cost Updated,Omkostninger opdateret
DocType: Employee,Date of Birth,Fødselsdato
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +129,Item {0} has already been returned,Element {0} er allerede 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: Patient,DOB,DOB
DocType: Supplier Scorecard Period,Supplier Scorecard Setup,Leverandør Scorecard Setup
apps/erpnext/erpnext/stock/doctype/item/item.py +209,Warning: Invalid SSL certificate on attachment {0},Advarsel: Ugyldigt SSL-certifikat på vedhæftet fil {0}
DocType: Student Admission,Eligibility,Berettigelse
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: Production 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/install_fixtures.py +226,Job Description,Stillingsbeskrivelse
DocType: Student Applicant,Applied,Anvendt
DocType: Sales Invoice Item,Qty as per Stock UOM,Mængde pr. lagerenhed
apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +59,Guardian2 Name,Guardian2 Navn
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +127,"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."
DocType: Expense Claim,Approver,Godkender
,SO Qty,SO Antal
DocType: Guardian,Work Address,Arbejdsadresse
DocType: Appraisal,Calculate Total Score,Beregn Total Score
DocType: Request for Quotation,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}
apps/erpnext/erpnext/config/stock.py +163,Split Delivery Note into packages.,Opdel følgeseddel i pakker.
apps/erpnext/erpnext/hooks.py +98,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 +227,Serial No {0} does not belong to any Warehouse,Serienummer {0} tilhører ikke noget lager
DocType: Purchase Invoice,In Words (Company Currency),I Words (Company Valuta)
DocType: Asset,Supplier,Leverandør
DocType: Consultation,Consultation Time,Hørings tid
DocType: C-Form,Quarter,Kvarter
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +106,Miscellaneous Expenses,Diverse udgifter
DocType: Global Defaults,Default Company,Standardfirma
apps/erpnext/erpnext/controllers/stock_controller.py +227,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: Payment Request,PR,PR
DocType: Cheque Print Template,Bank Name,Bank navn
apps/erpnext/erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.py +29,-Above,-over
DocType: Employee Loan,Employee Loan Account,Medarbejder Lån konto
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 +102,Item Variant Settings,Variantindstillinger
apps/erpnext/erpnext/manufacturing/page/production_analytics/production_analytics.js +39,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/config/hr.py +219,"Types of employment (permanent, contract, intern etc.).","Typer af beskæftigelse (permanent, kontrakt, praktikant osv)."
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +423,{0} is mandatory for Item {1},{0} er obligatorisk for vare {1}
DocType: Process Payroll,Fortnightly,Hver 14. dag
DocType: Currency Exchange,From Currency,Fra Valuta
DocType: Vital Signs,Weight (In Kilogram),Vægt (i kilogram)
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +170,"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 +125,Cost of New Purchase,Udgifter til nye køb
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +97,Sales Order required for Item {0},Salgsordre påkrævet for vare {0}
DocType: Purchase Invoice Item,Rate (Company Currency),Sats (firmavaluta)
DocType: Student Guardian,Others,Andre
DocType: Payment Entry,Unallocated Amount,Ufordelt beløb
apps/erpnext/erpnext/templates/includes/product_page.js +71,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 +154,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
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/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
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
apps/erpnext/erpnext/schools/doctype/course_scheduling_tool/course_scheduling_tool.py +56,There were errors while deleting following schedules:,Der var fejl under sletning af følgende skemaer:
DocType: Bin,Ordered Quantity,Bestilt antal
apps/erpnext/erpnext/public/js/setup_wizard.js +111,"e.g. ""Build tools for builders""",fx &quot;Byg værktøjer til bygherrer&quot;
DocType: Grading Scale,Grading Scale Intervals,Grading Scale Intervaller
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +125,{0} {1}: Accounting Entry for {2} can only be made in currency: {3},{0} {1}: Regnskab Overgang til {2} kan kun foretages i valuta: {3}
DocType: Production Order,In Process,I Process
DocType: Authorization Rule,Itemwise Discount,Itemwise Discount
apps/erpnext/erpnext/config/accounts.py +75,Tree of financial accounts.,Tree af finansielle konti.
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +364,{0} against Sales Order {1},{0} mod salgsordre {1}
DocType: Account,Fixed Asset,Anlægsaktiv
apps/erpnext/erpnext/config/stock.py +320,Serialized Inventory,Serienummer-lager
DocType: Employee Loan,Account Info,Kontooplysninger
DocType: Activity Type,Default Billing Rate,Standard-faktureringssats
DocType: Fees,Include Payment,Inkluder betaling
apps/erpnext/erpnext/schools/doctype/student_group_creation_tool/student_group_creation_tool.py +77,{0} Student Groups created.,{0} Studentgrupper oprettet.
DocType: Sales Invoice,Total Billing Amount,Samlet faktureringsbeløb
apps/erpnext/erpnext/hr/doctype/daily_work_summary_settings/daily_work_summary_settings.py +17,There must be a default incoming Email Account enabled for this to work. Please setup a default incoming Email Account (POP/IMAP) and try again.,"Der skal være en standard indgående e-mail-konto aktiveret for at dette virker. Venligst setup en standard indgående e-mail-konto (POP / IMAP), og prøv igen."
DocType: Healthcare Settings,Receivable Account,Tilgodehavende konto
apps/erpnext/erpnext/controllers/accounts_controller.py +553,Row #{0}: Asset {1} is already {2},Row # {0}: Asset {1} er allerede {2}
DocType: Quotation Item,Stock Balance,Stock Balance
apps/erpnext/erpnext/config/selling.py +316,Sales Order to Payment,Salgsordre til betaling
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +119,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
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +859,Please select correct account,Vælg korrekt konto
DocType: Item,Weight UOM,Vægtenhed
DocType: Salary Structure Employee,Salary Structure Employee,Lønstruktur medarbejder
DocType: Patient,Blood Group,Blood Group
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +961,Pending,Afventer
DocType: Course,Course Name,Kursusnavn
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 +52,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/industry_type.py +24,Electronics,Elektronik
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/install_fixtures.py +94,Full-time,Fuld tid
DocType: Salary Structure,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
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"
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +28,Please specify a country for this Shipping Rule or check Worldwide Shipping,"Angiv et land for denne forsendelsesregel eller check ""Levering til hele verden"""
DocType: Stock Entry,Total Incoming Value,Samlet værdi indgående
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +351,Debit To is required,Debet-til skal angives
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 +39,Purchase Price List,Indkøbsprisliste
apps/erpnext/erpnext/config/buying.py +155,Templates of supplier scorecard variables.,Skabeloner af leverandør scorecard variabler.
DocType: Offer Letter Term,Offer Term,Tilbudsbetingelser
DocType: Quality Inspection,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/industry_type.py +51,Technology,Teknologi
apps/erpnext/erpnext/public/js/utils.js +98,Total Unpaid: {0},Sum ubetalt: {0}
DocType: BOM Website Operation,BOM Website Operation,BOM Website Operation
apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.js +13,Offer Letter,Ansættelsesbrev
apps/erpnext/erpnext/config/manufacturing.py +18,Generate Material Requests (MRP) and Production Orders.,Opret materialeanmodninger og produktionsordrer
DocType: Supplier Scorecard,Supplier Score,Leverandør score
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +76,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: Physician Schedule Time Slot,To Time,Til Time
DocType: Authorization Rule,Approving Role (above authorized value),Godkendelse (over autoriserede værdi) Rolle
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +115,Credit To account must be a Payable account,Kredit til konto skal være en Betales konto
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +329,BOM recursion: {0} cannot be parent or child of {2},BOM rekursion: {0} kan ikke være forælder eller barn af {2}
DocType: Production Order Operation,Completed Qty,Afsluttet Antal
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +148,"For {0}, only debit accounts can be linked against another credit entry",For {0} kan kun betalingskort konti knyttes mod en anden kredit post
apps/erpnext/erpnext/stock/doctype/item_price/item_price.py +27,Price List {0} is disabled,Prisliste {0} er deaktiveret
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +127,Row {0}: Completed Qty cannot be more than {1} for operation {2},Række {0}: Afsluttet Antal kan ikke være mere end {1} til drift {2}
DocType: Manufacturing Settings,Allow Overtime,Tillad overarbejde
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +146,"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/healthcare/doctype/physician_schedule/physician_schedule.js +6,Add Time Slots,Tilføj tidspor
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +201,{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: Item,Customer Item Codes,Kunde varenumre
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +122,Exchange Gain/Loss,Exchange Gevinst / Tab
DocType: Opportunity,Lost Reason,Tabsårsag
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 +369,All items have already been invoiced,Alle varer er allerede blevet faktureret
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +47,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/config/setup.py +66,Users and Permissions,Brugere og tilladelser
DocType: Vehicle Log,VLOG.,Vlog.
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +941,Production Orders Created: {0},Produktionsordrer Oprettet: {0}
DocType: Branch,Branch,Filial
apps/erpnext/erpnext/config/setup.py +61,Printing and Branding,Udskriving
DocType: Company,Total Monthly Sales,Samlet salg pr. måned
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
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +220,Subscription has been {0},Abonnementet har været {0}
DocType: Fee Schedule Program,Fee Schedule Program,Fee Schedule Program
DocType: Fee Schedule Program,Student Batch,Elevgruppe
apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +117,select * from `tabVital Signs` where patient='{0}' order by signs_date desc limit 1,vælg * fra `tabVital Signs` hvor patient = &#39;{0}&#39; rækkefølge af signs_date desc limit 1
apps/erpnext/erpnext/utilities/activation.py +119,Make Student,Opret studerende
DocType: Supplier Scorecard Scoring Standing,Min Grade,Min Grade
apps/erpnext/erpnext/projects/doctype/project/project.py +198,You have been invited to collaborate on the project: {0},Du er blevet inviteret til at samarbejde om sag: {0}
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +73,Physician not available on {0},Læge ikke tilgængelig på {0}
DocType: Leave Block List Date,Block Date,Blokeringsdato
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +70,Add custom field Subscription Id in the doctype {0},Tilføj brugerdefineret felt Abonnements-id i doktypen {0}
DocType: Purchase Receipt,Supplier Delivery Note,Leverandør levering Note
apps/erpnext/erpnext/templates/generators/student_admission.html +23,Apply Now,Ansøg nu
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 +106,"Create and manage daily, weekly and monthly email digests.","Opret og administrér de daglige, ugentlige og månedlige e-mail-nyhedsbreve."
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 +58,Buildings,Bygninger
DocType: Fee Schedule,Fee Structure,Gebyr struktur
DocType: Timesheet Detail,Costing Amount,Koster Beløb
DocType: Student Admission,Application Fee,Tilmeldingsgebyr
DocType: Process Payroll,Submit Salary Slip,Godkend lønseddel
apps/erpnext/erpnext/controllers/selling_controller.py +164,Maxiumm discount for Item {0} is {1}%,Maksimal rabat for vare {0} er {1}%
apps/erpnext/erpnext/stock/doctype/item_price/item_price.js +16,Import in Bulk,Import i bulk
DocType: Sales Partner,Address & Contacts,Adresse & kontaktpersoner
DocType: SMS Log,Sender Name,Afsendernavn
DocType: POS Profile,[Select],[Vælg]
DocType: Vital Signs,Blood Pressure (diastolic),Blodtryk (diastolisk)
DocType: SMS Log,Sent To,Sendt Til
DocType: Payment Request,Make Sales Invoice,Opret salgsfaktura
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +61,Softwares,Softwares
apps/erpnext/erpnext/crm/doctype/lead/lead.py +50,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/healthcare/doctype/patient_appointment/patient_appointment.js +91,Physician {0} not available on {1},Læge {0} ikke tilgængelig på {1}
apps/erpnext/erpnext/accounts/page/pos/pos.js +2527,Select Batch No,Vælg partinr.
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +52,Invalid {0}: {1},Ugyldig {0}: {1}
DocType: Purchase Invoice,PINV-RET-,PINV-Retsinformation
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
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,Employment Details,Beskæftigelse Detaljer
DocType: Employee,New Workplace,Ny Arbejdsplads
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +17,Set as Closed,Angiv som Lukket
apps/erpnext/erpnext/stock/get_item_details.py +131,No Item with Barcode {0},Ingen vare med stregkode {0}
DocType: Normal Test Items,Require Result Value,Kræver resultatværdi
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +51,Case No. cannot be 0,Case No. ikke være 0
DocType: Item,Show a slideshow at the top of the page,Vis et diasshow på toppen af siden
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +508,Boms,styklister
apps/erpnext/erpnext/stock/doctype/item/item.py +138,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 +27,Ageing Based On,Aldring Baseret på
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +52,Appointment cancelled,Afstemning annulleret
DocType: Item,End of Life,End of Life
apps/erpnext/erpnext/demo/setup/setup_data.py +329,Travel,Rejser
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +180,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.
apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +1,Recurring,Tilbagevendende
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 +72,Update Cost,Opdatering Omkostninger
DocType: Item Reorder,Item Reorder,Genbestil vare
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +446,Show Salary Slip,Vis lønseddel
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +814,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."
apps/erpnext/erpnext/controllers/status_updater.py +201,This document is over limit by {0} {1} for item {4}. Are you making another {3} against the same {2}?,Dette 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 +1006,Please set recurring after saving,Venligst sæt tilbagevendende efter besparelse
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +757,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: Topic,Topic,Emne
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +40,Cash Flow from Financing,Pengestrømme fra finansaktiviteter
DocType: Budget Account,Budget Account,Budget-konto
DocType: Quality Inspection,Verified By,Bekræftet af
apps/erpnext/erpnext/setup/doctype/company/company.py +70,"Cannot change company's default currency, because there are existing transactions. Transactions must be cancelled to change the default currency.","Kan ikke ændre virksomhedens standard valuta, fordi den anvendes i eksisterende transaktioner. Transaktioner skal annulleres for at ændre standard valuta."
DocType: Grading Scale Interval,Grade Description,Grade Beskrivelse
DocType: Stock Entry,Purchase Receipt No,Købskvitteringsnr.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +30,Earnest Money,Earnest Money
DocType: Process Payroll,Create Salary Slip,Opret lønseddel
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +34,Traceability,Sporbarhed
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +137,Source of Funds (Liabilities),Finansieringskilde (Passiver)
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +381,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: Sample Collection,Collected Time,Samlet tid
DocType: Company,Sales Monthly History,Salg Månedlig historie
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +190,Select Batch,Vælg Batch
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +244,{0} {1} is fully billed,{0} {1} er fuldt faktureret
apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.js +48,Vital Signs,Vitale tegn
DocType: Training Event,End Time,End Time
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +63,Active Salary Structure {0} found for employee {1} for the given dates,Aktiv lønstruktur {0} fundet for medarbejder {1} for de givne datoer
DocType: Payment Entry,Payment Deductions or Loss,Betalings Fradrag eller Tab
apps/erpnext/erpnext/config/setup.py +42,Standard contract terms for Sales or Purchase.,Standardkontraktvilkår for Salg eller Indkøb.
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +100,Group by Voucher,Sortér efter Bilagstype
apps/erpnext/erpnext/config/crm.py +6,Sales Pipeline,Salgspipeline
apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +216,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 +204,Please select BOM for Item in Row {0},Vælg BOM for Item i række {0}
apps/erpnext/erpnext/accounts/doctype/mode_of_payment/mode_of_payment.py +28,Account {0} does not match with Company {1} in Mode of Account: {2},Konto {0} stemmer ikke overens med virksomhed {1} i kontoens tilstand: {2}
apps/erpnext/erpnext/controllers/buying_controller.py +270,Specified BOM {0} does not exist for Item {1},Specificeret stykliste {0} findes ikke for vare {1}
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +221,Maintenance Schedule {0} must be cancelled before cancelling this Sales Order,"Vedligeholdelsesplan {0} skal annulleres, før denne salgsordre kan annulleres"
DocType: Notification Control,Expense Claim Approved,Udlæg godkendt
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +319,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/install_fixtures.py +151,Pharmaceutical,Farmaceutiske
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: Selling Settings,Sales Order Required,Salgsordre påkrævet
DocType: Purchase Invoice,Credit To,Credit Til
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +31,Active Leads / Customers,Aktive Emner / Kunder
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 +217,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: Warranty Claim,Raised By,Oprettet af
DocType: Payment Gateway Account,Payment Account,Betalingskonto
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +880,Please specify Company to proceed,Angiv venligst firma for at fortsætte
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +22,Net Change in Accounts Receivable,Nettoændring i Debitor
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +84,Compensatory Off,Kompenserende Off
DocType: Offer Letter,Accepted,Accepteret
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +25,Organization,Organisation
DocType: BOM Update Tool,BOM Update Tool,BOM Update Tool
DocType: SG Creation Tool Course,Student Group Name,Elevgruppenavn
apps/erpnext/erpnext/schools/doctype/fee_schedule/fee_schedule_list.js +7,Creating Fees,Oprettelse af gebyrer
apps/erpnext/erpnext/setup/doctype/company/company.js +62,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."
DocType: Room,Room Number,Værelsesnummer
apps/erpnext/erpnext/utilities/transaction_base.py +96,Invalid reference {0} {1},Ugyldig henvisning {0} {1}
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +167,{0} ({1}) cannot be greater than planned quanitity ({2}) in Production Order {3},{0} ({1}) kan ikke være større end planlagt antal ({2}) på produktionsordre {3}
DocType: Shipping Rule,Shipping Rule Label,Forsendelseregeltekst
apps/erpnext/erpnext/public/js/conf.js +28,User Forum,Brugerforum
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +299,Raw Materials cannot be blank.,Råmaterialer kan ikke være tom.
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +487,"Could not update stock, invoice contains drop shipping item.","Kunne ikke opdatere lager, faktura indeholder drop shipping element."
DocType: Lab Test Sample,Lab Test Sample,Lab Test prøve
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +484,Quick Journal Entry,Hurtig kassekladde
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +200,You can not change rate if BOM mentioned agianst any item,"Du kan ikke ændre kurs, hvis BOM nævnt agianst ethvert element"
DocType: Employee,Previous Work Experience,Tidligere erhvervserfaring
DocType: Stock Entry,For Quantity,For Mængde
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +209,Please enter Planned Qty for Item {0} at row {1},Indtast venligst Planned Antal for Item {0} på rækken {1}
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +241,{0} {1} is not submitted,{0} {1} er ikke godkendt
apps/erpnext/erpnext/config/stock.py +27,Requests for items.,Anmodning om.
DocType: Production Planning Tool,Separate production order will be created for each finished good item.,"Vil blive oprettet separat produktion, for hver færdigvare god element."
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +127,{0} must be negative in return document,{0} skal være negativ til gengæld dokument
,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 +102,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 +30,Latest price updated in all BOMs,Seneste pris opdateret i alle BOMs
DocType: Fee Schedule,Successful,Vellykket
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)
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +428,The following Production Orders were created:,Følgende produktionsordrer blev dannet:
DocType: Student Admission,Naming Series (for Student Applicant),Navngivningsnummerserie (for elevansøger)
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 +68,Total Absent,Ialt ikke-tilstede
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +794,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 +999,Opportunity,Salgsmulighed
,Completed Production Orders,Afsluttede produktionsordrer
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 +247,{0} {1} is closed,{0} {1} er lukket
DocType: Email Digest,How frequently?,Hvor ofte?
apps/erpnext/erpnext/schools/doctype/fee_schedule/fee_schedule.js +57,Total Collected: {0},Samlet samlet: {0}
DocType: Purchase Receipt,Get Current Stock,Hent aktuel lagerbeholdning
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"
apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +152,Mark Present,Marker tilstede
DocType: Project,% Complete Method,% Complete Method
apps/erpnext/erpnext/setup/setup_wizard/healthcare.py +186,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: Production Order,Actual End Date,Faktisk slutdato
DocType: BOM,Operating Cost (Company Currency),Driftsomkostninger (Company Valuta)
DocType: Purchase Invoice,PINV-,PINV-
DocType: Authorization Rule,Applicable To (Role),Gælder for (Rolle)
DocType: BOM Update Tool,Replace BOM,Udskift BOM
apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.py +110,Code {0} already exist,Kode {0} eksisterer allerede
DocType: Stock Entry,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: Production Order,Manufacture against Material Request,Produktion mod materialeanmodning
apps/erpnext/erpnext/schools/report/course_wise_assessment_report/course_wise_assessment_report.html +10,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 +243,Leave Without Pay does not match with approved Leave Application records,Fravær uden løn stemmer ikke med de godkendte fraværsansøgninger
DocType: Campaign,Campaign-.####,Kampagne -. ####
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +21,Next Steps,Næste skridt
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +769,Please supply the specified items at the best possible rates,Angiv venligst de angivne poster på de bedste mulige priser
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +28,Make Invoice,Make Faktura
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 +74,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/public/js/financial_statements.js +83,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 +119,Contract End Date must be greater than Date of Joining,Fratrædelsesdato skal være større end ansættelsesdato
DocType: Vital Signs,Nutrition Values,Ernæringsværdier
DocType: Lab Test Template,Is billable,Kan faktureres
DocType: Delivery Note,DN-,DN-
DocType: Sales Partner,A third party distributor / dealer / commission agent / affiliate / reseller who sells the companies products for a commission.,"En 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 +376,{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 +37,Ageing Range 1,Ageing Range 1
DocType: Purchase Taxes and Charges Template,"Standard tax template that can be applied to all Purchase Transactions. This template can contain list of tax heads and also other expense heads like ""Shipping"", ""Insurance"", ""Handling"" etc.

#### Note

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

#### Description of Columns

1. Calculation Type: 
    - This can be on **Net Total** (that is the sum of basic amount).
    - **On Previous Row Total / Amount** (for cumulative taxes or charges). If you select this option, the tax will be applied as a percentage of the previous row (in the tax table) amount or total.
    - **Actual** (as mentioned).
2. Account Head: The Account ledger under which this tax will be booked
3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.
4. Description: Description of the tax (that will be printed in invoices / quotes).
5. Rate: Tax rate.
6. Amount: Tax amount.
7. Total: Cumulative total to this point.
8. Enter Row: If based on ""Previous Row Total"" you can select the row number which will be taken as a base for this calculation (default is the previous row).
9. Consider Tax or Charge for: In this section you can specify if the tax / charge is only for valuation (not a part of total) or only for total (does not add value to the item) or for both.
10. Add or Deduct: Whether you want to add or deduct the tax.","Standard 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
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +71,Select Physician...,Vælg læge ...
apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.py +81,update tabConsultation set invoice='{0}' where name='{1}',Opdater tabConsultation set faktura = &#39;{0}&#39; hvor navn = &#39;{1}&#39;
DocType: Purchase Receipt Item,Recd Quantity,RECD Mængde
apps/erpnext/erpnext/schools/doctype/program_enrollment/program_enrollment.py +57,Fee Records Created - {0},Fee Records Oprettet - {0}
DocType: Asset Category Account,Asset Category Account,Asset Kategori konto
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +117,Cannot produce more Item {0} than Sales Order quantity {1},Kan ikke producere mere Item {0} end Sales Order mængde {1}
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +539,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 +44,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/config/accounts.py +333,"e.g. Bank, Cash, Credit Card","fx Bank, Kontant, Kreditkort"
DocType: Lead Source,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;"
DocType: Journal Entry,Credit Note,Kreditnota
DocType: Warranty Claim,Service Address,Tjeneste Adresse
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +49,Furnitures and Fixtures,Havemøbler og Kampprogram
DocType: Item,Manufacture,Fremstilling
apps/erpnext/erpnext/utilities/user_progress.py +24,Setup Company,Setup Company
,Lab Test Report,Lab Test Report
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 Detail,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 +99,Clearance Date not mentioned,Clearance Dato ikke nævnt
apps/erpnext/erpnext/config/manufacturing.py +7,Production,Produktion
DocType: Patient,Occupation,Beskæftigelse
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
apps/erpnext/erpnext/controllers/trends.py +19,Total(Qty),I alt (antal)
DocType: Sales Invoice,This Document,Dette dokument
DocType: Installation Note Item,Installed Qty,Antal installeret
apps/erpnext/erpnext/utilities/user_progress.py +28,You added ,Du tilføjede
DocType: Purchase Taxes and Charges,Parenttype,Parenttype
apps/erpnext/erpnext/hr/doctype/training_event/training_event.js +7,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: Stock Ledger Entry,Outgoing Rate,Udgående Rate
apps/erpnext/erpnext/config/hr.py +224,Organization branch master.,Organisation filial-master.
apps/erpnext/erpnext/controllers/accounts_controller.py +280, 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/public/js/setup_wizard.js +28,Education (beta),Uddannelse (beta)
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +120,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 +241,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
DocType: Buying Settings,Default Buying Price List,Standard indkøbsprisliste
DocType: Process Payroll,Salary Slip Based on Timesheet,Lønseddel baseret på timeregistreringen
apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +113,No employee for the above selected criteria OR salary slip already created,Ingen medarbejder for de ovenfor udvalgte kriterier eller lønseddel allerede skabt
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 +130,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: Process Payroll,Select Employees,Vælg Medarbejdere
DocType: Opportunity,Potential Sales Deal,Potentielle Sales Deal
DocType: Complaint,Complaints,klager
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
DocType: Item,Quality Parameters,Kvalitetsparametre
,sales-browser,salg-browser
apps/erpnext/erpnext/accounts/doctype/account/account.js +73,Ledger,Ledger
DocType: Patient Medical Record,PMR-,PMR-
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/setup/doctype/authorization_rule/authorization_rule.py +24,Duplicate Entry. Please check Authorization Rule {0},Duplicate indtastning. Forhør Authorization Rule {0}
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +29,Global POS Profile {0} already created for company {1},Global POS Profil {0} allerede skabt til selskab {1}
DocType: Purchase Order,Ref SQ,Ref SQ
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +55,Receipt document must be submitted,Kvittering 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 +320,Not Paid and Not Delivered,Ikke betalte og ikke leveret
DocType: Product Bundle,Parent Item,Overordnet vare
DocType: Account,Account Type,Kontotype
DocType: Delivery Note,DN-RET-,DN-Retsinformation
apps/erpnext/erpnext/templates/pages/projects.html +58,No time sheets,Ingen tidsregistreringer
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +123,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
apps/erpnext/erpnext/config/hr.py +93,Payroll,Løn
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +179,"For row {0} in {1}. To include {2} in Item rate, rows {3} must also be included","For rækken {0} i {1}. For at inkludere {2} i Item sats, rækker {3} skal også medtages"
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
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +546,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/install_fixtures.py +70,Arrear,bagud
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +155,Depreciation Amount during the period,Afskrivningsbeløb i perioden
apps/erpnext/erpnext/accounts/doctype/sales_taxes_and_charges_template/sales_taxes_and_charges_template.py +38,Disabled template must not be default template,Deaktiveret skabelon må ikke være standardskabelon
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 +776,Delivery,Levering
DocType: Stock Reconciliation Item,Current Qty,Aktuel Antal
apps/erpnext/erpnext/utilities/user_progress.py +85,Add Suppliers,Tilføj leverandører
apps/erpnext/erpnext/templates/generators/item_group.html +36,Prev,forrige
DocType: Appraisal Goal,Key Responsibility Area,Key Responsibility Area
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 +147,Set default inventory account for perpetual inventory,Indstil standard lagerkonto for evigvarende opgørelse
DocType: Item Reorder,Material Request Type,Materialeanmodningstype
apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +268,Accural Journal Entry for salaries from {0} to {1},Accural Kassekladde til løn fra {0} til {1}
apps/erpnext/erpnext/accounts/page/pos/pos.js +817,"LocalStorage is full, did not save","LocalStorage er fuld, kan ikke gemme"
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +85,Row {0}: UOM Conversion Factor is mandatory,Række {0}: Enhedskode-konverteringsfaktor er obligatorisk
apps/erpnext/erpnext/utilities/user_progress.py +214,Room Capacity,Rum Kapacitet
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +14,Ref,Ref
DocType: Lab Test,LP-,LP-
DocType: Healthcare Settings,Registration Fee,Registreringsafgift
DocType: Budget,Cost Center,Omkostningssted
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +45,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
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
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +130,Head of Marketing and Sales,Salg- og marketingschef
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +68,Income Tax,Indkomstskat
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +17,"If selected Pricing Rule is made for 'Price', it will overwrite Price List. Pricing Rule price is the final price, so no further discount should be applied. Hence, in transactions like Sales Order, Purchase Order etc, it will be fetched in 'Rate' field, rather than 'Price List Rate' field.","Hvis valgte Prisfastsættelse Regel er lavet til &quot;pris&quot;, vil det overskrive prislisten. Prisfastsættelse Regel prisen er den endelige pris, så ingen yderligere rabat bør anvendes. Derfor i transaktioner som Sales Order, Indkøbsordre osv, det vil blive hentet i &quot;Rate &#39;felt, snarere end&#39; Prisliste Rate &#39;område."
apps/erpnext/erpnext/config/selling.py +174,Track Leads by Industry Type.,Analysér emner efter branchekode.
DocType: Item Supplier,Item Supplier,Vareleverandør
apps/erpnext/erpnext/public/js/controllers/transaction.js +1107,Please enter Item Code to get batch no,Indtast venligst varenr. for at få partinr.
apps/erpnext/erpnext/selling/doctype/quotation/quotation.js +827,Please select a value for {0} quotation_to {1},Vælg en værdi for {0} quotation_to {1}
apps/erpnext/erpnext/config/selling.py +46,All Addresses.,Alle adresser.
DocType: Company,Stock Settings,Lagerindstillinger
apps/erpnext/erpnext/accounts/doctype/account/account.py +199,"Merging is only possible if following properties are same in both records. Is Group, Root Type, Company","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 +123,Gain/Loss on Asset Disposal,Gevinst/tab vedr. salg af anlægsaktiv
DocType: Task,Depends on Tasks,Afhænger af opgaver
apps/erpnext/erpnext/config/selling.py +36,Manage Customer Group Tree.,Administrér Kundegruppetræ.
DocType: Shopping Cart Settings,Attachments can be shown without enabling the shopping cart,Vedhæftede filer kan vises uden at gøre det muligt for indkøbskurven
DocType: Normal Test Items,Result Value,Resultatværdi
DocType: Supplier Quotation,SQTN-,LT-
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 +21,Not in Stock,Ikke på lager
DocType: Appraisal,HR User,HR-bruger
DocType: Purchase Invoice,Taxes and Charges Deducted,Skatter og Afgifter Fratrukket
apps/erpnext/erpnext/hooks.py +129,Issues,Spørgsmål
apps/erpnext/erpnext/controllers/status_updater.py +12,Status must be one of {0},Status skal være en af {0}
DocType: Sales Invoice,Debit To,Debit Til
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
apps/erpnext/erpnext/hr/report/salary_register/salary_register.py +65,No salary slip found between {0} and {1},Ingen lønseddel fundet mellem {0} og {1}
,Pending SO Items For Purchase Request,Afventende salgsordre-varer til indkøbsanmodning
apps/erpnext/erpnext/schools/doctype/student_admission/student_admission.py +29,Student Admissions,Studerende optagelser
apps/erpnext/erpnext/accounts/party.py +353,{0} {1} is disabled,{0} {1} er deaktiveret
DocType: Supplier,Billing Currency,Fakturering Valuta
DocType: Sales Invoice,SINV-RET-,SF-RET
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +196,Extra Large,Extra Large
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68,Total Leaves,Fravær i alt
DocType: Consultation,In print,Udskriv
,Profit and Loss Statement,Resultatopgørelse
DocType: Bank Reconciliation Detail,Cheque Number,Anvendes ikke
,Sales Browser,Salg Browser
DocType: Journal Entry,Total Credit,Samlet kredit
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +542,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 +51,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/install_fixtures.py +195,Large,Stor
DocType: Homepage Featured Product,Homepage Featured Product,Hjemmeside Featured Product
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +236,All Assessment Groups,Alle Assessment Grupper
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js +15,New Warehouse Name,Nyt lagernavn
apps/erpnext/erpnext/accounts/report/financial_statements.py +233,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/schools/doctype/student/student_dashboard.py +26,Fee,Betaling
DocType: Vehicle Log,Fuel Qty,Brændstofmængde
DocType: Production Order Operation,Planned Start Time,Planlagt starttime
DocType: Course,Assessment,Vurdering
DocType: Payment Entry Reference,Allocated,Allokeret
apps/erpnext/erpnext/config/accounts.py +275,Close Balance Sheet and book Profit or Loss.,Luk Balance og book resultatopgørelsen.
DocType: Student Applicant,Application Status,Ansøgning status
DocType: Sensitivity Test Items,Sensitivity Test Items,Sensitivitetstest
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 +158,Quotation {0} is cancelled,Tilbud {0} er ikke længere gyldigt
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +25,Total Outstanding Amount,Samlede udestående beløb
DocType: Sales Partner,Targets,Mål
DocType: Price List,Price List Master,Master-Prisliste
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."
,S.O. No.,SÅ No.
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +204,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 +52,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/schools/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: Employee,AB-,AB-
DocType: POS Profile,Ignore Pricing Rule,Ignorér prisfastsættelsesregel
DocType: Employee Education,Graduate,Graduate
DocType: Leave Block List,Block Days,Blokér dage
DocType: Journal Entry,Excise Entry,Excise indtastning
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +64,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: Attendance,Leave Type,Fraværstype
DocType: Purchase Invoice,Supplier Invoice Details,Leverandør fakturadetaljer
apps/erpnext/erpnext/controllers/stock_controller.py +233,Expense / Difference account ({0}) must be a 'Profit or Loss' account,Udgifts- differencekonto ({0}) skal være en resultatskonto
DocType: Project,Copied From,Kopieret fra
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +94,Name error: {0},Navn fejl: {0}
apps/erpnext/erpnext/stock/doctype/item/item_list.js +8,Shortage,Mangel
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +209,{0} {1} does not associated with {2} {3},{0} {1} ikke tilknyttet {2} {3}
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +18,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)
,Salary Register,Løn Register
DocType: Warehouse,Parent Warehouse,Forældre Warehouse
DocType: C-Form Invoice Detail,Net Total,Netto i alt
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +493,Default BOM not found for Item {0} and Project {1},Standard BOM ikke fundet for Item {0} og Project {1}
apps/erpnext/erpnext/config/hr.py +163,Define various loan types,Definer forskellige låneformer
DocType: Bin,FCFS Rate,FCFS Rate
DocType: Payment Reconciliation Invoice,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 +120,Financial Year,Finansielt år
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +41,{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 +119,Cost as on,Omkostninger som på
DocType: Healthcare Settings,Out Patient Settings,Ud patientindstillinger
DocType: Account,Round Off,Afrundninger
,Requested Qty,Anmodet mængde
DocType: Tax Rule,Use for Shopping Cart,Bruges til Indkøbskurv
apps/erpnext/erpnext/controllers/item_variant.py +96,Value {0} for Attribute {1} does not exist in the list of valid Item Attribute Values for Item {2},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 +78,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: Maintenance Visit,Purposes,Formål
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +111,Atleast one item should be entered with negative quantity in return document,Mindst ét element skal indtastes med negativt mængde gengæld dokument
apps/erpnext/erpnext/utilities/user_progress.py +166,Add Courses,Tilføj kurser
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"
,Requested,Anmodet
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +90,No Remarks,Ingen bemærkninger
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 +87,Root Account must be a group,Root Der skal være en gruppe
DocType: Consultation,Drug Prescription,Lægemiddel recept
DocType: Fees,FEE.,BETALING.
DocType: Employee Loan,Repaid/Closed,Tilbagebetales / Lukket
DocType: Item,Total Projected Qty,Den forventede samlede Antal
DocType: Monthly Distribution,Distribution Name,Distribution Name
DocType: Course,Course Code,Kursuskode
apps/erpnext/erpnext/controllers/stock_controller.py +331,Quality Inspection required for Item {0},Kvalitetskontrol kræves for vare {0}
DocType: POS Settings,Use POS in Offline Mode,Brug POS i offline-tilstand
DocType: Supplier Scorecard,Supplier Variables,Leverandørvariabler
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: Journal Entry Account,Sales Invoice,Salgsfaktura
DocType: Journal Entry Account,Party Balance,Party Balance
apps/erpnext/erpnext/accounts/page/pos/pos.js +479,Please select Apply Discount On,Vælg Anvend Rabat på
DocType: Company,Default Receivable Account,Standard Tilgodehavende konto
DocType: Process Payroll,Create Bank Entry for the total salary paid for the above selected criteria,Opret Bank Punktet om den samlede løn for de ovenfor valgte kriterier
DocType: Physician,Physician Schedule,Læge Schema
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.
DocType: Purchase Invoice,Half-yearly,Halvårlig
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +402,Accounting Entry for Stock,Regnskab Punktet om Stock
DocType: Lab Test,LabTest Approver,LabTest Approver
apps/erpnext/erpnext/schools/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
DocType: Sales Invoice,Sales Team1,Salgs TEAM1
apps/erpnext/erpnext/accounts/doctype/asset/asset.py +39,Item {0} does not exist,Element {0} eksisterer ikke
DocType: Sales Invoice,Customer Address,Kundeadresse
DocType: Employee Loan,Loan Details,Lånedetaljer
DocType: Company,Default Inventory Account,Standard lagerkonto
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +124,Row {0}: Completed Qty must be greater than zero.,Række {0}: suppleret Antal skal være større end nul.
DocType: Antibiotic,Antibiotic Name,Antibiotikum Navn
DocType: Purchase Invoice,Apply Additional Discount On,Påfør Yderligere Rabat på
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +69,Select Type...,Vælg type ...
DocType: Account,Root Type,Rodtype
DocType: Item,FIFO,FIFO
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +132,Row # {0}: Cannot return more than {1} for Item {2},Row # {0}: Kan ikke returnere mere end {1} for Item {2}
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +45,Plot,Plot
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 +150,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: Purchase Invoice,Select Supplier Address,Vælg leverandør Adresse
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +380,Add Employees,Tilføj medarbejdere
DocType: Purchase Invoice Item,Quality Inspection,Kvalitetskontrol
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +192,Extra Small,Extra Small
DocType: Company,Standard Template,Standardskabelon
DocType: Training Event,Theory,Teori
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +777,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 +211,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/industry_type.py +29,"Food, Beverage & Tobacco","Mad, drikke og tobak"
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +684,Can only make payment against unbilled {0},Kan kun gøre betaling mod faktureret {0}
apps/erpnext/erpnext/controllers/selling_controller.py +129,Commission rate cannot be greater than 100,Provisionssats kan ikke være større end 100
DocType: Stock Entry,Subcontract,Underleverance
apps/erpnext/erpnext/public/js/utils/party.js +165,Please enter {0} first,Indtast venligst {0} først
apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py +87,No replies from,Ingen svar fra
DocType: Production Order Operation,Actual End Time,Faktisk sluttid
DocType: Production Planning Tool,Download Materials Required,Hent Påkrævede materialer
DocType: Item,Manufacturer Part Number,Producentens varenummer
DocType: Production Order Operation,Estimated Time and Cost,Estimeret tid og omkostninger
DocType: Bin,Bin,Bin
DocType: SMS Log,No of Sent SMS,Antal afsendte SMS'er
DocType: Antibiotic,Healthcare Administrator,Sundhedsadministrator
apps/erpnext/erpnext/utilities/user_progress.py +44,Set a Target,Indstil et mål
DocType: Dosage Strength,Dosage Strength,Doseringsstyrke
DocType: Account,Expense Account,Udgiftskonto
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +49,Software,Software
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +199,Colour,Farve
DocType: Assessment Plan Criteria,Assessment Plan Criteria,Vurdering Plan Kriterier
DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,Forhindre indkøbsordrer
DocType: Patient Appointment,Scheduled,Planlagt
apps/erpnext/erpnext/config/buying.py +18,Request for quotation.,Anmodning om tilbud.
apps/erpnext/erpnext/hr/doctype/employee/employee.py +23,Please setup Employee Naming System in Human Resource &gt; HR Settings,Opsæt venligst medarbejdernavnesystem i menneskelige ressourcer&gt; HR-indstillinger
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"
DocType: Student Log,Academic,Akademisk
DocType: Patient,Personal and Social History,Personlig og social historie
DocType: Fee Schedule,Fee Breakup for each student,Fee Breakup for hver elev
apps/erpnext/erpnext/controllers/accounts_controller.py +476,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/lab_test_template/lab_test_template.js +78,Change Code,Skift kode
DocType: Purchase Invoice Item,Valuation Rate,Værdiansættelsesbeløb
DocType: Stock Reconciliation,SR/,SR /
DocType: Vehicle,Diesel,Diesel
apps/erpnext/erpnext/stock/get_item_details.py +329,Price List Currency not selected,Prisliste Valuta ikke valgt
apps/erpnext/erpnext/config/healthcare.py +46,Results,Resultater
,Student Monthly Attendance Sheet,Student Månedlig Deltagelse Sheet
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +185,Employee {0} has already applied for {1} between {2} and {3},Medarbejder {0} har allerede ansøgt om {1} mellem {2} og {3}
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 +5,Until,Indtil
DocType: Rename Tool,Rename Log,Omdøb log
apps/erpnext/erpnext/schools/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 +196,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 +131,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
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
DocType: C-Form,C-Form No,C-Form Ingen
DocType: BOM,Exploded_items,Exploded_items
apps/erpnext/erpnext/utilities/user_progress.py +118,List your products or services that you buy or sell.,"Skriv dine produkter eller tjenester, som du køber eller sælger."
DocType: Employee Attendance Tool,Unmarked Attendance,umærket Deltagelse
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +133,Researcher,Forsker
DocType: Program Enrollment Tool Student,Program Enrollment Tool Student,Program Tilmelding Tool Student
apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py +25,Name or Email is mandatory,Navn eller E-mail er obligatorisk
apps/erpnext/erpnext/config/stock.py +168,Incoming quality inspection.,Kommende kvalitetskontrol.
DocType: Purchase Order Item,Returned Qty,Returneret Antal
DocType: Employee,Exit,Udgang
apps/erpnext/erpnext/accounts/doctype/account/account.py +159,Root Type is mandatory,Rodtypen er obligatorisk
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +42,"{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: BOM,Total Cost(Company Currency),Totale omkostninger (firmavaluta)
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +315,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 +152,Could not retrieve information for {0}.,Kunne ikke hente oplysninger for {0}.
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/install_fixtures.py +221,Probationary Period,Prøvetid
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js +25,View {0},Se {0}
DocType: Customer Group,Only leaf nodes are allowed in transaction,Kun blade noder er tilladt i transaktionen
DocType: Expense Claim,Expense Approver,Udlægsgodkender
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +136,Row {0}: Advance against Customer must be credit,Række {0}: Advance mod Kunden skal være kredit
apps/erpnext/erpnext/accounts/doctype/account/account.js +83,Non-Group to Group,Ikke-gruppe til gruppe
apps/erpnext/erpnext/schools/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: Payment Entry,Pay,Betale
apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py +24,To Datetime,Til datotid
apps/erpnext/erpnext/schools/doctype/course_scheduling_tool/course_scheduling_tool.py +54,Course Schedules deleted:,Kursusskema udgår:
apps/erpnext/erpnext/config/selling.py +297,Logs for maintaining sms delivery status,Logs for opretholdelse sms leveringsstatus
apps/erpnext/erpnext/patches/v8_9/add_setup_progress_actions.py +14,Set Sales Target,Indstil salgsmål
DocType: Accounts Settings,Make Payment via Journal Entry,Foretag betaling via kassekladden
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +86,Printed On,Trykt On
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
DocType: Patient Appointment,Reminded,mindet
DocType: Patient,PID-,PID-
apps/erpnext/erpnext/public/js/setup_wizard.js +99,Your Organization,Din organisation
DocType: Fee Component,Fees Category,Gebyrer Kategori
apps/erpnext/erpnext/hr/doctype/employee/employee.py +129,Please enter relieving date.,Indtast lindre dato.
apps/erpnext/erpnext/controllers/trends.py +149,Amt,Amt
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/industry_type.py +38,Newspaper Publishers,Dagbladsudgivere
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 +114,Expected Delivery Date should be after Sales Order Date,Forventet Leveringsdato skal være efter salgsordre
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/stock/get_item_details.py +293,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 +131,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/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 +85,Duplicate entry,Duplicate entry
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 +491,[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
DocType: Student Batch Attendance Tool,Student Batch Attendance Tool,Elevgruppe fremmødeværktøj
apps/erpnext/erpnext/controllers/status_updater.py +210,Limit Crossed,Grænse overskredet
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +55,Venture Capital,Venture Capital
apps/erpnext/erpnext/schools/doctype/academic_term/academic_term.py +40,An academic term with this 'Academic Year' {0} and 'Term Name' {1} already exists. Please modify these entries and try again.,"En akademisk betegnelse for denne ""skoleår '{0} og"" betingelsesnavn' {1} findes allerede. Korrigér venligst og prøv igen."
apps/erpnext/erpnext/stock/doctype/item/item.py +463,"As there are existing transactions against item {0}, you can not change the value of {1}","Da der er eksisterende transaktioner mod element {0}, kan du ikke ændre værdien af {1}"
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: Pricing Rule,Discount Percentage,Discount Procent
DocType: Payment Reconciliation Invoice,Invoice Number,Fakturanummer
DocType: Shopping Cart Settings,Orders,Ordrer
DocType: Employee Leave Approver,Leave Approver,Fraværsgodkender
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +258,Please select a batch,Vælg venligst et parti
DocType: Assessment Group,Assessment Group Name,Assessment Group Name
DocType: Manufacturing Settings,Material Transferred for Manufacture,Materiale Overført til Fremstilling
DocType: Expense Claim,"A user with ""Expense Approver"" role",En bruger med 'Udlægsgodkender'-rolle
DocType: Landed Cost Item,Receipt Document Type,Kvittering Dokumenttype
DocType: Daily Work Summary Settings,Select Companies,Vælg Virksomheder
,Issued Items Against Production Order,Udstedte Varer Against produktionsordre
DocType: Antibiotic,Healthcare,Healthcare
DocType: Target Detail,Target Detail,Target Detail
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +24,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 +49,Period Closing Entry,Periode Lukning indtastning
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +75,Select Department...,Vælg afdelingen ...
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +38,Cost Center with existing transactions can not be converted to group,Omkostningssted med eksisterende transaktioner kan ikke konverteres til gruppe
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +355,Amount {0} {1} {2} {3},Mængden {0} {1} {2} {3}
DocType: Account,Depreciation,Afskrivninger
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +49,Supplier(s),Leverandør (er)
DocType: Employee Attendance Tool,Employee Attendance Tool,Medarbejder Deltagerliste Værktøj
DocType: Guardian Student,Guardian Student,Guardian Student
DocType: Supplier,Credit Limit,Kreditgrænse
DocType: Production Plan Sales Order,Salse Order Date,Salse Order Dato
DocType: Salary Component,Salary Component,Lønart
apps/erpnext/erpnext/accounts/utils.py +490,Payment Entries {0} are un-linked,Betalings Entries {0} er un-linked
DocType: GL Entry,Voucher No,Bilagsnr.
,Lead Owner Efficiency,Lederegenskaber Effektivitet
DocType: Leave Allocation,Leave Allocation,Fraværstildeling
DocType: Payment Request,Recipient Message And Payment Details,Modtager Besked Og Betalingsoplysninger
DocType: Training Event,Trainer Email,Trainer Email
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +548,Material Requests {0} created,Materialeanmodning {0} oprettet
DocType: Production Planning Tool,Include sub-contracted raw materials,Medtag underleverandører råmaterialer
apps/erpnext/erpnext/config/selling.py +164,Template of terms or contract.,Skabelon til vilkår eller kontrakt.
DocType: Purchase Invoice,Address and Contact,Adresse og kontaktperson
DocType: Cheque Print Template,Is Account Payable,Er konto Betales
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +273,Stock cannot be updated against Purchase Receipt {0},Lager kan ikke opdateres mod købskvittering {0}
DocType: Supplier,Last Day of the Next Month,Sidste dag i den næste måned
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 +71,"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 +312,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/schools/doctype/program/program.js +8,Student Applicant,Student Ansøger
DocType: Purchase Invoice,ORIGINAL FOR RECIPIENT,OPRINDELIGT FOR RECIPIENT
DocType: Asset Category Account,Accumulated Depreciation Account,Akkumuleret Afskrivninger konto
DocType: Stock Settings,Freeze Stock Entries,Frys Stock Entries
DocType: Program Enrollment,Boarding Student,Boarding Student
DocType: Asset,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
,Stock Analytics,Lageranalyser
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +499,Operations cannot be left blank,Operationer kan ikke være tomt
DocType: Maintenance Visit Purpose,Against Document Detail No,Imod Dokument Detail Nej
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +98,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 +395,{0} {1} is cancelled or closed,{0} {1} er aflyst eller lukket
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 +30,Net Cash from Investing,Netto kontant fra Investering
DocType: Production Order,Work-in-Progress Warehouse,Work-in-Progress Warehouse
apps/erpnext/erpnext/accounts/doctype/asset/depreciation.py +111,Asset {0} must be submitted,Aktiv {0} skal godkendes
DocType: Fee Schedule Program,Total Students,Samlet Studerende
apps/erpnext/erpnext/schools/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 +354,Reference #{0} dated {1},Henvisning # {0} dateret {1}
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +161,Depreciation Eliminated due to disposal of assets,Bortfaldne afskrivninger grundet afhændelse af aktiver
apps/erpnext/erpnext/templates/includes/cart/cart_address.html +15,Manage Addresses,Administrér adresser
DocType: Asset,Item Code,Varenr.
DocType: Production Planning Tool,Create Production Orders,Opret produktionsordrer
DocType: Serial No,Warranty / AMC Details,Garanti / AMC Detaljer
apps/erpnext/erpnext/schools/doctype/student_group/student_group.js +116,Select students manually for the Activity based Group,Vælg studerende manuelt for aktivitetsbaseret gruppe
DocType: Journal Entry,User Remark,Brugerbemærkning
DocType: Lead,Market Segment,Markedssegment
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +933,Paid Amount cannot be greater than total negative outstanding amount {0},Betalt beløb kan ikke være større end den 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 +239,Closing (Dr),Lukning (dr)
DocType: Cheque Print Template,Cheque Size,Anvendes ikke
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +232,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: School 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/hr/doctype/employee_loan/employee_loan.py +32,Against Employee Loan: {0},Imod medarbejderlån: {0}
DocType: Landed Cost Item,Receipt Document,Kvittering dokument
DocType: Production Planning Tool,Create Material Requests,Opret materialeanmodning
DocType: Employee Education,School/University,Skole / Universitet
DocType: Payment Request,Reference Details,Henvisning Detaljer
apps/erpnext/erpnext/accounts/doctype/asset/asset.py +59,Expected Value After Useful Life must be less than Gross Purchase Amount,Forventet værdi efter brugstid skal være mindre end bruttokøbesummen
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: Asset,Double Declining Balance,Dobbelt Faldende Balance
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +179,Closed order cannot be cancelled. Unclose to cancel.,Lukket ordre kan ikke annulleres. Unclose at annullere.
DocType: Patient Relation,Father,Far
apps/erpnext/erpnext/controllers/accounts_controller.py +562,'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 +96,{0} {1}: Account {2} does not belong to Company {3},{0} {1}: Konto {2} tilhører ikke firma {3}
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +147,Material Request {0} is cancelled or stopped,Materialeanmodning {0} er annulleret eller stoppet
apps/erpnext/erpnext/config/hr.py +301,Leave Management,Fraværsadministration
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +106,Group by Account,Sortér efter konto
DocType: Sales Order,Fully Delivered,Fuldt Leveres
DocType: Lead,Lower Income,Lavere indkomst
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +169,Source and target warehouse cannot be same for row {0},Kilde og mål lageret ikke kan være ens for rækken {0}
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +241,"Difference Account must be a Asset/Liability type account, since this Stock Reconciliation is an Opening Entry","Differencebeløbet skal være af kontotypen Aktiv / Fordring, da denne lagerafstemning er en åbningsbalance"
apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +107,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 +155,Go to Programs,Gå til Programmer
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +89,Purchase Order number required for Item {0},Indkøbsordrenr. påkrævet for vare {0}
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +892,Production Order not created,Produktionsordre ikke oprettet
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/schools/doctype/student_applicant/student_applicant.py +29,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
,Stock Projected Qty,Stock Forventet Antal
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +433,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 Order,Customer's Purchase Order,Kundens Indkøbsordre
DocType: Consultation,Patient,Patient
apps/erpnext/erpnext/config/stock.py +117,Serial No and Batch,Serienummer og parti
DocType: Warranty Claim,From Company,Fra firma
apps/erpnext/erpnext/schools/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/accounts/doctype/asset/asset.py +77,Please set Number of Depreciations Booked,Venligst sæt Antal Afskrivninger Reserveret
DocType: Supplier Scorecard Period,Calculations,Beregninger
apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +89,Value or Qty,Værdi eller mængde
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +430,Productions Orders cannot be raised for:,Productions Ordrer kan ikke hæves til:
apps/erpnext/erpnext/utilities/user_progress.py +126,Minute,Minut
DocType: Purchase Invoice,Purchase Taxes and Charges,Indkøb Moms og afgifter
apps/erpnext/erpnext/utilities/user_progress.py +100,Go to Suppliers,Gå til leverandører
,Qty to Receive,Antal til Modtag
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
apps/erpnext/erpnext/patches/v7_0/create_warehouse_nestedset.py +59,All Warehouses,Alle lagre
DocType: Sales Partner,Retailer,Detailhandler
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +112,Credit To account must be a Balance Sheet account,Kredit til konto skal være en balance konto
apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +122,All Supplier Types,Alle leverandørtyper
DocType: Global Defaults,Disable In Words,Deaktiver i ord
apps/erpnext/erpnext/stock/doctype/item/item.py +46,Item Code is mandatory because Item is not automatically numbered,"Varenr. er obligatorisk, fordi varen ikke nummereres automatisk"
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +97,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/schools/doctype/fees/fees.js +105,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: Production Order,PRO-,PRO-
DocType: Patient,Medical History,Medicinsk historie
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +157,Bank Overdraft Account,Bank kassekredit
DocType: Patient,Patient ID,Patient ID
DocType: Physician Schedule,Schedule Name,Planlægningsnavn
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js +48,Make Salary Slip,Opret lønseddel
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +813,Add All Suppliers,Tilføj alle leverandører
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +81,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 +75,Browse BOM,Gennemse styklister
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +155,Secured Loans,Sikrede lån
DocType: Purchase Invoice,Edit Posting Date and Time,Redigér bogføringsdato og -tid
apps/erpnext/erpnext/accounts/doctype/asset/depreciation.py +101,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/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +169,Opening Balance Equity,Åbning Balance Egenkapital
DocType: Lead,CRM,CRM
DocType: Purchase Invoice,N,N
DocType: Appraisal,Appraisal,Vurdering
DocType: Purchase Invoice,GST Details,GST Detaljer
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +154,Email sent to supplier {0},E-mail sendt til leverandør {0}
DocType: Opportunity,OPTY-,OPTY-
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/hr/doctype/leave_application/leave_application.py +215,Leave approver must be one of {0},Fraværsgodkender skal være en af {0}
apps/erpnext/erpnext/schools/doctype/fee_schedule/fee_schedule.js +66,Create Fees,Opret gebyrer
DocType: Hub Settings,Seller Email,Sælger Email
DocType: Project,Total Purchase Cost (via Purchase Invoice),Samlet anskaffelsespris (via købsfaktura)
DocType: Training Event,Start Time,Start Time
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +368,Select Quantity,Vælg antal
DocType: Customs Tariff Number,Customs Tariff Number,Toldtarif nummer
DocType: Patient Appointment,Patient Appointment,Patientavn
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 +803,Get Suppliers By,Få leverandører af
apps/erpnext/erpnext/utilities/user_progress.py +176,Go to Courses,Gå til kurser
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +28,Message Sent,Besked sendt
apps/erpnext/erpnext/accounts/doctype/account/account.py +101,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)
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: Production Order,Material Transferred for Manufacturing,Materiale Overført til Manufacturing
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +32,Account {0} does not exists,Konto {0} findes ikke
DocType: Project,Project Type,Sagstype
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +16,Either target qty or target amount is mandatory.,Enten target qty eller målbeløbet er obligatorisk.
apps/erpnext/erpnext/config/projects.py +50,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 +150,Source and target warehouse must be different,Kilde og mål lager skal være forskellige
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: Purchase Invoice Item,PR Detail,PR Detail
DocType: Sales Order,Fully Billed,Fuldt Billed
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 +136,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)
apps/erpnext/erpnext/schools/doctype/course/course.js +3,Program,Program
DocType: Accounts Settings,Users with this role are allowed to set frozen accounts and create / modify accounting entries against frozen accounts,Brugere med denne rolle får lov til at sætte indefrosne konti og oprette / ændre regnskabsposter mod indefrosne konti
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:"
apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.js +128,Do you really want to Submit all Salary Slip from {0} to {1},Vil du virkelig ønsker at sende alle lønseddel fra {0} til {1}
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
DocType: Hub Settings,Publish Items to Hub,Udgive varer i Hub
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +43,From value must be less than to value in row {0},Fra værdi skal være mindre end at værdien i række {0}
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +178,Wire Transfer,Bankoverførsel
apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +132,Check all,Vælg alle
DocType: Vehicle Log,Invoice Ref,Fakturareference
DocType: Purchase Order,Recurring Order,Tilbagevendende Order
DocType: Company,Default Income Account,Standard Indkomst konto
apps/erpnext/erpnext/selling/page/sales_analytics/sales_analytics.js +32,Customer Group / Customer,Kundegruppe / Kunde
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +37,Unclosed Fiscal Years Profit / Loss (Credit),Uafsluttede regnskabsår Profit / Loss (Credit)
DocType: Sales Invoice,Time Sheets,Tidsregistreringer
DocType: Lab Test Template,Change In Item,Skift i vare
DocType: Payment Gateway Account,Default Payment Request Message,Standard Betaling Request Message
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/config/accounts.py +142,Banking and Payments,Bank- og betalinger
,Welcome to ERPNext,Velkommen til ERPNext
apps/erpnext/erpnext/config/learn.py +102,Lead to Quotation,Emne til tilbud
DocType: Patient,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 +325,Calls,Opkald
apps/erpnext/erpnext/utilities/user_progress.py +122,A Product,Et produkt
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +183,Batches,partier
DocType: Project,Total Costing Amount (via Time Logs),Total Costing Beløb (via Time Logs)
apps/erpnext/erpnext/schools/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 +230,Purchase Order {0} is not submitted,Indkøbsordre {0} er ikke godkendt
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: Production Order Item,Available Qty at WIP Warehouse,Tilgængelig antal på WIP Warehouse
apps/erpnext/erpnext/stock/doctype/item/item.js +39,Projected,Forventet
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +222,Serial No {0} does not belong to Warehouse {1},Serienummer {0} hører ikke til lager {1}
apps/erpnext/erpnext/controllers/status_updater.py +174,Note: System will not check over-delivery and over-booking for Item {0} as quantity or amount is 0,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: Employee Loan,Employee Loan Application,Medarbejder låneansøgning
DocType: Issue,Opening Date,Åbning Dato
apps/erpnext/erpnext/schools/api.py +80,Attendance has been marked successfully.,Deltagelse er mærket korrekt.
DocType: Program Enrollment,Public Transport,Offentlig transport
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 +165,Account Type for {0} must be {1},Kontotype for {0} skal være {1}
DocType: Healthcare Settings,Default income accounts to be used if not set in Physician to book Consultation charges.,"Standardindkomstkonti, der skal bruges, hvis det ikke er fastsat i Læge at bestille Høringsgebyrer."
apps/erpnext/erpnext/config/hr.py +55,Leaves and Holiday,Ferie og fravær
DocType: School Settings,Current Academic Term,Nuværende akademisk betegnelse
DocType: Sales Order,Not Billed,Ikke Billed
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +75,Both Warehouse must belong to same Company,Begge lagre skal høre til samme firma
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
apps/erpnext/erpnext/config/accounts.py +17,Bills raised by Suppliers.,Regninger oprettet af leverandører.
DocType: POS Profile,Write Off Account,Skriv Off konto
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +78,Debit Note Amt,Debet notat Amt
apps/erpnext/erpnext/templates/print_formats/includes/taxes.html +5,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/healthcare/doctype/patient_appointment/patient_appointment.py +128,update `tabPatient Appointment` set sales_invoice='{0}' where name='{1}',opdatér `tabPatient Appointment` sæt sales_invoice = &#39;{0}&#39; hvor navn = &#39;{1}&#39;
apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +56,Relation with Guardian1,Forholdet til Guardian1
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +18,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/schools/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 +59,"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"
apps/erpnext/erpnext/accounts/page/pos/pos.js +2022,Please select customer,Vælg venligst kunde
DocType: C-Form,I,jeg
DocType: Company,Asset Depreciation Cost Center,Asset Afskrivninger Omkostninger center
DocType: Sales Order Item,Sales Order Date,Salgsordredato
DocType: Sales Invoice Item,Delivered Qty,Leveres Antal
DocType: Production Planning Tool,"If checked, all the children of each production item will be included in the Material Requests.","Hvis markeret, vil alle underelementer i hvert produktionselement indgå i materialeanmodningerne."
DocType: Assessment Plan,Assessment Plan,Plan Assessment
apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +90,Customer {0} is created.,Kunden {0} er oprettet.
DocType: Stock Settings,Limit Percent,Begrænsningsprocent
,Payment Period Based On Invoice Date,Betaling Periode Baseret på Fakturadato
DocType: Sample Collection,No. of print,Antal udskrifter
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +58,Missing Currency Exchange Rates for {0},Manglende Valutakurser for {0}
DocType: Assessment Plan,Examiner,Censor
DocType: Patient Relation,Siblings,Søskende
DocType: Journal Entry,Stock Entry,Lagerindtastning
DocType: Payment Entry,Payment References,Betalingsreferencer
DocType: C-Form,C-FORM-,C-form-
DocType: Vehicle,Insurance Details,Forsikring Detaljer
DocType: Account,Payable,Betales
apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +113,Please enter Repayment Periods,Indtast venligst Tilbagebetalingstid
apps/erpnext/erpnext/shopping_cart/cart.py +365,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 +75,Gross Profit %,Gross Profit%
DocType: Appraisal Goal,Weightage (%),Vægtning (%)
DocType: Bank Reconciliation Detail,Clearance Date,Clearance Dato
apps/erpnext/erpnext/schools/report/course_wise_assessment_report/course_wise_assessment_report.html +7,Assessment Report,Vurderingsrapport
apps/erpnext/erpnext/accounts/doctype/asset/asset.py +62,Gross Purchase Amount is mandatory,Bruttokøbesummen er obligatorisk
DocType: Lead,Address Desc,Adresse
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +101,Party is mandatory,Party er obligatorisk
DocType: Journal Entry,JV-,JV-
DocType: Topic,Topic Name,Emnenavn
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +36,Atleast one of the Selling or Buying must be selected,Mindst en af salg eller køb skal vælges
apps/erpnext/erpnext/public/js/setup_wizard.js +33,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 +73,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.
DocType: Asset Movement,Source Warehouse,Kildelager
DocType: Installation Note,Installation Date,Installation Dato
apps/erpnext/erpnext/controllers/accounts_controller.py +541,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/lab_test/lab_test.js +206,Sales Invoice {0} created,Salgsfaktura {0} oprettet
DocType: Employee,Confirmation Date,Bekræftet den
DocType: C-Form,Total Invoiced Amount,Totalt faktureret beløb
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +49,Min Qty can not be greater than Max Qty,Min Antal kan ikke være større end Max Antal
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: Employee Loan Application,Required by Date,Kræves af Dato
DocType: Lead,Lead Owner,Emneejer
DocType: Bin,Requested Quantity,Anmodet mængde
DocType: Patient,Marital Status,Civilstand
DocType: Stock Settings,Auto Material Request,Automatisk materialeanmodning
DocType: Delivery Note Item,Available Batch Qty at From Warehouse,Tilgængeligt batch-antal fra lageret
DocType: Customer,CUST-,CUST-
DocType: Salary Slip,Gross Pay - Total Deduction - Loan Repayment,Bruttoløn - Fradrag i alt - Tilbagebetaling af lån
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +26,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 +38,Salary Slip ID,Lønseddel id
apps/erpnext/erpnext/hr/doctype/employee/employee.py +113,Date Of Retirement must be greater than Date of Joining,Pensioneringsdato skal være større end ansættelsesdato
apps/erpnext/erpnext/schools/doctype/course_scheduling_tool/course_scheduling_tool.py +52,There were errors while scheduling course on :,Der var fejl under planlægning af kursus:
DocType: Sales Invoice,Against Income Account,Mod Indkomst konto
apps/erpnext/erpnext/controllers/website_list_for_contact.py +117,{0}% Delivered,{0}% Leveret
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +94,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: Monthly Distribution Percentage,Monthly Distribution Percentage,Månedlig Distribution Procent
DocType: Territory,Territory Targets,Områdemål
DocType: Delivery Note,Transporter Info,Transporter Info
apps/erpnext/erpnext/accounts/utils.py +497,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 +31,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
DocType: Purchase Order Item Supplied,Purchase Order Item Supplied,Indkøbsordre leveret vare
apps/erpnext/erpnext/public/js/setup_wizard.js +139,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
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +201,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."
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +39,BOM Rate,BOM Rate
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/accounts/utils.py +467,Journal Entries {0} are un-linked,Journaloptegnelser {0} er un-forbundet
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 +168,Please mention Round Off Cost Center in Company,Henvis afrunde omkostningssted i selskabet
DocType: Purchase Invoice,Terms,Betingelser
DocType: Academic Term,Term Name,Betingelsesnavn
DocType: Buying Settings,Purchase Order Required,Indkøbsordre påkrævet
,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
DocType: Expense Claim,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 +13,This is a root sales person and cannot be edited.,Dette er en rod salg person og kan ikke redigeres.
DocType: Salary Detail,"If selected, the value specified or calculated in this component will not contribute to the earnings or deductions. However, it's value can be referenced by other components that can be added or deducted. ","Hvis valgt, vil 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."
,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
apps/erpnext/erpnext/config/hr.py +7,Employee and Attendance,Medarbejder og fremmøde
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +78,Purpose must be one of {0},Formålet skal være en af {0}
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +105,Fill the form and save it,Udfyld skærmbilledet og gem det
DocType: Production Planning Tool,Download a report containing all raw materials with their latest inventory status,Download en rapport med alle råmaterialer med deres seneste opgørelsesstatus
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 +51,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 +46,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: Lab Test Template,Standard Selling Rate,Standard salgspris
DocType: Account,Rate at which this tax is applied,"Hastighed, hvormed denne afgift anvendes"
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +65,Reorder Qty,Genbestil Antal
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +28,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: 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/support/doctype/warranty_claim/warranty_claim.py +16,{0}: From {1},{0}: Fra {1}
DocType: Task,depends_on,depends_on
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +48,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
apps/erpnext/erpnext/config/setup.py +37,Country wise default Address Templates,Standard-adresseskabeloner sorteret efter lande
DocType: Sales Order Item,Supplier delivers to Customer,Leverandøren leverer til Kunden
apps/erpnext/erpnext/utilities/bot.py +34,[{0}](#Form/Item/{0}) is out of stock,[{0}] (# Form / Vare / {0}) er udsolgt
apps/erpnext/erpnext/accounts/party.py +315,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: Patient,Account Details,konto detaljer
apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +71,No students Found,Ingen studerende Fundet
DocType: Medical Department,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: Sales Invoice,Rounded Total,Afrundet i alt
DocType: Product Bundle,List items that form the package.,"Vis varer, der er indeholdt i pakken."
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 +567,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
apps/erpnext/erpnext/public/js/utils.js +259,Please select Quotations,Vælg venligst Citater
apps/erpnext/erpnext/accounts/doctype/asset/asset.py +82,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
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +47,Make Maintenance Visit,Make Vedligeholdelse Besøg
apps/erpnext/erpnext/selling/doctype/customer/customer.py +170,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 +62,Company (not Customer or Supplier) master.,Company (ikke kunde eller leverandør) herre.
apps/erpnext/erpnext/schools/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/schools/doctype/student_attendance_tool/student_attendance_tool.js +178,No Students in,Ingen studerende i
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +166,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 +206,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 +238,Go to Users,Gå til Brugere
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +82,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 +149,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 +15,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: Opportunity,Opportunity Type,Salgsmulighedstype
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +16,New Company,Nyt firma
apps/erpnext/erpnext/setup/doctype/company/delete_company_transactions.py +17,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: Hub Settings,Publish Availability,Offentliggøre Tilgængelighed
DocType: Company,Create Chart Of Accounts Based On,Opret kontoplan baseret på
apps/erpnext/erpnext/hr/doctype/employee/employee.py +107,Date of Birth cannot be greater than today.,Fødselsdato kan ikke være større end i dag.
,Stock Ageing,Stock Ageing
apps/erpnext/erpnext/schools/doctype/student/student.py +38,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 +31,Timesheet,Tidsregistrering
apps/erpnext/erpnext/controllers/accounts_controller.py +233,{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
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +20,Item 3,Vare 3
DocType: Purchase Order,Customer Contact Email,Kundeservicekontakt e-mail
DocType: Warranty Claim,Item and Warranty Details,Item og garanti Detaljer
DocType: Sales Team,Contribution (%),Bidrag (%)
apps/erpnext/erpnext/controllers/accounts_controller.py +75,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
DocType: Medical Department,Nursing User,Sygeplejerske bruger
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +227,Responsibilities,Ansvar
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +130,Validity period of this quotation has ended.,Gyldighedsperioden for dette citat er afsluttet.
DocType: Expense Claim Account,Expense Claim Account,Udlægskonto
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 +225,Add Users,Tilføj brugere
DocType: POS Item Group,Item Group,Varegruppe
DocType: Item,Safety Stock,Minimum lagerbeholdning
DocType: Healthcare Settings,Healthcare Settings,Sundhedsindstillinger
apps/erpnext/erpnext/projects/doctype/task/task.py +53,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 +434,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/accounts/doctype/asset/asset.py +43,Item {0} must be a Fixed Asset Item,Vare {0} skal være en anlægsaktiv-vare
DocType: Item,Default BOM,Standard stykliste
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +24,Debit Note Amount,Debet Note Beløb
apps/erpnext/erpnext/setup/doctype/company/company.js +60,Please re-type company name to confirm,Prøv venligst igen typen firmanavn for at bekræfte
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +79,Total Outstanding Amt,Total Enestående Amt
DocType: Journal Entry,Printing Settings,Udskrivningsindstillinger
DocType: Sales Invoice,Include Payment (POS),Medtag betaling (Kassesystem)
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +292,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/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 +397,Variable,Variabel
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.js +47,From Delivery Note,Fra følgeseddel
DocType: Student,Student Email Address,Studerende e-mailadresse
DocType: Physician Schedule Time Slot,From Time,Fra Time
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/industry_type.py +33,Investment Banking,Investment Banking
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +78,Cash or Bank Account is mandatory for making payment entry,Kontant eller bankkonto skal indtastes for post
apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +54,Student Address,Studentadresse
DocType: Purchase Invoice,Price List Exchange Rate,Prisliste valutakurs
DocType: Purchase Invoice Item,Rate,Sats
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +100,Intern,Intern
apps/erpnext/erpnext/accounts/page/pos/pos.js +1592,Address Name,Adresse Navn
DocType: Stock Entry,From BOM,Fra stykliste
DocType: Assessment Code,Assessment Code,Assessment Code
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +69,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/config/stock.py +195,"e.g. Kg, Unit, Nos, m","f.eks Kg, Unit, Nos, m"
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +122,Reference No is mandatory if you entered Reference Date,"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 +110,Date of Joining must be greater than Date of Birth,Ansættelsesdato skal være større end fødselsdato
DocType: Salary Slip,Salary Structure,Lønstruktur
DocType: Account,Bank,Bank
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +9,Airline,Flyselskab
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +818,Issue Material,Issue Materiale
DocType: Material Request Item,For Warehouse,Til lager
DocType: Employee,Offer Date,Dato
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +33,Quotations,Tilbud
apps/erpnext/erpnext/accounts/page/pos/pos.js +706,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/schools/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/employee_loan/employee_loan.py +119,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 +55,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: Subscription,Next Schedule Date,Næste planlægningsdato
DocType: Stock Entry,Including items for sub assemblies,Herunder elementer til sub forsamlinger
apps/erpnext/erpnext/accounts/page/pos/pos.js +1951,Enter value must be positive,Indtast værdien skal være positiv
apps/erpnext/erpnext/accounts/doctype/sales_invoice/pos.py +389,All Territories,Alle områder
DocType: Purchase Invoice,Items,Varer
apps/erpnext/erpnext/schools/doctype/program_enrollment/program_enrollment.py +26,Student is already enrolled.,Student er allerede tilmeldt.
DocType: Fiscal Year,Year Name,År navn
DocType: Process Payroll,Process Payroll,Lønafregning
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +238,There are more holidays than working days this month.,Der er flere helligdage end arbejdsdage i denne måned.
DocType: Product Bundle Item,Product Bundle Item,Produktpakkevare
DocType: Sales Partner,Sales Partner Name,Forhandlernavn
apps/erpnext/erpnext/hooks.py +123,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: Student Language,Student Language,Student Sprog
apps/erpnext/erpnext/config/selling.py +23,Customers,Kunder
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +24,Order/Quot %,Ordre / Quot%
apps/erpnext/erpnext/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 +92,From and To dates required,Fra og Til dato kræves
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +46,Securities & Commodity Exchanges,Værdipapirer og Commodity Exchanges
apps/erpnext/erpnext/stock/doctype/item/item.py +643,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: Delivery Note Item,From Warehouse,Fra lager
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +893,No Items with Bill of Materials to Manufacture,Ingen stykliste-varer at fremstille
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"
DocType: Program Enrollment Course,Program Enrollment Course,Tilmeldingskursusprogramm
DocType: Purchase Taxes and Charges,Valuation and Total,Værdiansættelse og Total
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py +11,Scorecards,scorecards
DocType: Tax Rule,Shipping City,Forsendelse By
DocType: Notification Control,Customize the Notification,Tilpas Underretning
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +19,Cash Flow from Operations,Pengestrøm fra driften
DocType: Sales 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/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: Process Payroll,Payroll Frequency,Lønafregningsfrekvens
DocType: Lab Test Template,Sensitivity,Følsomhed
DocType: Asset,Amended From,Ændret Fra
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +58,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 +55,Plants and Machineries,Planter og Machineries
DocType: Purchase Taxes and Charges,Tax Amount After Discount Amount,Skat Beløb Efter Discount Beløb
DocType: Daily Work Summary Settings,Daily Work Summary Settings,Daglige Arbejde Resumé Indstillinger
DocType: Payment Entry,Internal Transfer,Intern overførsel
apps/erpnext/erpnext/accounts/doctype/account/account.py +179,Child account exists for this account. You can not delete this account.,Eksisterer barn konto til denne konto. Du kan ikke slette denne konto.
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/stock/get_item_details.py +527,No default BOM exists for Item {0},Ingen standard-stykliste eksisterer for vare {0}
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +359,Please select Posting Date first,Vælg bogføringsdato først
apps/erpnext/erpnext/public/js/account_tree_grid.js +210,Opening Date should be before Closing Date,"Åbning Dato bør være, før Closing Dato"
DocType: Leave Control Panel,Carry Forward,Benyt fortsat fravær fra sidste regnskabsår
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +30,Cost Center with existing transactions can not be converted to ledger,Cost Center med eksisterende transaktioner kan ikke konverteres til finans
DocType: Department,Days for which Holidays are blocked for this department.,"Dage, for hvilke helligdage er blokeret for denne afdeling."
,Produced,Produceret
apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +118,Created Salary Slips,Oprettede lønsedler
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
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +355,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 +234,Serial Nos Required for Serialized Item {0},Serienummer påkrævet for serienummervare {0}
apps/erpnext/erpnext/config/accounts.py +152,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 +62,Add to Cart,Føj til indkøbsvogn
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.js +28,Group By,Sortér efter
DocType: Guardian,Interests,Interesser
apps/erpnext/erpnext/config/accounts.py +306,Enable / disable currencies.,Aktivér / deaktivér valuta.
DocType: Production Planning Tool,Get Material Request,Hent materialeanmodning
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +111,Postal Expenses,Portoudgifter
apps/erpnext/erpnext/controllers/trends.py +19,Total(Amt),I alt (Amt)
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +26,Entertainment & Leisure,Entertainment &amp; Leisure
DocType: Quality Inspection,Item Serial No,Serienummer til varer
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 +68,Total Present,Samlet tilstede
apps/erpnext/erpnext/config/accounts.py +113,Accounting Statements,Regnskabsoversigter
DocType: Drug Prescription,Hour,Time
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +29,New Serial No cannot have Warehouse. Warehouse must be set by Stock Entry or Purchase Receipt,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 +133,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 +383,All these items have already been invoiced,Alle disse varer er allerede blevet faktureret
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: 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
DocType: Shipping Rule,Shipping Rule Conditions,Forsendelsesregelbetingelser
DocType: Purchase Invoice,Export Type,Eksporttype
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: Production Planning Tool,"Create for full quantity, ignoring quantity already on order","Opret fuld mængde, ignorerer mængde allerede er i ordre"
DocType: Account,Tax,Skat
apps/erpnext/erpnext/schools/report/student_batch_wise_attendance/student_batch_wise_attendance.py +45,Not Marked,Ikke Markeret
DocType: Production Planning Tool,Production Planning Tool,Produktionsplanlægningsværktøj
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +150,"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: C-Form,Invoices,Fakturaer
DocType: Batch,Source Document Name,Kildedokumentnavn
DocType: Job Opening,Job Title,Titel
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py +84,"{0} indicates that {1} will not provide a quotation, but all items \
					have been quoted. Updating the RFQ quote status.","{0} indikerer at {1} ikke giver et citat, men alle elementer \ er blevet citeret. Opdatering af RFQ citat status."
DocType: Manufacturing Settings,Update BOM Cost Automatically,Opdater BOM omkostninger automatisk
DocType: Lab Test,Test Name,Testnavn
apps/erpnext/erpnext/utilities/activation.py +99,Create Users,Opret Brugere
apps/erpnext/erpnext/utilities/user_progress.py +126,Gram,Gram
DocType: Supplier Scorecard,Per Month,Om måneden
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +389,Quantity to Manufacture must be greater than 0.,Mængde til Fremstilling skal være større end 0.
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: POS Customer Group,Customer Group,Kundegruppe
apps/erpnext/erpnext/stock/doctype/batch/batch.js +108,New Batch ID (Optional),Nyt partinr. (valgfri)
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +198,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 +42,Net Change in Equity,Nettoændring i Equity
apps/erpnext/erpnext/accounts/doctype/asset/asset.py +163,Please cancel Purchase Invoice {0} first,Annullér købsfaktura {0} først
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
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +815,Receipt,Kvittering
,Sales Register,Salgs Register
DocType: Daily Work Summary Settings Company,Send Emails At,Send e-mails på
DocType: Quotation,Quotation Lost Reason,Tilbud afvist - årsag
apps/erpnext/erpnext/public/js/setup_wizard.js +19,Select your Domain,Vælg dit domæne
apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +114,select * from tabPatient where name='{0}',vælg * fra tabPatient hvor navn = &#39;{0}&#39;
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +362,Transaction reference no {0} dated {1},Transaktion henvisning ingen {0} dateret {1}
apps/erpnext/erpnext/setup/doctype/supplier_type/supplier_type.js +5,There is nothing to edit.,Der er intet at redigere.
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +325,Form View,Formularvisning
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +117,Summary for this month and pending activities,Resumé for denne måned og verserende aktiviteter
apps/erpnext/erpnext/utilities/user_progress.py +227,"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 +100,No Customers yet!,Ingen kunder endnu!
apps/erpnext/erpnext/public/js/financial_statements.js +56,Cash Flow Statement,Pengestrømsanalyse
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 +480,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: Physician,Phone (R),Telefon (R)
apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +50,Time slots added,Time slots tilføjet
DocType: Item,Attributes,Attributter
apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +31,Enable Template,Aktivér skabelon
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +201,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Indstil navngivningsserien for {0} via Setup&gt; Settings&gt; Naming Series
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +223,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: Patient,B Negative,B Negativ
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +47,Account {0} does not belongs to company {1},Konto {0} ikke hører til virksomheden {1}
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +872,Serial Numbers in row {0} does not match with Delivery Note,Serienumre i række {0} stemmer ikke overens med Leveringsnotat
DocType: Student,Guardian Details,Guardian Detaljer
DocType: C-Form,C-Form,C-Form
apps/erpnext/erpnext/config/hr.py +18,Mark Attendance for multiple employees,Mark Deltagelse for flere medarbejdere
DocType: Vehicle,Chassis No,Stelnummer
DocType: Payment Request,Initiated,Indledt
DocType: Production Order,Planned Start Date,Planlagt startdato
DocType: Serial No,Creation Document Type,Oprettet dokumenttype
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +35,End date must be greater than start date,Slutdato skal være større end startdato
DocType: Leave Type,Is Encash,Er indløse
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
DocType: Project,Expected End Date,Forventet slutdato
DocType: Budget Account,Budget Amount,Budget Beløb
DocType: Appraisal Template,Appraisal Template Title,Vurderingsskabelonnavn
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +39,From Date {0} for Employee {1} cannot be before employee's joining Date {2},"Fradato {0} for medarbekder {1} kan ikke være, før medarbejderens ansættelsesdato {2}"
apps/erpnext/erpnext/utilities/user_progress_utils.py +29,Commercial,Kommerciel
DocType: Patient,Alcohol Current Use,Alkohol Nuværende Brug
DocType: Payment Entry,Account Paid To,Konto Betalt Til
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/config/selling.py +57,All Products or Services.,Alle produkter eller tjenesteydelser.
DocType: Expense Claim,More Details,Flere detaljer
DocType: Supplier Quotation,Supplier Address,Leverandør Adresse
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +128,{0} Budget for Account {1} against {2} {3} is {4}. It will exceed by {5},{0} budget for konto {1} mod {2} {3} er {4}. Det vil overstige med {5}
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +685,Row {0}# Account must be of type 'Fixed Asset',Række {0} # konto skal være af typen 'Anlægsaktiv'
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37,Out Qty,Out Antal
apps/erpnext/erpnext/config/accounts.py +322,Rules to calculate shipping amount for a sale,Regler til at beregne forsendelsesmængden for et salg
apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +46,Series is mandatory,Nummerserien er obligatorisk
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +28,Financial Services,Financial Services
DocType: Student Sibling,Student ID,Studiekort
apps/erpnext/erpnext/config/projects.py +45,Types of activities for Time Logs,Typer af aktiviteter for Time Logs
DocType: Tax Rule,Sales,Salg
DocType: Stock Entry Detail,Basic Amount,Grundbeløb
DocType: Training Event,Exam,Eksamen
DocType: Complaint,Complaint,Klage
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +451,Warehouse required for stock Item {0},Lager kræves for lagervare {0}
DocType: Leave Allocation,Unused leaves,Ubrugte blade
DocType: Patient,Alcohol Past Use,Alkohol tidligere brug
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +179,Cr,Cr
DocType: Tax Rule,Billing State,Anvendes ikke
apps/erpnext/erpnext/accounts/doctype/asset/asset.js +287,Transfer,Overførsel
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +882,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 +110,Due Date is mandatory,Forfaldsdato er obligatorisk
apps/erpnext/erpnext/controllers/item_variant.py +80,Increment for Attribute {0} cannot be 0,Tilvækst til Attribut {0} kan ikke være 0
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: Supplier,Contact HTML,Kontakt HTML
,Inactive Customers,Inaktive kunder
DocType: Landed Cost Voucher,LCV,LCV
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: Production Planning Tool,"If checked, only Purchase material requests for final raw materials will be included in the Material Requests. Otherwise, Material Requests for parent items will be created","Hvis markeret, vil kun indkøbs-materialeanmodninger om endelige råmaterialer indgå i materialeanmodningerne. Ellers vil materialeanmodninger for overordnede varer blive dannet"
DocType: Cheque Print Template,Message to show,Besked for at vise
DocType: Company,Retail,Retail
DocType: Attendance,Absent,Ikke-tilstede
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +566,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 +212,Row {0}: Invalid reference {1},Række {0}: Ugyldig henvisning {1}
DocType: Purchase Taxes and Charges Template,Purchase Taxes and Charges Template,Indkøb Moms- og afgiftsskabelon
DocType: Upload Attendance,Download Template,Hent skabelon
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: Payment Entry,Account Paid From,Konto Betalt Fra
DocType: Purchase Order Item Supplied,Raw Material Item Code,Råmateriale varenr.
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 +112,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 +782,Send Supplier Emails,Send Leverandør Emails
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +115,"Salary already processed for period between {0} and {1}, Leave application period cannot be between this date range.","Løn allerede behandlet for perioden {0} til {1}, ferie ansøgningsperiode kan ikke være i dette datointerval."
apps/erpnext/erpnext/config/stock.py +132,Installation record for a Serial No.,Installationspost for et serienummer
DocType: Guardian Interest,Guardian Interest,Guardian Renter
apps/erpnext/erpnext/config/hr.py +177,Training,Uddannelse
DocType: Timesheet,Employee Detail,Medarbejderoplysninger
apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +58,Guardian1 Email ID,Guardian1 Email ID
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +49,Next Date's day and Repeat on Day of Month must be equal,Næste dagsdato og Gentagelsesdag i måneden skal være ens
DocType: Lab Prescription,Test Code,Testkode
apps/erpnext/erpnext/config/website.py +11,Settings for website homepage,Indstillinger for hjemmesidens startside
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +38,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}
DocType: Offer Letter,Awaiting Response,Afventer svar
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +60,Above,Frem
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1113,Total Amount {0},Samlede beløb {0}
apps/erpnext/erpnext/controllers/item_variant.py +217,Invalid attribute {0} {1},Ugyldig attribut {0} {1}
DocType: Supplier,Mention if non-standard payable account,Angiv hvis ikke-standard betalingskonto
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +315,Same item has been entered multiple times. {list},Samme vare er indtastet flere gange. {liste}
apps/erpnext/erpnext/schools/report/course_wise_assessment_report/course_wise_assessment_report.py +18,Please select the assessment group other than 'All Assessment Groups',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
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 +108,Negative Valuation Rate is not allowed,Negative Værdiansættelses Rate er ikke tilladt
DocType: Holiday List,Weekly Off,Ugedag fri
DocType: Fiscal Year,"For e.g. 2012, 2012-13","Til fx 2012, 2012-13"
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +96,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
DocType: Production Order Item,Production Order Item,Produktionsordre Item
apps/erpnext/erpnext/healthcare/report/lab_test_report/lab_test_report.py +15,No record found,Ingen post fundet
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +137,Cost of Scrapped Asset,Udgifter kasseret anlægsaktiv
apps/erpnext/erpnext/controllers/stock_controller.py +236,{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 +659,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 +59,Split,Dele
DocType: GL Entry,Is Advance,Er Advance
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +21,Attendance From Date and Attendance To Date is mandatory,Fremmøde fradato og Fremmøde tildato er obligatoriske
apps/erpnext/erpnext/controllers/buying_controller.py +153,Please enter 'Is Subcontracted' as Yes or No,Indtast &quot;underentreprise&quot; som Ja eller Nej
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +29,Last Communication Date,Sidste kommunikationsdato
DocType: Sales Team,Contact No.,Kontaktnr.
DocType: Bank Reconciliation,Payment Entries,Betalings Entries
DocType: Production Order,Scrap Warehouse,Skrotlager
DocType: Production 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
DocType: Hub Settings,Seller Country,Sælgers land
apps/erpnext/erpnext/config/learn.py +273,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 +85,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 +68,Total (Credit),I alt (kredit)
DocType: Repayment Schedule,Payment Date,Betalingsdato
apps/erpnext/erpnext/stock/doctype/batch/batch.js +102,New Batch Qty,Ny partimængde
apps/erpnext/erpnext/setup/setup_wizard/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/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: 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 +28,Cannot convert Cost Center to ledger as it has child nodes,"Kan ikke konvertere Cost Center til hovedbog, som det har barneknudepunkter"
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +56,Opening Value,åbning Value
DocType: Salary Detail,Formula,Formel
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +47,Serial #,Serienummer
DocType: Lab Test Template,Lab Test Template,Lab Test Template
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +94,Commission on Sales,Salgsprovisioner
DocType: Offer Letter Term,Value / Description,/ Beskrivelse
apps/erpnext/erpnext/controllers/accounts_controller.py +565,"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
apps/erpnext/erpnext/accounts/general_ledger.py +132,Debit and Credit not equal for {0} #{1}. Difference is {2}.,Debet og kredit ikke ens for {0} # {1}. Forskellen er {2}.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +98,Entertainment Expenses,Repræsentationsudgifter
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +48,Make Material Request,Opret materialeanmodning
apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html +20,Open Item {0},Åbent Item {0}
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +214,Sales Invoice {0} must be cancelled before cancelling this Sales Order,"Salgsfaktura {0} skal annulleres, før denne salgsordre annulleres"
DocType: Consultation,Age,Alder
DocType: Sales Invoice Timesheet,Billing Amount,Faktureret beløb
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.
apps/erpnext/erpnext/config/hr.py +60,Applications for leave.,Søg om tilladelse til fravær.
apps/erpnext/erpnext/accounts/doctype/account/account.py +177,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 +102,Legal Expenses,Advokatudgifter
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +119,Please select quantity on row ,Vælg venligst antal på række
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 +118,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 +135,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 +79,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 +119,Travel Expenses,Rejseudgifter
DocType: Maintenance Visit,Breakdown,Sammenbrud
apps/erpnext/erpnext/controllers/accounts_controller.py +677,Account: {0} with currency: {1} can not be selected,Konto: {0} med valuta: kan ikke vælges {1}
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: Bank Reconciliation Detail,Cheque Date,Anvendes ikke
apps/erpnext/erpnext/accounts/doctype/account/account.py +54,Account {0}: Parent account {1} does not belong to company: {2},Konto {0}: Forældre-konto {1} tilhører ikke virksomheden: {2}
DocType: Program Enrollment Tool,Student Applicants,Student Ansøgere
apps/erpnext/erpnext/setup/doctype/company/company.js +77,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 +21,As on Date,Som på dato
DocType: Appraisal,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/install_fixtures.py +96,Probation,Kriminalforsorgen
apps/erpnext/erpnext/config/hr.py +115,Salary Components,Lønarter
DocType: Program Enrollment Tool,New Academic Year,Nyt skoleår
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +762,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 +23,Total Paid Amount,Samlet indbetalt beløb
DocType: Production Order Item,Transferred Qty,Overført antal
apps/erpnext/erpnext/config/learn.py +11,Navigating,Navigering
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +184,Planning,Planlægning
DocType: Material Request,Issued,Udstedt
apps/erpnext/erpnext/schools/doctype/student/student_dashboard.py +14,Student Activity,Studentaktivitet
DocType: Project,Total Billing Amount (via Time Logs),Faktureringsbeløb i alt (via Time Logs)
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 +258,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: Leave Application,Half Day Date,Halv dag dato
DocType: Academic Year,Academic Year Name,Skoleårsnavn
DocType: Sales Partner,Contact Desc,Kontaktbeskrivelse
apps/erpnext/erpnext/config/hr.py +65,"Type of leaves like casual, sick etc.","Type blade som afslappet, syge etc."
DocType: Email Digest,Send regular summary reports via Email.,Send regelmæssige sammenfattende rapporter via e-mail.
DocType: Payment Entry,PE-,PE-
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +254,Please set default account in Expense Claim Type {0},Angiv standardkonto i udlægstype {0}
DocType: Assessment Result,Student Name,Elevnavn
DocType: Brand,Item Manager,Varechef
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +143,Payroll Payable,Udbetalt løn
DocType: Buying Settings,Default Supplier Type,Standard-leverandørtype
DocType: Production Order,Total Operating Cost,Samlede driftsomkostninger
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +171,Note: Item {0} entered multiple times,Bemærk: Varer {0} indtastet flere gange
apps/erpnext/erpnext/config/selling.py +41,All Contacts.,Alle kontakter.
apps/erpnext/erpnext/public/js/setup_wizard.js +67,Company Abbreviation,Firma-forkortelse
apps/erpnext/erpnext/healthcare/doctype/physician/physician.py +47,User {0} does not exist,Brugeren {0} eksisterer ikke
DocType: Subscription,SUB-,SUB
DocType: Item Attribute Value,Abbreviation,Forkortelse
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +182,Payment Entry already exists,Betaling indtastning findes allerede
apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py +36,Not authroized since {0} exceeds limits,Ikke authroized da {0} overskrider grænser
apps/erpnext/erpnext/config/hr.py +110,Salary template master.,Løn skabelon mester.
DocType: Leave Type,Max Days Leave Allowed,Maksimalt antal tilladte fraværsdage
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +63,Set Tax Rule for shopping cart,Sæt momsregel for indkøbskurv
DocType: Purchase Invoice,Taxes and Charges Added,Skatter og Afgifter Tilføjet
,Sales Funnel,Salgstragt
apps/erpnext/erpnext/setup/doctype/company/company.py +48,Abbreviation is mandatory,Forkortelsen er obligatorisk
DocType: Project,Task Progress,Opgave-fremskridt
apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html +7,Cart,Kurv
,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/accounts/doctype/tax_rule/tax_rule.py +139,All Customer Groups,Alle kundegrupper
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +114,Accumulated Monthly,Akkumuleret månedlig
apps/erpnext/erpnext/controllers/accounts_controller.py +638,{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2}.,{0} er obligatorisk. Måske Valutaveksling record er ikke skabt for {1} til {2}.
apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +40,Tax Template is mandatory.,Momsskabelon er obligatorisk.
apps/erpnext/erpnext/accounts/doctype/account/account.py +48,Account {0}: Parent account {1} does not exist,Konto {0}: Forældre-konto {1} findes ikke
DocType: Purchase Invoice Item,Price List Rate (Company Currency),Prisliste Rate (Company Valuta)
DocType: Products Settings,Products Settings,Produkter Indstillinger
DocType: Lab Prescription,Test Created,Test oprettet
DocType: Healthcare Settings,Custom Signature in Print,Brugerdefineret signatur i udskrivning
DocType: Account,Temporary,Midlertidig
DocType: Program,Courses,Kurser
DocType: Monthly Distribution Percentage,Percentage Allocation,Procentvis fordeling
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +124,Secretary,Sekretær
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"
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/sales_invoice/sales_invoice.js +1213,Please set Company,Angiv venligst firma
DocType: Pricing Rule,Buying,Køb
DocType: HR Settings,Employee Records to be created by,Medarbejdere skal oprettes af
DocType: Patient,AB Negative,AB Negativ
DocType: Sample Collection,SMPL-,SMPL-
DocType: POS Profile,Apply Discount On,Påfør Rabat på
,Reqd By Date,Reqd Efter dato
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +140,Creditors,Kreditorer
DocType: Assessment Plan,Assessment Name,Vurdering Navn
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +96,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
apps/erpnext/erpnext/public/js/setup_wizard.js +67,Institute Abbreviation,Institut Forkortelse
,Item-wise Price List Rate,Item-wise Prisliste Rate
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +921,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 +153,Quantity ({0}) cannot be a fraction in row {1},Mængde ({0}) kan ikke være en brøkdel i række {1}
DocType: Consultation,C-,C-
DocType: Attendance,ATT-,ATT-
apps/erpnext/erpnext/stock/doctype/item/item.py +446,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: 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/controllers/sales_and_purchase_return.py +20,{0} is mandatory for Return,{0} er obligatorisk for Return
DocType: Purchase Order,To Receive,At Modtage
apps/erpnext/erpnext/utilities/user_progress.py +231,user@example.com,user@example.com
DocType: Employee,Personal Email,Personlig e-mail
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +57,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/industry_type.py +15,Brokerage,Brokerage
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +232,Attendance for employee {0} is already marked for this day,Deltagelse for medarbejder {0} er allerede markeret for denne dag
DocType: Production Order Operation,"in Minutes
Updated via 'Time Log'",i minutter Opdateret via &#39;Time Log&#39;
DocType: Customer,From Lead,Fra Emne
apps/erpnext/erpnext/config/manufacturing.py +13,Orders released for production.,Ordrer frigives til produktion.
apps/erpnext/erpnext/public/js/account_tree_grid.js +66,Select Fiscal Year...,Vælg regnskabsår ...
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +556,POS Profile required to make POS Entry,POS profil kræves for at gøre POS indtastning
DocType: Program Enrollment Tool,Enroll Students,Tilmeld Studerende
DocType: Hub Settings,Name Token,Navn Token
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 +138,Atleast one warehouse is mandatory,Mindst ét lager skal angives
DocType: Serial No,Out of Warranty,Garanti udløbet
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 +360,{0} against Sales Invoice {1},{0} mod salgsfaktura {1}
DocType: Antibiotic,Laboratory User,Laboratoriebruger
DocType: Sales Invoice,SINV-,SF-
DocType: Request for Quotation Item,Project Name,Sagsnavn
DocType: Customer,Mention if non-standard receivable account,"Nævne, hvis ikke-standard tilgodehavende konto"
DocType: Journal Entry Account,If Income or Expense,Hvis indtægter og omkostninger
DocType: Production Order,Required Items,Nødvendige varer
DocType: Stock Ledger Entry,Stock Value Difference,Stock Value Forskel
apps/erpnext/erpnext/config/learn.py +234,Human Resource,Menneskelige Ressourcer
DocType: Payment Reconciliation Payment,Payment Reconciliation Payment,Betaling Afstemning Betaling
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +38,Tax Assets,Skatteaktiver
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +621,Production Order has been {0},Produktionsordre har været {0}
DocType: BOM Item,BOM No,Styklistenr.
DocType: Instructor,INS/,INS /
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +160,Journal Entry {0} does not have account {1} or already matched against other voucher,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 +46,Electronic Equipments,Elektronisk udstyr
DocType: Account,Debit,Debet
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +49,Leaves must be allocated in multiples of 0.5,"Fravær skal angives i multipla af 0,5"
DocType: Production Order,Operation Cost,Operation Cost
apps/erpnext/erpnext/config/hr.py +29,Upload attendance from a .csv file,Indlæs fremmøde fra en .csv-fil
apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +39,Outstanding Amt,Enestående Amt
DocType: Sales Person,Set targets Item Group-wise for this Sales Person.,Fastsatte mål Item Group-wise for denne Sales Person.
DocType: Stock Settings,Freeze Stocks Older Than [Days],Frys Stocks Ældre end [dage]
apps/erpnext/erpnext/controllers/accounts_controller.py +535,Row #{0}: Asset is mandatory for fixed asset purchase/sale,Række {0}: Aktiv er obligatorisk for anlægsaktiv køb / salg
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +42,"If two or more Pricing Rules are found based on the above conditions, Priority is applied. Priority is a number between 0 to 20 while default value is zero (blank). Higher number means it will take precedence if there are multiple Pricing Rules with same conditions.","Hvis to eller flere 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/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/config/hr.py +132,Types of Expense Claim.,Udlægstyper.
apps/erpnext/erpnext/controllers/selling_controller.py +175,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: Item,Taxes,Moms
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +324,Paid and Not Delivered,Betalt og ikke leveret
DocType: Project,Default Cost Center,Standard omkostningssted
DocType: Bank Guarantee,End Date,Slutdato
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: Depreciation Schedule,Accumulated Depreciation Amount,Akkumuleret Afskrivninger Beløb
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +42,Private Equity,Private Equity
DocType: Supplier Scorecard Variable,Supplier Scorecard Variable,Leverandør Scorecard Variable
DocType: Employee Loan,Fully Disbursed,fuldt udbetalt
DocType: Maintenance Visit,Customer Feedback,Kundefeedback
DocType: Account,Expense,Udlæg
apps/erpnext/erpnext/schools/doctype/assessment_result/assessment_result.js +34,Score cannot be greater than Maximum Score,Score kan ikke være større end maksimal score
apps/erpnext/erpnext/utilities/user_progress.py +108,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
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +96,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 +123,Item {0} ignored since it is not a stock item,"Vare {0} ignoreres, da det ikke er en lagervare"
DocType: Appraisal,APRSL,APRSL
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +101,Submit this Production Order for further processing.,Indsend denne produktionsordre til videre forarbejdning.
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: Assessment Group,Parent Assessment Group,Parent Group Assessment
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +27,Jobs,Stillinger
,Sales Order Trends,Salgsordre Trends
DocType: Employee,Held On,Held On
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order_calendar.js +36,Production Item,Produktion Vare
,Employee Information,Medarbejder Information
DocType: Stock Entry Detail,Additional Cost,Yderligere omkostning
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +39,"Can not filter based on Voucher No, if grouped by Voucher",Kan ikke filtrere baseret på bilagsnr. hvis der sorteres efter Bilagstype
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +891,Make Supplier Quotation,Opret Leverandørtilbud
DocType: Quality Inspection,Incoming,Indgående
apps/erpnext/erpnext/schools/doctype/assessment_result/assessment_result.py +47,Assessment Result record {0} already exists.,Vurdering Resultatoptegnelsen {0} eksisterer allerede.
DocType: BOM,Materials Required (Exploded),Nødvendige materialer (Sprængskitse)
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 +66,Posting Date cannot be future date,Bogføringsdato kan ikke være en fremtidig dato
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +101,Row # {0}: Serial No {1} does not match with {2} {3},Række # {0}: serienummer {1} matcher ikke med {2} {3}
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +82,Casual Leave,Casual Leave
apps/erpnext/erpnext/config/healthcare.py +138,Lab Test UOM.,Lab Test UOM.
DocType: Batch,Batch ID,Parti-id
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +380,Note: {0},Bemærk: {0}
,Delivery Note Trends,Følgeseddel Tendenser
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +113,This Week's Summary,Denne uges oversigt
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py +20,In Stock Qty,På lager Antal
apps/erpnext/erpnext/accounts/general_ledger.py +111,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: GL Entry,Party,Selskab
DocType: Healthcare Settings,Patient Name,Patientnavn
DocType: Variant Field,Variant Field,Variant Field
DocType: Sales Order,Delivery Date,Leveringsdato
DocType: Opportunity,Opportunity Date,Salgsmulighedsdato
DocType: Purchase Receipt,Return Against Purchase Receipt,Retur mod købskvittering
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: School 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: Purchase Invoice,"Enter Email Address separated by commas, invoice will be mailed automatically on particular date","Indtast e-mail-adresse adskilt af kommaer, vil faktura blive sendt automatisk på bestemt dato"
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +99,Piecework,Akkordarbejde
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +71,Avg. Buying Rate,Gns. købssats
DocType: Task,Actual Time (in Hours),Faktisk tid (i timer)
DocType: Employee,History In Company,Historie I Company
apps/erpnext/erpnext/config/learn.py +107,Newsletters,Nyhedsbreve
DocType: Drug Prescription,Description/Strength,Beskrivelse / Strength
DocType: Stock Ledger Entry,Stock Ledger Entry,Lagerpost
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +82,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: Sales Invoice,Tax ID,CVR-nr.
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +192,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/healthcare/doctype/lab_test/lab_test.js +38,Approve,Godkende
apps/erpnext/erpnext/schools/doctype/assessment_result_tool/assessment_result_tool.js +148,No Result to submit,Intet resultat at indsende
DocType: Customer,Sales Partner and Commission,Forhandler og provision
DocType: Employee 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;"
DocType: Opportunity,To Discuss,Samtaleemne
apps/erpnext/erpnext/stock/stock_ledger.py +368,{0} units of {1} needed in {2} to complete this transaction.,{0} enheder af {1} behov i {2} at fuldføre denne transaktion.
DocType: Loan Type,Rate of Interest (%) Yearly,Rente (%) Årlig
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +71,Temporary Accounts,Midlertidige konti
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +203,Black,Sort
DocType: BOM Explosion Item,BOM Explosion Item,BOM Explosion Vare
DocType: Account,Auditor,Revisor
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +124,{0} items produced,{0} varer produceret
apps/erpnext/erpnext/utilities/user_progress.py +55,Learn More,Lær mere
DocType: Cheque Print Template,Distance from top edge,Afstand fra overkanten
apps/erpnext/erpnext/stock/get_item_details.py +308,Price List {0} is disabled or does not exist,Prisliste {0} er deaktiveret eller findes ikke
DocType: Purchase Invoice,Return,Retur
DocType: Production Order Operation,Production Order Operation,Produktionsordre Operation
DocType: Pricing Rule,Disable,Deaktiver
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +161,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/healthcare/doctype/patient/patient_dashboard.py +10,Appointments and Consultations,Udnævnelser og konsultationer
apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +38,{0} - {1} is not enrolled in the Batch {2},{0} - {1} er ikke indskrevet i batch {2}
apps/erpnext/erpnext/accounts/doctype/asset/depreciation.py +113,"Asset {0} cannot be scrapped, as it is already {1}","Anlægsaktiv {0} kan ikke kasseres, da det allerede er {1}"
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
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +140,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 +574,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 +195,Fleet Management,Firmabiler
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +919,Add items from,Tilføj varer fra
DocType: Cheque Print Template,Regular,Fast
apps/erpnext/erpnext/schools/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: BOM,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: Lab Test,Mobile,Mobil
,Sales Person-wise Transaction Summary,SalgsPerson Transaktion Totaler
DocType: Training Event,Contact Number,Kontaktnummer
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +72,Warehouse {0} does not exist,Lager {0} eksisterer ikke
apps/erpnext/erpnext/hub_node/page/hub/register_in_hub.html +2,Register For ERPNext Hub,Tilmeld dig ERPNext Hub
DocType: Monthly Distribution,Monthly Distribution Percentages,Månedlige Distribution Procenter
apps/erpnext/erpnext/stock/doctype/batch/batch.py +37,The selected item cannot have Batch,Den valgte vare kan ikke have parti
apps/erpnext/erpnext/stock/stock_ledger.py +464,"Valuation rate not found for the Item {0}, which is required to do accounting entries for {1} {2}. If the item is transacting as a sample item in the {1}, please mention that in the {1} Item table. Otherwise, please create an incoming stock transaction for the item or mention valuation rate in the Item record, and then try submiting/cancelling this entry","Værdiansættelse fald ikke fundet for Item {0}, som er forpligtet til at gøre regnskabsmæssige poster for {1} {2}. Hvis varen er transaktionsomkostninger som en prøve post i nævne {1}, bedes der i {1} Item bord. Ellers skal du oprette en indgående bestand transaktion for elementet eller omtale værdiansættelse sats i Item rekord, og derefter prøve submiting / annullering denne post"
DocType: Delivery Note,% of materials delivered against this Delivery Note,% af materialer leveret mod denne følgeseddel
DocType: Project,Customer Details,Kunde Detaljer
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 +137,Explore Sales Cycle,Udforsk salgscyklus
DocType: Assessment Plan,Supervisor,Tilsynsførende
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +63,Online,Online
,Available Stock for Packing Items,Tilgængelig Stock til Emballerings- Varer
DocType: Item Variant,Item Variant,Varevariant
DocType: Assessment Result Tool,Assessment Result Tool,Assessment Resultat Tool
DocType: BOM Scrap Item,BOM Scrap Item,Stykliste skrotvare
apps/erpnext/erpnext/accounts/page/pos/pos.js +894,Submitted orders can not be deleted,Godkendte ordrer kan ikke slettes
apps/erpnext/erpnext/accounts/doctype/account/account.py +117,"Account balance already in Debit, you are not allowed to set 'Balance Must Be' as 'Credit'",Konto balance er debit. Du har ikke lov til at ændre 'Balancetype' til 'kredit'
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +114,Quality Management,Kvalitetssikring
apps/erpnext/erpnext/accounts/doctype/asset/asset.py +41,Item {0} has been disabled,Vare {0} er blevet deaktiveret
DocType: Employee Loan,Repay Fixed Amount per Period,Tilbagebetale fast beløb pr Periode
apps/erpnext/erpnext/buying/utils.py +47,Please enter quantity for Item {0},Indtast mængde for vare {0}
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +78,Credit Note Amt,Kreditnota Amt
DocType: Employee External Work History,Employee External Work History,Medarbejder Ekstern Work History
DocType: Tax Rule,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
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 +35,Cost Centers,Omkostningssteder
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"
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: Training Event Employee,Invited,inviteret
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +175,Multiple active Salary Structures found for employee {0} for the given dates,Flere aktive lønstrukturer fundet for medarbejder {0} for de givne datoer
apps/erpnext/erpnext/config/accounts.py +316,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 +42,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
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +92,Application period cannot be across two alocation records,Ansøgningsperiode kan ikke være på tværs af to alocation optegnelser
DocType: Item Group,Default Expense Account,Standard udgiftskonto
apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +53,Student Email ID,Student Email ID
DocType: Employee,Notice (days),Varsel (dage)
DocType: Tax Rule,Sales Tax Template,Salg Momsskabelon
apps/erpnext/erpnext/accounts/page/pos/pos.js +2456,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: Production Order,Planned Operating Cost,Planlagte driftsomkostninger
DocType: Academic Term,Term Start Date,Betingelser startdato
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +18,Opp Count,Opp Count
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +183,Please find attached {0} #{1},Vedlagt {0} # {1}
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +34,Bank Statement balance as per General Ledger,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
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +43,Please specify from/to range,Angiv fra / til spænder
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/public/js/utils.js +45,Add Serial No,Tilføj serienummer
DocType: Production 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
DocType: Production Order,Warehouses,Lagre
apps/erpnext/erpnext/accounts/doctype/asset_movement/asset_movement.py +18,{0} asset cannot be transferred,{0} aktiv kan ikke overføres
apps/erpnext/erpnext/stock/doctype/item/item.js +66,This Item is a Variant of {0} (Template).,Denne vare er en variant af {0} (skabelon).
DocType: Workstation,per hour,per time
apps/erpnext/erpnext/config/buying.py +7,Purchasing,Indkøb
DocType: Announcement,Announcement,Bekendtgørelse
DocType: School 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."
DocType: Company,Distribution,Distribution
DocType: Lab Test,Report Preference,Rapportindstilling
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +129,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/install_fixtures.py +110,Dispatch,Dispatch
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +73,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 +173,Net Asset value as on,Indre værdi som på
DocType: Account,Receivable,Tilgodehavende
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +288,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: 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 +925,Select Items to Manufacture,Vælg varer til Produktion
apps/erpnext/erpnext/accounts/page/pos/pos.js +962,"Master data syncing, it might take some time","Master data synkronisering, kan det tage nogen tid"
DocType: Item,Material Issue,Materiale Issue
DocType: Hub Settings,Seller Description,Sælger Beskrivelse
DocType: Employee Education,Qualification,Kvalifikation
DocType: Item Price,Item Price,Varepris
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +48,Soap & Detergent,Sæbe &amp; Vaskemiddel
DocType: BOM,Show Items,Vis elementer
apps/erpnext/erpnext/schools/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/setup/setup_wizard/industry_type.py +36,Motion Picture & Video,Motion Picture &amp; Video
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js +5,Ordered,Bestilt
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js +44,Resume,Genoptag
DocType: Salary Detail,Component,Lønart
DocType: Assessment Criteria,Assessment Criteria Group,Vurderingskriterier Group
DocType: Healthcare Settings,Patient Name By,Patientnavn By
apps/erpnext/erpnext/accounts/doctype/asset/asset.py +72,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
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å
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +54,Supplier &gt; Supplier Type,Leverandør&gt; Leverandør Type
apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +21,Support Analtyics,Support Analtyics
apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +142,Uncheck all,Fravælg alle
DocType: POS Profile,Terms and Conditions,Betingelser
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 +202,Cannot cancel because submitted Stock Entry {0} exists,"Kan ikke annullere, for en godkendt lagerindtastning {0} eksisterer"
DocType: Employee Loan,Disbursement Date,Udbetaling Dato
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +61,'Recipients' not specified,&#39;Modtagere&#39; er ikke angivet
DocType: BOM Update Tool,Update latest price in all BOMs,Opdater seneste pris i alle BOM&#39;er
apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.js +40,Medical Record,Medicinsk post
DocType: Vehicle,Vehicle,Køretøj
DocType: Purchase Invoice,In Words,I Words
apps/erpnext/erpnext/hr/doctype/training_result/training_result.py +15,{0} must be submitted,{0} skal indsendes
DocType: POS Profile,Item Groups,Varegrupper
apps/erpnext/erpnext/hr/doctype/employee/employee.py +217,Today is {0}'s birthday!,I dag er {0} &#39;s fødselsdag!
DocType: Production Planning Tool,Material Request For Warehouse,Materialeanmodning for lager
DocType: Sales Order Item,For Production,For Produktion
DocType: Payment Request,payment_url,payment_url
DocType: Project Task,View Task,Vis opgave
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +22,Opp/Lead %,Opp / Lead%
DocType: Material Request,MREQ-,MANM-
,Asset Depreciations and Balances,Asset Afskrivninger og Vægte
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +351,Amount {0} {1} transferred from {2} to {3},Mængden {0} {1} overført fra {2} til {3}
DocType: Sales Invoice,Get Advances Received,Få forskud
DocType: Email Digest,Add/Remove Recipients,Tilføj / fjern modtagere
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +461,Transaction not allowed against stopped Production Order {0},Transaktion ikke tilladt mod stoppet produktionsordre {0}
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.js +19,"To set this Fiscal Year as Default, click on 'Set as Default'","For at indstille dette regnskabsår som standard, skal du klikke på &#39;Vælg som standard&#39;"
apps/erpnext/erpnext/projects/doctype/project/project.py +200,Join,Tilslutte
apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +20,Shortage Qty,Mangel Antal
apps/erpnext/erpnext/stock/doctype/item/item.py +667,Item variant {0} exists with same attributes,Vare variant {0} eksisterer med samme attributter
DocType: Employee Loan,Repay from Salary,Tilbagebetale fra Løn
DocType: Leave Application,LAP/,ANFR/
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +347,Requesting payment against {0} {1} for amount {2},Anmodning betaling mod {0} {1} for beløb {2}
DocType: Salary Slip,Salary Slip,Lønseddel
DocType: Lead,Lost Quotation,Lost Citat
apps/erpnext/erpnext/utilities/user_progress.py +200,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."
DocType: Sales Invoice Item,Sales Order Item,Salgsordrevare
DocType: Salary Slip,Payment Days,Betalingsdage
DocType: Patient,Dormant,hvilende
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +121,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: 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."
apps/erpnext/erpnext/config/setup.py +14,Global Settings,Globale indstillinger
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 +48,Duplicate item group found in the item group table,Samme varegruppe findes to gange i varegruppetabellen
apps/erpnext/erpnext/public/js/controllers/transaction.js +965,It is needed to fetch Item Details.,Det er nødvendigt at hente Elementdetaljer.
DocType: Salary Slip,Net Pay,Nettoløn
DocType: Account,Account,Konto
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +217,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: Purchase Invoice,Recurring Id,Tilbagevendende Id
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 +1349,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.
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +228,Invalid {0},Ugyldig {0}
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +86,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/industry_type.py +22,Department Stores,Varehuse
,Item Delivery Date,Leveringsdato for vare
DocType: Warehouse,PIN,PIN
apps/erpnext/erpnext/setup/setup_wizard/sample_data.py +109,Setup your School in ERPNext,Opsætning din skole i ERPNext
DocType: Sales Invoice,Base Change Amount (Company Currency),Base ændring beløb (Company Currency)
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +304,No accounting entries for the following warehouses,Ingen bogføring for følgende lagre
apps/erpnext/erpnext/projects/doctype/project/project.js +111,Save the document first.,Gem dokumentet først.
DocType: Account,Chargeable,Gebyr
DocType: Company,Change Abbreviation,Skift Forkortelse
DocType: Expense Claim Detail,Expense Date,Udlægsdato
DocType: Item,Max Discount (%),Maksimal rabat (%)
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +70,Last Order Amount,Sidste ordrebeløb
DocType: Task,Is Milestone,Er Milestone
DocType: Daily Work Summary,Email Sent To,E-mail til
DocType: Budget,Warn,Advar
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: BOM,Manufacturing User,Produktionsbruger
DocType: Purchase Invoice,Raw Materials Supplied,Leverede råvarer
DocType: Purchase Invoice,Recurring Print Format,Tilbagevendende Print Format
DocType: C-Form,Series,Nummerserie
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +264,Currency of the price list {0} must be {1} or {2},Valuta på prislisten {0} skal være {1} eller {2}
apps/erpnext/erpnext/utilities/user_progress.py +114,Add Products,Tilføj produkter
DocType: Appraisal,Appraisal Template,Vurderingsskabelon
DocType: Item Group,Item Classification,Item Klassifikation
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +127,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: Drug Prescription,Period,Periode
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.js +18,General Ledger,Finansbogholderi
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +33,Employee {0} on Leave on {1},Medarbejder {0} tjenestefrihed af {1}
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
,Itemwise Recommended Reorder Level,Itemwise Anbefalet genbestillings Level
DocType: Salary Detail,Salary Detail,Løn Detail
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1022,Please select {0} first,Vælg {0} først
DocType: Appointment Type,Physician,Læge
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +804,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
DocType: Sales Invoice,Commission,Provision
apps/erpnext/erpnext/config/manufacturing.py +27,Time Sheet for manufacturing.,Tidsregistrering til Produktion.
apps/erpnext/erpnext/templates/pages/cart.html +37,Subtotal,Subtotal
DocType: Physician,Charges,Afgifter
DocType: Salary Detail,Default Amount,Standard Mængde
DocType: Lab Test Template,Descriptive,Beskrivende
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +93,Warehouse not found in the system,Lager ikke fundet i systemet
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +116,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 +24,`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 +45,Set a sales goal you'd like to achieve for your company.,"Indstil et salgsmål, du gerne vil opnå for din virksomhed."
,Project wise Stock Tracking,Opfølgning på lager sorteret efter sager
DocType: GST HSN Code,Regional,Regional
apps/erpnext/erpnext/config/healthcare.py +40,Laboratory,Laboratorium
DocType: Stock Entry Detail,Actual Qty (at source/target),Faktiske Antal (ved kilden / mål)
DocType: Item Customer Detail,Ref Code,Ref Code
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +66,Customer Group is Required in POS Profile,Kundegruppe er påkrævet i POS-profil
apps/erpnext/erpnext/config/hr.py +12,Employee records.,Medarbejder Records.
apps/erpnext/erpnext/accounts/doctype/asset/asset.py +92,Please set Next Depreciation Date,Indtast Næste afskrivningsdato
DocType: HR Settings,Payroll Settings,Lønindstillinger
apps/erpnext/erpnext/config/accounts.py +154,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 +24,Root cannot have a parent cost center,Root kan ikke have en forælder cost center
apps/erpnext/erpnext/public/js/stock_analytics.js +57,Select Brand...,Vælg varemærke ...
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +18,Training Events/Results,Træningsarrangementer / Resultater
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +149,Accumulated Depreciation as on,Akkumulerede afskrivninger som på
DocType: Sales Invoice,C-Form Applicable,C-anvendelig
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +394,Operation Time must be greater than 0 for Operation {0},Driftstid skal være større end 0 til drift {0}
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +106,Warehouse is mandatory,Lager er obligatorisk
DocType: Supplier,Address and Contacts,Adresse og kontaktpersoner
DocType: UOM Conversion Detail,UOM Conversion Detail,UOM Konvertering Detail
DocType: Program,Program Abbreviation,Program Forkortelse
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +382,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
DocType: Bank Guarantee,Start Date,Startdato
apps/erpnext/erpnext/config/hr.py +75,Allocate leaves for a period.,Afsætte blade i en periode.
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 +50,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
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: Sample Collection,Collected By,Indsamlet af
apps/erpnext/erpnext/schools/doctype/assessment_plan/assessment_plan.js +22,Assessment Result,Vurdering Resultat
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +13,Hours,Timer
DocType: Project,Expected Start Date,Forventet startdato
DocType: Setup Progress Action,Setup Progress Action,Setup Progress Action
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/payment_request/payment_request.py +34,Transaction currency must be same as Payment Gateway currency,Transaktion valuta skal være samme som Payment Gateway valuta
DocType: Payment Entry,Receive,Modtag
apps/erpnext/erpnext/templates/pages/rfq.html +75,Quotations: ,Tilbud:
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
DocType: Budget,Action if Accumulated Monthly Budget Exceeded,Action hvis Akkumulerede Månedligt budget overskredet
DocType: Purchase Invoice,Submit on creation,Godkend ved oprettelse
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +464,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 +497,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 +81,"Cannot declare as lost, because Quotation has been made.","Kan ikke erklæres tabt, fordi tilbud er afgivet."
apps/erpnext/erpnext/hr/doctype/training_event/training_event.js +13,Training Feedback,Træning Feedback
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +458,Production Order {0} must be submitted,Produktionsordre {0} skal godkendes
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}
apps/erpnext/erpnext/schools/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
apps/erpnext/erpnext/stock/doctype/item/item.js +264,Add / Edit Prices,Tilføj / rediger priser
DocType: Batch,Parent Batch,Overordnet parti
DocType: Cheque Print Template,Cheque Print Template,Anvendes ikke
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +36,Chart of Cost Centers,Diagram af omkostningssteder
DocType: Lab Test Template,Sample Collection,Prøveopsamling
,Requested Items To Be Ordered,Anmodet Varer skal bestilles
DocType: Price List,Price List Name,Prislistenavn
apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py +32,Daily Work Summary for {0},Daglige arbejde Summary for {0}
DocType: Employee Loan,Totals,Totaler
DocType: BOM,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 +124,Warning: Leave application contains following block dates,Advarsel: Fraværsansøgningen indeholder følgende blokerede dage
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +266,Sales Invoice {0} has already been submitted,Salgsfaktura {0} er allerede blevet godkendt
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
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +30,Completion Date,Afslutning Dato
DocType: Purchase Invoice Item,Amount (Company Currency),Beløb (firmavaluta)
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 +372,{0} units of {1} needed in {2} on {3} {4} for {5} to complete this transaction.,{0} enheder af {1} behov 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/config/hr.py +229,Organization unit (department) master.,Organisationsenheds-master.
apps/erpnext/erpnext/utilities/user_progress.py +218,Go to Rooms,Gå til værelser
apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +75,Please enter message before sending,"Indtast venligst en meddelelse, før du sender"
DocType: Purchase Invoice,DUPLICATE FOR SUPPLIER,DUPLIKATE FOR LEVERANDØR
DocType: Email Digest,Pending Quotations,Afventende tilbud
apps/erpnext/erpnext/config/accounts.py +321,Point-of-Sale Profile,Kassesystemprofil
apps/erpnext/erpnext/config/healthcare.py +153,Lab Test Configurations.,Lab Test Configurations.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +156,Unsecured Loans,Usikrede lån
DocType: Cost Center,Cost Center Name,Omkostningsstednavn
DocType: Employee,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/accounts_receivable.html +77,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
,Serial No Service Contract Expiry,Serienummer Servicekontrakt-udløb
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +299,You cannot credit and debit same account at the same time,Du kan ikke 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}
apps/erpnext/erpnext/utilities/user_progress.py +88,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 +365,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/accounts/doctype/payment_entry/payment_entry.py +358,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/hr/doctype/expense_claim/expense_claim.py +24,{0}: From {0} for {1},{0}: Fra {0} for {1}
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +219,"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 +166,Row #{0}: Set Supplier for item {1},Række # {0}: Indstil Leverandør for vare {1}
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +121,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 +172,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
apps/erpnext/erpnext/setup/setup_wizard/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.
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/journal_entry/journal_entry.py +323,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 +85,Item: {0} does not exist in the system,Item: {0} findes ikke i systemet
apps/erpnext/erpnext/accounts/doctype/account/account.py +109,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
DocType: Payment Reconciliation,From Invoice Date,Fra fakturadato
apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.py +28,You don't have permission to submit,Du har ikke tilladelse til at indsende
apps/erpnext/erpnext/accounts/party.py +261,Billing currency must be equal to either default comapany's currency or party account currency,Faktureringsvaluta skal være lig med enten firmaets standardvaluta eller partens kontovaluta
DocType: Healthcare Settings,Laboratory Settings,Laboratorieindstillinger
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +71,Leave Encashment,Udbetal fravær
apps/erpnext/erpnext/public/js/setup_wizard.js +107,What does it do?,Hvad gør det?
apps/erpnext/erpnext/stock/doctype/batch/batch.js +70,To Warehouse,Til lager
apps/erpnext/erpnext/schools/doctype/student_admission/student_admission.py +23,All Student Admissions,Alle Student Indlæggelser
,Average Commission Rate,Gennemsnitlig provisionssats
apps/erpnext/erpnext/stock/doctype/item/item.py +407,'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 +62,Select Status,Vælg Status
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +41,Attendance can not be marked for future dates,Fremmøde kan ikke markeres for fremtidige datoer
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: Purchase Taxes and Charges,Account Head,Konto hoved
apps/erpnext/erpnext/config/stock.py +173,Update additional costs to calculate landed cost of items,Opdater yderligere omkostninger til at beregne landede udgifter til poster
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +149,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)
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +348,Row {0}: Exchange Rate is mandatory,Række {0}: Valutakursen er obligatorisk
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +27,User ID not set for Employee {0},Bruger-id ikke indstillet til Medarbejder {0}
DocType: Vehicle,Vehicle Value,Køretøjsværdi
DocType: Stock Entry,Default Source Warehouse,Standardkildelager
DocType: Item,Customer Code,Kundekode
apps/erpnext/erpnext/hr/doctype/employee/employee.py +216,Birthday Reminder for {0},Birthday Reminder for {0}
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 +354,Debit To account must be a Balance Sheet account,Debit-Til konto skal være en balance konto
DocType: Buying Settings,Naming Series,Navngivningsnummerserie
DocType: Leave Block List,Leave Block List Name,Blokering af fraværsansøgninger
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
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +32,Stock Assets,Lageraktiver
DocType: Timesheet,Production Detail,Produktion Detail
DocType: Target Detail,Target Qty,Target Antal
DocType: Shopping Cart Settings,Checkout Settings,Kassen Indstillinger
DocType: Attendance,Present,Tilstede
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +35,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 +323,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: Sales Order Item,Ordered Qty,Bestilt antal
apps/erpnext/erpnext/stock/doctype/item/item.py +695,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 +895,BOM does not contain any stock item,Stykliste indeholder ikke nogen lagervarer
apps/erpnext/erpnext/config/projects.py +18,Project activity / task.,Sagsaktivitet / opgave.
DocType: Vehicle Log,Refuelling Details,Brændstofpåfyldningsdetaljer
apps/erpnext/erpnext/config/hr.py +104,Generate Salary Slips,Generer lønsedler
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +44,"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
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +121,Last purchase rate not found,Sidste købsværdi ikke fundet
DocType: Purchase Invoice,Write Off Amount (Company Currency),Skriv Off Beløb (Company Valuta)
DocType: Sales Invoice Timesheet,Billing Hours,Fakturerede timer
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +495,Default BOM for {0} not found,Standard stykliste for {0} blev ikke fundet
apps/erpnext/erpnext/stock/doctype/item/item.py +487,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: Landed Cost Voucher,Landed Cost Voucher,Landed Cost Voucher
apps/erpnext/erpnext/public/js/queries.js +39,Please set {0},Indstil {0}
DocType: Purchase Invoice,Repeat on Day of Month,Gentag på dag i måneden
apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +36,{0} - {1} is inactive student,{0} - {1} er inaktiv studerende
DocType: Employee,Health Details,Sundhedsdetaljer
DocType: Offer Letter,Offer Letter Terms,Ansættelsesvilkår
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +24,To create a Payment Request reference document is required,For at oprette en betalingsanmodning kræves referencedokument
DocType: Payment Entry,Allocate Payment Amount,Tildel Betaling Beløb
DocType: Employee External Work History,Salary,Løn
DocType: Serial No,Delivery Document Type,Levering Dokumenttype
DocType: Process Payroll,Submit all salary slips for the above selected criteria,Godkend alle lønsedler for de ovenfor valgte kriterier
apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +93,{0} Items synced,synkroniseret {0} varer
DocType: Sales Order,Partly Delivered,Delvist leveret
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 +225,"{0} {1} is associated with {2}, but Party Account is {3}","{0} {1} er forbundet med {2}, men Party Account er {3}"
apps/erpnext/erpnext/healthcare/doctype/sample_collection/sample_collection.js +7,View Lab Tests,Se labtest
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 +94,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 +319,BOM and Manufacturing Quantity are required,Stykliste and produceret mængde skal angives
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +44,Ageing Range 2,Ageing Range 2
DocType: SG Creation Tool Course,Max Strength,Max Strength
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +22,BOM replaced,Stykliste erstattet
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +988,Select Items based on Delivery Date,Vælg varer baseret på Leveringsdato
,Sales Analytics,Salgsanalyser
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +114,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/schools/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 +103,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 +110,Daily Reminders,Daglige påmindelser
DocType: Products Settings,Home Page is Products,Home Page er Produkter
,Asset Depreciation Ledger,Asset Afskrivninger Ledger
apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +87,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
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +111,Customer Service,Kundeservice
DocType: BOM,Thumbnail,Thumbnail
DocType: Item Customer Detail,Item Customer Detail,Item Customer Detail
apps/erpnext/erpnext/config/hr.py +50,Offer candidate a Job.,Tilbyd ansøger en stilling
DocType: Notification Control,Prompt for Email on Submission of,Spørg til Email på Indsendelse af
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +88,Total allocated leaves are more than days in the period,Samlede fordelte blade er mere end dage i perioden
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/config/accounts.py +296,Default settings for accounting transactions.,Standardindstillinger regnskabsmæssige transaktioner.
DocType: Maintenance Visit,MV,MV
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +59,Expected Date cannot be before Material Request Date,Forventet dato kan ikke være før materialeanmodningsdatoen
DocType: Fees,Student Details,Studentoplysninger
DocType: Purchase Invoice Item,Stock Qty,Antal på lager
DocType: Employee 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 +78,{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: Sales Order,Printing Details,Udskrivningsindstillinger
DocType: Task,Closing Date,Closing Dato
DocType: Sales Order Item,Produced Quantity,Produceret Mængde
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +122,Engineer,Ingeniør
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 +168,Item Code required at Row No {0},Varenr. kræves på rækkenr. {0}
apps/erpnext/erpnext/utilities/user_progress.py +133,Go to Items,Gå til varer
DocType: Sales Partner,Partner Type,Partnertype
DocType: Purchase Taxes and Charges,Actual,Faktiske
DocType: Authorization Rule,Customerwise Discount,Customerwise Discount
apps/erpnext/erpnext/config/projects.py +40,Timesheet for tasks.,Timeseddel til opgaver.
DocType: Purchase Invoice,Against Expense Account,Mod udgiftskonto
DocType: Production Order,Production Order,Produktionsordre
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +273,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: Purchase Invoice,Select the period when the invoice will be generated automatically,"Vælg den periode, hvor fakturaen vil blive genereret automatisk"
DocType: BOM,Raw Material Cost,Råmaterialeomkostninger
DocType: Item Reorder,Re-Order Level,Re-Order Level
DocType: Production Planning Tool,Enter items and planned qty for which you want to raise production orders or download raw materials for analysis.,"Indtast poster og planlagt qty, som du ønsker at hæve produktionsordrer eller downloade råmaterialer til analyse."
apps/erpnext/erpnext/projects/doctype/project/project.js +64,Gantt Chart,Gantt-diagram
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +95,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 +59,Series Updated,Nummerserien opdateret
apps/erpnext/erpnext/accounts/doctype/account/account.py +162,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/utilities/user_progress.py +145,Add Programs,Tilføj programmer
apps/erpnext/erpnext/setup/setup_wizard/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}
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +97,Clearance Date updated,Clearance Dato opdateret
apps/erpnext/erpnext/stock/doctype/batch/batch.js +126,Split Batch,Opdel parti
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +131,Successfully Reconciled,Succesfuld Afstemt
DocType: Request for Quotation Supplier,Download PDF,Download PDF
DocType: Production Order,Planned End Date,Planlagt slutdato
apps/erpnext/erpnext/config/stock.py +189,Where items are stored.,Hvor varer er på lager.
DocType: Request for Quotation,Supplier Detail,Leverandør Detail
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +98,Error in formula or condition: {0},Fejl i formel eller betingelse: {0}
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +16,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%
DocType: Attendance,Attendance,Fremmøde
apps/erpnext/erpnext/public/js/pos/pos.html +106,Stock Items,Lagervarer
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/accounts/doctype/asset_movement/asset_movement.py +28,Source and Target Warehouse cannot be same,Kilde og Target Warehouse kan ikke være samme
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +535,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: Period Closing Voucher,Period Closing Voucher,Periode Lukning Voucher
DocType: Consultation,Review Details,Gennemgå detaljer
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: Company,Series for Asset Depreciation Entry (Journal Entry),Serie for Asset Depreciation Entry (Journal Entry)
DocType: Purchase Invoice,Advance Payments,Forudbetalinger
DocType: Purchase Taxes and Charges,On Net Total,On Net Total
apps/erpnext/erpnext/controllers/item_variant.py +90,Value for Attribute {0} must be within the range of {1} to {2} in the increments of {3} for Item {4},Værdi for Egenskab {0} skal være inden for området af {1} og {2} i intervaller af {3} til konto {4}
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +161,Target warehouse in row {0} must be same as Production Order,Target lager i rækken {0} skal være samme som produktionsordre
apps/erpnext/erpnext/accounts/doctype/account/account.py +127,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: 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 +93,Administrative Expenses,Administrationsomkostninger
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +18,Consulting,Rådgivning
DocType: Customer Group,Parent Customer Group,Overordnet kundegruppe
DocType: Journal Entry,Subscription,Abonnement
DocType: Purchase Invoice,Contact Email,Kontakt e-mail
apps/erpnext/erpnext/schools/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/install_fixtures.py +229,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: Delivery Note Item,Against Sales Invoice,Mod salgsfaktura
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +128,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 +493,Credit Account,Kreditkonto
DocType: Landed Cost Item,Landed Cost Item,Landed Cost Vare
apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.js +57,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
apps/erpnext/erpnext/stock/doctype/item/item.py +662,Please specify Attribute Value for attribute {0},Angiv Attribut Værdi for attribut {0}
DocType: Item,Default Warehouse,Standard-lager
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +45,Budget cannot be assigned against Group Account {0},Budget kan ikke tildeles mod Group konto {0}
DocType: Healthcare Settings,Patient Registration,Patientregistrering
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +22,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 +57,Depreciation Date,Afskrivningsdato
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: Fee Structure,FS.,FS.
DocType: Student Attendance Tool,Batch,Parti
apps/erpnext/erpnext/stock/doctype/item/item.js +27,Balance,Balance
DocType: Room,Seating Capacity,Seating Capacity
DocType: Issue,ISS-,ISS-
DocType: Lab Test Groups,Lab Test Groups,Lab Test Grupper
DocType: Project,Total Expense Claim (via Expense Claims),Udlæg ialt (via Udlæg)
DocType: GST Settings,GST Summary,GST Sammendrag
DocType: Assessment Result,Total Score,Samlet score
DocType: Journal Entry,Debit Note,Debitnota
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: Batch,Source Document Type,Kilde dokumenttype
DocType: Journal Entry,Total Debit,Samlet debet
DocType: Manufacturing Settings,Default Finished Goods Warehouse,Standard færdigvarer Warehouse
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +77,Sales Person,Salgsmedarbejder
apps/erpnext/erpnext/config/accounts.py +241,Budget and Cost Center,Budget og Omkostningssted
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +60,Multiple default mode of payment is not allowed,Flere standard betalingsmåder er ikke tilladt
,Appointment Analytics,Aftale Analytics
DocType: Vehicle Service,Half Yearly,Halvårlig
DocType: Lead,Blog Subscriber,Blog Subscriber
DocType: Guardian,Alternate Number,Alternativ Number
DocType: Healthcare Settings,Consultations in valid days,Konsultationer i gyldige dage
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.
apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +49, Group Roll No,Gruppe Roll nr
apps/erpnext/erpnext/schools/doctype/fee_schedule/fee_schedule_list.js +9,Fee Creation Failed,Fee Creation mislykkedes
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"
DocType: Purchase Invoice,Total Advance,Samlet Advance
apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +27,Change Template Code,Skift skabelonkode
apps/erpnext/erpnext/schools/doctype/academic_term/academic_term.py +23,The Term End Date cannot be earlier than the Term Start Date. Please correct the dates and try again.,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
,BOM Stock Report,BOM Stock Rapport
DocType: Stock Reconciliation Item,Quantity Difference,Mængdeforskel
apps/erpnext/erpnext/config/hr.py +311,Processing Payroll,Lønadministration
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 +175,Set as Lost,Sæt som Lost
DocType: Timesheet,Total Billable Hours,Total fakturerbare timer
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
DocType: Supplier,Credit Days Based On,Kreditdage baseret på
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +161,Row {0}: Allocated amount {1} must be less than or equals to Payment Entry amount {2},Række {0}: Allokeret beløb {1} skal være mindre end eller lig med Payment indtastning beløb {2}
,Course wise Assessment Report,Kursusbaseret vurderingsrapport
DocType: Tax Rule,Tax Rule,Momsregel
DocType: Selling Settings,Maintain Same Rate Throughout Sales Cycle,Oprethold Samme Rate Gennem Sales Cycle
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 +89,Customers in Queue,Kunder i kø
DocType: Student,Nationality,Nationalitet
,Items To Be Requested,Varer til bestilling
DocType: Purchase Order,Get Last Purchase Rate,Hent sidste købssats
DocType: Company,Company Info,Firmainformation
apps/erpnext/erpnext/accounts/page/pos/pos.js +1382,Select or add new customer,Vælg eller tilføj ny kunde
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +154,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
apps/erpnext/erpnext/schools/doctype/student_attendance_tool/student_attendance_tool.js +112,Mark Attendance,Mark Attendance
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +487,Debit Account,Debetkonto
DocType: Fiscal Year,Year Start Date,År Startdato
DocType: Attendance,Employee Name,Medarbejdernavn
DocType: Sales Invoice,Rounded Total (Company Currency),Afrundet i alt (firmavaluta)
apps/erpnext/erpnext/accounts/doctype/account/account.py +99,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 +240,{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/report/asset_depreciation_ledger/asset_depreciation_ledger.py +63,Purchase Amount,Indkøbsbeløb
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +259,Supplier Quotation {0} created,Leverandørtilbud {0} oprettet
apps/erpnext/erpnext/accounts/report/financial_statements.py +97,End Year cannot be before Start Year,Slutår kan ikke være før startår
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +222,Employee Benefits,Personalegoder
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +255,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: Production Order,Manufactured Qty,Fremstillet mængde
DocType: Purchase Receipt Item,Accepted Quantity,Mængde
apps/erpnext/erpnext/hr/doctype/employee/employee.py +238,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 +31,{0}: {1} does not exists,{0}: {1} eksisterer ikke
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +75,Select Batch Numbers,Vælg batchnumre
apps/erpnext/erpnext/config/accounts.py +12,Bills raised to Customers.,Regninger sendt til kunder.
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26,Project Id,Sags-id
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +534,Row No {0}: Amount cannot be greater than Pending Amount against Expense Claim {1}. Pending Amount is {2},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: Maintenance Schedule,Schedule,Køreplan
DocType: Account,Parent Account,Parent Konto
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +239,Available,Tilgængelig
DocType: Quality Inspection Reading,Reading 3,Reading 3
,Hub,Hub
DocType: GL Entry,Voucher Type,Bilagstype
apps/erpnext/erpnext/accounts/page/pos/pos.js +1714,Price List not found or disabled,Prisliste ikke fundet eller deaktiveret
DocType: Lab Test,Approved,Godkendt
DocType: Pricing Rule,Price,Pris
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +264,Employee relieved on {0} must be set as 'Left',Medarbejder lettet på {0} skal indstilles som &quot;Left&quot;
DocType: Guardian,Guardian,Guardian
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +42,Appraisal {0} created for Employee {1} in the given date range,Vurdering {0} dannet for medarbejder {1} i det givne datointerval
DocType: Employee,Education,Uddannelse
apps/erpnext/erpnext/public/js/pos/pos.html +80,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 +48,Monthly Sales Target (,Månedligt salgsmål (
apps/erpnext/erpnext/templates/includes/projects/project_tasks.html +9,modified,modificeret
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
apps/erpnext/erpnext/config/accounts.py +67,Accounting journal entries.,Regnskab journaloptegnelser.
DocType: Delivery Note Item,Available Qty at From Warehouse,Tilgængeligt antal fra vores lager
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +295,Please select Employee Record first.,Vælg Medarbejder Record først.
DocType: POS Profile,Account for Change Amount,Konto for returbeløb
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +217,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}
apps/erpnext/erpnext/schools/report/course_wise_assessment_report/course_wise_assessment_report.html +9,Course Code: ,Kursuskode:
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +238,Please enter Expense Account,Indtast venligst udgiftskonto
DocType: Account,Stock,Lager
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1047,"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 +325,Batch Inventory,Partilager
DocType: Employee,Contract End Date,Kontrakt Slutdato
DocType: Sales Order,Track this Sales Order against any Project,Spor denne salgsordre mod enhver sag
DocType: Sales Invoice Item,Discount and Margin,Rabat og Margin
DocType: Lab Test,Prescription,Recept
DocType: Production Planning Tool,Pull sales orders (pending to deliver) based on the above criteria,Pull salgsordrer (afventer at levere) baseret på ovenstående kriterier
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +90,Not Available,Ikke tilgængelig
DocType: Pricing Rule,Min Qty,Minimum mængde
apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +36,Disable Template,Deaktiver skabelon
DocType: Asset Movement,Transaction Date,Transaktionsdato
DocType: Production Plan Item,Planned Qty,Planlagt mængde
apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +121,Total Tax,Moms i alt
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +177,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)
apps/erpnext/erpnext/schools/doctype/academic_year/academic_year.py +14,The Year End Date cannot be earlier than the Year Start Date. Please correct the dates and try again.,Året Slutdato kan ikke være tidligere end året startdato. Ret de datoer og prøv igen.
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +105,Row {0}: Party Type and Party is only applicable against Receivable / Payable account,Række {0}: Party Type og Party gælder kun mod Tilgodehavende / Betales konto
DocType: Notification Control,Purchase Receipt Message,Købskvittering meddelelse
DocType: BOM,Scrap Items,Skrotvarer
DocType: Production Order,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/stock.py +12,Record item movement.,Optag element bevægelse.
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +57,Set default mode of payment,Indstil standard betalingsform
DocType: Hub Settings,Hub Settings,Hub Indstillinger
DocType: Project,Gross Margin %,Gross Margin%
DocType: BOM,With Operations,Med Operations
apps/erpnext/erpnext/accounts/party.py +257,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 Detail,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
DocType: Purchase Taxes and Charges,On Previous Row Amount,På Forrige Row Beløb
DocType: Student,Home Address,Hjemmeadresse
apps/erpnext/erpnext/config/stock.py +111,Item Variant Settings.,Variantindstillinger.
apps/erpnext/erpnext/accounts/doctype/asset/asset.js +260,Transfer Asset,Transfer Asset
DocType: POS Profile,POS Profile,Kassesystemprofil
DocType: Training Event,Event Name,begivenhed Navn
DocType: Physician,Phone (Office),Telefon (Office)
apps/erpnext/erpnext/schools/doctype/student/student_dashboard.py +10,Admission,Adgang
apps/erpnext/erpnext/schools/doctype/student_admission/student_admission.py +26,Admissions for {0},Indlæggelser for {0}
apps/erpnext/erpnext/config/accounts.py +265,"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 +147,"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: Asset,Asset Category,Asset Kategori
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +31,Net pay cannot be negative,Nettoløn kan ikke være negativ
DocType: Assessment Plan,Room,Værelse
DocType: Purchase Order,Advance Paid,Forudbetalt
DocType: Item,Item Tax,Varemoms
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +818,Material to Supplier,Materiale til leverandøren
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +384,Excise Invoice,Skattestyrelsen Faktura
apps/erpnext/erpnext/schools/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 +138,Current Liabilities,Kortfristede forpligtelser
apps/erpnext/erpnext/config/selling.py +292,Send mass SMS to your contacts,Send masse-SMS til dine kontakter
DocType: Patient,A Positive,En positiv
DocType: Program,Program Name,Programnavn
DocType: Purchase Taxes and Charges,Consider Tax or Charge for,Overvej Skat eller Gebyr for
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 +79,"{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: Employee Loan,Loan Type,Lånetype
DocType: Scheduling Tool,Scheduling Tool,Planlægning Tool
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +176,Credit Card,Kreditkort
DocType: BOM,Item to be manufactured or repacked,"Element, der skal fremstilles eller forarbejdes"
apps/erpnext/erpnext/config/stock.py +184,Default settings for stock transactions.,Standardindstillinger for lagertransaktioner.
DocType: Purchase Invoice,Next Date,Næste dato
DocType: Employee Education,Major/Optional Subjects,Større / Valgfag
DocType: Sales Invoice Item,Drop Ship,Drop Ship
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: Hub Settings,Seller Name,Sælger Navn
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
apps/erpnext/erpnext/utilities/user_progress.py +186,Add Instructors,Tilføj instruktører
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 +96,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 +52,Attach Logo,Vedhæft Logo
apps/erpnext/erpnext/stock/doctype/batch/batch.js +38,Stock Levels,lagrene
DocType: Customer,Commission Rate,Provisionssats
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 +338,Make Variant,Opret Variant
apps/erpnext/erpnext/config/hr.py +87,Block leave applications by department.,Blokér fraværsansøgninger pr. afdeling.
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +144,"Payment Type must be one of Receive, Pay and Internal Transfer","Betaling Type skal være en af Modtag, Pay og Intern Transfer"
apps/erpnext/erpnext/config/selling.py +179,Analytics,Analyser
apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html +21,Cart is Empty,Indkøbskurv er tom
DocType: Vehicle,Model,Model
DocType: Production Order,Actual Operating Cost,Faktiske driftsomkostninger
DocType: Payment Entry,Cheque/Reference No,Anvendes ikke
apps/erpnext/erpnext/accounts/doctype/account/account.py +84,Root cannot be edited.,Root kan ikke redigeres.
DocType: Item,Units of Measure,Måleenheder
DocType: Manufacturing Settings,Allow Production on Holidays,Tillad produktion på helligdage
DocType: Sales Order,Customer's Purchase Order Date,Kundens Indkøbsordre Dato
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +163,Capital Stock,Capital Stock
DocType: Shopping Cart Settings,Show Public Attachments,Vis offentlige vedhæftede filer
DocType: Packing Slip,Package Weight Details,Pakkevægtdetaljer
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 +84,"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/upload_attendance/upload_attendance.py +103,Please select a csv file,Vælg en CSV-fil
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/templates/pages/home.html +14,Featured Products,Fremhævede varer
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +132,Designer,Designer
apps/erpnext/erpnext/config/selling.py +163,Terms and Conditions Template,Skabelon til vilkår og betingelser
DocType: Serial No,Delivery Details,Levering Detaljer
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +487,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: Batch,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 +351,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 +209,"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: 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/leave_application/leave_application.py +459, (Half Day),(Halv dag)
DocType: Supplier,Credit Days,Kreditdage
apps/erpnext/erpnext/utilities/activation.py +128,Make Student Batch,Masseopret elever
DocType: Fee Schedule,FRQ.,FRQ.
DocType: Leave Type,Is Carry Forward,Er fortsat fravær fra sidste regnskabsår
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +806,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
apps/erpnext/erpnext/controllers/accounts_controller.py +556,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 +129,Please enter Sales Orders in the above table,Indtast salgsordrer i ovenstående tabel
apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +182,Not Submitted Salary Slips,Ikke-godkendte lønsedler
,Stock Summary,Stock Summary
apps/erpnext/erpnext/config/accounts.py +280,Transfer an asset from one warehouse to another,Overfør et aktiv fra et lager til et andet
DocType: Vehicle,Petrol,Benzin
apps/erpnext/erpnext/config/learn.py +217,Bill of Materials,Styklister
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +103,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}
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: Employee Loan Application,Rate of Interest,Rentesats
DocType: Expense Claim Detail,Sanctioned Amount,Sanktioneret Beløb
DocType: GL Entry,Is Opening,Er Åbning
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +196,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 +193,Account {0} does not exist,Konto {0} findes ikke
DocType: Account,Cash,Kontanter
DocType: Employee,Short biography for website and other publications.,Kort biografi for hjemmesiden og andre publikationer.
