apps/erpnext/erpnext/stock/get_item_details.py +281,Price List Currency not selected,Pris List Valuta ikke valgt
apps/erpnext/erpnext/accounts/doctype/payment_tool/payment_tool.js +238,Row {0}: Payment Amount cannot be greater than Outstanding Amount,Række {0}: Betaling Beløb kan ikke være større end udestående beløb
DocType: Opportunity,Enter name of campaign if source of enquiry is campaign,"Indtast navnet på kampagne, hvis kilden undersøgelsesudvalg er kampagne"
,Schedule Date,Tidsplan Dato
DocType: Landed Cost Purchase Receipt,Landed Cost Purchase Receipt,Landed Cost kvittering
apps/erpnext/erpnext/config/hr.py +150,Template for performance appraisals.,Skabelon til præstationsvurderinger.
DocType: Hub Settings,Hub Settings,Hub Indstillinger
apps/frappe/frappe/public/js/frappe/model/indicator.js +43,Submitted,Indsendt
apps/erpnext/erpnext/projects/report/daily_time_log_summary/daily_time_log_summary.py +18,Task Subject,Task Emne
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +78,{0} is not a valid Batch Number for Item {1},{0} er ikke en gyldig Batchnummer for Item {1}
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +174,Loans (Liabilities),Lån (passiver)
DocType: Features Setup,Quality,Kvalitet
DocType: Pricing Rule,Sales Partner,Salg Partner
DocType: Workstation,Electricity Cost,Elektricitet Omkostninger
DocType: Journal Entry,Total Credit,Total Credit
DocType: Purchase Receipt,Rate at which supplier's currency is converted to company's base currency,"Hastighed, hvormed leverandørens valuta omregnes til virksomhedens basisvaluta"
DocType: Sales Invoice,Source,Kilde
apps/erpnext/erpnext/config/accounts.py +153,"Seasonality for setting budgets, targets etc.","Sæsonudsving til indstilling budgetter, mål etc."
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +312,Account {0} must be of type 'Fixed Asset' as Item {1} is an Asset Item,Konto {0} skal være af typen 'Anlægskonto' da enheden {1} er et aktiv
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +310,Please enter Reference date,Indtast Referencedato
apps/erpnext/erpnext/setup/page/setup_wizard/data/sample_home_page.html +14,Awesome Services,Awesome Services
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +406,Your financial year begins on,Din regnskabsår begynder på
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +242,Create New,Opret ny
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +141,Set as Lost,Sæt som Lost
DocType: Sales Order,Recurring Order,Tilbagevendende Order
DocType: Global Defaults,Disable Rounded Total,Deaktiver Afrundet Total
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +57,Investments,Investeringer
DocType: Production Order Operation,Planned End Time,Planned Sluttid
DocType: Upload Attendance,Get Template,Få skabelon
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +85,Please pull items from Delivery Note,Venligst trække elementer fra følgeseddel
,Available Qty,Tilgængelig Antal
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/manufacturing/doctype/bom/bom.py +199,Item {0} does not exist in the system or has expired,Vare {0} findes ikke i systemet eller er udløbet
apps/erpnext/erpnext/selling/doctype/quotation/quotation.js +581,Make Sales Order,Make kundeordre
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +450,Amount,Beløb
apps/erpnext/erpnext/accounts/doctype/payment_tool/payment_tool.py +59,No permission to use Payment Tool,Ingen tilladelse til at bruge Betaling Tool
DocType: Stock Settings,Default Stock UOM,Standard Stock UOM
DocType: Purchase Invoice,In Words (Company Currency),I Words (Company Valuta)
DocType: Serial No,Delivery Time,Leveringstid
DocType: Mode of Payment Account,Default Account,Standard-konto
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/accounts/doctype/sales_invoice/sales_invoice.js +561,Cost Center For Item with Item Code ',Cost Center For Item med Item Code &#39;
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +47,"To filter based on Party, select Party Type first","Hvis du vil filtrere baseret på Party, skal du vælge Party Type først"
DocType: Lead,Next Contact By,Næste Kontakt By
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +494,Invoice,Faktura
DocType: Bin,Actual Quantity,Faktiske Mængde
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +33,Investment Banking,Investment Banking
DocType: Stock Entry,Subcontract,Underleverance
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/setup/page/setup_wizard/setup_wizard.js +190,Welcome to ERPNext,Velkommen til ERPNext
DocType: Maintenance Schedule Detail,Scheduled Date,Planlagt dato
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +37,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: Purchase Taxes and Charges,Account Head,Konto hoved
apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +157,Start date should be less than end date for Item {0},Start dato bør være mindre end slutdato for Item {0}
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/page/setup_wizard/fixtures/operations.py +108,Abrasive jet machining,Sandblæsnings udstyr
apps/erpnext/erpnext/selling/report/territory_target_variance_item_group_wise/territory_target_variance_item_group_wise.py +57,Total Target,Samlet Target
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +478,Get Items from BOM,Få elementer fra BOM
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +109,Note: There is not enough leave balance for Leave Type {0},Bemærk: Der er ikke nok orlov balance for Leave Type {0}
DocType: Purchase Invoice,Total (Company Currency),I alt (Company Valuta)
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +32,Opportunity From field is mandatory,Mulighed Fra feltet er obligatorisk
DocType: Naming Series,Series List for this Transaction,Serie Liste for denne transaktion
DocType: Purchase Invoice Item,Price List Rate,Prisliste Rate
DocType: Payment Reconciliation Invoice,Outstanding Amount,Udestående beløb
apps/erpnext/erpnext/accounts/page/financial_analytics/financial_analytics.js +56,Opening (Dr),Åbning (dr)
DocType: Account,Accounts User,Regnskab Bruger
DocType: Rename Tool,Rename Tool,Omdøb Tool
DocType: Delivery Note,Print Without Amount,Print uden Beløb
DocType: C-Form,Invoices,Fakturaer
DocType: Item Attribute,Item Attribute,Item Attribut
apps/erpnext/erpnext/hr/doctype/employee/employee.py +213,Today is {0}'s birthday!,I dag er {0} &#39;s fødselsdag!
DocType: Deduction Type,Deduction Type,Fradrag Type
DocType: Expense Claim,Total Amount Reimbursed,Samlede godtgjorte beløb
DocType: Stock Settings,Item Naming By,Item Navngivning By
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."
apps/erpnext/erpnext/setup/doctype/company/company.js +38,Successfully deleted all transactions related to this company!,Succesfuld slettet alle transaktioner i forbindelse med dette selskab!
DocType: Material Request Item,Required Date,Nødvendig Dato
apps/erpnext/erpnext/controllers/trends.py +36,Fiscal Year: {0} does not exists,Fiscal År: {0} ikke eksisterer
,Supplier-Wise Sales Analytics,Forhandler-Wise Sales Analytics
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +549,From Material Request,Fra Material Request
,Customers Not Buying Since Long Time,Kunder Ikke købe siden lang tid
DocType: Purchase Receipt Item,Recd Quantity,RECD Mængde
apps/erpnext/erpnext/projects/doctype/time_log_batch/time_log_batch.py +39,Time Log {0} must be 'Submitted',Time Log {0} skal være »Tilmeldt &#39;
DocType: Opportunity,Potential Sales Deal,Potentielle Sales Deal
DocType: Production Planning Tool,"Items to be requested which are ""Out of Stock"" considering all warehouses based on projected qty and minimum order qty",Varer der skal ansøges som er &quot;på lager&quot; i betragtning af alle lagre baseret på forventede qty og mindste bestilling qty
DocType: Hub Settings,Hub Node,Hub Node
DocType: Communication,Rejected,Afvist
DocType: Employee,Personal Details,Personlige oplysninger
DocType: Global Defaults,Current Fiscal Year,Indeværende finansår
DocType: Stock UOM Replace Utility,Stock UOM Replace Utility,Stock UOM Udskift Utility
DocType: Purchase Invoice,Total Advance,Samlet Advance
DocType: Production Order,Actual Start Date,Faktiske startdato
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +15,Countergravity casting,Countergravity støbning
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +79,Decambering,Decambering
DocType: Employee,Place of Issue,Sted for Issue
apps/erpnext/erpnext/config/accounts.py +148,Currency exchange rate master.,Valutakursen mester.
DocType: Appraisal,For Employee,For Medarbejder
DocType: Leave Block List,Leave Block List Allowed,Lad Block List tilladt
apps/erpnext/erpnext/stock/doctype/item/item.py +307,'Has Serial No' can not be 'Yes' for non-stock item,'Har serienummer' kan ikke være 'Ja' for ikke-lagervare
DocType: Job Applicant,Applicant Name,Ansøger Navn
DocType: Quality Inspection,Readings,Aflæsninger
DocType: Pricing Rule,Pricing Rule Help,Prisfastsættelse Rule Hjælp
apps/erpnext/erpnext/crm/doctype/newsletter_list/newsletter_list.js +8,Import Subscribers,Import Abonnenter
apps/erpnext/erpnext/crm/doctype/newsletter/newsletter.py +137,Please verify your email id,Skal du bekræfte din e-mail-id
apps/erpnext/erpnext/stock/get_item_details.py +128,"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: Features Setup,POS View,POS View
DocType: Sales Order Item,Produced Quantity,Produceret Mængde
DocType: Sales Partner,Sales Partner Target,Salg Partner Target
DocType: Journal Entry Account,Sales Order,Sales Order
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +158,Source of Funds (Liabilities),Finansieringskilde (Passiver)
apps/erpnext/erpnext/accounts/doctype/monthly_distribution/monthly_distribution.py +26,Percentage Allocation should be equal to 100%,Procentdel Tildeling bør være lig med 100%
DocType: Account,Accounts Manager,Accounts Manager
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +394,Company Abbreviation,Firma Forkortelse
apps/erpnext/erpnext/utilities/transaction_base.py +104,Row #{0}: Rate must be same as {1}: {2} ({3} / {4}) ,Row # {0}: Pris skal være samme som {1}: {2} ({3} / {4})
DocType: Issue,Resolution Date,Opløsning Dato
DocType: Maintenance Schedule Item,No of Visits,Ingen af ​​besøg
DocType: Employee,Ms,Ms
apps/erpnext/erpnext/config/crm.py +64,Sales campaigns.,Salgskampagner.
DocType: Expense Claim,"A user with ""Expense Approver"" role",En bruger med 'Godkend udgifter' rolle
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +86,Milling,Milling
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +100,Countersinking,Undersænkning
DocType: Sales Order Item,Sales Order Date,Sales Order Date
DocType: Production Order Operation,In minutes,I minutter
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +65,Item {0} not found,Vare {0} ikke fundet
apps/erpnext/erpnext/projects/doctype/task/task.py +35,'Expected Start Date' can not be greater than 'Expected End Date','Forventet startdato' kan ikke være større end 'Forventet slutdato '
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +58,Notching,Udhugning
DocType: Supplier,Default Payable Accounts,Standard betales Konti
DocType: Quality Inspection Reading,Reading 7,Reading 7
DocType: Communication,Delivery Status,Levering status
DocType: Event,Wednesday,Onsdag
apps/erpnext/erpnext/setup/doctype/company/company.js +44,Delete all the Transactions for this Company,Slette alle transaktioner for denne Company
apps/erpnext/erpnext/crm/doctype/newsletter/newsletter.py +30,Newsletter has already been sent,Nyhedsbrev er allerede blevet sendt
apps/erpnext/erpnext/controllers/trends.py +19,Total(Qty),I alt (Antal)
DocType: Manufacturing Settings,Manufacturing Settings,Manufacturing Indstillinger
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +170,Job Description,Jobbeskrivelse
apps/erpnext/erpnext/accounts/party.py +284,Note: Due / Reference Date exceeds allowed customer credit days by {0} day(s),Bemærk: På grund / reference Date overstiger tilladte kunde kredit dage efter {0} dag (e)
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +81,Installation date cannot be before delivery date for Item {0},Installation dato kan ikke være før leveringsdato for Item {0}
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +31,Health Care,Health Care
DocType: Notification Control,Notification Control,Meddelelse Kontrol
apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.js +121,Please save the document before generating maintenance schedule,"Gem venligst dokumentet, før generere vedligeholdelsesplan"
DocType: Purchase Invoice Advance,Purchase Invoice Advance,Købsfaktura Advance
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +491,The Brand,Brand
apps/erpnext/erpnext/stock/get_item_details.py +449,No default BOM exists for Item {0},Ingen standard BOM eksisterer for Item {0}
DocType: Employee,Salary Mode,Løn-tilstand
,Sales Analytics,Salg Analytics
apps/erpnext/erpnext/config/hr.py +120,Salary components.,Løn komponenter.
DocType: Supplier,Communications,Kommunikation
apps/erpnext/erpnext/config/manufacturing.py +29,All Products or Services.,Alle produkter eller tjenesteydelser.
DocType: Bank Reconciliation,Get Relevant Entries,Få relevante oplysninger
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +541,Add Taxes,Tilføj Skatter
DocType: Delivery Note Item,Against Sales Order Item,Mod Sales Order Item
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +306,All these items have already been invoiced,Alle disse punkter er allerede blevet faktureret
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +95,'Opening','Åbning'
apps/erpnext/erpnext/stock/doctype/item/item.py +552,Item {0} is cancelled,Vare {0} er aflyst
apps/erpnext/erpnext/projects/doctype/time_log/time_log_list.js +9,Make Time Log Batch,Make Time Log Batch
DocType: Serial No,Out of Warranty,Ud af garanti
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +67,Row # {0}:,Row # {0}:
apps/erpnext/erpnext/config/setup.py +93,Email Notifications,E-mail-meddelelser
apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.js +33,Make Maintenance Visit,Make Vedligeholdelse Besøg
DocType: Warehouse,Warehouse Contact Info,Lager Kontakt Info
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: Delivery Note,In Words (Export) will be visible once you save the Delivery Note.,"I Words (eksport) vil være synlig, når du gemmer følgesedlen."
DocType: Employee,Offer Date,Offer Dato
DocType: Stock Ledger Entry,Stock Queue (FIFO),Stock kø (FIFO)
DocType: Sales Order,Delivery Date,Leveringsdato
DocType: Sales Order,Billing Status,Fakturering status
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +17,Resin casting,Harpiks støbning
apps/frappe/frappe/core/doctype/doctype/doctype.py +106,Series {0} already used in {1},Serien {0} allerede anvendes i {1}
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +480,From Purchase Order,Fra indkøbsordre
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +101,Not allowed to update stock transactions older than {0},Ikke lov til at opdatere lagertransaktioner ældre end {0}
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +492,Upload your letter head and logo. (you can edit them later).,Upload dit brev hoved og logo. (Du kan redigere dem senere).
apps/erpnext/erpnext/setup/doctype/item_group/item_group.py +52,"An item exists with same name ({0}), please change the item group name or rename the item","Et element eksisterer med samme navn ({0}), skal du ændre navnet elementet gruppe eller omdøbe elementet"
,Customer Acquisition and Loyalty,Customer Acquisition og Loyalitet
DocType: C-Form Invoice Detail,Grand Total,Grand Total
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +396,Material Requests {0} created,Materiale Anmodning {0} skabt
DocType: System Settings,In Hours,I Hours
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +86,Opportunity Lost,Opportunity Lost
DocType: Customer,From Lead,Fra Lead
DocType: Supplier,Credit Days,Credit Dage
DocType: Operation,Default Workstation,Standard Workstation
DocType: Purchase Receipt,Return Against Purchase Receipt,Retur Against kvittering
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +63,Sales Order {0} is not valid,Sales Order {0} er ikke gyldig
DocType: Supplier,Contact HTML,Kontakt HTML
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.py +182,Standard Buying,Standard Buying
DocType: Purchase Taxes and Charges,Actual,Faktiske
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.js +48,Voucher #,Voucher #
DocType: Sales Team,Contribution (%),Bidrag (%)
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +65,Another Salary Structure {0} is active for employee {1}. Please make its status 'Inactive' to proceed.,En anden Løn Struktur {0} er aktiv for medarbejder {1}. Venligst gøre sin status &quot;Inaktiv&quot; for at fortsætte.
DocType: Features Setup,To track item in sales and purchase documents based on their serial nos. This is can also used to track warranty details of the product.,At spore post i salgs- og købsdokumenter baseret på deres løbenr. Dette er også bruges til at spore garantiforpligtelser detaljer af produktet.
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +60,Warehouse cannot be changed for Serial No.,Warehouse kan ikke ændres for Serial No.
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 bestand Vare
DocType: Customer,Credit Days Based On,Credit Dage Baseret på
apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +137,Not Set,Ikke Sæt
DocType: Naming Series,Set prefix for numbering series on your transactions,Sæt præfiks for nummerering serie om dine transaktioner
DocType: Contact,Enter department to which this Contact belongs,"Indtast afdeling, som denne Kontakt hører"
DocType: Company,Abbr,Fork
apps/frappe/frappe/website/template.py +140,Next,Næste
apps/erpnext/erpnext/setup/page/setup_wizard/default_website.py +72,General,Generelt
apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py +50,Taken,Taget
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.js +17,Set as Default,Indstil som standard
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +30,Rotational molding,Rotationsstøbning
DocType: Supplier,Is Frozen,Er Frozen
DocType: Employee External Work History,Total Experience,Total Experience
,Amount to Bill,Beløb til Bill
,Item-wise Price List Rate,Item-wise Prisliste Rate
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +76,Account {0} cannot be a Group,Konto {0} kan ikke være en gruppe
DocType: Serial No,Warehouse can only be changed via Stock Entry / Delivery Note / Purchase Receipt,Warehouse kan kun ændres via Stock indtastning / følgeseddel / kvittering
,Pending Amount,Afventer Beløb
DocType: Newsletter,Test Email Id,Test Email Id
DocType: Production Planning Tool,Select Sales Orders from which you want to create Production Orders.,"Vælg salgsordrer, som du ønsker at skabe produktionsordrer."
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +365,Operations cannot be left blank.,Operationer kan ikke være tomt.
DocType: Packing Slip,Gross Weight UOM,Gross Weight UOM
apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +29,Activity Cost exists for Employee {0} against Activity Type - {1},Aktivitet Omkostninger eksisterer for Medarbejder {0} mod Activity Type - {1}
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +207,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}
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +17,Computer,Computer
apps/erpnext/erpnext/config/selling.py +294,Customer and Supplier,Kunde og leverandør
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +21,Attendance From Date and Attendance To Date is mandatory,Fremmøde Fra Dato og fremmøde til dato er obligatorisk
apps/erpnext/erpnext/setup/doctype/company/company.py +47,Account {0} does not belong to company: {1},Konto {0} tilhører ikke virksomheden: {1}
DocType: SMS Center,All Sales Partner Contact,Alle Sales Partner Kontakt
DocType: Bin,Moving Average Rate,Glidende gennemsnit Rate
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +563,Your Customers,Dine kunder
,Produced,Produceret
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +152,Red,Rød
DocType: Quality Inspection Reading,Reading 8,Reading 8
DocType: Sales Invoice,Rate at which Customer Currency is converted to customer's base currency,"Hastighed, hvormed kunden Valuta omdannes til kundens basisvaluta"
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +81,Overlapping conditions found between:,Overlappende betingelser fundet mellem:
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +57,Total Absent,Total Fraværende
,Customer Credit Balance,Customer Credit Balance
DocType: Journal Entry,Stock Entry,Stock indtastning
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +70,Swaging,Sænksmedning
DocType: Customer Group,Only leaf nodes are allowed in transaction,Kun blade noder er tilladt i transaktionen
DocType: Global Defaults,Do not show any symbol like $ etc next to currencies.,Du må ikke vise nogen symbol ligesom $ etc siden valutaer.
DocType: GL Entry,Against Voucher Type,Mod Voucher Type
DocType: Journal Entry Account,Party Balance,Party Balance
DocType: Authorization Control,Authorization Control,Authorization Kontrol
apps/erpnext/erpnext/config/accounts.py +127,Point-of-Sale Profile,Point-of-Sale profil
DocType: Monthly Distribution,Name of the Monthly Distribution,Navnet på den månedlige Distribution
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +47,Party Type and Party is required for Receivable / Payable account {0},Party Type og parti er nødvendig for Tilgodehavende / Betales konto {0}
DocType: Lead,Campaign Name,Kampagne Navn
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +17,Ref,Ref
DocType: Activity Cost,Billing Rate,Fakturering Rate
DocType: Account,Chargeable,Gebyr
DocType: Lead,Request for Information,Anmodning om information
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +38,Newspaper Publishers,Dagblades
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +14,Investment casting,Investeringer støbning
DocType: Buying Settings,Naming Series,Navngivning Series
DocType: Account,Cost of Goods Sold,Vareforbrug
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +20,Item 3,Punkt 3
DocType: Employee,The first Leave Approver in the list will be set as the default Leave Approver,"Den første Lad Godkender i listen, vil blive indstillet som standard Forlad Godkender"
apps/erpnext/erpnext/public/js/pos/pos.js +343,Pay,Betale
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},Materiale Request af maksimum {0} kan gøres for Item {1} mod Sales Order {2}
DocType: Journal Entry,Accounts Payable,Kreditor
DocType: Sales Partner,Dealer,Forhandler
DocType: Purchase Invoice,Monthly,Månedlig
apps/erpnext/erpnext/setup/page/setup_wizard/data/sample_home_page.html +3,Awesome Products,Awesome Products
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +108,Fill the form and save it,Udfyld formularen og gemme det
DocType: Global Defaults,Global Defaults,Globale standarder
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +34,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
apps/erpnext/erpnext/hr/report/monthly_salary_register/monthly_salary_register.py +67, and year: ,og år:
DocType: Purchase Invoice,Items,Varer
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +154,Direct metal laser sintering,Direkte metal lasersintring
DocType: Leave Type,Allow Negative Balance,Tillad Negativ Balance
apps/erpnext/erpnext/public/js/templates/address_list.html +21,No address added yet.,Ingen adresse tilføjet endnu.
DocType: Appraisal Goal,Goal,Goal
apps/erpnext/erpnext/config/support.py +13,Support queries from customers.,Support forespørgsler fra kunder.
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +68,Ironing,Strygning
apps/erpnext/erpnext/accounts/page/financial_analytics/financial_analytics.js +36,Select Company...,Vælg Company ...
DocType: Pricing Rule,Price or Discount,Pris eller rabat
DocType: Global Defaults,Hide Currency Symbol,Skjul Valuta Symbol
DocType: Pricing Rule,Valid Upto,Gyldig Op
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +45,Retail & Wholesale,Detail &amp; Wholesale
DocType: Sales Invoice,Commission,Kommissionen
DocType: Purchase Invoice,Return Against Purchase Invoice,Retur Against købsfaktura
DocType: Workflow State,Stop,Stands
DocType: Authorization Rule,Applicable To (Role),Gælder for (Rolle)
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +251,Sales Invoice {0} has already been submitted,Salg Faktura {0} er allerede blevet indsendt
DocType: Pricing Rule,Supplier,Leverandør
DocType: DocField,Password,Adgangskode
DocType: Account,Expense,Expense
DocType: Journal Entry,Remark,Bemærkning
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +587,Your Suppliers,Dine Leverandører
apps/erpnext/erpnext/controllers/accounts_controller.py +391,"Total advance ({0}) against Order {1} cannot be greater \
				than the Grand Total ({2})",Total forhånd ({0}) mod Order {1} kan ikke være større \ end Grand Total ({2})
DocType: Purchase Invoice,The date on which recurring invoice will be stop,"Den dato, hvor tilbagevendende faktura vil blive stoppe"
DocType: Production Order Operation,Updated via 'Time Log',Opdateret via &#39;Time Log&#39;
DocType: Lead,Fax,Fax
,Profit and Loss Statement,Resultatopgørelse
DocType: Lead,Lead,Bly
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +389,Stock cannot be updated against Delivery Note {0},Stock kan ikke opdateres mod følgeseddel {0}
apps/erpnext/erpnext/stock/doctype/stock_uom_replace_utility/stock_uom_replace_utility.py +102,Stock Ledger entries balances updated,Stock Ledger poster saldi opdateret
apps/erpnext/erpnext/controllers/selling_controller.py +236,Item {0} must be Sales or Service Item in {1},Vare {0} skal være Salg eller service Item i {1}
apps/erpnext/erpnext/selling/page/sales_browser/sales_browser.js +121,New {0} Name,Ny {0} Navn
apps/erpnext/erpnext/selling/report/territory_target_variance_item_group_wise/territory_target_variance_item_group_wise.py +50,Variance,Varians
DocType: Leave Block List,Leave Block List Name,Lad Block List Name
DocType: Email Digest,Receivables / Payables,Tilgodehavender / Gæld
DocType: Purchase Order,Ref SQ,Ref SQ
DocType: SMS Settings,Receiver Parameter,Modtager Parameter
DocType: C-Form,Customer,Kunde
DocType: Serial No,Purchase / Manufacture Details,Køb / Fremstilling Detaljer
DocType: SMS Center,SMS Center,SMS-center
DocType: Manufacturing Settings,Allow Production on Holidays,Tillad Produktion på helligdage
DocType: Quality Inspection Reading,Reading 9,Reading 9
DocType: Event,Sunday,Søndag
apps/erpnext/erpnext/utilities/transaction_base.py +78,Duplicate row {0} with same {1},Duplicate række {0} med samme {1}
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +151,Stapling,Hæftning
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +22,Molding,Molding
DocType: SMS Center,All Employee (Active),Alle Medarbejder (Active)
DocType: Pricing Rule,Price,Pris
DocType: Naming Series,Update Series,Opdatering Series
apps/erpnext/erpnext/stock/utils.py +174,Warehouse {0} does not belong to company {1},Warehouse {0} ikke hører til virksomheden {1}
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +63,Avg. Selling Rate,Gns. Salgskurs
DocType: Journal Entry Account,Purchase Invoice,Indkøb Faktura
DocType: Maintenance Schedule,Generate Schedule,Generer Schedule
apps/erpnext/erpnext/accounts/doctype/payment_tool/payment_tool.js +9,"Note: If payment is not made against any reference, make Journal Entry manually.","Bemærk: Hvis betaling ikke sker mod nogen reference, gør Kassekladde manuelt."
apps/erpnext/erpnext/accounts/page/pos/pos_page.html +13,Make new POS Profile,Foretag ny POS profil
DocType: Sales Partner,Sales Partner Name,Salg Partner Navn
DocType: Packing Slip,If more than one package of the same type (for print),Hvis mere end én pakke af samme type (til print)
DocType: Appraisal Template Goal,Key Performance Area,Key Performance Area
DocType: Address Template,"<h4>Default Template</h4>
<p>Uses <a href=""http://jinja.pocoo.org/docs/templates/"">Jinja Templating</a> and all the fields of Address (including Custom Fields if any) will be available</p>
<pre><code>{{ address_line1 }}&lt;br&gt;
{% if address_line2 %}{{ address_line2 }}&lt;br&gt;{% endif -%}
{{ city }}&lt;br&gt;
{% if state %}{{ state }}&lt;br&gt;{% endif -%}
{% if pincode %} PIN:  {{ pincode }}&lt;br&gt;{% endif -%}
{{ country }}&lt;br&gt;
{% if phone %}Phone: {{ phone }}&lt;br&gt;{% endif -%}
{% if fax %}Fax: {{ fax }}&lt;br&gt;{% endif -%}
{% if email_id %}Email: {{ email_id }}&lt;br&gt;{% endif -%}
</code></pre>","<h4> Standardskabelon </h4><p> Bruger <a href=""http://jinja.pocoo.org/docs/templates/"">Jinja Templatering</a> og alle områderne adresse (herunder brugerdefinerede felter hvis nogen) vil være til rådighed </p><pre> <code>{{ address_line1 }}&lt;br&gt; {% if address_line2 %}{{ address_line2 }}&lt;br&gt;{% endif -%} {{ city }}&lt;br&gt; {% if state %}{{ state }}&lt;br&gt;{% endif -%} {% if pincode %} PIN: {{ pincode }}&lt;br&gt;{% endif -%} {{ country }}&lt;br&gt; {% if phone %}Phone: {{ phone }}&lt;br&gt;{% endif -%} {% if fax %}Fax: {{ fax }}&lt;br&gt;{% endif -%} {% if email_id %}Email: {{ email_id }}&lt;br&gt;{% endif -%}</code> </pre>"
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +195,Select Your Language,Vælg dit sprog
DocType: Employee,Owned,Ejet
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +60,New Customer Revenue,Ny kunde Omsætning
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +179,Make Excise Invoice,Make Excise Faktura
DocType: Purchase Order,Get Last Purchase Rate,Få Sidste Purchase Rate
apps/erpnext/erpnext/hooks.py +70,Orders,Ordrer
apps/erpnext/erpnext/config/accounts.py +164,"e.g. Bank, Cash, Credit Card","fx Bank, Kontant, Kreditkort"
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js +7,Lost,Tabt
DocType: Leave Control Panel,Leave blank if considered for all departments,Lad stå tomt hvis det anses for alle afdelinger
DocType: Stock Settings,Raise Material Request when stock reaches re-order level,Hæv Materiale Request når bestanden når re-order-niveau
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +149,Pinning,Pinning
DocType: POS Profile,[Select],[Vælg]
apps/erpnext/erpnext/stock/doctype/batch/batch.py +16,The selected item cannot have Batch,Det valgte emne kan ikke have Batch
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +103,Filing,Arkivering
apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +198,Maintenance start date can not be before delivery date for Serial No {0},Vedligeholdelse startdato kan ikke være før leveringsdato for Serial Nej {0}
DocType: Batch,Batch,Batch
apps/erpnext/erpnext/accounts/party.py +287,Due / Reference Date cannot be after {0},Due / reference Dato kan ikke være efter {0}
DocType: Leave Application,Total Leave Days,Total feriedage
apps/erpnext/erpnext/config/hr.py +18,Applications for leave.,Ansøgning om orlov.
apps/erpnext/erpnext/accounts/doctype/account/account.py +47,Account {0}: Parent account {1} does not belong to company: {2},Konto {0}: Forældre-konto {1} tilhører ikke virksomheden: {2}
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +650,Setting Up,Opsætning
DocType: Employee,Short biography for website and other publications.,Kort biografi for hjemmesiden og andre publikationer.
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +155,Black,Sort
apps/erpnext/erpnext/buying/doctype/purchase_common/purchase_common.py +95,{0} {1} has already been submitted,{0} {1} er allerede indsendt
DocType: Time Log,Operation ID,Operation ID
DocType: Features Setup,"To track brand name in the following documents Delivery Note, Opportunity, Material Request, Item, Purchase Order, Purchase Voucher, Purchaser Receipt, Quotation, Sales Invoice, Product Bundle, Sales Order, Serial No","At spore mærke i følgende dokumenter Delivery Note, Opportunity, Material Request, punkt, Indkøbsordre, Indkøb Gavekort, køber Modtagelse, Citat, Sales Faktura, Produkt Bundle, salgsordre, Løbenummer"
DocType: Production Order,Operation Cost,Operation Cost
apps/erpnext/erpnext/config/setup.py +32,Titles for print templates e.g. Proforma Invoice.,Titler til print skabeloner f.eks Proforma Invoice.
DocType: Expense Claim Detail,Sanctioned Amount,Sanktioneret Beløb
DocType: Landed Cost Voucher,Landed Cost Help,Landed Cost Hjælp
DocType: Communication,Closed,Lukket
DocType: Quotation,Term Details,Term Detaljer
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html +4,Statement of Account,Kontoudtog
apps/erpnext/erpnext/config/setup.py +27,Letter Heads for print templates.,Brev hoveder for print skabeloner.
DocType: Features Setup,"All export related fields like currency, conversion rate, export total, export grand total etc are available in Delivery Note, POS, Quotation, Sales Invoice, Sales Order etc.","Alle eksport relaterede områder som valuta, konverteringsfrekvens, eksport i alt, eksport grand total etc er tilgængelige i Delivery Note, POS, Citat, Sales Invoice, Sales Order etc."
DocType: Production Order,Qty To Manufacture,Antal Til Fremstilling
apps/erpnext/erpnext/setup/doctype/item_group/item_group.js +31,This is a root item group and cannot be edited.,Dette er en rod varegruppe og kan ikke redigeres.
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +57,Actual Qty is mandatory,Faktiske Antal er obligatorisk
DocType: Packing Slip,Gross Weight,Bruttovægt
DocType: Communication,Email,Email
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +285,New Cost Center Name,Ny Cost center navn
apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +41,From Date cannot be greater than To Date,Fra dato ikke kan være større end til dato
DocType: Purchase Invoice,Recurring Print Format,Tilbagevendende Print Format
DocType: Hub Settings,Seller City,Sælger By
DocType: Material Request,Material Issue,Materiale Issue
,Ordered Items To Be Delivered,"Bestilte varer, der skal leveres"
DocType: Journal Entry,Total Amount in Words,Samlet beløb i Words
DocType: Purchase Order Item,Qty as per Stock UOM,Antal pr Stock UOM
DocType: Purchase Invoice,Select the period when the invoice will be generated automatically,"Vælg den periode, hvor fakturaen vil blive genereret automatisk"
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +157,Laser engineered net shaping,Laser manipuleret netto formgivning
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js +15,Unpaid,Ulønnet
DocType: DocField,Fold,Fold
DocType: Process Payroll,Check if you want to send salary slip in mail to each employee while submitting salary slip,"Kontroller, om du vil sende lønseddel i e-mail til den enkelte medarbejder, samtidig indsende lønseddel"
DocType: Purchase Taxes and Charges,Valuation and Total,Værdiansættelse og Total
apps/frappe/frappe/email/doctype/email_account/email_account.py +58,{0} is mandatory,{0} er obligatorisk
DocType: SMS Settings,Enter url parameter for message,Indtast url parameter for besked
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +159,Current Liabilities,Kortfristede forpligtelser
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +34,Basic,Grundlæggende
DocType: Selling Settings,Default Customer Group,Standard Customer Group
DocType: Packing Slip,The net weight of this package. (calculated automatically as sum of net weight of items),Nettovægten af ​​denne pakke. (Beregnes automatisk som summen af ​​nettovægt på poster)
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +34,Shrink wrapping,Shrink indpakning
DocType: Shipping Rule,Calculate Based On,Beregn baseret på
apps/erpnext/erpnext/config/accounts.py +84,Financial / accounting year.,Finansiel / regnskabsår.
DocType: BOM,Costing,Koster
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +94,Stock transactions before {0} are frozen,Stock transaktioner før {0} er frosset
DocType: Bin,Ordered Quantity,Bestilt Mængde
,Purchase Order Items To Be Billed,Købsordre Varer at blive faktureret
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +517,Select Item,Vælg Item
apps/erpnext/erpnext/controllers/status_updater.py +12,Status must be one of {0},Status skal være en af ​​{0}
DocType: Sales Invoice,"Check if recurring invoice, uncheck to stop recurring or put proper End Date","Kontroller, om tilbagevendende faktura, skal du fjerne markeringen for at stoppe tilbagevendende eller sætte ordentlig Slutdato"
apps/erpnext/erpnext/accounts/doctype/account/account.py +105,Account with existing transaction cannot be converted to ledger,Konto med eksisterende transaktion kan ikke konverteres til finans
DocType: Sales Order,"The day of the month on which auto order will be generated e.g. 05, 28 etc","Den dag i den måned, hvor auto ordre vil blive genereret f.eks 05, 28 osv"
DocType: SMS Center,All Sales Person,Alle Sales Person
DocType: Account,Auditor,Revisor
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +82,Hot metal gas forming,Hot metal gas danner
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +22,Department Stores,Varehuse
DocType: Dropbox Backup,Dropbox Access Secret,Dropbox Access Secret
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +69,Total Paid Amt,Total Betalt Amt
DocType: Item,Valuation Method,Værdiansættelsesmetode
DocType: BOM Item,BOM Item,BOM Item
DocType: Sales Invoice,Mass Mailing,Mass Mailing
,Bank Reconciliation Statement,Bank Saldoopgørelsen
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +17,All Item Groups,Alle varegrupper
DocType: Custom Field,Custom,Brugerdefineret
DocType: Opportunity,Maintenance,Vedligeholdelse
DocType: Item,Customer Items,Kunde Varer
DocType: Lead,Industry,Industri
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +59,Please enter company name first,Indtast venligst firmanavn først
DocType: Journal Entry Account,Journal Entry Account,Kassekladde konto
DocType: Company,For Reference Only.,Kun til reference.
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.py +459,Local,Lokal
apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +191,Payment of salary for the month {0} and year {1},Udbetaling af løn for måneden {0} og år {1}
DocType: Lead,Middle Income,Midterste indkomst
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +99,The day(s) on which you are applying for leave are holiday. You need not apply for leave.,"Den dag (e), hvor du ansøger om orlov er ferie. Du har brug for ikke søge om orlov."
DocType: Purchase Receipt,Rejected Warehouse,Afvist Warehouse
apps/erpnext/erpnext/config/accounts.py +79,Company (not Customer or Supplier) master.,Company (ikke kunde eller leverandør) herre.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +12,Debtors,Debitorer
apps/erpnext/erpnext/config/crm.py +96,Newsletter Mailing List,Nyhedsbrev Mailing List
DocType: Production Order Operation,Work In Progress,Work In Progress
DocType: Bank Reconciliation Detail,Clearance Date,Clearance Dato
apps/erpnext/erpnext/stock/doctype/item/item.py +49,Please enter default Unit of Measure,Indtast venligst standard Måleenhed
DocType: Sales Order Item,For Production,For Produktion
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +152,Press fitting,Tryk fitting
,Billed Amount,Faktureret beløb
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +46,Blanking,Blanking
DocType: Production Planning Tool,Get Sales Orders,Få salgsordrer
DocType: Landed Cost Voucher,Distribute Charges Based On,Distribuere afgifter baseret på
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +53,Chart of Cost Centers,Diagram af Cost Centers
DocType: Shopping Cart Settings,Shopping Cart Settings,Indkøbskurv Indstillinger
apps/frappe/frappe/public/js/frappe/model/model.js +25,Comments,Kommentarer
apps/erpnext/erpnext/config/selling.py +70,Default settings for selling transactions.,Standardindstillinger for at sælge transaktioner.
DocType: Accounts Settings,Credit Controller,Credit Controller
DocType: Bank Reconciliation Detail,Voucher ID,Voucher ID
DocType: Email Account,Service,Service
DocType: Purchase Taxes and Charges,Deduct,Fratrække
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +90,Please enter default currency in Company Master,Indtast standard valuta i Company Master
,Financial Analytics,Finansielle Analytics
DocType: Lead,Call,Opkald
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +537,Error: {0} > {1},Fejl: {0}&gt; {1}
DocType: Purchase Receipt Item,Landed Cost Voucher Amount,Landed Cost Voucher Beløb
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +500,Attach Logo,Vedhæft Logo
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +136,Laser drilling,Laserboring
DocType: Page,All,Alle
DocType: Production Order,Additional Operating Cost,Yderligere driftsomkostninger
DocType: Company,Retail,Retail
DocType: Sales Invoice Item,Time Log Batch,Time Log Batch
DocType: Shipping Rule Condition,From Value,Fra Value
DocType: Quality Inspection,Purchase Receipt No,Kvittering Nej
apps/erpnext/erpnext/controllers/website_list_for_contact.py +65,{0}% Billed,{0}% Billed
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +106,Planing,Planing
,Qty to Order,Antal til ordre
DocType: Purchase Invoice,Price List Exchange Rate,Prisliste Exchange Rate
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +92,{0} is not a stock Item,{0} er ikke et lager Vare
apps/erpnext/erpnext/projects/doctype/project/project.js +22,Save the document first.,Gem dokumentet først.
apps/erpnext/erpnext/config/setup.py +94,Automatically compose message on submission of transactions.,Automatisk skrive besked på indsendelse af transaktioner.
apps/erpnext/erpnext/crm/doctype/newsletter_list/newsletter_list.js +40,New Newsletter,Ny Nyhedsbrev
DocType: Stock Settings,Default Item Group,Standard Punkt Group
DocType: Stock Reconciliation,Reconciliation JSON,Afstemning JSON
apps/erpnext/erpnext/public/js/queries.js +39,Please specify a,Angiv en
apps/erpnext/erpnext/stock/doctype/item/item.py +484,Item Variants {0} updated,Item Varianter {0} opdateret
DocType: Mode of Payment Account,Mode of Payment Account,Mode Betalingskonto
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +228,Serial No {0} not in stock,Løbenummer {0} ikke er på lager
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: Sales Invoice,Terms and Conditions Details,Betingelser Detaljer
DocType: Time Log,Projects Manager,Projekter manager
apps/erpnext/erpnext/templates/form_grid/material_request_grid.html +7,Required On,Nødvendig On
DocType: Item Supplier,Item Supplier,Vare Leverandør
DocType: Employee,Previous Work Experience,Tidligere erhvervserfaring
DocType: Product Bundle Item,Product Bundle Item,Produkt Bundle Item
apps/frappe/frappe/core/doctype/user/user_list.js +12,Active,Aktiv
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +188,Item {0} is not setup for Serial Nos. Column must be blank,Vare {0} er ikke setup for Serial nr. Kolonne skal være tomt
DocType: Offer Letter,Offer Letter Terms,Tilbyd Letter Betingelser
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +56,Full-time,Fuld tid
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +111,Office Rent,Kontorleje
apps/erpnext/erpnext/accounts/doctype/account/account.py +172,Account with existing transaction can not be deleted,Konto med eksisterende transaktion kan ikke slettes
DocType: Purchase Invoice,Total Taxes and Charges,Total Skatter og Afgifter
DocType: Employee External Work History,Salary,Løn
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +121,Linishing,Linishing
DocType: Employee,Bank Name,Bank navn
apps/erpnext/erpnext/accounts/doctype/account/account.js +50,Chart of Accounts,Kontoplan
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +236,"Difference Account must be a Asset/Liability type account, since this Stock Reconciliation is an Opening Entry","Forskel Der skal være en Asset / Liability typen konto, da dette Stock Forsoning er en åbning indtastning"
DocType: Payment Tool,Set Matching Amounts,Set matchende Beløb
DocType: Accounts Settings,Accounts Settings,Konti Indstillinger
apps/erpnext/erpnext/config/selling.py +121,Terms and Conditions Template,Vilkår og betingelser Skabelon
apps/erpnext/erpnext/controllers/buying_controller.py +131,Please enter 'Is Subcontracted' as Yes or No,Indtast &quot;underentreprise&quot; som Ja eller Nej
DocType: Attendance,Absent,Fraværende
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +517,Make ,Lave
DocType: Stock Entry,Material Transfer for Manufacture,Materiale Transfer til Fremstilling
DocType: File,old_parent,old_parent
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +328,Please enter Item Code to get batch no,Indtast venligst Item Code for at få batchnr
DocType: Features Setup,"All import related fields like currency, conversion rate, import total, import grand total etc are available in Purchase Receipt, Supplier Quotation, Purchase Invoice, Purchase Order etc.","Alle import- relaterede områder som valuta, konverteringsfrekvens, samlede import, import grand total etc er tilgængelige i købskvittering, leverandør Citat, købsfaktura, Indkøbsordre etc."
DocType: Web Page,Left,Venstre
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +54,Expected Delivery Date cannot be before Purchase Order Date,"Forventet leveringsdato kan ikke være, før indkøbsordre Dato"
DocType: DocField,Image,Billede
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +248,Warehouse is required,Warehouse kræves
DocType: SMS Center,All Supplier Contact,Alle Leverandør Kontakt
DocType: Purchase Invoice,Half-yearly,Halvårligt
DocType: Lead,Interested,Interesseret
DocType: Salary Structure Earning,Salary Structure Earning,Løn Struktur Earning
apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js +12,Transfered,Overført
apps/erpnext/erpnext/projects/doctype/project/project.py +43,Expected End Date can not be less than Expected Start Date,Forventet Slutdato kan ikke være mindre end forventet startdato
DocType: Project,Expected End Date,Forventet Slutdato
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.js +28,Payment Type,Betaling Type
DocType: Salary Slip Deduction,Depends on Leave Without Pay,Afhænger Leave uden løn
DocType: Production Planning Tool,Create Production Orders,Opret produktionsordrer
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +314,{0} against Sales Invoice {1},{0} mod salgsfaktura {1}
DocType: Fiscal Year,"For e.g. 2012, 2012-13","Til fx 2012, 2012-13"
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +54,Total cannot be zero,Samlede kan ikke være nul
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
DocType: Event,Saturday,Lørdag
DocType: Production Planning Tool,Production Planning Tool,Produktionsplanlægning Tool
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +25,"To add child nodes, explore tree and click on the node under which you want to add more nodes.","Hvis du vil tilføje barn noder, udforske træet og klik på noden, hvorunder du ønsker at tilføje flere noder."
DocType: Item,Manufacturer,Producent
DocType: Budget Detail,Fiscal Year,Regnskabsår
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +128,Balance for Account {0} must always be {1},Balance for konto {0} skal altid være {1}
,Qty to Receive,Antal til Modtag
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +259,Region,Region
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +177,Outstanding for {0} cannot be less than zero ({1}),Enestående for {0} kan ikke være mindre end nul ({1})
DocType: HR Settings,Payroll Settings,Payroll Indstillinger
apps/erpnext/erpnext/controllers/recurring_document.py +162,Please select {0},Vælg {0}
DocType: Sales Taxes and Charges Template,Sales Master Manager,Salg Master manager
DocType: Appraisal,Appraisal,Vurdering
DocType: Item,Average time taken by the supplier to deliver,Gennemsnitlig tid taget af leverandøren til at levere
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +642,From Quotation,Fra tilbudsgivning
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: Item,Is Service Item,Er service Item
DocType: HR Settings,Don't send Employee Birthday Reminders,Send ikke Medarbejder Fødselsdag Påmindelser
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +65,Straight shearing,Lige klipning
DocType: Production Plan Sales Order,SO Date,SO Dato
DocType: Authorization Rule,Transaction,Transaktion
,Finished Goods,Færdigvarer
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +43,"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/accounts/doctype/purchase_invoice/purchase_invoice.js +272,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;"
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: Pricing Rule,Brand,Brand
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +138,Research,Forskning
apps/erpnext/erpnext/projects/doctype/time_log_batch/time_log_batch.js +23,This Time Log Batch has been billed.,This Time Log Batch er blevet faktureret.
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +36,Message Sent,Besked sendt
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41,Minimum Inventory Level,Minimum Inventory Level
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +295,Serial No {0} created,Løbenummer {0} oprettet
DocType: Maintenance Schedule,Schedules,Tidsplaner
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +58,Repeat Customers,Gentag Kunder
DocType: Payment Reconciliation,Get Unreconciled Entries,Få ikke-afstemte Entries
,Budget Variance Report,Budget Variance Report
DocType: Monthly Distribution,Distribution Name,Distribution Name
DocType: Production Planning Tool,Download a report containing all raw materials with their latest inventory status,Download en rapport med alle råvarer med deres seneste opgørelse status
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +233,Please enter Expense Account,Indtast venligst udgiftskonto
apps/erpnext/erpnext/accounts/doctype/account/account.py +115,Cannot covert to Group because Account Type is selected.,"Kan ikke skjult til gruppen, fordi Kontotype er valgt."
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +258,Installation Note {0} has already been submitted,Installation Bemærk {0} er allerede blevet indsendt
DocType: Authorization Rule,Applicable To (Designation),Gælder for (Betegnelse)
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/crm/doctype/newsletter_list/newsletter_list.py +40,{0} subscribers added,{0} abonnenter tilføjet
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +15,Brokerage,Brokerage
apps/erpnext/erpnext/stock/doctype/item/item.py +334,Item Tax Row {0} must have account of type Tax or Income or Expense or Chargeable,Item Skat Row {0} skal have højde for typen Skat eller indtægt eller omkostning eller Afgiftspligtens
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/setup/page/setup_wizard/fixtures/operations.py +122,Mass finishing,Masse efterbehandling
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +193,Row {0}: {1} {2} does not match with {3},Række {0}: {1} {2} ikke passer med {3}
apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.js +22,Target On,Target On
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +66,No Remarks,Ingen Bemærkninger
DocType: Purchase Invoice,Is Recurring,Er Tilbagevendende
DocType: Purchase Invoice Item,Image View,Billede View
DocType: Naming Series,Prefix,Præfiks
DocType: Payment Tool,Get Outstanding Vouchers,Få Udestående Vouchers
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js +15,Period,Periode
DocType: Sales 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"
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +76,Batch number is mandatory for Item {0},Batchnummer er obligatorisk for Item {0}
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +95,Warehouse can not be deleted as stock ledger entry exists for this warehouse.,"Warehouse kan ikke slettes, da der eksisterer lager hovedbog post for dette lager."
DocType: Sales Invoice,Rounded Total,Afrundet alt
apps/erpnext/erpnext/projects/doctype/project/project.js +40,Time Logs,Time Logs
DocType: Sales Team,Contact No.,Kontakt No.
DocType: Installation Note Item,Installation Note Item,Installation Bemærk Vare
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +13,Biotechnology,Bioteknologi
apps/erpnext/erpnext/config/selling.py +132,Rules for adding shipping costs.,Regler for at tilføje forsendelsesomkostninger.
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +746,Item or Warehouse for row {0} does not match Material Request,Element eller Warehouse for række {0} matcher ikke Materiale Request
DocType: Leave Allocation,New Leaves Allocated,Nye Blade Allokeret
,Purchase Order Trends,Indkøbsordre Trends
DocType: Leave Application,Apply / Approve Leaves,Anvend / Godkend Blade
DocType: Payment Reconciliation,Payments,Betalinger
apps/erpnext/erpnext/stock/doctype/stock_uom_replace_utility/stock_uom_replace_utility.py +37,Item is required,Element er påkrævet
DocType: Serial No,Creation Date,Oprettelsesdato
apps/erpnext/erpnext/accounts/doctype/payment_tool/payment_tool.py +28,Row {0}: {1} is not a valid {2},Række {0}: {1} er ikke en gyldig {2}
DocType: Leave Application,Leave Balance Before Application,Lad Balance Før Application
DocType: Workflow State,Edit,Edit
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +27,Ageing Based On,Aldring Baseret på
,Bank Clearance Summary,Bank Clearance Summary
DocType: Notification Control,Sales Invoice Message,Salg Faktura Message
DocType: Employee,Leave Encashed?,Efterlad indkasseres?
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +36,In Qty,I Antal
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +81,Net pay cannot be negative,Nettoløn kan ikke være negativ
DocType: Time Log,Time Log,Time Log
DocType: Purchase Invoice Item,Net Rate (Company Currency),Net Rate (Company Valuta)
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: Stock Entry Detail,Actual Qty (at source/target),Faktiske Antal (ved kilden / mål)
DocType: Lead,Organization Name,Organisationens navn
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: Manufacturing Settings,Over Production Allowance Percentage,Over Produktion GODTGØRELSESPROCENT
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +64,Against Supplier Invoice {0} dated {1},Imod Leverandør Faktura {0} dateret {1}
DocType: Sales Invoice Item,Delivered Qty,Leveres Antal
DocType: Appraisal,Start Date,Startdato
DocType: Bin,Stock Value,Stock Value
apps/erpnext/erpnext/setup/doctype/sms_settings/sms_settings.py +25,Please enter valid mobile nos,Indtast venligst gyldige mobile nos
DocType: Employee,Holiday List,Holiday List
DocType: SMS Log,Requested Numbers,Anmodet Numbers
DocType: Expense Claim,Approver,Godkender
apps/erpnext/erpnext/controllers/accounts_controller.py +499,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
DocType: Opportunity,Contact Info,Kontakt Info
DocType: Website Item Group,Cross Listing of Item in multiple groups,Cross Notering af Item i flere grupper
DocType: Maintenance Schedule Item,Maintenance Schedule Item,Vedligeholdelse Skema Vare
DocType: Holiday List,Holidays,Helligdage
DocType: Workflow State,Tasks,Opgaver
apps/erpnext/erpnext/selling/page/sales_browser/sales_browser.js +37,{0} Tree,{0} Tree
apps/erpnext/erpnext/config/buying.py +23,Quotations received from Suppliers.,Citater modtaget fra leverandører.
DocType: Item Attribute Value,Attribute Value,Attribut Værdi
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +73,Customer Service,Kundeservice
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js +20,Please select Company and Party Type first,Vælg Company og Party Type først
DocType: Purchase Invoice,Repeat on Day of Month,Gentag på Dag Måned
DocType: DocField,Type,Type
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +62,Cutting,Skæring
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +45,Expected balance as per bank,Forventet balance pr bank
DocType: Cost Center,Add rows to set annual budgets on Accounts.,Tilføj rækker til at fastsætte årlige budgetter på Konti.
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
DocType: Batch,Expiry Date,Udløbsdato
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +46,Consumed Amount,Forbrugt Mængde
DocType: User,Gender,Køn
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +183,Capital Stock,Capital Stock
DocType: Production Planning Tool,Select Items,Vælg emner
apps/erpnext/erpnext/projects/doctype/task/task.py +44,Cannot close task as its dependant task {0} is not closed.,Kan ikke lukke opgave som sin afhængige opgave {0} ikke er lukket.
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +137,Against Journal Entry {0} does not have any unmatched {1} entry,Mod Kassekladde {0} har ikke nogen uovertruffen {1} indgang
DocType: Upload Attendance,Download Template,Hent skabelon
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +11,Evaporative-pattern casting,Fordampningsemissioner-mønster støbning
DocType: POS Profile,Write Off Cost Center,Skriv Off Cost center
DocType: Production Order Operation,Actual Start Time,Faktiske Start Time
apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +152,Please mention no of visits required,"Henvis ikke af besøg, der kræves"
apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +75,Please enter message before sending,"Indtast venligst besked, før du sender"
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +99,Reaming,Rivning
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +100,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: Material Request Item,Sales Order No,Salg bekendtgørelse nr
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +165,Stock Liabilities,Stock Passiver
,Employee Information,Medarbejder Information
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +334,Note: {0},Bemærk: {0}
DocType: Dropbox Backup,Allow Dropbox Access,Tillad Dropbox Access
apps/erpnext/erpnext/controllers/accounts_controller.py +474,{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}.
DocType: Production Planning Tool,Download Materials Required,Hent Påkrævede materialer
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +32,Stock Assets,Stock Assets
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +202,Row {0}: Allocated amount {1} must be less than or equals to JV amount {2},Række {0}: Allokeret mængde {1} skal være mindre end eller lig med JV beløb {2}
DocType: Stock Entry,As per Stock UOM,Pr Stock UOM
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +9,Application of Funds (Assets),Anvendelse af midler (Assets)
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +36,Currency is required for Price List {0},Valuta er nødvendig for prisliste {0}
DocType: Purchase Order,Delivered,Leveret
DocType: Serial No,Out of AMC,Ud af AMC
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +119,"For row {0} in {1}. To include {2} in Item rate, rows {3} must also be included","For rækken {0} i {1}. For at inkludere {2} i Item sats, rækker {3} skal også medtages"
DocType: Project,Internal,Intern
DocType: Authorization Rule,Based On,Baseret på
DocType: Opportunity,Customer / Lead Address,Kunde / Lead Adresse
apps/erpnext/erpnext/hr/doctype/employee/employee.js +27,Make Salary Structure,Foretag Løn Struktur
apps/erpnext/erpnext/public/js/feature_setup.js +220,"Grid """,Grid &quot;
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +39,Medical,Medicinsk
DocType: Item,"Allow in Sales Order of type ""Service""",Tillad i kundeordre af typen &quot;Service&quot;
DocType: Item,Is Sales Item,Er Sales Item
DocType: Warranty Claim,Raised By,Rejst af
DocType: Sales Order,% Amount Billed,% Beløb Billed
DocType: Account,Expense Account,Udgiftskonto
apps/frappe/frappe/core/page/data_import_tool/data_import_tool.js +108,Import Successful!,Import Vellykket!
apps/erpnext/erpnext/setup/doctype/territory/territory.js +14,This is a root territory and cannot be edited.,Dette er en rod territorium og kan ikke redigeres.
apps/erpnext/erpnext/stock/get_item_details.py +122,Item {0} must be a Service Item.,Vare {0} skal være en service Item.
DocType: Leave Type,Is Carry Forward,Er Carry Forward
DocType: Employee,History In Company,Historie I Company
,Received Items To Be Billed,Modtagne varer skal faktureres
DocType: Sales Team,Contribution to Net Total,Bidrag til Net Total
apps/erpnext/erpnext/stock/doctype/batch/batch_list.js +7,Not Expired,Ikke er udløbet
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +38,Rolling,Rullende
DocType: Features Setup,Sales Extras,Salg Extras
DocType: Sales Invoice,Supplier Reference,Leverandør reference
DocType: Item,Has Variants,Har Varianter
DocType: Material Request Item,Lead Time Date,Leveringstid Dato
DocType: Task,Actual End Date (via Time Logs),Faktiske Slutdato (via Time Logs)
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +66,Transfer Materials for Manufacture,Overfør Materialer til Fremstilling
apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +213,Maintenance Schedule is not generated for all the items. Please click on 'Generate Schedule',Vedligeholdelsesplan ikke genereret for alle poster. Klik på &quot;Generer Schedule &#39;
DocType: BOM,Manufacturing,Produktion
DocType: Note,Note,Bemærk
DocType: Stock Entry,Total Incoming Value,Samlet Indgående Value
DocType: Delivery Note,Return Against Delivery Note,Retur Against følgeseddel
DocType: Account,Is Group,Is Group
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +115,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: Expense Claim,Project,Projekt
DocType: Stock Entry Detail,Serial No / Batch,Løbenummer / Batch
,Available Stock for Packing Items,Tilgængelig Stock til Emballerings- Varer
DocType: Leave Block List Date,Block Date,Block Dato
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +20,Cosmetics,Kosmetik
DocType: Leave Block List,Block Days,Bloker dage
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +50,Sports,Sport
DocType: Purchase Invoice Item,PR Detail,PR Detail
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +62,Intern,Intern
DocType: Employee,Bank A/C No.,Bank A / C No.
DocType: Serial No,Distinct unit of an Item,Særskilt enhed af et element
apps/erpnext/erpnext/config/stock.py +263,Items and Pricing,Varer og Priser
DocType: Upload Attendance,Import Attendance,Import Fremmøde
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +106,Please enter 'Expected Delivery Date',Indtast &#39;Forventet leveringsdato&#39;
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +90,Row #{0}: Rejected Qty can not be entered in Purchase Return,Row # {0}: Afvist Antal kan ikke indtastes i Indkøb Return
DocType: Territory,Territory Manager,Territory manager
apps/erpnext/erpnext/utilities/doctype/address_template/address_template.py +15,Setting this Address Template as default as there is no other default,"Angivelse af denne adresse skabelon som standard, da der ikke er nogen anden standard"
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +104,Negative Valuation Rate is not allowed,Negative Værdiansættelse Rate er ikke tilladt
apps/erpnext/erpnext/config/accounts.py +101,Tree of finanial Cost Centers.,Tree of finanial Cost Centers.
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +622,Products,Produkter
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +15,Make Salary Slip,Foretag lønseddel
DocType: Product Bundle,List items that form the package.,"Listeelementer, der danner pakken."
DocType: Event,All Day,All Day
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, vil listen skal lægges til hver afdeling, hvor det skal anvendes."
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +74,Purpose must be one of {0},Formålet skal være en af ​​{0}
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +47,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/stock.py +268,Item Variants,Item Varianter
DocType: Task,Urgent,Urgent
DocType: ToDo,Priority,Prioritet
DocType: BOM Explosion Item,Qty Consumed Per Unit,Antal Consumed Per Unit
apps/erpnext/erpnext/stock/doctype/stock_uom_replace_utility/stock_uom_replace_utility.py +111,Item valuation updated,Item værdiansættelse opdateret
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +26,Injection molding,Sprøjtestøbning
DocType: Quality Inspection,Get Specification Details,Få Specifikation Detaljer
,Qty to Transfer,Antal til Transfer
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +318,Please select Company,Vælg Firma
DocType: Item,Quality Parameters,Kvalitetsparametre
apps/erpnext/erpnext/support/doctype/maintenance_visit/maintenance_visit.py +12,To {0},Til {0}
DocType: BOM,Last Purchase Rate,Sidste Purchase Rate
DocType: Notification Control,Expense Claim Approved,Expense krav Godkendt
DocType: Sales Invoice,Existing Customer,Eksisterende kunde
DocType: Item Customer Detail,Ref Code,Ref Code
DocType: Quality Inspection Reading,Parameter,Parameter
DocType: Task,Actual Start Date (via Time Logs),Faktiske startdato (via Time Logs)
DocType: Manufacturing Settings,Plan time logs outside Workstation Working Hours.,Planlæg tid logs uden Workstation arbejdstid.
DocType: Maintenance Schedule Detail,Actual Date,Faktiske dato
DocType: Hub Settings,Publish Items to Hub,Udgive varer i Hub
apps/erpnext/erpnext/accounts/doctype/account/account.js +54,Convert to non-Group,Konverter til ikke-Group
DocType: Target Detail,Target Qty,Target Antal
DocType: Payment Reconciliation,Unreconciled Payment Details,Ikke-afstemte Betalingsoplysninger
DocType: Leave Block List,Applies to Company,Gælder for Company
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +96,Freight and Forwarding Charges,Fragt og Forwarding Afgifter
DocType: Contact,Passive,Passiv
DocType: Payment Tool,Total Payment Amount,Samlet Betaling Beløb
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +158,"Sorry, Serial Nos cannot be merged","Beklager, kan Serial Nos ikke blive slået sammen"
apps/erpnext/erpnext/accounts/doctype/account/account.py +45,Account {0}: Parent account {1} can not be a ledger,Konto {0}: Forældre-konto {1} kan ikke være en finanskonto
DocType: Sales Partner,Targets,Mål
DocType: Contact Us Settings,State,Stat
DocType: Payment Reconciliation,Bank / Cash Account,Bank / kontantautomat konto
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +175,Cannot cancel because submitted Stock Entry {0} exists,Kan ikke annullere fordi indsendt Stock indtastning {0} eksisterer
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +40,Average Age,Gennemsnitlig alder
DocType: Employee,Relation,Relation
DocType: Workstation,Operating Costs,Drifts- omkostninger
DocType: Item,Manufacturer Part Number,Producentens varenummer
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +12,Banking,Banking
DocType: Quotation,Maintenance User,Vedligeholdelse Bruger
apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.js +17,Make Offer Letter,Kom med et tilbud Letter
DocType: Purchase Taxes and Charges,Tax Amount After Discount Amount,Skat Beløb Efter Discount Beløb
DocType: Warranty Claim,Issue Date,Udstedelsesdagen
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +99,Quotation {0} not of type {1},Notering {0} ikke af typen {1}
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +134,Electrochemical machining,Elektrokemisk bearbejdning
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +61,Serial No {0} does not belong to Delivery Note {1},Løbenummer {0} ikke hører til følgeseddel {1}
DocType: Period Closing Voucher,"The account head under Liability, in which Profit/Loss will be booked","Kontoen hoved under ansvar, hvor gevinst / tab vil være reserveret"
DocType: Sales Partner,Implementation Partner,Implementering Partner
apps/frappe/frappe/public/js/frappe/form/print.js +96,Start,Start
DocType: Event,Thursday,Torsdag
DocType: Leave Block List Allow,Leave Block List Allow,Lad Block List Tillad
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +57,Shaving,Barbering
DocType: Item,Publish in Hub,Offentliggør i Hub
DocType: Territory,Parent Territory,Parent Territory
DocType: Item,Sales Details,Salg Detaljer
apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +93,{0} Items synced,synkroniseret {0} Varer
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +19,Invoiced Amount,Fakturerede beløb
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."
DocType: Maintenance Schedule Detail,Maintenance Schedule Detail,Vedligeholdelse Skema Detail
DocType: Purchase Invoice Item,Purchase Order Item,Indkøbsordre Item
apps/erpnext/erpnext/projects/report/daily_time_log_summary/daily_time_log_summary.py +16,From Datetime,Fra datotid
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +207,New Account Name,Ny Kontonavn
DocType: Purchase Invoice,Contact Person,Kontakt Person
DocType: Communication,Other,Andre
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: Email Alert,Reference Date,Henvisning Dato
DocType: Authorization Rule,Average Discount,Gennemsnitlig rabat
DocType: DocField,Label,Label
DocType: Item,Automatically create Material Request if quantity falls below this level,Automatisk oprette Materiale Request hvis mængde falder under dette niveau
DocType: Upload Attendance,Upload HTML,Upload HTML
DocType: Project Task,Pending Review,Afventer anmeldelse
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +455,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: Async Task,Status,Status
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +81,Group by Account,Gruppe af konto
apps/erpnext/erpnext/setup/doctype/company/company.js +22,Please re-type company name to confirm,Prøv venligst igen typen firmanavn for at bekræfte
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +30,Project Start Date,Projekt startdato
DocType: Quality Inspection Reading,Reading 5,Reading 5
DocType: Item,Publish Item to hub.erpnext.com,Udgive Vare til hub.erpnext.com
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +147,Customer {0} does not belong to project {1},Kunden {0} ikke hører til projekt {1}
DocType: Lead,Person Name,Person Name
apps/erpnext/erpnext/controllers/buying_controller.py +283,Row {0}: Conversion Factor is mandatory,Række {0}: Konvertering Factor er obligatorisk
apps/erpnext/erpnext/config/accounts.py +13,Accounting journal entries.,Regnskab journaloptegnelser.
DocType: Maintenance Visit,Partially Completed,Delvist Afsluttet
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +37,{0} does not belong to Company {1},{0} ikke tilhører selskabet {1}
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +651,Sit tight while your system is being setup. This may take a few moments.,"Sidde stramt, mens dit system bliver setup. Dette kan tage et øjeblik."
apps/erpnext/erpnext/stock/doctype/item/item.js +33,This Item is a Template and cannot be used in transactions. Item attributes will be copied over into the variants unless 'No Copy' is set,"Dette element er en skabelon, og kan ikke anvendes i transaktioner. Item attributter kopieres over i varianterne medmindre &#39;Ingen Copy &quot;er indstillet"
DocType: Purchase Receipt Item,Required By,Kræves By
DocType: Item Tax,Tax Rate,Skat
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +55,Piercing,Piercing
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +6,Advertising,Reklame
DocType: Time Log,From Time,Fra Time
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +489,Transfer Material,Transfer Materiale
DocType: Selling Settings,Maintain Same Rate Throughout Sales Cycle,Oprethold Samme Rate Gennem Sales Cycle
DocType: Purchase Invoice,Recurring Id,Tilbagevendende Id
DocType: Journal Entry,Credit Note,Kreditnota
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +35,To create a Tax Account,Sådan opretter du en Tax-konto
DocType: Email Digest,Add/Remove Recipients,Tilføj / fjern modtagere
apps/erpnext/erpnext/config/hr.py +125,Tax and other salary deductions.,Skat og andre løn fradrag.
apps/erpnext/erpnext/stock/get_item_details.py +260,Price List {0} is disabled,Prisliste {0} er deaktiveret
DocType: Production Order,Use Multi-Level BOM,Brug Multi-Level BOM
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +77,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/setup/page/setup_wizard/fixtures/operations.py +27,Compression molding,Kompressionsstøbning
DocType: Address,Plant,Plant
DocType: Item,Supply Raw Materials for Purchase,Supply råstoffer til Indkøb
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +92,Head of Marketing and Sales,Chef for Marketing og Salg
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +223,Please enter Cost Center,Indtast Cost center
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +48,Total Qty,Antal Total
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +52,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/config/hr.py +65,Generate Salary Slips,Generer lønsedler
DocType: Purchase Receipt Item Supplied,Consumed Qty,Forbrugt Antal
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +143,Sintering,Sintring
DocType: Purchase Order Item Supplied,Purchase Order Item Supplied,Indkøbsordre Item Leveres
DocType: Newsletter List,Total Subscribers,Total Abonnenter
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: Purchase Order,% Billed,% Billed
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +48,Soap & Detergent,Sæbe &amp; Vaskemiddel
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +148,Clinching,Clinching
DocType: Event,Groups,Grupper
DocType: Bank Reconciliation Detail,Bank Reconciliation Detail,Bank Afstemning Detail
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +396,What does it do?,Hvad gør det?
,Lead Id,Bly Id
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +397,"e.g. ""Build tools for builders""",fx &quot;Byg værktøjer til bygherrer&quot;
DocType: Lead,From Customer,Fra kunde
DocType: Sales Partner,Partner Type,Partner Type
DocType: Employee Education,Year of Passing,År for Passing
apps/erpnext/erpnext/projects/doctype/time_log/time_log_list.js +13,Please select Time Logs.,Vælg Time Logs.
DocType: Customer,Customer Details,Kunde Detaljer
DocType: Address,Utilities,Forsyningsvirksomheder
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +48,"There can only be one Shipping Rule Condition with 0 or blank value for ""To Value""",Der kan kun være én Forsendelse Rule Condition med 0 eller blank værdi for &quot;til værdi&quot;
apps/frappe/frappe/desk/page/backups/backups.html +13,Size,Størrelse
apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +21,Support Analtyics,Support Analtyics
apps/erpnext/erpnext/stock/doctype/item_price/item_price.js +16,Import in Bulk,Import i bulk
apps/erpnext/erpnext/support/doctype/maintenance_visit/maintenance_visit.js +30,From Warranty Claim,Fra garanti krav
apps/erpnext/erpnext/config/crm.py +27,All Contacts.,Alle kontakter.
DocType: Company,Default Bank Account,Standard bankkonto
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +446,Item {0} is not active or end of life has been reached,Vare {0} er ikke aktiv eller slutningen af ​​livet er nået
DocType: Address,Shipping,Forsendelse
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +10,Current Assets,Omsætningsaktiver
apps/frappe/frappe/core/page/permission_manager/permission_manager.js +379,Add,Tilføje
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +38,Sales Price List,Salg prisliste
DocType: Employee External Work History,Employee External Work History,Medarbejder Ekstern Work History
,Accounts Browser,Konti Browser
apps/erpnext/erpnext/config/support.py +23,Plan for maintenance visits.,Plan for vedligeholdelse besøg.
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +43,Pressing,Ved at trykke
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +153,Green,Grøn
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +143,Direct Income,Direkte Indkomst
apps/erpnext/erpnext/stock/doctype/stock_uom_replace_utility/stock_uom_replace_utility.py +65,Stock UOM updated for Item {0},Stock UOM opdateret for Item {0}
apps/erpnext/erpnext/config/projects.py +28,Batch Time Logs for billing.,Batch Time Logs for fakturering.
DocType: Purchase Invoice,Ignore Pricing Rule,Ignorer Prisfastsættelse Rule
DocType: Item,Max Discount (%),Max Rabat (%)
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +468,Delivery Note {0} is not submitted,Levering Note {0} er ikke indsendt
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +35,Opening Qty,Åbning Antal
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: Sales Order,Not Billed,Ikke Billed
DocType: Account,Company,Firma
DocType: Lead,Blog Subscriber,Blog Subscriber
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +58,Cannot set as Lost as Sales Order is made.,Kan ikke indstilles som Lost som Sales Order er foretaget.
DocType: Item Variant,Item Variant,Item Variant
DocType: Holiday List,Weekly Off,Ugentlig Off
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: Purchase Order Item Supplied,Stock UOM,Stock UOM
DocType: Account,Payable,Betales
DocType: Serial No,Delivery Document Type,Levering Dokumenttype
DocType: Sales Invoice,C-Form Applicable,C-anvendelig
DocType: Page,No,Ingen
apps/erpnext/erpnext/config/stock.py +33,Goods received from Suppliers.,Varer modtaget fra leverandører.
DocType: Maintenance Visit Purpose,Work Done,Arbejde Udført
DocType: Packed Item,Packed Item,Pakket Vare
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/delivery_note/delivery_note.py +281,My Shipments,Mine forsendelser
DocType: Workstation,Consumable Cost,Forbrugsmaterialer Cost
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +552,Manufacturing Quantity is mandatory,Produktion Mængde er obligatorisk
,Serial No Status,Løbenummer status
DocType: Opportunity Item,Basic Rate,Grundlæggende Rate
apps/frappe/frappe/core/doctype/doctype/boilerplate/controller_list.html +31,Completed,Afsluttet
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +50,Total weightage assigned should be 100%. It is {0},Samlet weightage tildelt skulle være 100%. Det er {0}
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +141,Welding,Svejsning
DocType: Item,Weight UOM,Vægt UOM
DocType: Purchase Invoice,Contact,Kontakt
DocType: HR Settings,Include holidays in Total no. of Working Days,Medtag helligdage i alt nej. Arbejdsdage
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/gl_entry/gl_entry.py +96,Cost Center {0} does not belong to Company {1},Omkostningssted {0} ikke tilhører selskabet {1}
DocType: Time Log,Will be updated when batched.,"Vil blive opdateret, når batched."
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +44,Serial No is mandatory for Item {0},Løbenummer er obligatorisk for Item {0}
DocType: Leave Type,Is Encash,Er indløse
apps/erpnext/erpnext/hr/doctype/employee/employee.py +117,Contract End Date must be greater than Date of Joining,Kontrakt Slutdato skal være større end Dato for Sammenføjning
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +61,Lancing,Lancing
DocType: Lead,Mobile No.,Mobil No.
DocType: Employee,Date Of Retirement,Dato for pensionering
DocType: Batch,Batch Description,Batch Beskrivelse
apps/frappe/frappe/public/js/frappe/views/module/module_section.html +27,More,Mere
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +528,Purchaser,Køber
DocType: Sales Invoice Item,Target Warehouse,Target Warehouse
apps/erpnext/erpnext/manufacturing/page/bom_browser/bom_browser.js +17,Select BOM to start,Vælg BOM at starte
DocType: Purchase Order Item,Received Qty,Modtaget Antal
DocType: SMS Center,Receiver List,Modtager liste
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +108,Customer {0} does not exist,Kunde {0} eksisterer ikke
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +41,Pharmaceuticals,Lægemidler
DocType: DocShare,Document Type,Dokumenttype
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order_list.js +7,Not Started,Ikke i gang
,Purchase Register,Indkøb Register
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +29,Project Value,Projekt Value
DocType: Pricing Rule,Supplier Type,Leverandør Type
apps/frappe/frappe/public/js/frappe/form/grid_body.html +6,No Data,Ingen data
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +71,Cannot carry forward {0},Kan ikke fortsætte {0}
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +191,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
DocType: BOM Item,BOM No,BOM Ingen
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +17,Set as Closed,Angiv som Lukket
DocType: Production Planning Tool,"If checked, BOM for sub-assembly items will be considered for getting raw materials. Otherwise, all sub-assembly items will be treated as a raw material.","Hvis markeret, vil BOM for sub-montage elementer overvejes for at få råvarer. Ellers vil alle sub-montage poster behandles som et råstof."
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +92,Coating,Belægning
apps/erpnext/erpnext/stock/get_item_details.py +133,Item {0} must be a Purchase Item,Vare {0} skal være et køb Vare
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +34,Item {0} must be Service Item,Vare {0} skal være service Item
DocType: Purchase Taxes and Charges,Reference Row #,Henvisning Row #
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +29,Please do NOT create Accounts for Customers and Suppliers. They are created directly from the Customer / Supplier masters.,Tøv ikke oprette konti for kunder og leverandører. De er skabt direkte fra kunden / Leverandør mestre.
DocType: Item,Synced With Hub,Synkroniseret med Hub
DocType: Employee,Applicable Holiday List,Gældende Holiday List
DocType: Dependent Task,Dependent Task,Afhængig Opgave
DocType: Manufacturing Settings,Default 10 mins,Standard 10 min
DocType: Cost Center,Budgets,Budgetter
apps/erpnext/erpnext/stock/doctype/item/item.py +258,Default Warehouse is mandatory for stock Item.,Standard Warehouse er obligatorisk for lager Item.
apps/erpnext/erpnext/hr/doctype/employee/employee.py +105,Date of Birth cannot be greater than today.,Fødselsdato kan ikke være større end i dag.
DocType: Authorization Rule,Applicable To (Employee),Gælder for (Medarbejder)
DocType: Journal Entry,Cash Entry,Cash indtastning
DocType: Leave Control Panel,New Leaves Allocated (In Days),Nye blade Tildelte (i dage)
DocType: Account,Stock,Lager
DocType: Sales Invoice Item,Serial No,Løbenummer
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +84,Row # {0}: Cannot return more than {1} for Item {2},Row # {0}: Kan ikke returnere mere end {1} for Item {2}
DocType: Production Order,Warehouses,Pakhuse
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +161,Creditors,Kreditorer
apps/erpnext/erpnext/public/js/pos/pos.html +28,Discount Amount,Rabat Beløb
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +129,Material Request {0} is cancelled or stopped,Materiale Request {0} er aflyst eller stoppet
DocType: Quality Inspection,Verified By,Verified by
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +218,Serial No {0} does not belong to Warehouse {1},Løbenummer {0} ikke hører til Warehouse {1}
apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +39,Outstanding Amt,Enestående Amt
DocType: Global Defaults,Default Company,Standard Company
DocType: Authorization Rule,This will be used for setting rule in HR module,Dette vil blive brugt til at indstille regel i HR-modulet
DocType: BOM,Manage cost of operations,Administrer udgifter til operationer
DocType: Naming Series,Change the starting / current sequence number of an existing series.,Skift start / aktuelle sekvensnummer af en eksisterende serie.
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +199,Select a group node first.,Vælg en gruppe node først.
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +138,Gashing,Gashing
apps/erpnext/erpnext/projects/doctype/time_log/time_log_list.js +25,Time Log Status must be Submitted.,Time Log status skal indsendes.
DocType: Purchase Invoice,Additional Discount Amount (Company Currency),Yderligere Discount Beløb (Company Valuta)
DocType: Department,Department,Afdeling
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.js +66,Please enter Item first,Indtast Vare først
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +240,Packed quantity must equal quantity for Item {0} in row {1},Pakket mængde skal være lig mængde for Item {0} i række {1}
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +51,Case No. cannot be 0,Case No. ikke være 0
DocType: Project,Default Cost Center,Standard Cost center
DocType: BOM,Item UOM,Item UOM
DocType: Sales Person,Parent Sales Person,Parent Sales Person
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +107,Both Warehouse must belong to same Company,Både Warehouse skal tilhøre samme firma
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +82,Item {0} has already been returned,Element {0} er allerede blevet returneret
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +19,Welcome,Velkommen
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +56,Trimming,Trimning
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +538,"For 'Product Bundle' items, Warehouse, Serial No and Batch No will be considered from the 'Packing List' table. If Warehouse and Batch No are same for all packing items for any 'Product Bundle' item, those values can be entered in the main Item table, values will be copied to 'Packing List' table.","For &#39;Product Bundle&#39; elementer, Warehouse, Serial No og Batch Ingen vil blive betragtet fra &quot;Packing List &#39;bord. Hvis Warehouse og Batch Ingen er ens for alle emballage poster for enhver &quot;Product Bundle &#39;post, kan indtastes disse værdier i de vigtigste element tabellen, vil værdierne blive kopieret til&quot; Packing List&#39; bord."
DocType: Upload Attendance,Attendance To Date,Fremmøde til dato
DocType: Project,Total Expense Claim (via Expense Claims),Total Expense krav (via Expense krav)
DocType: Sales Partner,Target Distribution,Target Distribution
DocType: Delivery Note,Required only for sample item.,Kræves kun for prøve element.
apps/erpnext/erpnext/config/selling.py +304,Point-of-Sale,Point-of-Sale
apps/erpnext/erpnext/config/hr.py +205,Setting up Employees,Opsætning af Medarbejdere
DocType: Production Plan Item,Planned Qty,Planned Antal
DocType: Company,Default Letter Head,Standard Letter hoved
DocType: Maintenance Schedule Item,Periodicity,Hyppighed
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +89,Refining,Raffinering
DocType: Leave Application,Follow via Email,Følg via e-mail
DocType: Employee,Contract End Date,Kontrakt Slutdato
DocType: Purchase Order,Supply Raw Materials,Supply råstoffer
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +68,Raw material cannot be same as main Item,Råvarer kan ikke være samme som vigtigste element
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +579,For Supplier,For Leverandøren
DocType: Price List,Price List Name,Pris List Name
DocType: Stock Reconciliation Item,Leave blank if no change,"Efterlad tom, hvis ingen ændring"
apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +128,All Supplier Types,Alle Leverandør Typer
apps/erpnext/erpnext/controllers/accounts_controller.py +324,"Journal Entry {0} is linked against Order {1}, check if it should be pulled as advance in this invoice.","Kassekladde {0} er forbundet mod Order {1}, kontrollere, om det skal trækkes forhånd i denne faktura."
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +326,Item is not allowed to have Production Order.,Varen er ikke tilladt at have produktionsordre.
DocType: Item,"Selecting ""Yes"" will give a unique identity to each entity of this item which can be viewed in the Serial No master.","Hvis du vælger &quot;Ja&quot; vil give en unik identitet til hver enhed i denne post, som kan ses i Serial Ingen mester."
DocType: Shipping Rule Condition,To Value,Til Value
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +137,Grinding,Slibning
apps/erpnext/erpnext/accounts/doctype/account/account.py +194,"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 koncernens, Root Type, Firma"
apps/erpnext/erpnext/stock/doctype/stock_uom_replace_utility/stock_uom_replace_utility.py +61,Conversion factor cannot be in fractions,Omregningsfaktor kan ikke være i fraktioner
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +170,Duties and Taxes,Told og afgifter
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +113,Pharmaceutical,Farmaceutiske
apps/frappe/frappe/model/rename_doc.py +343,Please select a valid csv file with data,Vælg en gyldig csv fil med data
DocType: Sales Invoice Item,Brand Name,Brandnavn
DocType: Company,Registration Details,Registrering Detaljer
DocType: BOM Operation,Hour Rate,Hour Rate
DocType: Job Applicant,Job Applicant,Job Ansøger
DocType: Features Setup,Purchase Discounts,Køb Rabatter
apps/erpnext/erpnext/shopping_cart/utils.py +33,Cart,Kurv
DocType: Journal Entry,Accounting Entries,Bogføring
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +219,Same item has been entered multiple times.,Samme element er indtastet flere gange.
DocType: Bank Reconciliation,Total Amount,Samlet beløb
DocType: Journal Entry,Bank Entry,Bank indtastning
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +41,"Buying must be checked, if Applicable For is selected as {0}","Opkøb skal kontrolleres, om nødvendigt er valgt som {0}"
apps/erpnext/erpnext/controllers/selling_controller.py +21,To {0} | {1} {2},Til {0} | {1} {2}
DocType: Serial No,Serial No Details,Serial Ingen Oplysninger
,Sales Funnel,Salg Tragt
DocType: Newsletter,Test,Prøve
apps/frappe/frappe/public/js/frappe/model/indicator.js +30,Draft,Udkast
DocType: Customer,Buyer of Goods and Services.,Køber af varer og tjenesteydelser.
DocType: Purchase Taxes and Charges,On Previous Row Amount,På Forrige Row Beløb
apps/erpnext/erpnext/stock/doctype/item/item.py +37,Item Code is mandatory because Item is not automatically numbered,"Item Code er obligatorisk, fordi Varen er ikke automatisk nummereret"
DocType: Activity Cost,Costing Rate,Costing Rate
DocType: Blog Post,Blog Post,Blog-indlæg
DocType: Employee,Rented,Lejet
DocType: Installation Note Item,Against Document Detail No,Imod Dokument Detail Nej
DocType: Leave Type,Leave Type Name,Lad Type Navn
DocType: Bank Reconciliation,Journal Entries,Journaloptegnelser
apps/erpnext/erpnext/config/selling.py +122,Template of terms or contract.,Skabelon af vilkår eller kontrakt.
apps/erpnext/erpnext/hr/doctype/employee/employee.py +127,Please enter relieving date.,Indtast lindre dato.
DocType: Job Applicant,Thread HTML,Tråd HTML
DocType: Letter Head,Is Default,Er Standard
apps/erpnext/erpnext/stock/doctype/item/item.py +489,Item has variants.,Element har varianter.
DocType: SMS Log,No of Requested SMS,Ingen af ​​Anmodet SMS
DocType: Issue,Opening Time,Åbning tid
apps/erpnext/erpnext/config/hr.py +77,Leave Allocation Tool,Lad Tildeling Tool
DocType: Upload Attendance,Import Log,Import Log
DocType: Purchase Invoice,In Words,I Words
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
apps/erpnext/erpnext/accounts/doctype/account/account.py +188,Account {0} does not exist,Konto {0} findes ikke
apps/erpnext/erpnext/stock/doctype/item/item_list.js +11,Template,Skabelon
DocType: Manufacturing Settings,Disable Capacity Planning and Time Tracking,Deaktiver kapacitetsplanlægning og tidsregistrering
DocType: Project Task,View Task,View Opgave
DocType: GL Entry,Against Voucher,Mod Voucher
DocType: Purchase Receipt,Other Details,Andre detaljer
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +194,Please see attachment,Se venligst vedhæftede
DocType: C-Form,Quarter,Kvarter
DocType: Holiday List,Holiday List Name,Holiday listenavn
apps/erpnext/erpnext/projects/doctype/time_log/time_log_list.js +21,Time Log is not billable,Time Log ikke fakturerbare
DocType: Lead,Add to calendar on this date,Føj til kalender på denne dato
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +40,"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/setup/page/setup_wizard/fixtures/operations.py +77,Flanging,Flanger
apps/erpnext/erpnext/config/stock.py +110,"e.g. Kg, Unit, Nos, m","f.eks Kg, Unit, Nos, m"
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +429,BOM {0} must be submitted,BOM {0} skal indsendes
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +393,"e.g. ""My Company LLC""",fx &quot;My Company LLC&quot;
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
DocType: Item Group,Show In Website,Vis I Website
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +45,Note: This Cost Center is a Group. Cannot make accounting entries against groups.,Bemærk: Denne Cost Center er en gruppe. Kan ikke gøre regnskabsposter mod grupper.
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +67,"Cannot declare as lost, because Quotation has been made.","Kan ikke erklære så tabt, fordi Citat er blevet gjort."
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +135,Utility Expenses,Utility Udgifter
apps/erpnext/erpnext/accounts/doctype/account/account.py +134,Root Type is mandatory,Root Typen er obligatorisk
DocType: Bank Reconciliation Detail,Cheque Date,Check Dato
apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +194,Serial No {0} is under maintenance contract upto {1},Løbenummer {0} er under vedligeholdelse kontrakt op {1}
DocType: Item Price,Item Price,Item Pris
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +88,Smelting,Smeltning
apps/erpnext/erpnext/stock/get_item_details.py +136,Item {0} must be a Sub-contracted Item,Vare {0} skal være en underentreprise Vare
DocType: Maintenance Visit,Maintenance Visit,Vedligeholdelse Besøg
DocType: SMS Parameter,SMS Parameter,SMS Parameter
DocType: Account,Frozen,Frosne
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +129,Wire brushing,Stålbørstning
DocType: Holiday List,Clear Table,Klar Table
DocType: Lead,Upper Income,Upper Indkomst
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +28,Project Status,Projekt status
DocType: SMS Log,No of Sent SMS,Ingen af ​​Sent SMS
apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +34,Default Activity Cost exists for Activity Type - {0},Standard Activity Omkostninger findes for Activity Type - {0}
,Trial Balance,Trial Balance
apps/erpnext/erpnext/hr/report/monthly_salary_register/monthly_salary_register.py +66,No salary slip found for month:,Ingen lønseddel fundet for måned:
apps/erpnext/erpnext/config/selling.py +158,Setup incoming server for sales email id. (e.g. sales@example.com),Opsætning indgående server til salg email id. (F.eks sales@example.com)
DocType: Purchase Invoice Item,Rate (Company Currency),Rate (Company Valuta)
DocType: Communication,Received,Modtaget
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +611,Your Products or Services,Dine produkter eller tjenester
DocType: DocType,Administrator,Administrator
DocType: POS Profile,POS Profile,POS profil
DocType: Production Order Operation,Actual Time and Cost,Aktuel leveringstid og omkostninger
DocType: Buying Settings,Settings for Buying Module,Indstillinger til køb modul
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +27,Cost of Delivered Items,Omkostninger ved Leverede varer
DocType: Sales Invoice,Return Against Sales Invoice,Retur Against Sales Invoice
,To Produce,At producere
apps/erpnext/erpnext/config/accounts.py +23,Bills raised by Suppliers.,Regninger rejst af leverandører.
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +41,Cryorolling,Cryorolling
,Serial No Service Contract Expiry,Løbenummer Service Kontrakt udløb
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +197,"Company Email ID not found, hence mail not sent","Firma Email ID ikke fundet, dermed mail ikke sendt"
DocType: Sales Order,Not Applicable,Gælder ikke
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +54,Cost Center with existing transactions can not be converted to ledger,Cost Center med eksisterende transaktioner kan ikke konverteres til finans
DocType: Employee,Leave Approvers,Lad godkendere
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +90,Please setup numbering series for Attendance via Setup > Numbering Series,Venligst setup nummerering serie for Deltagelse via Setup&gt; Nummerering Series
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +88,Administrative Officer,Kontorfuldmægtig
apps/erpnext/erpnext/config/crm.py +90,Manage Sales Person Tree.,Administrer Sales Person Tree.
DocType: Sales Invoice,Posting Time,Udstationering Time
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +230,Serial Nos Required for Serialized Item {0},Seriel Nos Nødvendig for Serialized Item {0}
DocType: Journal Entry,Credit Card Entry,Credit Card indtastning
apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +67,"Operation {0} longer than any available working hours in workstation {1}, break down the operation into multiple operations","Betjening {0} længere end alle tilgængelige arbejdstimer i arbejdsstation {1}, nedbryde driften i flere operationer"
DocType: Shipping Rule Condition,Shipping Rule Condition,Forsendelse Rule Betingelse
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +46,Item Code > Item Group > Brand,Item Code&gt; Vare Gruppe&gt; Brand
apps/erpnext/erpnext/selling/page/sales_browser/sales_browser.js +123,Further nodes can be only created under 'Group' type nodes,Yderligere noder kan kun oprettes under &#39;koncernens typen noder
DocType: Address,Name of person or organization that this address belongs to.,"Navn på den person eller organisation, der denne adresse tilhører."
DocType: Item Attribute Value,Abbreviation,Forkortelse
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +308,Reference #{0} dated {1},Henvisning # {0} dateret {1}
apps/erpnext/erpnext/config/stock.py +23,Record item movement.,Optag element bevægelse.
DocType: Expense Claim,Employees Email Id,Medarbejdere Email Id
apps/erpnext/erpnext/stock/doctype/item/item.py +304,"As Production Order can be made for this item, it must be a stock item.","Som kan Produktionsordre gøres for denne post, skal det være en lagervare."
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +87,Commission on Sales,Provision på salg
DocType: Quality Inspection Reading,Accepted,Accepteret
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +261,"Select your Country, Time Zone and Currency","Vælg dit land, tidszone og valuta"
apps/erpnext/erpnext/config/accounts.py +53,Update bank payment dates with journals.,Opdater bank terminer med tidsskrifter.
DocType: Accounts Settings,Accounts Frozen Upto,Regnskab Frozen Op
apps/erpnext/erpnext/config/support.py +33,"Newsletters to contacts, leads.","Nyhedsbreve til kontakter, fører."
DocType: Account,Root Type,Root Type
DocType: User,Male,Mand
apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.js +50,"Company, Month and Fiscal Year is mandatory","Company, Måned og regnskabsår er obligatorisk"
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +103,Please enter sales order in the above table,Indtast salgsordre i ovenstående tabel
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +132,Travel Expenses,Rejser Udgifter
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +259,Purchase Invoice {0} is already submitted,Købsfaktura {0} er allerede indsendt
apps/erpnext/erpnext/stock/doctype/stock_uom_replace_utility/stock_uom_replace_utility.py +51,Item is updated,Element er opdateret
DocType: Employee,Exit,Udgang
DocType: Bulk Email,Not Sent,Ikke Sent
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +98,Drilling,Boring
DocType: Website Settings,Website Settings,Website Settings
DocType: Purchase Order Item,Material Request Detail No,Materiale Request Detail Nej
DocType: Item Price,Multiple Item prices.,Flere Item priser.
DocType: Purchase Receipt Item,Received and Accepted,Modtaget og accepteret
DocType: Address,Billing,Fakturering
apps/erpnext/erpnext/controllers/selling_controller.py +157,Maxiumm discount for Item {0} is {1}%,Maxiumm rabat for Item {0} er {1}%
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +192,Let's prepare the system for first use.,Lad os forberede systemet til første brug.
DocType: Employee,Date of Birth,Fødselsdato
apps/erpnext/erpnext/stock/doctype/batch/batch_list.js +5,Expired,Udløbet
DocType: Lead,Next Contact Date,Næste Kontakt Dato
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +588,List a few of your suppliers. They could be organizations or individuals.,Nævne et par af dine leverandører. De kunne være organisationer eller enkeltpersoner.
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +25,Metal injection molding,Metal sprøjtestøbning
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +92,Conversion rate cannot be 0 or 1,Omregningskurs kan ikke være 0 eller 1
DocType: Features Setup,Sales Discounts,Salg Rabatter
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +99,Negative Quantity is not allowed,Negative Mængde er ikke tilladt
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +48,Bulging,Svulmende
DocType: Journal Entry Account,Exchange Rate,Exchange Rate
DocType: Stock Entry,Total Outgoing Value,Samlet Udgående Value
DocType: Cost Center,Parent Cost Center,Parent Cost center
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +91,Pickling,Bejdsning
DocType: Warranty Claim,If different than customer address,Hvis anderledes end kunde adresse
DocType: Shopping Cart Settings,Quotation Series,Citat Series
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +96,Knurling,Rifling
,Batch-Wise Balance History,Batch-Wise Balance History
DocType: Production Order,Actual Operating Cost,Faktiske driftsomkostninger
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +29,"Food, Beverage & Tobacco","Mad, drikke og tobak"
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +110,Photochemical machining,Fotokemisk bearbejdning
DocType: Brand,Item Manager,Item manager
DocType: Customer,Last Day of the Next Month,Sidste dag i den næste måned
DocType: Purchase Invoice Item,Valuation Rate,Værdiansættelse Rate
DocType: Sales Order Item,Projected Qty,Projiceret Antal
DocType: SMS Log,SMS Log,SMS Log
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +113,Finishing & industrial finishing,Efterbehandling &amp; industriel efterbehandling
DocType: Customer,Commission Rate,Kommissionens Rate
DocType: C-Form Invoice Detail,Net Total,Net Total
apps/erpnext/erpnext/accounts/utils.py +42,{0} {1} not in any active Fiscal Year. For more details check {2}.,{0} {1} ikke i noget aktiv regnskabsår. For flere detaljer tjek {2}.
,Sales Register,Salg Register
apps/erpnext/erpnext/stock/doctype/stock_uom_replace_utility/stock_uom_replace_utility.py +43,New Stock UOM must be different from current stock UOM,New Stock UOM skal være forskellig fra nuværende bestand UOM
DocType: Company,Stock Settings,Stock Indstillinger
DocType: Company,Company Info,Firma Info
DocType: Manufacturing Settings,Capacity Planning,Capacity Planning
DocType: Item,Item Code for Suppliers,Item Code for leverandører
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +79,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: Salary Slip,Bank Account No.,Bankkonto No.
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +44,Embossing,Prægning
DocType: Cost Center,Cost Center Name,Cost center Navn
apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +33,Contribution Amount,Bidrag Beløb
,Gross Profit,Gross Profit
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +408,Please remove this Invoice {0} from C-Form {1},Fjern denne faktura {0} fra C-Form {1}
DocType: Account,Accounts,Konti
DocType: Payment Tool,Against Vouchers,Mod Vouchers
DocType: Account,Parent Account,Parent Konto
apps/erpnext/erpnext/config/stock.py +38,Installation record for a Serial No.,Installation rekord for en Serial No.
DocType: Workflow State,Refresh,Opdater
DocType: Expense Claim Detail,Claim Amount,Krav Beløb
DocType: Item,UOMs,UOMs
DocType: Journal Entry,Bill Date,Bill Dato
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/setup/page/setup_wizard/install_fixtures.py +132,Credit Card,Credit Card
apps/erpnext/erpnext/stock/get_item_details.py +107,No Item with Serial No {0},Ingen Vare med Serial Nej {0}
apps/erpnext/erpnext/config/projects.py +51,Gantt chart of all tasks.,Gantt-diagram af alle opgaver.
DocType: Production Planning Tool,Material Requirement,Material Requirement
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +84,Engineer,Ingeniør
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +46,Compensatory Off,Kompenserende Off
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +167,Row {0}: Credit entry can not be linked with a {1},Række {0}: Kredit indgang ikke kan knyttes med en {1}
DocType: DocPerm,Level,Level
DocType: Naming Series,Update Series Number,Opdatering Series Number
DocType: Production Order,Production Order,Produktionsordre
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +232,"Row {0}: Qty not avalable in warehouse {1} on {2} {3}.
					Available Qty: {4}, Transfer Qty: {5}","Række {0}: Antal ikke avalable i lageret {1} på {2} {3}. Tilgængelig Antal: {4}, Transfer Antal: {5}"
,Quotation Trends,Citat Trends
apps/erpnext/erpnext/config/support.py +43,Single unit of an Item.,Enkelt enhed af et element.
DocType: Employee,Health Details,Sundhed Detaljer
apps/erpnext/erpnext/controllers/selling_controller.py +143,Total allocated percentage for sales team should be 100,Samlede fordelte procentdel for salgsteam bør være 100
DocType: Accounts Settings,Make Accounting Entry For Every Stock Movement,Lav Regnskab indtastning For hver Stock Movement
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +34,Leaves must be allocated in multiples of 0.5,"Blade skal afsættes i multipla af 0,5"
,Production Orders in Progress,Produktionsordrer i Progress
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +329,Production Order cannot be raised against a Item Template,Produktionsordre kan ikke rejses mod en Vare skabelon
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +33,"Can not filter based on Account, if grouped by Account","Kan ikke filtrere baseret på konto, hvis grupperet efter konto"
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +442,POS Profile required to make POS Entry,POS profil kræves for at gøre POS indtastning
apps/erpnext/erpnext/projects/doctype/time_log/time_log.py +81,This Time Log conflicts with {0} for {1} {2},Denne tidslog konflikter med {0} for {1} {2}
apps/erpnext/erpnext/accounts/page/pos/pos.js +15,Billing (Sales Invoice),Billing (Sales Invoice)
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: Attendance,Attendance,Fremmøde
DocType: Features Setup,Item Serial Nos,Vare Serial Nos
DocType: Employee,Organization Profile,Organisation profil
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}
DocType: Item,website page link,webside link
DocType: Lead,Lower Income,Lavere indkomst
DocType: Salary Structure,Monthly Earning & Deduction,Månedlige Earning &amp; Fradrag
DocType: BOM Operation,Operation Time,Operation Time
DocType: Payment Reconciliation,Invoice/Journal Entry Details,Faktura / Kassekladde Detaljer
apps/erpnext/erpnext/hr/doctype/employee/employee.py +187,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: Salary Slip,Arrear Amount,Bagud Beløb
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +162,Woodworking,Træbearbejdning
,Qty to Deliver,Antal til Deliver
apps/erpnext/erpnext/stock/utils.py +89,Item {0} ignored since it is not a stock item,Element {0} ignoreres da det ikke er en lagervare
DocType: BOM,Operating Cost,Driftsomkostninger
apps/frappe/frappe/core/page/modules_setup/modules_setup.py +11,Updated,Opdateret
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +458,Warning: Material Requested Qty is less than Minimum Order Qty,Advarsel: Materiale Anmodet Antal er mindre end Minimum Antal
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +318,Expected Delivery Date is lesser than Planned Start Date.,Forventet leveringsdato er mindre end planlagt startdato.
DocType: Naming Series,User must always select,Brugeren skal altid vælge
DocType: Project,Gross Margin %,Gross Margin%
DocType: Attendance,Attendance Date,Fremmøde Dato
DocType: Item,List this Item in multiple groups on the website.,Liste denne vare i flere grupper på hjemmesiden.
apps/erpnext/erpnext/hub_node/page/hub/hub_body.html +18,No more results.,Ikke flere resultater.
DocType: Buying Settings,Default Supplier Type,Standard Leverandør Type
DocType: Quality Inspection,Item Serial No,Vare Løbenummer
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +287,Capacity Planning Error,Capacity Planning Fejl
DocType: Packing Slip,Get Items,Få Varer
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41,Latest,Seneste
DocType: Task Depends On,Task Depends On,Task Afhænger On
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +496,Keep it web friendly 900px (w) by 100px (h),Hold det web venlige 900px (w) ved 100px (h)
DocType: SMS Center,All Contact,Alle Kontakt
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +32,"Go to the appropriate group (usually Application of Funds > Current Assets > Bank Accounts and create a new Account (by clicking on Add Child) of type ""Bank""",Gå til den relevante gruppe (som regel Anvendelse af fondene&gt; Omsætningsaktiver&gt; bankkonti og oprette en ny konto (ved at klikke på Tilføj barn) af typen &quot;Bank&quot;
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +218,Quality Inspection required for Item {0},Inspektion kvalitet kræves for Item {0}
apps/erpnext/erpnext/public/js/pos/pos_bill_item.html +12,In Stock,På lager
apps/erpnext/erpnext/config/setup.py +51,Data Import and Export,Data import og eksport
DocType: Issue,Support,Support
DocType: Stock Settings,Freeze Stocks Older Than [Days],Frys Stocks Ældre end [dage]
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +21,{0}: From {0} of type {1},{0}: Fra {0} af typen {1}
apps/erpnext/erpnext/controllers/trends.py +39,'Based On' and 'Group By' can not be same,'Baseret på' og 'Grupper efter' ikke kan være samme
apps/erpnext/erpnext/accounts/doctype/payment_tool/payment_tool.js +172,"Against Voucher Type must be one of Sales Order, Sales Invoice or Journal Entry","Imod Voucher type skal være en af ​​kundeordre, Salg Faktura eller Kassekladde"
DocType: Authorization Rule,Approving Role,Godkendelse Rolle
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +66,Buying Amount,Køb Beløb
DocType: Supplier,Statutory info and other general information about your Supplier,Lovpligtig info og andre generelle oplysninger om din leverandør
DocType: Production Plan Item,Production Plan Item,Produktion Plan Vare
DocType: Sales Order,In Words will be visible once you save the Sales Order.,"I Ord vil være synlig, når du gemmer Sales Order."
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +27,Executive Search,Executive Search
apps/erpnext/erpnext/utilities/doctype/address/address.py +113,My Addresses,Mine Adresser
DocType: Quotation,Shopping Cart,Indkøbskurv
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +398,Nothing to request,Intet at anmode
,Download Backups,Hent Backups
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +16,Chemical,Kemisk
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +70,Total Outstanding Amt,Total Enestående Amt
DocType: Landed Cost Taxes and Charges,Landed Cost Taxes and Charges,Landede Cost Skatter og Afgifter
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +111,Honing,Honing
DocType: Email Digest,Income / Expense,Indtægter / Expense
apps/erpnext/erpnext/config/crm.py +22,Potential opportunities for selling.,Potentielle muligheder for at sælge.
DocType: Opportunity,Contact Mobile No,Kontakt Mobile Ingen
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +143,Source warehouse is mandatory for row {0},Kilde lageret er obligatorisk for rækken {0}
DocType: Appraisal,Select the Employee for whom you are creating the Appraisal.,"Vælg Medarbejder, for hvem du opretter Vurdering."
apps/erpnext/erpnext/crm/doctype/newsletter/newsletter.py +25,Scheduled to send to {0},Planlagt at sende til {0}
DocType: Designation,Designation,Betegnelse
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +8,Centrifugal casting,Centrifugal casting
apps/erpnext/erpnext/config/setup.py +88,Create rules to restrict transactions based on values.,Oprette regler til at begrænse transaktioner baseret på værdier.
apps/erpnext/erpnext/config/stock.py +69,Split Delivery Note into packages.,Split følgeseddel i pakker.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +192,Retained Earnings,Overført overskud
apps/erpnext/erpnext/selling/page/sales_browser/sales_browser.js +128,Please enter Employee Id of this sales person,Indtast venligst Medarbejder Id dette salg person
DocType: Appraisal,Employee,Medarbejder
DocType: Sales Order Item,Delivery Warehouse,Levering Warehouse
DocType: Sales Taxes and Charges Template,Sales Taxes and Charges Template,Salg Skatter og Afgifter Skabelon
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +114,Abrasive blasting,Sandblæsning
apps/erpnext/erpnext/config/stock.py +43,Where items are stored.,Hvor emner er gemt.
DocType: Process Payroll,Submit Salary Slip,Indsend lønseddel
apps/erpnext/erpnext/setup/doctype/company/company.py +172,"Sorry, companies cannot be merged","Beklager, kan virksomhederne ikke slås sammen"
DocType: Item Group,Item Classification,Item Klassifikation
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +488,Transfer Material to Supplier,Overførsel Materiale til Leverandøren
DocType: Sales Invoice Item,Available Qty at Warehouse,Tilgængelig Antal på Warehouse
apps/erpnext/erpnext/crm/doctype/newsletter/newsletter.py +107,{0} has been successfully unsubscribed from this list.,{0} er blevet afmeldt fra denne liste.
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +63,Stamping,Stempling
DocType: Activity Cost,Projects User,Projekter Bruger
,Stock Analytics,Stock Analytics
DocType: Pricing Rule,Max Qty,Max Antal
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."
DocType: Serial No,Under Warranty,Under Garanti
DocType: Selling Settings,Allow user to edit Price List Rate in transactions,Tillad brugeren at redigere Prisliste Rate i transaktioner
DocType: Email Digest,Receivables,Tilgodehavender
DocType: Purchase Receipt,Time at which materials were received,"Tidspunkt, hvor materialer blev modtaget"
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +123,Tumbling,Tumbling
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +72,Peening,Peening
DocType: Time Log,Hours,Timer
,Purchase Order Items To Be Received,"Købsordre, der modtages"
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +47,Delivered Amount,Leveres Beløb
DocType: Purchase Order Item,Warehouse and Reference,Warehouse og reference
DocType: Employee,Permanent Address Is,Faste adresse
DocType: Purchase Receipt,Add / Edit Taxes and Charges,Tilføj / rediger Skatter og Afgifter
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +302,Debit To account must be a Receivable account,Betalingskort Til konto skal være et tilgodehavende konto
DocType: GL Entry,Against,Imod
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} betalingssystemer poster ikke kan filtreres af {1}
DocType: Delivery Note,Delivery To,Levering Til
apps/erpnext/erpnext/crm/doctype/newsletter/newsletter.js +19,Send,Sende
DocType: Stock Settings,Allowance Percent,Godtgørelse Procent
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +8,Agriculture,Landbrug
DocType: Employee,Passport Number,Passport Number
apps/erpnext/erpnext/crm/doctype/lead/lead.js +30,Create Customer,Opret kunde
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +54,Shearing,Shearing
DocType: Purchase Invoice Item,Amount (Company Currency),Beløb (Company Valuta)
apps/erpnext/erpnext/accounts/report/profit_and_loss_statement/profit_and_loss_statement.py +30,Net Profit / Loss,Netto Resultat / Loss
DocType: Hub Settings,Publish Pricing,Offentliggøre Pricing
,Ordered Items To Be Billed,Bestilte varer at blive faktureret
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +173,Notice Period,Opsigelsesperiode
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +684,From Delivery Note,Fra følgeseddel
DocType: Communication,Phone,Telefon
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +493,Issue Material,Issue Materiale
DocType: Quality Inspection,Inspection Type,Inspektion Type
apps/erpnext/erpnext/config/manufacturing.py +120,Bill of Materials,Bill of Materials
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +94,Cannot select charge type as 'On Previous Row Amount' or 'On Previous Row Total' for first row,Kan ikke vælge charge type som &#39;On Forrige Row Beløb&#39; eller &#39;On Forrige Row alt &quot;for første række
DocType: Landed Cost Item,Landed Cost Item,Landed Cost Vare
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +31,"Pricing Rule is first selected based on 'Apply On' field, which can be Item, Item Group or Brand.","Prisfastsættelse Regel først valgt baseret på &quot;Apply On &#39;felt, som kan være Item, punkt Group eller Brand."
DocType: Print Settings,Classic,Klassisk
DocType: Employee,Encashment Date,Indløsning Dato
DocType: SMS Settings,SMS Settings,SMS-indstillinger
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +626,Kg,Kg
,Monthly Attendance Sheet,Månedlig Deltagelse Sheet
DocType: Salary Slip,Total Deduction,Samlet Fradrag
apps/erpnext/erpnext/controllers/accounts_controller.py +101,Due Date is mandatory,Forfaldsdato er obligatorisk
DocType: Production Order Operation,Estimated Time and Cost,Estimeret tid og omkostninger
DocType: SMS Log,Sent To,Sendt Til
DocType: Stock Reconciliation,Stock Reconciliation,Stock Afstemning
apps/erpnext/erpnext/stock/doctype/item/item.py +543,Item {0} is not a stock Item,Vare {0} er ikke et lager Vare
DocType: Time Log,Will be updated only if Time Log is 'Billable',"Vil kun blive opdateret, hvis Time Log er &quot;faktureres&quot;"
apps/erpnext/erpnext/accounts/doctype/account/account.py +131,Report Type is mandatory,Rapporttype er obligatorisk
DocType: Payment Tool,Payment Account,Betaling konto
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 Carry Forward hvis du også ønsker at inkludere foregående regnskabsår balance blade til indeværende regnskabsår
DocType: Quotation,Order Type,Bestil Type
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +140,Execution,Udførelse
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +120,Etching,Ætsning
apps/frappe/frappe/public/js/frappe/model/indicator.js +34,Cancelled,Annulleret
DocType: GL Entry,Transaction Date,Transaktion Dato
DocType: Item Attribute,Item Attribute Values,Item Egenskab Værdier
DocType: Selling Settings,Selling Settings,Salg af indstillinger
DocType: Purchase Invoice,Start date of current invoice's period,Startdato for nuværende faktura menstruation
apps/frappe/frappe/core/page/user_permissions/user_permissions.js +246,Allow User,Tillad Bruger
apps/erpnext/erpnext/config/crm.py +72,Manage Customer Group Tree.,Administrer Customer Group Tree.
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +91,From Date in Salary Structure cannot be lesser than Employee Joining Date.,Fra dato i Løn Structure ikke kan være mindre end Medarbejder Sammenføjning Dato.
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +40,Hot rolling,Varmvalsning
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +40,Pension Funds,Pensionskasserne
DocType: Purchase Invoice,Next Date,Næste dato
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 et forkert konto i transaktionen.
DocType: Email Digest,Email Digest,Email Digest
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +34,Attendance can not be marked for future dates,Fremmøde kan ikke markeres for fremtidige datoer
apps/erpnext/erpnext/public/js/pos/pos.js +147,Please select {0} first.,Vælg {0} først.
DocType: Purchase Invoice Advance,Journal Entry Detail No,Kassekladde Detail Nej
,POS,POS
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +44,Real Estate,Real Estate
DocType: Salary Structure,Total Earning,Samlet Earning
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +73,Explosive forming,Eksplosiv danner
DocType: Sales Invoice,Sales Team1,Salg TEAM1
DocType: Delivery Note,Vehicle No,Vehicle Ingen
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +57,Part-time,Deltid
DocType: Sales Invoice,Customer's Vendor,Kundens Vendor
DocType: Employee,Notice (days),Varsel (dage)
DocType: Cost Center,Budget,Budget
DocType: Maintenance Visit,Scheduled,Planlagt
DocType: Bank Reconciliation Detail,Against Account,Mod konto
apps/erpnext/erpnext/config/selling.py +153,Bundle items at time of sale.,Bundle elementer på salgstidspunktet.
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +63,Item Row {0}: Purchase Receipt {1} does not exist in above 'Purchase Receipts' table,Item Row {0}: kvittering {1} findes ikke i ovenstående &#39;Køb Kvitteringer&#39; bord
apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +19,Shortage Qty,Mangel Antal
DocType: Employee,Provide email id registered in company,Giv email id er registreret i selskab
DocType: SMS Center,All Customer Contact,Alle Customer Kontakt
apps/erpnext/erpnext/config/hr.py +135,"Type of leaves like casual, sick etc.","Type blade som afslappet, syge etc."
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +176,Closing (Opening + Totals),Lukning (Åbning + Totals)
apps/frappe/frappe/public/js/frappe/form/workflow.js +116,To,Til
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +137,Planning,Planlægning
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +156,Only the selected Leave Approver can submit this Leave Application,Kun den valgte Leave Godkender kan indsende denne Leave Application
DocType: Selling Settings,Delivery Note Required,Følgeseddel Nødvendig
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +172,Leaves per Year,Blade pr år
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å Leads, Citater, Sales Order osv fra kampagner til at måle Return on Investment."
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/setup/page/setup_wizard/fixtures/industry_type.py +42,Private Equity,Private Equity
,S.O. No.,SÅ No.
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +68,Total Invoiced Amt,Samlede fakturerede Amt
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +132,Ultrasonic machining,Ultrasonic bearbejdning
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.py +24,Setup Already Complete!!,Opsætning Allerede Complete !!
DocType: Notification Control,Purchase Order Message,Indkøbsordre Message
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +215,Quantity required for Item {0} in row {1},"Mængde, der kræves for Item {0} i række {1}"
apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +17,Reserved Qty,Reserveret Antal
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +36,Out Qty,Out Antal
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +95,{0} {1} has been modified. Please refresh.,{0} {1} er blevet ændret. Venligst opdater.
DocType: Payment Tool Detail,Payment Amount,Betaling Beløb
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +97,Hard turning,Hård drejning
DocType: Accounts Settings,Role Allowed to Set Frozen Accounts & Edit Frozen Entries,Rolle Tilladt til Indstil Frosne Konti og Rediger Frosne Entries
apps/erpnext/erpnext/config/support.py +18,Warranty Claim against Serial No.,Garanti krav mod Serial No.
apps/erpnext/erpnext/stock/doctype/item/item.py +295,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
,Reserved,Reserveret
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +213,Serial No {0} has already been received,Løbenummer {0} er allerede blevet modtaget
apps/erpnext/erpnext/config/buying.py +59,Supplier Type master.,Leverandør Type mester.
DocType: Journal Entry,Pay To / Recd From,Betal Til / RECD Fra
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +465,Sales Order {0} is not submitted,Sales Order {0} er ikke indsendt
DocType: Journal Entry,Reference Number,Referencenummer
apps/frappe/frappe/config/setup.py +59,Settings,Indstillinger
apps/erpnext/erpnext/accounts/doctype/account/account.py +142,Warehouse is mandatory if account type is Warehouse,"Warehouse er obligatorisk, hvis kontotype er Warehouse"
DocType: Account,Profit and Loss,Resultatopgørelse
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +65,Selling Amount,Selling Beløb
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +45,Account {0} has been entered more than once for fiscal year {1},Konto {0} er indtastet mere end en gang for regnskabsåret {1}
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +205,New Account,Ny konto
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +157,Lead must be set if Opportunity is made from Lead,"Bly skal indstilles, hvis Opportunity er lavet af Lead"
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +31,Thermoforming,Termoformning
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: Delivery Note,Billing Address,Faktureringsadresse
DocType: Warranty Claim,"To assign this issue, use the ""Assign"" button in the sidebar.",For at tildele problemet ved at bruge knappen &quot;Tildel&quot; i indholdsoversigten.
DocType: Production Order,Expected Delivery Date,Forventet leveringsdato
DocType: Company,Round Off Account,Afrunde konto
DocType: Purchase Invoice,Yearly,Årlig
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +76,Max 100 rows for Stock Reconciliation.,Max 100 rækker for Stock Afstemning.
DocType: BOM,Item to be manufactured or repacked,"Element, der skal fremstilles eller forarbejdes"
DocType: Employee,Blood Group,Blood Group
apps/erpnext/erpnext/stock/utils.py +162,Serial number {0} entered more than once,Serienummer {0} indtastet mere end én gang
DocType: Account,Temporary,Midlertidig
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order_calendar.js +39,WIP Warehouse,WIP Warehouse
DocType: Serial No,Creation Time,Creation Time
DocType: Contact Us Settings,Address Line 1,Adresse Line 1
DocType: Page,Yes,Ja
apps/erpnext/erpnext/accounts/general_ledger.py +106,Account: {0} can only be updated via Stock Transactions,Konto: {0} kan kun opdateres via Stock Transaktioner
DocType: Purchase Receipt Item Supplied,Current Stock,Aktuel Stock
DocType: Purchase Invoice,Quarterly,Kvartalsvis
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +38,Food,Mad
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +56,Cost Center is required for 'Profit and Loss' account {0},Cost center er nødvendig for &quot;Resultatopgørelsen&quot; konto {0}
apps/erpnext/erpnext/accounts/doctype/account/account.py +113,Account with existing transaction can not be converted to group.,Konto med eksisterende transaktion kan ikke konverteres til gruppen.
DocType: Lead,Address & Contact,Adresse og kontakt
DocType: UOM,Check this to disallow fractions. (for Nos),Markér dette for at forbyde fraktioner. (For NOS)
DocType: Account,"If the account is frozen, entries are allowed to restricted users.","Hvis kontoen er frossen, er poster lov til begrænsede brugere."
,Employee Birthday,Medarbejder Fødselsdag
DocType: Purchase Order Item Supplied,Supplied Qty,Medfølgende Antal
DocType: Packing Slip Item,DN Detail,DN Detail
,Terretory,Terretory
DocType: Workstation,Working Hours,Arbejdstider
,Stock Ageing,Stock Ageing
DocType: Employee Education,Graduate,Graduate
DocType: Features Setup,After Sale Installations,Efter salg Installationer
DocType: Purchase Invoice,End date of current invoice's period,Slutdato for aktuelle faktura menstruation
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +14,Item 2,Punkt 2
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +49,'From Date' is required,'Fra dato' er nødvendig
DocType: System Settings,Loading...,Indlæser ...
DocType: Lead,Consultant,Konsulent
DocType: Stock Entry,Repack,Pakke
apps/erpnext/erpnext/config/projects.py +13,Project activity / task.,Projektaktivitet / opgave.
apps/erpnext/erpnext/config/setup.py +66,Users and Permissions,Brugere og tilladelser
,Setup Wizard,Setup Wizard
apps/erpnext/erpnext/config/buying.py +13,Supplier database.,Leverandør database.
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +79,You need to enable Shopping Cart,Du skal aktivere Indkøbskurv
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +37,Calls,Opkald
DocType: Production Plan Sales Order,Production Plan Sales Order,Produktion Plan kundeordre
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +9,View Now,Se nu
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +253,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: Sales Invoice,Paid Amount,Betalt Beløb
apps/erpnext/erpnext/stock/stock_ledger.py +336,Negative Stock Error ({6}) for Item {0} in Warehouse {1} on {2} {3} in {4} {5},Negativ Stock Error ({6}) for Item {0} i Warehouse {1} på {2} {3} i {4} {5}
DocType: Item,Is Fixed Asset Item,Er Fast aktivpost
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +54,Transportation,Transport
DocType: Maintenance Visit,Customer Feedback,Kundefeedback
DocType: Fiscal Year,Year Name,År Navn
,Territory Target Variance Item Group-Wise,Territory Target Variance Item Group-Wise
apps/erpnext/erpnext/config/stock.py +120,Brand master.,Brand mester.
DocType: Manufacturing Settings,Capacity Planning For (Days),Kapacitet Planlægning For (dage)
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +92,Reference No & Reference Date is required for {0},Referencenummer &amp; Reference Dato er nødvendig for {0}
DocType: Purchase Taxes and Charges Template,Purchase Taxes and Charges Template,Købe Skatter og Afgifter Skabelon
DocType: Monthly Distribution,Monthly Distribution,Månedlig Distribution
apps/erpnext/erpnext/controllers/accounts_controller.py +493,"To include tax in row {0} in Item rate, taxes in rows {1} must also be included","Hvis du vil medtage skat i række {0} i Item sats, skatter i rækker {1} skal også medtages"
DocType: Stock Entry Detail,Source Warehouse,Kilde Warehouse
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +114,Postal Expenses,Postale Udgifter
DocType: Leave Block List Date,Leave Block List Date,Lad Block List Dato
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +54,'To Date' is required,&#39;Til dato&#39; er nødvendig
DocType: Monthly Distribution,"**Monthly Distribution** helps you distribute your budget across months if you have seasonality in your business.

To distribute a budget using this distribution, set this **Monthly Distribution** in the **Cost Center**","** Månedlig Distribution ** hjælper du distribuerer dit budget tværs måneder, hvis du har sæsonudsving i din virksomhed. At distribuere et budget ved hjælp af denne fordeling, skal du indstille dette ** Månedlig Distribution ** i ** Cost Center **"
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.py +440,Commercial,Kommerciel
apps/erpnext/erpnext/support/doctype/maintenance_visit/maintenance_visit.py +65,Cancel Material Visits {0} before cancelling this Maintenance Visit,"Annuller Materiale Besøg {0}, før den annullerer denne vedligeholdelse Besøg"
DocType: SMS Center,Create Receiver List,Opret Modtager liste
apps/erpnext/erpnext/selling/report/customers_not_buying_since_long_time/customers_not_buying_since_long_time.py +69,Total Order Considered,Samlet Order Anses
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +630,We buy this Item,Vi køber denne vare
DocType: Appraisal Goal,Score (0-5),Score (0-5)
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +29,Budget cannot be set for Group Cost Center,Budget kan ikke indstilles for gruppe Cost center
DocType: Dropbox Backup,Dropbox Access Key,Dropbox adgangsnøgle
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +57,New Customers,Nye kunder
apps/erpnext/erpnext/config/accounts.py +58,Match non-linked Invoices and Payments.,Match ikke-forbundne fakturaer og betalinger.
DocType: Appraisal Goal,Appraisal Goal,Vurdering Goal
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +160,Target warehouse in row {0} must be same as Production Order,Target lager i rækken {0} skal være samme som produktionsordre
DocType: Holiday,Holiday,Holiday
DocType: Item Customer Detail,"For the convenience of customers, these codes can be used in print formats like Invoices and Delivery Notes","For nemheds af kunder, kan disse koder bruges i trykte formater som fakturaer og følgesedler"
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +18,Consulting,Rådgivning
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +104,Sales Order required for Item {0},Sales Order kræves for Item {0}
DocType: Item,Default Selling Cost Center,Standard Selling Cost center
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +139,Biomachining,Biomachining
DocType: Expense Claim Detail,Expense Date,Expense Dato
DocType: Employee,You can enter any date manually,Du kan indtaste et hvilket som helst tidspunkt manuelt
DocType: Leave Control Panel,Employee Type,Medarbejder Type
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +39,BOM Rate,BOM Rate
DocType: Purchase Invoice,Additional Discount Amount,Yderligere Discount Beløb
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 er inkluderet i Print Rate / Print Beløb"
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +357,Finished Item {0} must be entered for Manufacture type entry,Færdig element {0} skal indtastes for Fremstilling typen post
DocType: Time Log,Billing Amount,Fakturering Beløb
DocType: GL Entry,GL Entry,GL indtastning
DocType: Project Task,Working,Working
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +182,Purchase Receipt number required for Item {0},Kvittering nummer kræves for Item {0}
apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +31,Please select Fiscal Year,Vælg venligst regnskabsår
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +94,Facing,Facing
DocType: Bank Reconciliation Detail,Cheque Number,Check Number
apps/erpnext/erpnext/controllers/trends.py +137,Amt,Amt
DocType: Contact Us Settings,Introduction,Introduktion
,Average Commission Rate,Gennemsnitlig Kommissionens Rate
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +23,Quick Help,Hurtig hjælp
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +30,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.
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +173,No Production Orders created,Ingen produktionsordrer oprettet
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: Purchase Invoice,Apply Additional Discount On,Påfør Yderligere Rabat på
DocType: Stock Entry,Manufacture,Fremstilling
DocType: Sales Person,Set targets Item Group-wise for this Sales Person.,Fastsatte mål Item Group-wise for denne Sales Person.
DocType: Stock Reconciliation Item,Current Qty,Aktuel Antal
DocType: Packing Slip Item,Packing Slip Item,Packing Slip Vare
DocType: Shopping Cart Shipping Rule,Shopping Cart Shipping Rule,Indkøbskurv Shipping Rule
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +46,Please enter Purchase Receipts,Indtast venligst Køb Kvitteringer
apps/frappe/frappe/public/js/frappe/form/save.js +78,Name is required,Navn er påkrævet
apps/erpnext/erpnext/projects/doctype/time_log_batch/time_log_batch.js +24,This Time Log Batch has been cancelled.,This Time Log Batch er blevet annulleret.
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +15,Update Cost,Opdatering Omkostninger
DocType: Address,Shop,Butik
DocType: SMS Center,Send To,Send til
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +168,Source and target warehouse cannot be same for row {0},Kilde og mål lageret ikke kan være ens for rækken {0}
DocType: Features Setup,Exports,Eksport
DocType: C-Form,C-Form,C-Form
DocType: Web Form,Select DocType,Vælg DocType
DocType: Item,Taxes,Skatter
DocType: Leave Control Panel,Allocate,Tildele
DocType: Expense Claim,Total Claimed Amount,Total krævede beløb
DocType: Employee,Exit Interview Details,Exit Interview Detaljer
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +114,Actual type tax cannot be included in Item rate in row {0},"Faktiske type skat, kan ikke indgå i Item sats i række {0}"
apps/erpnext/erpnext/config/manufacturing.py +19,Orders released for production.,Ordrer frigives til produktion.
,Employee Leave Balance,Medarbejder Leave Balance
DocType: Stock UOM Replace Utility,Current Stock UOM,Aktuel Stock UOM
apps/erpnext/erpnext/config/projects.py +79,Managing Projects,Håndtering af Projekter
apps/erpnext/erpnext/selling/doctype/quotation/quotation.js +591,From Opportunity,Fra Opportunity
apps/erpnext/erpnext/config/stock.py +74,Incoming quality inspection.,Inspektion indkommende kvalitet.
apps/erpnext/erpnext/config/stock.py +273,Opening Stock Balance,Åbning Stock Balance
apps/frappe/frappe/model/rename_doc.py +348,Maximum {0} rows allowed,Maksimum {0} rækker tilladt
DocType: Campaign,Campaign-.####,Kampagne -. ####
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +612,"List your products or services that you buy or sell. Make sure to check the Item Group, Unit of Measure and other properties when you start.","Liste dine produkter eller tjenester, som du købe eller sælge. Sørg for at kontrollere Item Group, måleenhed og andre egenskaber, når du starter."
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +166,Employee Benefits,Personaleydelser
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +51,Either debit or credit amount is required for {0},Enten kredit- eller beløb er påkrævet for {0}
apps/frappe/frappe/templates/base.html +145,Please enter email address,Indtast e-mail-adresse
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +287,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
DocType: Quality Inspection Reading,Acceptance Criteria,Acceptkriterier
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +90,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 Invoice Item,Sales Invoice Item,Salg Faktura Vare
apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +88,Tree Type,Tree Type
apps/erpnext/erpnext/config/crm.py +146,Lead to Quotation,Føre til Citat
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +32,Internet Publishing,Internet Publishing
apps/erpnext/erpnext/config/hr.py +33,Monthly salary statement.,Månedlige lønseddel.
DocType: Purchase Invoice,Taxes and Charges Added,Skatter og Afgifter Tilføjet
DocType: Time Log,Costing Amount,Koster Beløb
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +27,Cost of Issued Items,Omkostninger ved Udstedte Varer
DocType: Stock Settings,Auto Material Request,Auto Materiale Request
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +25,Total Paid Amount,Samlet indbetalte beløb
DocType: Salary Slip,Leave Encashment Amount,Lad Indløsning Beløb
DocType: Project,Total Purchase Cost (via Purchase Invoice),Samlet anskaffelsespris (via købsfaktura)
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +43,Amounts not reflected in system,"Beløb, der ikke afspejles i systemet"
DocType: Process Payroll,Process Payroll,Proces Payroll
apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +54,Please enter atleast 1 invoice in the table,Indtast venligst mindst 1 faktura i tabellen
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +511,Add Users,Tilføj Brugere
DocType: Warranty Claim,Resolved By,Løst Af
apps/erpnext/erpnext/accounts/doctype/payment_tool/payment_tool.py +24,Please enter Payment Amount in atleast one row,Indtast Betaling Beløb i mindst én række
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +37,Forging,Smedning
apps/erpnext/erpnext/config/buying.py +28,Purchase Orders given to Suppliers.,Indkøbsordrer givet til leverandører.
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +65,90-Above,90-Above
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +74,Row # {0}: Returned Item {1} does not exists in {2} {3},Row # {0}: returnerede vare {1} ikke eksisterer i {2} {3}
apps/erpnext/erpnext/selling/doctype/customer/customer.py +187,Please contact to the user who have Sales Master Manager {0} role,"Kontakt venligst til den bruger, der har Sales Master manager {0} rolle"
apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +96,Items already synced,Varer allerede synkroniseret
apps/erpnext/erpnext/public/js/utils.js +57,Add Serial No,Tilføj Løbenummer
DocType: Communication,Communication,Kommunikation
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +49,Supplier(s),Leverandør (er)
apps/erpnext/erpnext/accounts/utils.py +193,Allocated amount can not be negative,Tildelte beløb kan ikke være negativ
DocType: Account,Stock Received But Not Billed,Stock Modtaget men ikke faktureret
DocType: Item Group,Parent Item Group,Moderselskab Item Group
DocType: Quality Inspection,In Process,I Process
DocType: Time Log Batch,updated via Time Logs,opdateret via Time Logs
DocType: Naming Series,Current Value,Aktuel værdi
DocType: Process Payroll,Creates salary slip for above mentioned criteria.,Opretter lønseddel for ovennævnte kriterier.
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +26,Item 4,Punkt 4
DocType: Lead,Product Enquiry,Produkt Forespørgsel
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +357,Email Address,E-mail-adresse
apps/erpnext/erpnext/hooks.py +84,Shipments,Forsendelser
DocType: Employee Education,Major/Optional Subjects,Større / Valgfag
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +210,"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: Employee,Employment Type,Beskæftigelse type
apps/erpnext/erpnext/config/selling.py +98,Manage Sales Partners.,Administrer Sales Partners.
DocType: Sales Invoice Advance,Advance Amount,Advance Beløb
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +37,Serial #,Serial #
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +395,"e.g. ""MC""",fx &quot;MC&quot;
apps/erpnext/erpnext/setup/doctype/sms_settings/sms_settings.py +86,SMS sent to following numbers: {0},SMS sendt til følgende numre: {0}
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard_page.html +16,Previous,Forrige
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: Serial No,Creation Document Type,Creation Dokumenttype
apps/erpnext/erpnext/stock/doctype/item/item.py +414,"To merge, following properties must be same for both items","At fusionere, skal følgende egenskaber være ens for begge poster"
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +52,Supplier > Supplier Type,Leverandør&gt; Leverandør type
DocType: Naming Series,Select Transaction,Vælg Transaktion
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +131,Hobbing,Hobbing
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +24,Hot isostatic pressing,Varm isostatisk presning
DocType: Department,Days for which Holidays are blocked for this department.,"Dage, som Holidays er blokeret for denne afdeling."
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +552,e.g. 5,f.eks 5
apps/erpnext/erpnext/config/hr.py +105,Organization unit (department) master.,Organisation enhed (departement) herre.
DocType: Employee,Job Profile,Job profil
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +373,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 Grand Total
DocType: Purchase Order,Advance Paid,Advance Betalt
DocType: Sales Partner,Logo,Logo
,Itemwise Recommended Reorder Level,Itemwise Anbefalet genbestillings Level
DocType: Bin,Quantity Requested for Purchase,"Mængde, der ansøges for Indkøb"
DocType: Purchase Receipt,Get Current Stock,Få Aktuel Stock
DocType: Account,Income,Indkomst
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +42,Amounts not reflected in bank,"Beløb, der ikke afspejles i bank"
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +193,Purchase Order {0} is not submitted,Indkøbsordre {0} er ikke indsendt
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +31,Please create Salary Structure for employee {0},Opret Løn Struktur for medarbejder {0}
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +57,"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/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/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +60,Temporary Accounts,Midlertidige Konti
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +57,Item Code cannot be changed for Serial No.,Item Code kan ikke ændres for Serial No.
DocType: Account,Sales User,Salg Bruger
DocType: Item Reorder,Transfer,Transfer
,Item-wise Purchase History,Vare-wise Købshistorik
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +361,Cannot deactivate or cancel BOM as it is linked with other BOMs,"Kan ikke deaktivere eller annullere BOM, som det er forbundet med andre styklister"
apps/erpnext/erpnext/stock/get_item_details.py +103,No Item with Barcode {0},Ingen Vare med Barcode {0}
apps/erpnext/erpnext/accounts/party.py +275,Due Date cannot be before Posting Date,"Forfaldsdato kan ikke være, før Udstationering Dato"
DocType: Landed Cost Item,Purchase Receipt Item,Kvittering Vare
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +36,{0} must appear only once,{0} må kun optræde én gang
apps/erpnext/erpnext/controllers/recurring_document.py +199,Please enter 'Repeat on Day of Month' field value,Indtast &#39;Gentag på dag i måneden »felt værdi
DocType: Material Request,Requested For,Anmodet om
apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.js +60,Row {0}:Start Date must be before End Date,Række {0}: Start dato skal være før slutdato
DocType: Payment Tool,Paid,Betalt
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +93,Entertainment Expenses,Repræsentationsudgifter
DocType: Contact Us Settings,Address,Adresse
apps/erpnext/erpnext/controllers/status_updater.py +136,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
apps/frappe/frappe/workflow/doctype/workflow/workflow_list.js +7,Not active,Ikke aktiv
,Accounts Payable Summary,Kreditorer Resumé
DocType: Features Setup,Item Groups in Details,Varegrupper i Detaljer
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +71,Production,Produktion
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +364,The first user will become the System Manager (you can change this later).,Den første bruger bliver System Manager (du kan ændre dette senere).
DocType: Issue,Attachment,Attachment
,Purchase Receipt Trends,Kvittering Tendenser
DocType: Opportunity,Walk In,Walk In
DocType: Sales Invoice,Sales Team,Salgsteam
DocType: Hub Settings,Seller Name,Sælger Navn
DocType: Purchase Order,End date of current order's period,Slutdato for aktuelle ordres periode
DocType: Quotation,Maintenance Manager,Vedligeholdelse manager
DocType: Installation Note Item,Against Document No,Mod dokument nr
apps/erpnext/erpnext/config/selling.py +23,Confirmed orders from Customers.,Bekræftede ordrer fra kunder.
DocType: Pricing Rule,Selling,Selling
DocType: Pricing Rule,Disable,Deaktiver
DocType: Salary Slip,Salary Slip,Lønseddel
DocType: Purchase Invoice Item,Expense Head,Expense Hoved
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +191,Account {0} is frozen,Konto {0} er spærret
apps/erpnext/erpnext/crm/doctype/newsletter_list/newsletter_list.js +10,Import Email From,Import Email Fra
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +27,From {0} to {1},Fra {0} til {1}
DocType: Authorization Rule,Applicable To (User),Gælder for (Bruger)
apps/erpnext/erpnext/setup/utils.py +14,Please specify Default Currency in Company Master and Global Defaults,Angiv venligst Standard Valuta i Company Master og Globale standardindstillinger
DocType: Leave Control Panel,Leave blank if considered for all employee types,Lad stå tomt hvis det anses for alle typer medarbejderaktier
DocType: Hub Settings,Publish Availability,Offentliggøre Tilgængelighed
DocType: Authorization Rule,Customerwise Discount,Customerwise Discount
DocType: Purchase Invoice,Supplier Name,Leverandør Navn
DocType: UOM,Must be Whole Number,Skal være hele tal
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +623,Sub Assemblies,Sub forsamlinger
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +181,Qty for {0},Antal for {0}
DocType: Holiday List,Get Weekly Off Dates,Få ugentlige Off Datoer
DocType: BOM Explosion Item,BOM Explosion Item,BOM Explosion Vare
DocType: Appraisal,Calculate Total Score,Beregn Total Score
DocType: Purchase Order,Supplied Items,Medfølgende varer
DocType: Email Digest,Send regular summary reports via Email.,Send regelmæssige sammenfattende rapporter via e-mail.
DocType: Pricing Rule,Sales Manager,Salgschef
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +209,Please select Employee Record first.,Vælg Medarbejder Record først.
apps/erpnext/erpnext/projects/doctype/time_log_batch/time_log_batch.py +37,Time Log {0} already billed,Time Log {0} allerede faktureret
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øbsordre."
DocType: Item,Re-Order Level,Re-Order Level
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +552,Rate (%),Sats (%)
apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +16,No record found,Ingen post fundet
DocType: Stock Settings,Default Valuation Method,Standard værdiansættelsesmetode
DocType: BOM Item,"See ""Rate Of Materials Based On"" in Costing Section",Se &quot;Rate Of Materials Based On&quot; i Costing afsnit
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +172,Successfully Reconciled,Succesfuld Afstemt
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +81,The Item {0} cannot have Batch,Item {0} kan ikke have Batch
apps/erpnext/erpnext/accounts/doctype/payment_tool/payment_tool.js +179,"Against Voucher Type must be one of Purchase Order, Purchase Invoice or Journal Entry","Imod Voucher type skal være en af ​​indkøbsordre, købsfaktura eller Kassekladde"
DocType: Stock Entry,Default Target Warehouse,Standard Target Warehouse
DocType: Sales 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.
DocType: Quality Inspection,Report Date,Report Date
DocType: Salary Slip,Payment Days,Betalings Dage
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +131,Salary Slip of employee {0} already created for this month,Løn Slip af medarbejder {0} allerede skabt for denne måned
DocType: Maintenance Schedule,Schedule,Køreplan
apps/erpnext/erpnext/accounts/doctype/account/account.py +81,You are not authorized to set Frozen value,Du er ikke autoriseret til at fastsætte Frozen værdi
DocType: Purchase Receipt Item,Purchase Order Item No,Indkøbsordre Konto nr
apps/erpnext/erpnext/public/js/feature_setup.js +220,""" does not exists",' findes ikke
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +92,You can not change rate if BOM mentioned agianst any item,"Du kan ikke ændre kurs, hvis BOM nævnt agianst ethvert element"
DocType: Territory,Territory Name,Territory Navn
apps/erpnext/erpnext/crm/doctype/newsletter/newsletter.py +166,{0} has been successfully added to our Newsletter list.,{0} er blevet føjet til vores nyhedsliste.
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +86,Employee can not be changed,Medarbejder kan ikke ændres
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +117,Print and Stationary,Print og Stationær
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 standard skabelon i Salg Skatter og Afgifter Skabelon, skal du vælge en, og klik på knappen nedenfor."
DocType: Purchase Invoice,Recurring Invoice,Tilbagevendende Faktura
apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py +22,Date is repeated,Dato gentages
DocType: Attendance,Employee Name,Medarbejder Navn
DocType: Project,Total Costing Amount (via Time Logs),Total Costing Beløb (via Time Logs)
DocType: Production Order,Planned End Date,Planlagt Slutdato
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +32,Item 5,Punkt 5
apps/erpnext/erpnext/accounts/page/pos/pos.js +4,Start Point-of-Sale (POS),Start Point-of-Sale (POS)
apps/erpnext/erpnext/config/accounts.py +68,Create Payment Entries against Orders or Invoices.,Opret Betaling Entries mod ordrer eller fakturaer.
DocType: Account,Liability,Ansvar
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/setup/page/setup_wizard/install_fixtures.py +98,All Territories,Alle områder
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +19,Consumer Products,Forbrugerprodukter
DocType: Manufacturing Settings,Allow Overtime,Tillad Overarbejde
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +20,{0} is mandatory for Return,{0} er obligatorisk for Return
DocType: Customer Group,Mention if non-standard receivable account applicable,"Nævne, hvis ikke-standard tilgodehavende konto gældende"
DocType: Leave Application,Reason,Årsag
DocType: Sales Invoice Advance,Sales Invoice Advance,Salg Faktura Advance
DocType: BOM Operation,Operation,Operation
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +27,How Pricing Rule is applied?,Hvordan Prisfastsættelse Regel anvendes?
DocType: Sales Person,Select company name first.,Vælg firmanavn først.
DocType: Leave Block List,Block Holidays on important days.,Bloker Ferie på vigtige dage.
DocType: Stock Ledger Entry,Stock Ledger Entry,Stock Ledger indtastning
apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py +23,Name or Email is mandatory,Navn eller E-mail er obligatorisk
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +111,Electrical,Elektrisk
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +212,Time Log Batch {0} must be 'Submitted',Time Log Batch {0} skal være »Tilmeldt &#39;
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +626,Pair,Par
DocType: Purchase Order,Raw Materials Supplied,Raw Materials Leveres
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +112,Batch {0} of Item {1} has expired.,Batch {0} af Item {1} er udløbet.
DocType: Quality Inspection Reading,Reading 4,Reading 4
apps/erpnext/erpnext/config/setup.py +15,"Set Default Values like Company, Currency, Current Fiscal Year, etc.","Indstil standardværdier som Company, Valuta, indeværende finansår, etc."
DocType: Shipping Rule,Specify conditions to calculate shipping amount,Angiv betingelser for at beregne forsendelse beløb
DocType: Purchase Taxes and Charges Template,Purchase Master Manager,Indkøb Master manager
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +138,Purchase Order number required for Item {0},Indkøbsordre nummer kræves for Item {0}
DocType: Purchase Invoice,Recurring Type,Tilbagevendende Type
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +164,Annual Salary,Årsløn
DocType: Item Group,General Settings,Generelle indstillinger
DocType: Sales Invoice,Product Bundle Help,Produkt Bundle Hjælp
DocType: Employee,Divorced,Skilt
DocType: Stock UOM Replace Utility,New Stock UOM,New Stock UOM
DocType: Notification Control,Expense Claim Rejected,Expense krav Afvist
DocType: Leave Block List,Allow the following users to approve Leave Applications for block days.,Lad følgende brugere til at godkende Udfyld Ansøgninger om blok dage.
DocType: Account,Account Type,Kontotype
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +146,Screwing,Skruning
DocType: Fiscal Year,Companies,Virksomheder
DocType: Time Log,Billed,Billed
apps/erpnext/erpnext/stock/doctype/price_list/price_list.py +14,Price List must be applicable for Buying or Selling,Prisliste skal være gældende for at købe eller sælge
DocType: Serial No,Is Cancelled,Er Annulleret
DocType: Sales Invoice,Write Off Outstanding Amount,Skriv Off Udestående beløb
DocType: Warranty Claim,Warranty Claim,Garanti krav
DocType: Employee,Confirmation Date,Bekræftelse Dato
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +158,Selective laser sintering,Selektiv lasersintring
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +627,Hour,Time
DocType: Opportunity,Customer / Lead Name,Kunde / Lead navn
DocType: Cost Center,"Select Monthly Distribution, if you want to track based on seasonality.","Vælg Månedlig Distribution, hvis du ønsker at spore baseret på sæsonudsving."
DocType: Leave Type,Is Leave Without Pay,Er Lad uden løn
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +185,Quantity must not be more than {0},Mængde må ikke være mere end {0}
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +635,Please set default Cash or Bank account in Mode of Payment {0},Indstil standard Kontant eller bank konto i mode for betaling {0}
DocType: Hub Settings,Access Token,Access Token
DocType: Project,Estimated Costing,Anslået Costing
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +126,"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: Company,Default Holiday List,Standard Holiday List
DocType: Production Order Operation,Completed Qty,Afsluttet Antal
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +36,"Go to the appropriate group (usually Source of Funds > Current Liabilities > Taxes and Duties and create a new Account (by clicking on Add Child) of type ""Tax"" and do mention the Tax rate.",Gå til den relevante gruppe (som regel finansieringskilde&gt; Aktuelle Passiver&gt; Skatter og Afgifter og oprette en ny konto (ved at klikke på Tilføj barn) af typen &quot;Skat&quot; og gøre nævne Skatteprocent.
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +59,There are more holidays than working days this month.,Der er flere helligdage end arbejdsdage i denne måned.
DocType: Stock Entry Detail,BOM No. for a Finished Good Item,BOM No. for en Færdig god Item
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +104,Cannot produce more Item {0} than Sales Order quantity {1},Kan ikke producere mere Item {0} end Sales Order mængde {1}
DocType: ToDo,Reference,Henvisning
DocType: Process Payroll,Activity Log,Activity Log
DocType: Time Log,For Manufacturing,For Manufacturing
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +42,Total Outgoing,Samlet Udgående
apps/erpnext/erpnext/config/accounts.py +41,Tree of finanial accounts.,Tree of finanial konti.
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +33,Atleast one of the Selling or Buying must be selected,Mindst en af ​​salg eller køb skal vælges
apps/erpnext/erpnext/config/crm.py +53,Logs for maintaining sms delivery status,Logs for opretholdelse sms leveringsstatus
DocType: Landed Cost Voucher,Purchase Receipts,Køb Kvitteringer
apps/erpnext/erpnext/config/support.py +54,Setup incoming server for support email id. (e.g. support@example.com),Opsætning indgående server til support email id. (F.eks support@example.com)
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +160,Quarrying,Stenbrud
DocType: Purchase Order Item,Supplier Quotation,Leverandør Citat
apps/erpnext/erpnext/config/setup.py +56,Setting up Email,Opsætning af E-mail
DocType: Quality Inspection,Quality Inspection,Quality Inspection
DocType: SMS Settings,SMS Gateway URL,SMS Gateway URL
DocType: Journal Entry,Total Debit,Samlet Debit
apps/erpnext/erpnext/support/doctype/maintenance_visit/maintenance_visit.js +18,From Maintenance Schedule,Fra vedligeholdelsesplan
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.","Standard vilkår og betingelser, der kan føjes til salg og køb. Eksempler: 1. gyldighed tilbuddet. 1. Betalingsbetingelser (i forvejen, på kredit, del forhånd osv). 1. Hvad er ekstra (eller skulle betales af Kunden). 1. Sikkerhed / forbrug advarsel. 1. Garanti hvis nogen. 1. Retur Politik. 1. Betingelser for skibsfart, hvis relevant. 1. Måder adressering tvister, erstatning, ansvar mv 1. Adresse og Kontakt i din virksomhed."
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +18,Sand casting,Sandstøbning
DocType: Salary Slip,Gross Pay,Gross Pay
DocType: Employee,Emergency Contact Details,Emergency Kontaktoplysning
DocType: Item Group,HTML / Banner that will show on the top of product list.,"HTML / Banner, der vil vise på toppen af ​​produktliste."
apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +20,Customer is required,Kunden er nødvendig
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +164,Row {0}: Debit entry can not be linked with a {1},Række {0}: Debit indgang ikke kan knyttes med en {1}
apps/erpnext/erpnext/config/manufacturing.py +63,Tree of Bill of Materials,Tree of Bill of Materials
apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +33,Supplier Type / Supplier,Leverandør Type / leverandør
DocType: Purchase Invoice,Advances,Forskud
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +51,Serial No {0} does not exist,Løbenummer {0} eksisterer ikke
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +143,"Item: {0} managed batch-wise, can not be reconciled using \
					Stock Reconciliation, instead use Stock Entry","Emne: {0} lykkedes batchvis, kan ikke forenes ved hjælp af \ Stock Forsoning, i stedet bruge Stock indtastning"
DocType: Item,Supplier Items,Leverandør Varer
DocType: Purchase Invoice Item,Item,Vare
apps/erpnext/erpnext/config/hr.py +100,Organization branch master.,Organisation gren mester.
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +152,Work-in-Progress Warehouse is required before Submit,"Work-in-Progress Warehouse er nødvendig, før Indsend"
DocType: Material Request,Terms and Conditions Content,Vilkår og betingelser Indhold
apps/erpnext/erpnext/buying/doctype/purchase_common/purchase_common.py +34,UOM Conversion factor is required in row {0},UOM Omregningsfaktor kræves i række {0}
DocType: Purchase Invoice Item,Accounting,Regnskab
,Sales Invoice Trends,Salgsfaktura Trends
apps/erpnext/erpnext/accounts/page/financial_analytics/financial_analytics.js +58,Opening (Cr),Åbning (Cr)
apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.js +29,Do you really want to Submit all Salary Slip for month {0} and year {1},Vil du virkelig ønsker at indsende alle lønseddel for måned {0} og år {1}
DocType: Purchase Order,To Receive and Bill,Til at modtage og Bill
DocType: Production Planning Tool,Sales Orders,Salgsordrer
DocType: Notification Control,Customize the Notification,Tilpas Underretning
DocType: Event,Monday,Mandag
apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js +14,Issued,Udstedt
DocType: Sales Order Item,Actual Qty,Faktiske Antal
DocType: Communication,Subject,Emne
DocType: Employee,Permanent Address,Permanent adresse
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +171,{0} created,{0} oprettet
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +626,Unit,Enhed
DocType: Packing Slip,To Package No.,At pakke No.
DocType: Employee,Single,Enkeltværelse
DocType: Purchase Taxes and Charges,Item Wise Tax Detail,Item Wise Tax Detail
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +99,Legal Expenses,Juridiske Udgifter
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +39,Please setup your chart of accounts before you start Accounting Entries,"Venligst opsætning din kontoplan, før du starter bogføring"
,Projected,Projiceret
DocType: Payment Reconciliation,Maximum Amount,Maksimumbeløb
apps/erpnext/erpnext/stock/doctype/item/item.py +346,Barcode {0} already used in Item {1},Stregkode {0} allerede brugt i Item {1}
apps/erpnext/erpnext/projects/doctype/time_log/time_log.py +214,Production Order is Mandatory,Produktionsordre er Obligatorisk
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +474,Warning: Another {0} # {1} exists against stock entry {2},Advarsel: En anden {0} # {1} eksisterer mod lager post {2}
DocType: User,Female,Kvinde
DocType: UOM,UOM Name,UOM Navn
DocType: Employee,Personal Email,Personlig Email
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +623,Consumable,Forbrugsmaterialer
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +26,Entertainment & Leisure,Entertainment &amp; Leisure
DocType: Newsletter,Create and Send Newsletters,Opret og send nyhedsbreve
DocType: Maintenance Visit,Maintenance Time,Vedligeholdelse Time
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +209,Raw Materials cannot be blank.,Raw Materials kan ikke være tom.
apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py +23,No employee found!,Ingen medarbejder fundet!
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +82,Manager,Leder
apps/erpnext/erpnext/config/hr.py +90,Settings for HR Module,Indstillinger for HR modul
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +52,Only Leave Applications with status 'Approved' can be submitted,Kun Lad Applikationer med status &quot;Godkendt&quot; kan indsendes
DocType: Sales Invoice,Shipping Address Name,Forsendelse Adresse Navn
DocType: Material Request Item,Min Order Qty,Min prisen evt
apps/erpnext/erpnext/setup/doctype/item_group/item_group.js +21,Item Group Tree,Item Group Tree
DocType: Account,Rate at which this tax is applied,"Hastighed, hvormed denne afgift anvendes"
DocType: Sales Partner,Agent,Agent
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +105,Shaping,Shaping
DocType: Currency Exchange,Currency Exchange,Valutaveksling
DocType: Purchase Taxes and Charges,Parenttype,Parenttype
DocType: Sales Partner,Reseller,Forhandler
apps/erpnext/erpnext/setup/doctype/supplier_type/supplier_type.js +5,There is nothing to edit.,Der er intet at redigere.
apps/erpnext/erpnext/controllers/recurring_document.py +188,"{0} is an invalid email address in 'Notification \
					Email Address'","{0} er en ugyldig e-mail-adresse i ""Notification \ e-mail adresse'"
DocType: Employee,Cheque,Cheque
DocType: Authorization Rule,Approving User,Godkendelse Bruger
DocType: Stock Entry,Material Receipt,Materiale Kvittering
DocType: Stock Entry Detail,Material Request used to make this Stock Entry,Materiale Request bruges til at gøre dette Stock indtastning
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +484,Make Supplier Quotation,Foretag Leverandør Citat
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +150,Stitching,Syning
apps/erpnext/erpnext/config/accounts.py +143,Enable / disable currencies.,Aktivere / deaktivere valutaer.
DocType: Stock Entry,Difference Account,Forskel konto
DocType: Company,Ignore,Ignorer
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +644,Please enter Item Code.,Indtast venligst Item Code.
DocType: Fiscal Year,Year End Date,År Slutdato
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +154,For Warehouse is required before Submit,"For Warehouse er nødvendig, før Indsend"
DocType: Workstation,Wages,Løn
DocType: Journal Entry,Get Outstanding Invoices,Få udestående fakturaer
DocType: Pricing Rule,Purchase Manager,Indkøb manager
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +80,{0} Recipients,{0} Modtagere
DocType: Employee,New Workplace,Ny Arbejdsplads
DocType: Bank Reconciliation,Bank Account,Bankkonto
DocType: Purchase Receipt Item,Rejected Serial No,Afvist Løbenummer
DocType: GL Entry,Party,Selskab
DocType: Account,Fixed Asset,Fast Asset
DocType: BOM,Operations,Operationer
DocType: Sales Invoice,Shipping Rule,Forsendelse Rule
DocType: Employee,Employee Number,Medarbejder nummer
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +10,Apparel & Accessories,Beklædning og tilbehør
DocType: Bank Reconciliation,From Date,Fra dato
apps/erpnext/erpnext/config/manufacturing.py +51,Generate Material Requests (MRP) and Production Orders.,Generer Materiale Anmodning (MRP) og produktionsordrer.
DocType: Notification Control,Delivery Note Message,Levering Note Message
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +187,Please set Naming Series for {0} via Setup > Settings > Naming Series,Du indstille Navngivning Series for {0} via Opsætning&gt; Indstillinger&gt; Navngivning Series
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +64,{0} can not be negative,{0} kan ikke være negativ
DocType: Employee Education,Qualification,Kvalifikation
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +79,Account {0} is inactive,Konto {0} er inaktiv
apps/erpnext/erpnext/config/stock.py +109,Unit of Measure,Måleenhed
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +75,Management,Ledelse
apps/erpnext/erpnext/config/projects.py +33,Types of activities for Time Sheets,Typer af aktiviteter for Time Sheets
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +145,{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: Features Setup,If you have Sales Team and Sale Partners (Channel Partners)  they can be tagged and maintain their contribution in the sales activity,Hvis du har salgsteam og salg Partners (Channel Partners) de kan mærkes og vedligeholde deres bidrag i salget aktivitet
apps/erpnext/erpnext/public/js/templates/contact_list.html +31,No contacts added yet.,Ingen kontakter tilføjet endnu.
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +140,Joining,Vær med
apps/erpnext/erpnext/config/manufacturing.py +24,Time Logs for manufacturing.,Time Logs til produktion.
DocType: Period Closing Voucher,Closing Fiscal Year,Lukning regnskabsår
apps/erpnext/erpnext/public/js/pos/pos.js +491,{0} View,{0} Vis
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +182,Max: {0},Max: {0}
apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +148,Please select item code,Vælg emne kode
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +100,Make Bank Entry,Make Bank indtastning
apps/erpnext/erpnext/config/learn.py +21,Customizing Forms,Tilpasning Forms
DocType: Employee,Resignation Letter Date,Udmeldelse Brev Dato
DocType: Item,Customer Code,Customer Kode
DocType: Purchase Receipt Item,Rate and Amount,Sats og Beløb
DocType: Purchase Invoice,Taxes and Charges Added (Company Currency),Skatter og Afgifter Tilføjet (Company Valuta)
DocType: Purchase Order Item Supplied,Raw Material Item Code,Raw Material Item Code
DocType: Item Website Specification,Item Website Specification,Item Website Specification
DocType: BOM,Rate Of Materials Based On,Rate Of materialer baseret på
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +51,Technology,Teknologi
DocType: BOM Replace Tool,The new BOM after replacement,Den nye BOM efter udskiftning
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +713,Please specify Company to proceed,Angiv venligst Company for at fortsætte
apps/erpnext/erpnext/config/stock.py +103,Tree of Item Groups.,Tree of varegrupper.
DocType: Purchase Invoice,Net Total (Company Currency),Net alt (Company Valuta)
apps/erpnext/erpnext/buying/doctype/supplier/supplier.js +43,Total Billing This Year:,Samlet fakturering Dette år:
DocType: Opportunity,Opportunity Type,Opportunity Type
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +15,"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."
DocType: Email Digest,Next email will be sent on:,Næste email vil blive sendt på:
DocType: Sales Invoice,Sales Taxes and Charges,Salg Skatter og Afgifter
DocType: Employee,Reports to,Rapporter til
DocType: Salary Slip,Gross Pay + Arrear Amount +Encashment Amount - Total Deduction,Gross Pay + bagud Beløb + Indløsning Beløb - Total Fradrag
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +194,Serial No {0} quantity {1} cannot be a fraction,Løbenummer {0} mængde {1} kan ikke være en brøkdel
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +186,Please enter Write Off Account,Indtast venligst Skriv Off konto
apps/erpnext/erpnext/config/stock.py +136,"Attributes for Item Variants. e.g Size, Color etc.","Attributter for Item Varianter. f.eks størrelse, farve etc."
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +75,Group by Voucher,Gruppe af Voucher
DocType: Customer Group,Customer Group Name,Customer Group Name
apps/erpnext/erpnext/stock/doctype/item/item.js +17,Show Balance,Vis Balance
apps/frappe/frappe/custom/doctype/customize_form/customize_form.js +88,Update,Opdatering
DocType: Expense Claim,Approval Status,Godkendelsesstatus
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +134,Employee {0} has already applied for {1} between {2} and {3},Medarbejder {0} har allerede ansøgt om {1} mellem {2} og {3}
apps/frappe/frappe/public/js/frappe/form/link_selector.js +21,Value,Value
DocType: Maintenance Visit,Unscheduled,Uplanlagt
DocType: Workstation Working Hour,End Time,End Time
DocType: Quality Inspection Reading,Quality Inspection Reading,Quality Inspection Reading
DocType: Purchase Order Item,Billed Amt,Billed Amt
DocType: Shipping Rule,Shipping Rule Label,Forsendelse Rule Label
DocType: Employee Education,Under Graduate,Under Graduate
DocType: Appraisal Goal,Score Earned,Score tjent
apps/erpnext/erpnext/config/hr.py +38,Performance appraisal.,Præstationsvurdering.
DocType: Sales Order,%  Delivered,% Leveres
apps/erpnext/erpnext/accounts/general_ledger.py +134,Please mention Round Off Cost Center in Company,Henvis afrunde Cost Center i selskabet
DocType: Item,End of Life,End of Life
DocType: Sales Invoice,"The date on which next invoice will be generated. It is generated on submit.
","Den dato, hvor næste faktura vil blive genereret. Det genereres på send."
DocType: Quotation,In Words will be visible once you save the Quotation.,"I Ord vil være synlig, når du gemmer tilbuddet."
DocType: Workflow,Is Active,Er Aktiv
DocType: Purchase Invoice Item,Net Amount,Nettobeløb
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +44,Casual Leave,Casual Leave
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +140,Please enter Production Item first,Indtast venligst Produktion Vare først
DocType: Contact Us Settings,Pincode,Pinkode
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +193,Not authorized to edit frozen Account {0},Ikke autoriseret til at redigere frosne konto {0}
apps/erpnext/erpnext/stock/doctype/item/item_list.js +13,Variant,Variant
DocType: Workflow State,Time,Tid
DocType: Sales Invoice,Cold Calling,Telefonsalg
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +134,Bank Draft,Bank Draft
DocType: Selling Settings,Campaign Naming By,Kampagne Navngivning Af
DocType: Opportunity,To Discuss,Til Diskuter
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +40,Employee {0} is not active or does not exist,Medarbejder {0} er ikke aktiv eller findes ikke
DocType: Payment Reconciliation Payment,Voucher Detail Number,Voucher Detail Number
,Maintenance Schedules,Vedligeholdelsesplaner
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +166,Packaging and labeling,Emballering og etikettering
DocType: Lead,Lead Owner,Bly Owner
DocType: Customer,Default Receivable Accounts,Standard kan modtages Konti
apps/erpnext/erpnext/setup/doctype/sms_settings/sms_settings.py +68,Please Update SMS Settings,Opdatér venligst SMS-indstillinger
,Requested Qty,Anmodet Antal
DocType: Employee Education,Post Graduate,Post Graduate
apps/erpnext/erpnext/accounts/doctype/account/account.py +103,Account with child nodes cannot be converted to ledger,Konto med barneknudepunkter kan ikke konverteres til finans
apps/erpnext/erpnext/selling/report/customers_not_buying_since_long_time/customers_not_buying_since_long_time.py +71,Last Order Date,Sidste Ordredato
DocType: Production Plan Item,SO Pending Qty,SO Afventer Antal
DocType: Process Payroll,Select Payroll Year and Month,Vælg Payroll År og Måned
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard_page.html +18,Complete Setup,Komplet opsætning
DocType: Blog Post,Guest,Gæst
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/setup/page/setup_wizard/setup_wizard.js +620,A Product or Service,En vare eller tjenesteydelse
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +271,Time Logs created:,Time Logs oprettet:
apps/erpnext/erpnext/projects/doctype/project/project.js +47,Expense Claims,Expense Krav
apps/erpnext/erpnext/projects/doctype/time_log_batch/time_log_batch.js +21,Select Time Logs and Submit to create a new Sales Invoice.,Vælg Time Logs og Send for at oprette en ny Sales Invoice.
DocType: Communication,Recipients,Modtagere
DocType: Customer,Credit Limit,Kreditgrænse
apps/erpnext/erpnext/selling/doctype/customer/customer.py +91,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/accounts/doctype/pricing_rule/pricing_rule.js +21,"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."
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +63,Warehouse {0}: Company is mandatory,Warehouse {0}: Selskabet er obligatorisk
DocType: Item,Warranty Period (in days),Garantiperiode (i dage)
DocType: Stock Settings,Allow Negative Stock,Tillad Negativ Stock
DocType: Territory,Territory Targets,Territory Mål
apps/erpnext/erpnext/selling/page/sales_analytics/sales_analytics.js +65,Territory / Customer,Område / kunde
apps/erpnext/erpnext/accounts/doctype/account/account.js +8,Please create new account from Chart of Accounts.,Opret ny konto fra kontoplanen.
apps/erpnext/erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.py +27,-Above,-over
apps/erpnext/erpnext/stock/doctype/item/item.py +300,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/accounts/doctype/payment_reconciliation/payment_reconciliation.py +198,{0}: {1} not found in Invoice Details table,{0}: {1} blev ikke fundet i Invoice Detaljer tabel
DocType: SMS Settings,SMS Sender Name,SMS Sender Name
DocType: Task,Total Expense Claim (via Expense Claim),Total Expense krav (via Expense krav)
DocType: Sales Order,Fully Billed,Fuldt Billed
apps/erpnext/erpnext/controllers/accounts_controller.py +200,{0} '{1}' is disabled,{0} &#39;{1}&#39; er deaktiveret
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +211,"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"
DocType: C-Form Invoice Detail,Invoice No,Faktura Nej
DocType: Item,Item Image (if not slideshow),Item Billede (hvis ikke lysbilledshow)
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +389,The Organization,Organisationen
DocType: Features Setup,Imports,Import
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +9,Continuous casting,Kontinuerlig støbning
DocType: Task,depends_on,depends_on
apps/erpnext/erpnext/controllers/buying_controller.py +23,From {0} | {1} {2},Fra {0} | {1} {2}
DocType: Address Template,This format is used if country specific format is not found,"Dette format bruges, hvis landespecifikke format ikke findes"
DocType: Sales Invoice,Commission Rate (%),Kommissionen Rate (%)
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +35,Another Sales Person {0} exists with the same Employee id,En anden Sales Person {0} eksisterer med samme Medarbejder id
apps/erpnext/erpnext/stock/utils.py +167,{0} valid serial nos for Item {1},{0} gyldige løbenr for Item {1}
DocType: Delivery Note Item,Against Sales Order,Mod kundeordre
DocType: Opportunity,Quotation,Citat
DocType: Item,Has Batch No,Har Batch Nej
DocType: Purchase Receipt,Warehouse where you are maintaining stock of rejected items,"Lager, hvor du vedligeholder lager af afviste emner"
DocType: Job Applicant,Applicant for a Job,Ansøger om et job
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +61,Age,Alder
DocType: Employee,Date of Issue,Udstedelsesdato
DocType: Offer Letter Term,Offer Term,Offer Term
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +158,There were errors.,Der var fejl.
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +89,Warehouse not found in the system,Warehouse ikke fundet i systemet
DocType: Purchase Receipt Item Supplied,Purchase Receipt Item Supplied,Kvittering Vare Leveres
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +148,Leave approver must be one of {0},Lad godkender skal være en af ​​{0}
DocType: Top Bar Item,Target,Target
DocType: ToDo,Due Date,Due Date
DocType: Payment Tool,Make Payment Entry,Foretag indbetaling indtastning
apps/erpnext/erpnext/controllers/stock_controller.py +175,{0} {1}: Cost Center is mandatory for Item {2},{0} {1}: Udgiftområde er obligatorisk for varen {2}
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +53,Hemming,Hemming
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +38,"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"
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +426,BOM {0} must be active,BOM {0} skal være aktiv
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +145,Cr,Cr
DocType: Purchase Invoice,Supplier Address,Leverandør Adresse
DocType: Item Group,Website Specifications,Website Specifikationer
apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +55,Please set {0},Indstil {0}
DocType: Delivery Note,Installation Status,Installation status
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +154,Blue,Blå
DocType: Delivery Note Item,Against Sales Invoice,Mod Salg Faktura
DocType: Item,Inventory,Inventory
DocType: BOM Replace Tool,The BOM which will be replaced,Den BOM som vil blive erstattet
DocType: Production Order Operation,Planned Start Time,Planlagt Start Time
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +56,None of the items have any change in quantity or value.,Ingen af ​​elementerne har nogen ændring i mængde eller værdi.
DocType: Workstation,Rent Cost,Leje Omkostninger
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +142,Brazing,Lodning
apps/erpnext/erpnext/manufacturing/doctype/bom_replace_tool/bom_replace_tool.py +21,BOM replaced,BOM erstattet
DocType: Sales Partner,Contact Desc,Kontakt Desc
DocType: Leave Block List,Leave Block List Dates,Lad Block List Datoer
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +515,Select Item for Transfer,Vælg Item for Transfer
DocType: Email Digest,Note: Email will not be sent to disabled users,Bemærk: E-mail vil ikke blive sendt til handicappede brugere
DocType: Territory,Set Item Group-wise budgets on this Territory. You can also include seasonality by setting the Distribution.,Set varegruppe-wise budgetter på denne Territory. Du kan også medtage sæsonudsving ved at indstille Distribution.
DocType: Supplier Quotation,Is Subcontracted,Underentreprise
DocType: Employee,Current Address,Nuværende adresse
apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +62,Leaves Allocated Successfully for {0},Blade Tildelt Succesfuld for {0}
apps/erpnext/erpnext/shopping_cart/utils.py +47,Addresses,Adresser
apps/erpnext/erpnext/config/setup.py +42,Standard contract terms for Sales or Purchase.,Standard kontraktvilkår for Salg eller Indkøb.
DocType: Issue,Opening Date,Åbning Dato
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +41,Please enter Company,Indtast Company
DocType: Job Opening,"Job profile, qualifications required etc.","Jobprofil, kvalifikationer kræves etc."
DocType: UOM Conversion Detail,UOM Conversion Detail,UOM Konvertering Detail
DocType: Workflow State,User,Bruger
DocType: Sales Invoice Item,Delivery Note Item,Levering Note Vare
DocType: Purchase Invoice Item,Net Amount (Company Currency),Nettobeløb (Company Valuta)
DocType: Supplier,Address HTML,Adresse HTML
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +49,Software,Software
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +16,{0}: From {0} for {1},{0}: Fra {0} for {1}
DocType: Sales Person,Sales Person Targets,Salg person Mål
DocType: Installation Note,Installation Time,Installation Time
apps/erpnext/erpnext/config/support.py +38,Communication log.,Kommunikation log.
DocType: Salary Slip Deduction,Default Amount,Standard Mængde
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +45,Stretch forming,Stretch danner
DocType: Delivery Note,Track this Delivery Note against any Project,Spor dette Delivery Note mod enhver Project
DocType: Purchase Receipt Item Supplied,Required Qty,Nødvendigt antal
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +50,Period Closing Entry,Periode Lukning indtastning
DocType: DocType,Setup,Opsætning
apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +217,Please click on 'Generate Schedule',Klik på &quot;Generer Schedule &#39;
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +626,Box,Kasse
DocType: Employee,"Here you can maintain height, weight, allergies, medical concerns etc","Her kan du vedligeholde højde, vægt, allergier, medicinske problemer osv"
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +141,Leave of type {0} cannot be longer than {1},Ferie af typen {0} må ikke være længere end {1}
DocType: Sales Order Item,Planned Quantity,Planlagt Mængde
apps/erpnext/erpnext/accounts/doctype/accounts_settings/accounts_settings.py +27,Company is missing in warehouses {0},Virksomheden mangler i pakhuse {0}
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +163,Lapping,Lapning
apps/erpnext/erpnext/stock/get_item_details.py +113,Please specify Company,Angiv venligst Company
apps/erpnext/erpnext/config/selling.py +127,Tax template for selling transactions.,Skat skabelon til at sælge transaktioner.
apps/erpnext/erpnext/config/hr.py +23,Claims for company expense.,Krav om selskabets regning.
DocType: Features Setup,Item Advanced,Item Avanceret
apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +91,Total Tax,I alt Skat
apps/erpnext/erpnext/config/hr.py +13,Employee records.,Medarbejder Records.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +44,Computers,Computere
apps/erpnext/erpnext/accounts/report/financial_statements.html +3,Too many columns. Export the report and print it using a spreadsheet application.,Alt for mange kolonner. Eksportere rapporten og udskrive det ved hjælp af en regnearksprogram.
apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +21,{0} for {1},{0} for {1}
DocType: BOM Replace Tool,New BOM,Ny BOM
DocType: Sales Invoice,Advertisement,Annonce
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +87,Associate,Associate
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +80,Cannot approve leave as you are not authorized to approve leaves on Block Dates,"Kan ikke godkende orlov, som du ikke har tilladelse til at godkende blade på Block Datoer"
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +49,Please enter Taxes and Charges,Indtast Skatter og Afgifter
apps/erpnext/erpnext/stock/doctype/item/item.py +388,"An Item Group exists with same name, please change the item name or rename the item group","Findes et Element Group med samme navn, skal du ændre elementet navn eller omdøbe varegruppe"
DocType: Leave Type,Max Days Leave Allowed,Max Dage Leave tilladt
DocType: Hub Settings,Seller Website,Sælger Website
DocType: Company,Default Cost of Goods Sold Account,Standard vareforbrug konto
apps/erpnext/erpnext/accounts/report/item_wise_sales_register/item_wise_sales_register.py +47,Receivable Account,Tilgodehavende konto
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +22,POS Profile {0} already created for user: {1} and company {2},POS Profil {0} allerede oprettet for bruger: {1} og selskab {2}
apps/erpnext/erpnext/config/setup.py +110,Setup SMS gateway settings,Opsætning SMS gateway-indstillinger
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +466,Row No {0}: Amount cannot be greater than Pending Amount against Expense Claim {1}. Pending Amount is {2},Række Nej {0}: Beløb kan ikke være større end Afventer Beløb mod Expense krav {1}. Afventer Beløb er {2}
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +11,Automotive,Automotive
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +36,Tax Assets,Skatteaktiver
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +40,System Balance,System Balance
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +104,Warehouse {0} does not exist,Oplag {0} eksisterer ikke
DocType: Item,Items with higher weightage will be shown higher,Elementer med højere weightage vises højere
DocType: Purchase Invoice,Taxes and Charges Deducted,Skatter og Afgifter Fratrukket
DocType: GL Entry,Is Advance,Er Advance
DocType: Payment Tool,Received Or Paid,Modtaget eller betalt
apps/frappe/frappe/public/js/frappe/misc/utils.js +110,and,og
DocType: Sales Order Item,Basic Rate (Company Currency),Basic Rate (Company Valuta)
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +67,'Profit and Loss' type account {0} not allowed in Opening Entry,'Resultatopgørelsen' konto {0} ikke tilladt i 'Åbning balance'
DocType: C-Form,Received Date,Modtaget Dato
DocType: Address,Address Type,Adressetype
apps/erpnext/erpnext/config/learn.py +11,Navigating,Navigering
apps/erpnext/erpnext/controllers/buying_controller.py +69,Tax Category can not be 'Valuation' or 'Valuation and Total' as all items are non-stock items,Skat Kategori kan ikke være &quot;Værdiansættelse&quot; eller &quot;Værdiansættelse og Total&quot; som alle elementer er ikke-lagervarer
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +74,"Total {0} for all items is zero, may you should change 'Distribute Charges Based On'","Total {0} for alle poster er nul, kan du skal ændre &#39;Fordel afgifter baseret på&#39;"
apps/erpnext/erpnext/selling/page/sales_browser/sales_browser.js +122,Group Node,Gruppe Node
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +127,Polishing,Polering
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +99,Rejected Warehouse is mandatory against regected item,Afvist Warehouse er obligatorisk mod regected post
DocType: Item Customer Detail,Item Customer Detail,Item Customer Detail
DocType: Serial No,Under AMC,Under AMC
apps/erpnext/erpnext/utilities/doctype/address/address.py +90,No default Address Template found. Please create a new one from Setup > Printing and Branding > Address Template.,Ingen standard Adresse Skabelon fundet. Opret en ny en fra Setup&gt; Trykning og Branding&gt; Adresse skabelon.
DocType: Sales Order Item,Ordered Qty,Bestilt Antal
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +172,Valuation Rate required for Item {0},Værdiansættelse Rate kræves for Item {0}
DocType: Purchase Invoice Item,Net Rate,Net Rate
DocType: Features Setup,Sales and Purchase,Salg og Indkøb
DocType: SMS Log,Sent On,Sendt On
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +414,[Error],[Fejl]
apps/erpnext/erpnext/stock/get_item_details.py +125,Item {0} must be a Sales Item,Vare {0} skal være en Sales Item
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +61,Item must be added using 'Get Items from Purchase Receipts' button,Konto suppleres ved hjælp af &quot;Find varer fra Køb Kvitteringer &#39;knappen
DocType: DocPerm,Delete,Slet
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +330,{0} against Purchase Order {1},{0} mod indkøbsordre {1}
,General Ledger,General Ledger
DocType: Notification Control,Sales Order Message,Sales Order Message
DocType: Monthly Distribution Percentage,Monthly Distribution Percentage,Månedlig Distribution Procent
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +72,Dispatch,Dispatch
apps/erpnext/erpnext/controllers/selling_controller.py +150,Order Type must be one of {0},Bestil type skal være en af ​​{0}
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41,Earliest,Tidligste
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +71,Spinning,Spinning
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js +10,Return,Retur
DocType: Address,Postal,Postal
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +85,Warehouse {0} can not be deleted as quantity exists for Item {1},"Warehouse {0} kan ikke slettes, da mængden findes for Item {1}"
DocType: Purchase Invoice,Get Advances Paid,Få forskud
DocType: Notification Control,Send automatic emails to Contacts on Submitting transactions.,Sende automatiske e-mails til Kontakter på Indsendelse transaktioner.
DocType: Sales Order,Fully Delivered,Fuldt Leveres
apps/erpnext/erpnext/config/setup.py +61,Printing and Branding,Trykning og Branding
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +334,Not allowed to tranfer more {0} than {1} against Purchase Order {2},Ikke lov til at overdragelsessteder mere {0} end {1} mod indkøbsordre {2}
DocType: Expense Claim,Expenses,Udgifter
apps/erpnext/erpnext/config/crm.py +12,Database of potential customers.,Database over potentielle kunder.
DocType: Item Group,Item Group Name,Item Group Name
DocType: Quotation,Rate at which Price list currency is converted to company's base currency,"Hastighed, hvormed Prisliste valuta omregnes til virksomhedens basisvaluta"
DocType: Employee,Cell Number,Cell Antal
DocType: Company,Default Payable Account,Standard Betales konto
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +42,Customer required for 'Customerwise Discount',Kunden kræves for &#39;Customerwise Discount&#39;
DocType: Warehouse,Account for the warehouse (Perpetual Inventory) will be created under this Account.,Konto for lageret (Perpetual Inventory) vil blive oprettet under denne konto.
apps/erpnext/erpnext/setup/doctype/company/company.py +32,Abbreviation cannot have more than 5 characters,Forkortelse kan ikke have mere end 5 tegn
DocType: Rename Tool,File to Rename,Fil til Omdøb
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +83,Indirect Expenses,Indirekte udgifter
DocType: Project,% Tasks Completed,% Opgaver Afsluttet
DocType: Maintenance Schedule,Maintenance Schedule,Vedligeholdelse Skema
apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +150,Please select Start Date and End Date for Item {0},Vælg Start og slutdato for Item {0}
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +13,Please enter company first,Indtast venligst selskab først
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +153,3D printing,3D-print
apps/erpnext/erpnext/config/buying.py +79,Tax template for buying transactions.,Skat skabelon til at købe transaktioner.
DocType: Sales Partner,Partner's Website,Partner s hjemmeside
,Support Analytics,Support Analytics
DocType: Item,Is Purchase Item,Er Indkøb Item
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +627,My Invoices,Mine Fakturaer
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/setup/page/setup_wizard/install_fixtures.py +61,Piecework,Akkordarbejde
apps/erpnext/erpnext/config/support.py +28,Visit report for maintenance call.,Besøg rapport til vedligeholdelse opkald.
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +67,Marketing,Marketing
DocType: Shipping Rule Condition,Shipping Amount,Forsendelse Mængde
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +575,Contact Name,Kontakt Navn
apps/erpnext/erpnext/projects/doctype/task/task.py +86,Circular Reference Error,Cirkulær reference Fejl
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +85,Item {0} is not Purchase Item,Vare {0} er ikke Indkøb Vare
DocType: Salary Slip,Deductions,Fradrag
apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +31,Select Fiscal Year,Vælg regnskabsår
apps/erpnext/erpnext/accounts/doctype/account/account.js +27,This is a root account and cannot be edited.,Dette er en rod-konto og kan ikke redigeres.
DocType: Account,Purchase User,Køb Bruger
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +137,Atleast one warehouse is mandatory,Mindst én lageret er obligatorisk
DocType: Buying Settings,Maintain same rate throughout purchase cycle,Bevar samme sats i hele køb cyklus
DocType: Maintenance Visit,Maintenance Date,Vedligeholdelse Dato
apps/erpnext/erpnext/controllers/buying_controller.py +245,Specified BOM {0} does not exist for Item {1},Specificeret BOM {0} findes ikke til konto {1}
apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +95,Value or Qty,Værdi eller Antal
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +30,Completion Date,Afslutning Dato
DocType: Maintenance Visit Purpose,Maintenance Visit Purpose,Vedligeholdelse Besøg Formål
DocType: Serial No,Warranty Period (Days),Garantiperiode (dage)
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"
DocType: Leave Control Panel,Leave Control Panel,Lad Kontrolpanel
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +18,Discount Percentage can be applied either against a Price List or for all Price List.,Rabat Procent kan anvendes enten mod en prisliste eller for alle prisliste.
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +101,All Customer Groups,Alle kundegrupper
apps/erpnext/erpnext/config/crm.py +81,Manage Territory Tree.,Administrer Territory Tree.
DocType: Production Order Operation,(Hour Rate / 60) * Actual Operation Time,(Timesats / 60) * TidsforbrugIMinutter
DocType: Leave Block List,Stop users from making Leave Applications on following days.,Stop brugere fra at Udfyld Programmer på følgende dage.
DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),Skatter og Afgifter Fratrukket (Company Valuta)
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +48,Sick Leave,Sygefravær
DocType: Purchase Receipt Item,Accepted Warehouse,Accepteret varelager
DocType: Notification Control,Quotation Message,Citat Message
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +407,Financial Year End Date,Regnskabsår Slutdato
apps/erpnext/erpnext/config/setup.py +105,"Create and manage daily, weekly and monthly email digests.","Oprette og administrere de daglige, ugentlige og månedlige email fordøjer."
DocType: Project,Expected Start Date,Forventet startdato
,Transferred Qty,Overført Antal
DocType: Purchase Invoice,Purchase Taxes and Charges,Købe Skatter og Afgifter
apps/erpnext/erpnext/selling/doctype/customer/customer.py +29,Series is mandatory,Serien er obligatorisk
apps/erpnext/erpnext/config/setup.py +14,Global Settings,Globale indstillinger
apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +188,Serial No {0} not found,Løbenummer {0} ikke fundet
DocType: Stock Ledger Entry,Outgoing Rate,Udgående Rate
DocType: Production Order Operation,Actual End Time,Faktiske Sluttid
DocType: GL Entry,Remarks,Bemærkninger
apps/erpnext/erpnext/config/hr.py +53,Offer candidate a Job.,Offer kandidat et job.
DocType: Issue,Issue,Issue
DocType: Communication,Sent,Sent
DocType: Customer,Individual,Individuel
DocType: Purchase Invoice,The date on which next invoice will be generated. It is generated on submit.,"Den dato, hvor næste faktura vil blive genereret. Det genereres på send."
DocType: Item,Purchase Details,Køb Detaljer
apps/erpnext/erpnext/crm/doctype/newsletter_list/newsletter_list.js +24,Add Subscribers,Tilføj Abonnenter
DocType: Purchase Invoice Item,Page Break,Side Break
apps/erpnext/erpnext/config/accounts.py +63,Close Balance Sheet and book Profit or Loss.,Luk Balance og book resultatopgørelsen.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +105,Miscellaneous Expenses,Diverse udgifter
,Sales Browser,Salg Browser
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +10,Die casting,Trykstøbning
apps/erpnext/erpnext/config/manufacturing.py +74,Global settings for all manufacturing processes.,Globale indstillinger for alle produktionsprocesser.
apps/erpnext/erpnext/shopping_cart/utils.py +46,Issues,Spørgsmål
DocType: Purchase Invoice Item,Raw Materials Supplied Cost,Raw Materials Leveres Cost
DocType: Journal Entry Account,Sales Invoice,Salg Faktura
apps/frappe/frappe/integrations/doctype/dropbox_backup/dropbox_backup.py +182,Please set Dropbox access keys in your site config,Venligst sæt Dropbox genvejstaster i dit site config
apps/erpnext/erpnext/setup/doctype/company/company.py +236,Abbr can not be blank or space,Forkortelsen kan ikke være tom eller bestå af mellemrum
DocType: Web Page,Slideshow,Slideshow
DocType: Item,Will also apply to variants,Vil også gælde for varianter
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +34,"Then Pricing Rules are filtered out based on Customer, Customer Group, Territory, Supplier, Supplier Type, Campaign, Sales Partner etc.","Så Priser Regler filtreres ud baseret på kunden, Kunde Group, Territory, leverandør, leverandør Type, Kampagne, Sales Partner etc."
DocType: Payment Tool,Payment Mode,Betaling tilstand
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +89,Business Development Manager,Business Development Manager
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +620,Sales Return,Salg Return
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +408,Your financial year ends on,Din regnskabsår slutter den
DocType: Mode of Payment Account,Default Bank / Cash account will be automatically updated in POS Invoice when this mode is selected.,"Standard Bank / Cash-konto vil automatisk blive opdateret i POS faktura, når denne tilstand er valgt."
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 Item Code af varianten. For eksempel, hvis dit forkortelse er &quot;SM&quot;, og punktet koden er &quot;T-SHIRT&quot;, punktet koden for den variant, vil være &quot;T-SHIRT-SM&quot;"
DocType: Event,Friday,Fredag
,Accounts Receivable Summary,Debitor Resumé
,Pending SO Items For Purchase Request,Afventer SO Varer til Indkøb Request
DocType: Journal Entry,Excise Entry,Excise indtastning
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +20,{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.
DocType: Employee Internal Work History,Employee Internal Work History,Medarbejder Intern Arbejde Historie
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +74,Warehouse {0}: Parent account {1} does not bolong to the company {2},Warehouse {0}: Forældre-konto {1} ikke Bolong til virksomheden {2}
apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +39,Credit Balance,Credit Balance
apps/erpnext/erpnext/hr/doctype/employee/employee.py +135,User {0} is disabled,Bruger {0} er deaktiveret
DocType: HR Settings,Stop Birthday Reminders,Stop Fødselsdag Påmindelser
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +42,Avg Daily Outgoing,Gennemsnitlig Daily Udgående
DocType: Sales Invoice Item,Batch No,Batch Nej
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +29,Dip molding,Dyppestøbning
DocType: Salary Slip,Earning,Optjening
apps/erpnext/erpnext/accounts/doctype/account/account.py +43,Account {0}: You can not assign itself as parent account,Konto {0}: Konto kan ikke samtidig være forældre-konto
DocType: Employee,Company Email,Firma Email
DocType: Salary Slip,Earning & Deduction,Earning &amp; Fradrag
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +81,Hubbing,Sænksmedning
DocType: Production Order,Manufactured Qty,Fremstillet Antal
DocType: Quality Inspection Reading,Reading 3,Reading 3
DocType: Party Account,Party Account,Party Account
DocType: Company,Warn,Advar
DocType: Journal Entry,Journal Entry,Kassekladde
DocType: Installation Note,Installation Date,Installation Dato
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +35,Delivery Note {0} must not be submitted,Levering Note {0} må ikke indsendes
DocType: Customer Group,Has Child Node,Har Child Node
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +305,Please enter Warehouse for which Material Request will be raised,Indtast venligst Warehouse for hvilke Materiale Request vil blive rejst
DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Hvis markeret, Total nej. af Arbejdsdage vil omfatte helligdage, og dette vil reducere værdien af ​​Løn Per Day"
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +35,End tube forming,Ende rør danner
DocType: Company,Delete Company Transactions,Slet Company Transaktioner
DocType: Sales Order,Customer's Purchase Order Date,Kundens Indkøbsordre Dato
DocType: Appraisal Goal,Weightage (%),Weightage (%)
apps/erpnext/erpnext/projects/doctype/time_log/time_log.py +146,Operation ID not set,Operation ID ikke indstillet
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.html +26,Ref Date,Ref Dato
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +16,Permanent mold casting,Permanent formstøbning
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.js +14,This is a root sales person and cannot be edited.,Dette er en rod salg person og kan ikke redigeres.
DocType: Stock Entry,Sales Invoice No,Salg faktura nr
DocType: SMS Settings,Eg. smsgateway.com/api/send_sms.cgi,F.eks. smsgateway.com/api/send_sms.cgi
DocType: Production Planning Tool,Material Request For Warehouse,Materiale Request For Warehouse
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +50,Missing Currency Exchange Rates for {0},Manglende Valutakurser for {0}
DocType: Installation Note,Installation Note,Installation Bemærk
DocType: Salary Structure Deduction,Salary Structure Deduction,Løn Struktur Fradrag
DocType: Item,Default Unit of Measure,Standard Måleenhed
DocType: Purchase Invoice Item,Item Name,Item Name
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +407,Accounting Entry for Stock,Regnskab Punktet om Stock
DocType: BOM Replace Tool,Replace,Udskifte
DocType: Item,Inspection Criteria,Inspektion Kriterier
DocType: Offer Letter Term,Value / Description,/ Beskrivelse
DocType: Stock Entry,Purpose,Formål
DocType: Purchase Order Item,Supplier Quotation Item,Leverandør Citat Vare
DocType: Opportunity Item,Opportunity Item,Opportunity Vare
DocType: Sales Order,Track this Sales Order against any Project,Spor denne salgsordre mod enhver Project
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +70,Sales Person,Salg Person
DocType: Employee,Relieving Date,Lindre Dato
DocType: Employee Leave Approver,Employee Leave Approver,Medarbejder Leave Godkender
apps/erpnext/erpnext/config/accounts.py +128,Rules to calculate shipping amount for a sale,Regler til at beregne forsendelse beløb for et salg
DocType: C-Form,C-Form No,C-Form Ingen
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +24,Electronics,Elektronik
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +384,'Entries' cannot be empty,'Indlæg' kan ikke være tomt
DocType: Communication,Open,Åbent
DocType: Stock Ledger Entry,Voucher Detail No,Voucher Detail Nej
DocType: Bank Reconciliation,Select account head of the bank where cheque was deposited.,"Vælg højde leder af den bank, hvor checken blev deponeret."
DocType: HR Settings,Employee Records to be created by,Medarbejder Records at være skabt af
DocType: Activity Cost,Projects,Projekter
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,Ny Løbenummer kan ikke have Warehouse. Warehouse skal indstilles af Stock indtastning eller kvittering
DocType: Sales Invoice,Exhibition,Udstilling
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js +13,Overdue,Forfaldne
apps/erpnext/erpnext/controllers/trends.py +19,Total(Amt),I alt (Amt)
apps/erpnext/erpnext/selling/report/customers_not_buying_since_long_time/customers_not_buying_since_long_time.py +67,Number of Order,Antal Order
,BOM Search,BOM Søg
DocType: Notification Control,Purchase Receipt Message,Kvittering Message
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +47,Drawing,Tegning
DocType: Quotation,Rate at which customer's currency is converted to company's base currency,"Hastighed, hvormed kundens valuta omregnes til virksomhedens basisvaluta"
apps/erpnext/erpnext/public/js/controllers/taxes_and_totals.js +437,Please select Apply Discount On,Vælg Anvend Rabat på
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +355,{0} is mandatory for Item {1},{0} er obligatorisk for Item {1}
DocType: ToDo,High,Høj
apps/erpnext/erpnext/config/selling.py +18,Quotes to Leads or Customers.,Citater til Leads eller kunder.
DocType: Sales Invoice,Shipping Address,Forsendelse Adresse
DocType: Quotation Item,Quotation Item,Citat Vare
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +178,For Quantity (Manufactured Qty) is mandatory,For Mængde (Fremstillet Antal) er obligatorisk
DocType: Item,Serial Number Series,Serial Number Series
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +115,Buffing,Polering
DocType: Time Log Batch,Will be updated after Sales Invoice is Submitted.,Vil blive opdateret efter Sales Invoice er indgivet.
DocType: Authorization Rule,Authorization Rule,Autorisation Rule
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +195,Sales Invoice {0} must be cancelled before cancelling this Sales Order,"Salg Faktura {0} skal annulleres, før den annullerer denne Sales Order"
DocType: Serial No,Warranty Expiry Date,Garanti Udløbsdato
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +146,Quotation {0} is cancelled,Citat {0} er aflyst
apps/erpnext/erpnext/stock/doctype/item/item.js +34,Show Variants,Vis varianter
DocType: Stock Ledger Entry,Actual Qty After Transaction,Aktuel Antal Efter Transaktion
DocType: Sales Taxes and Charges Template,* Will be calculated in the transaction.,* Vil blive beregnet i transaktionen.
apps/erpnext/erpnext/manufacturing/doctype/bom_replace_tool/bom_replace_tool.py +25,Current BOM and New BOM can not be same,Nuværende BOM og New BOM må ikke være samme
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +53,Clearance date cannot be before check date in row {0},Clearance dato kan ikke være før check dato i række {0}
apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +26,Please select the document type first,Vælg dokumenttypen først
DocType: Item Group,Show this slideshow at the top of the page,Vis denne slideshow øverst på siden
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +25,Root cannot have a parent cost center,Root kan ikke have en forælder cost center
DocType: Page,Page Name,Side Navn
DocType: Account,Expenses Included In Valuation,Udgifter inkluderet i Værdiansættelse
DocType: Expense Claim,Task,Opgave
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +56,Show zero values,Vis nul værdier
apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +65,Supplier Id,Leverandør id
DocType: Landed Cost Voucher,Landed Cost Voucher,Landed Cost Voucher
apps/erpnext/erpnext/accounts/page/pos/pos_page.html +4,Select type of transaction,Vælg type transaktion
DocType: Sales Invoice,Payment Due Date,Betaling Due Date
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +30,Approval Status must be 'Approved' or 'Rejected',Godkendelsesstatus skal &quot;Godkendt&quot; eller &quot;Afvist&quot;
DocType: Production Order,Total Operating Cost,Samlede driftsomkostninger
DocType: Purchase Invoice,Is Return,Er Return
DocType: Opportunity,Lost Reason,Tabt Årsag
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +522,user@example.com,user@example.com
DocType: Sales Order Item,Used for Production Plan,Bruges til Produktionsplan
apps/erpnext/erpnext/accounts/doctype/account/account.py +169,Root account can not be deleted,Root-konto kan ikke slettes
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +81,Duplicate entry,Duplicate entry
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +31,To create a Bank Account,For at oprette en bankkonto
DocType: Item,Unit of Measure Conversion,Måleenhed Conversion
DocType: Production Order,Material Transferred for Manufacturing,Materiale Overført til Manufacturing
DocType: Sales Order,% of materials billed against this Sales Order,% Af materialer faktureret mod denne Sales Order
DocType: Pricing Rule,Apply On,Påfør On
DocType: Salary Structure,Salary breakup based on Earning and Deduction.,Løn breakup baseret på Optjening og fradrag.
DocType: Stock Entry,Total Value Difference (Out - In),Samlet værdi Difference (Out - In)
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +177,Bank Overdraft Account,Bank kassekredit
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 ** i anden ** Item **. Dette er nyttigt, hvis du bundling en bestemt ** Varer ** i en pakke, og du kan bevare status over de pakkede ** Varer ** og ikke den samlede ** Item **. Pakken ** Item ** vil have &quot;Er Stock Item&quot; som &quot;Nej&quot; og &quot;Er Sales Item&quot; som &quot;Ja&quot;. For eksempel: Hvis du sælger Laptops og Rygsække separat og har en særlig pris, hvis kunden køber både, så Laptop + Rygsæk vil være en ny Product Bundle Item. Bemærk: BOM = Bill of Materials"
apps/erpnext/erpnext/accounts/utils.py +344,{0} budget for Account {1} against Cost Center {2} will exceed by {3},{0} budget for konto {1} mod udgiftsområde {2} vil blive overskredet med {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: Item,"Example: ABCD.#####
If series is set and Serial No is not mentioned in transactions, then automatic serial number will be created based on this series. If you always want to explicitly mention Serial Nos for this item. leave this blank.","Eksempel:. ABCD ##### Hvis serien er indstillet, og Løbenummer nævnes ikke i transaktioner, så automatisk serienummer vil blive oprettet på grundlag af denne serie. Hvis du altid ønsker at eksplicit nævne Serial Nos for dette element. lader dette være blankt."
DocType: Company,Default Terms,Standard Vilkår
DocType: Company,Default Income Account,Standard Indkomst konto
,Sales Partners Commission,Salg Partners Kommissionen
DocType: Item Variant Attribute,Attribute,Attribut
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +57,Total Present,Samlet Present
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.js +61,To Date should be same as From Date for Half Day leave,Til dato skal være samme som fra dato for Half Day orlov
apps/erpnext/erpnext/accounts/doctype/account/account.py +89,"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'
DocType: BOM Replace 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","Udskift en bestemt BOM i alle andre styklister, hvor det bruges. Det vil erstatte den gamle BOM linket, opdatere omkostninger og regenerere &quot;BOM Explosion Item&quot; tabel som pr ny BOM"
apps/erpnext/erpnext/config/hr.py +71,Upload attendance from a .csv file,Upload fremmøde fra en .csv-fil
DocType: Quality Inspection,Sample Size,Sample Size
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +92,Show Time Logs,Vis Time Logs
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.
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +427,Transaction not allowed against stopped Production Order {0},Transaktion ikke tilladt mod stoppet produktionsordre {0}
DocType: Workstation,per hour,per time
apps/erpnext/erpnext/config/buying.py +54,Default settings for buying transactions.,Standardindstillinger for at købe transaktioner.
DocType: Sales Order,"Check if recurring order, uncheck to stop recurring or put proper End Date","Kontroller, om tilbagevendende orden, skal du fjerne markeringen for at stoppe tilbagevendende eller sætte ordentlig Slutdato"
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +84,Administrative Expenses,Administrationsomkostninger
DocType: Purchase Invoice Item,Project Name,Projektnavn
DocType: Opportunity,Opportunity From,Mulighed Fra
apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +228,Please click on 'Generate Schedule' to fetch Serial No added for Item {0},Klik på &quot;Generer Schedule &#39;at hente Løbenummer tilføjet for Item {0}
DocType: Selling Settings,Customer Naming By,Customer Navngivning Af
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +32,Laminating,Laminering
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +623,Raw Material,Raw Material
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +26,Total Outstanding Amount,Samlede udestående beløb
apps/frappe/frappe/templates/base.html +137,Error: Not a valid id?,Fejl: Ikke et gyldigt id?
apps/erpnext/erpnext/buying/doctype/supplier/supplier.js +45,Total Unpaid,Total Ulønnet
apps/erpnext/erpnext/accounts/doctype/account/account.js +67,Convert to Group,Konverter til Group
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +25,Global POS Profile {0} already created for company {1},Global POS Profil {0} allerede skabt til selskab {1}
DocType: Purchase Receipt Item,Prevdoc DocType,Prevdoc DocType
DocType: Notification Control,Custom Message,Tilpasset Message
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +159,Mining,Minedrift
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/accounts/doctype/purchase_invoice/purchase_invoice.py +164,Expense account is mandatory for item {0},Udgiftskonto er obligatorisk for element {0}
DocType: C-Form Invoice Detail,Territory,Territory
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +152,Indirect Income,Indirekte Indkomst
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +93,Turning,Drejning
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +145,Small,Lille
DocType: Newsletter,Email Sent?,E-mail Sendt?
DocType: Budget Detail,Budget Allocated,Budgettet
apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.js +13,View Offer Letter,Se tilbud Letter
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +384,Warehouse required at Row No {0},Warehouse kræves på Row Nej {0}
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +49,Necking,Necking
apps/erpnext/erpnext/projects/doctype/task/task.py +38,'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/config/stock.py +64,Upload stock balance via csv.,Upload lager balance via csv.
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +14,Broadcasting,Broadcasting
DocType: Item,Apply Warehouse-wise Reorder Level,Påfør Warehouse-wise Omarranger Level
apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py +51,Balance,Balance
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +39,Appraisal {0} created for Employee {1} in the given date range,Vurdering {0} skabt til Medarbejder {1} i givet datointerval
DocType: Task,Closing Date,Closing Dato
DocType: Sales Order,Not Delivered,Ikke leveret
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +51,Deep drawing,Dybtrækning
DocType: Attendance,Present,Present
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +103,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/setup/doctype/currency_exchange/currency_exchange.py +19,From Currency and To Currency cannot be same,Fra Valuta og Til valuta ikke kan være samme
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +25,Energy,Energi
DocType: Purchase Invoice,Supplier Invoice No,Leverandør faktura nr
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +23,Please enter parent cost center,Indtast forælder omkostningssted
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +8,Until,Indtil
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.py +517,Rest Of The World,Resten af ​​verden
DocType: Authorization Rule,Itemwise Discount,Itemwise Discount
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +52,Telecommunications,Telekommunikation
DocType: Features Setup,Item Barcode,Item Barcode
DocType: Communication,Date,Dato
DocType: Offer Letter,Select Terms and Conditions,Vælg Betingelser
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +46,Securities & Commodity Exchanges,Værdipapirer og Commodity Exchanges
,Purchase Analytics,Køb Analytics
DocType: Purchase Invoice Item,Purchase Invoice Item,Købsfaktura Item
apps/erpnext/erpnext/stock/doctype/stock_uom_replace_utility/stock_uom_replace_utility.py +58,New UOM must NOT be of type Whole Number,Ny UOM må IKKE være af typen heltal
apps/erpnext/erpnext/config/accounts.py +169,C-Form records,C-Form optegnelser
DocType: BOM,Total Cost,Total Cost
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: SMS Center,All Lead (Open),Alle Bly (Open)
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +41,Capital Equipments,Capital Udstyr
apps/erpnext/erpnext/stock/doctype/item/item.py +409,Item {0} does not exist,Element {0} eksisterer ikke
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +46,Min Qty can not be greater than Max Qty,Min Antal kan ikke være større end Max Antal
DocType: Item,Weightage,Weightage
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +84,Hydroforming,Hydroformning
DocType: Quality Inspection,Inspected By,Inspiceres af
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +303,Completed Qty can not be greater than 'Qty to Manufacture',Afsluttet Antal kan ikke være større end &#39;antal til Fremstilling&#39;
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +141,You are not authorized to add or update entries before {0},Du er ikke autoriseret til at tilføje eller opdatere poster før {0}
DocType: Lead,Do Not Contact,Må ikke komme i kontakt
DocType: GL Entry,Voucher Type,Voucher Type
DocType: Bank Reconciliation,Bank Reconciliation,Bank Afstemning
apps/frappe/frappe/public/js/frappe/views/ganttview.js +45,Gantt Chart,Gantt Chart
DocType: Employee,Reason for Resignation,Årsag til Udmeldelse
DocType: BOM Replace Tool,Current BOM,Aktuel BOM
DocType: Sales Invoice,Is Opening Entry,Åbner post
DocType: Payment Tool,Make Journal Entry,Make Kassekladde
DocType: SMS Center,Total Message(s),Total Besked (r)
DocType: Employee,Salutation,Salutation
DocType: Feed,Full Name,Fulde navn
apps/erpnext/erpnext/stock/doctype/stock_uom_replace_utility/stock_uom_replace_utility.py +47,Conversion Factor is required,Konvertering Factor er nødvendig
DocType: Fiscal Year Company,Fiscal Year Company,Fiscal År Company
DocType: Item,Variant Of,Variant af
DocType: Bin,FCFS Rate,FCFS Rate
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +111,Production Order status is {0},Produktionsordre status er {0}
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +95,Boring,Boring
DocType: Print Settings,Modern,Moderne
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +9,Get Updates,Hent opdateringer
DocType: Payment Tool Detail,Payment Tool Detail,Betaling Tool Detail
apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +36,Row #{0}: Timings conflicts with row {1},Row # {0}: tider konflikter med rækken {1}
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +629,We sell this Item,Vi sælger denne Vare
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +60,Import Failed!,Import mislykkedes!
DocType: Item,Default Supplier,Standard Leverandør
DocType: BOM,Item Desription,Item desription
DocType: Employee Education,Class / Percentage,Klasse / Procent
DocType: Sales Invoice,Debit To,Betalingskort Til
DocType: Bank Reconciliation,To Date,Til dato
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +130,Routing,Routing
DocType: Sales Partner,Retailer,Forhandler
DocType: Comment,Reference Name,Henvisning Navn
DocType: Purchase Invoice Item,Quantity and Rate,Mængde og Pris
DocType: Period Closing Voucher,Period Closing Voucher,Periode Lukning Voucher
DocType: Expense Claim,Approved,Godkendt
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +30,Earnest Money,Earnest Money
DocType: Account,Equity,Egenkapital
apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +69,Publish to sync items,Udgive synkronisere emner
apps/erpnext/erpnext/accounts/doctype/account/account.js +57,View Ledger,Vis Ledger
DocType: Pricing Rule,Buying,Køb
DocType: Territory,For reference,For reference
apps/erpnext/erpnext/config/learn.py +77,Opening Accounting Balance,Åbning Regnskab Balance
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +432,BOM {0} does not belong to Item {1},BOM {0} ikke hører til Vare {1}
DocType: Features Setup,Point of Sale,Point of Sale
DocType: Payment Reconciliation Invoice,Invoice Number,Fakturanummer
DocType: Landed Cost Item,Applicable Charges,Gældende gebyrer
DocType: Stock Reconciliation Item,Stock Reconciliation Item,Stock Afstemning Item
apps/erpnext/erpnext/config/hr.py +28,Attendance record.,Fremmøde rekord.
DocType: Quality Inspection Reading,Reading 6,Læsning 6
DocType: Currency Exchange,From Currency,Fra Valuta
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +112,You are the Expense Approver for this record. Please Update the 'Status' and Save,Du er bekostning Godkender til denne oplysning. Venligst Opdater &quot;Status&quot; og Gem
DocType: Buying Settings,Buying Settings,Opkøb Indstillinger
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +395,Max 5 characters,Max 5 tegn
DocType: Job Opening,Job Title,Jobtitel
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order_calendar.js +33,Production Item,Produktion Vare
DocType: Notification Control,Prompt for Email on Submission of,Spørg til Email på Indsendelse af
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +139,Proposal Writing,Forslag Skrivning
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +86,Warning: Same item has been entered multiple times.,Advarsel: Samme element er indtastet flere gange.
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +49,Expected Delivery Date cannot be before Sales Order Date,"Forventet leveringsdato kan ikke være, før Sales Order Date"
DocType: Pricing Rule,Min Qty,Min Antal
,Sales Order Trends,Salg Order Trends
DocType: Delivery Note,Instructions,Instruktioner
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +117,Electroplating,Galvanisering
DocType: Item Price,Bulk Import Help,Bulk Import Hjælp
DocType: Customer Group,Parent Customer Group,Overordnet kunde Group
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +29,Submit this Production Order for further processing.,Indsend denne produktionsordre til videre forarbejdning.
DocType: Purchase Invoice Item,Purchase Receipt,Kvittering
DocType: Delivery Note Item,Against Sales Invoice Item,Mod Sales Invoice Item
DocType: Expense Claim,From Employee,Fra Medarbejder
DocType: Features Setup,To get Item Group in details table,At få Item Group i detaljer tabel
DocType: Appraisal Template,Appraisal Template Title,Vurdering Template Titel
apps/erpnext/erpnext/config/hr.py +43,Applicant for a Job.,Ansøger om et job.
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +105,Government,Regeringen
apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.js +14,This is a root customer group and cannot be edited.,Dette er en rod kundegruppe og kan ikke redigeres.
DocType: Time Log,"Log of Activities performed by users against Tasks that can be used for tracking time, billing.","Log af aktiviteter udført af brugere mod Opgaver, der kan bruges til sporing af tid, fakturering."
DocType: Branch,Branch,Branch
apps/erpnext/erpnext/utilities/doctype/address/address.py +21,Address Title is mandatory.,Adresse Titel er obligatorisk.
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +119,Magnetic field-assisted finishing,Magnetfelt-assisteret efterbehandling
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +271,Packing Slip(s) cancelled,Packing Slip (r) annulleret
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +208,Maintenance Visit {0} must be cancelled before cancelling this Sales Order,"Vedligeholdelse Besøg {0} skal annulleres, før den annullerer denne Sales Order"
DocType: Stock Reconciliation Item,Before reconciliation,Før forsoning
,Item Shortage Report,Item Mangel Rapport
DocType: Stock Settings,Stock Frozen Upto,Stock Frozen Op
DocType: Purchase Invoice Item,Item Tax Rate,Item Skat
DocType: Bin,Bin,Bin
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +217,{0} {1} is stopped,{0} {1} er stoppet
DocType: Production Order,Manufacture against Sales Order,Fremstilling mod kundeordre
DocType: Leave Control Panel,Carry Forward,Carry Forward
DocType: Item,Moving Average,Glidende gennemsnit
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +12,"Pricing Rule is made to overwrite Price List / define discount percentage, based on some criteria.","Prisfastsættelse Regel er lavet til at overskrive Prisliste / definere rabatprocent, baseret på nogle kriterier."
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +392,Company Name,Firmaets navn
DocType: Price List,Price List Master,Prisliste Master
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +39,Purchase Price List,Indkøb prisliste
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +62,Cost Center with existing transactions can not be converted to group,Cost Center med eksisterende transaktioner kan ikke konverteres til gruppe
DocType: Stock Entry Detail,Stock Entry Detail,Stock indtastning Detail
apps/erpnext/erpnext/setup/doctype/company/company.py +55,"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 der er eksisterende transaktioner. Transaktioner skal annulleres for at ændre standard valuta."
DocType: Pricing Rule,Item Group,Item Group
apps/erpnext/erpnext/hr/doctype/employee/employee.py +114,Relieving Date must be greater than Date of Joining,Lindre Dato skal være større end Dato for Sammenføjning
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +660,Setup Complete,Setup Complete
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +161,Blasting,Sprængning
apps/erpnext/erpnext/public/js/account_tree_grid.js +50,Closing (Dr),Lukning (dr)
DocType: Item Group,Default Expense Account,Standard udgiftskonto
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +334,Please select Company first,Vælg venligst Company først
DocType: BOM Operation,Workstation,Arbejdsstation
DocType: Newsletter,Newsletter List,Nyhedsbrev List
DocType: Features Setup,Brands,Mærker
DocType: Quality Inspection Reading,Reading 10,Reading 10
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +50,Nosing,Forkant
apps/frappe/frappe/core/page/permission_manager/permission_manager.js +428,Set,Sæt
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +30,End Date can not be less than Start Date,Slutdato kan ikke være mindre end Startdato
apps/erpnext/erpnext/controllers/recurring_document.py +128,Please find attached {0} #{1},Vedlagt {0} # {1}
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +108,Office Maintenance Expenses,Office vedligeholdelsesudgifter
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +39,Cold rolling,Koldvalsning
apps/erpnext/erpnext/config/website.py +13,"Settings for online shopping cart such as shipping rules, price list etc.","Indstillinger for online indkøbskurv, såsom skibsfart regler, prisliste mv"
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +16,Bank Accounts,Bankkonti
apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +166,Maintenance Schedule {0} exists against {0},Vedligeholdelsesplan {0} eksisterer imod {0}
DocType: Fiscal Year,Year Start Date,År Startdato
DocType: Item,If subcontracted to a vendor,Hvis underentreprise til en sælger
apps/erpnext/erpnext/config/manufacturing.py +39,Details of the operations carried out.,Oplysninger om de gennemførte transaktioner.
DocType: Hub Settings,Name Token,Navn Token
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +565,From Supplier Quotation,Fra Leverandør Citat
DocType: Delivery Note,Customer's Purchase Order No,Kundens Indkøbsordre Nej
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +83,Analyst,Analytiker
DocType: Company,Round Off Cost Center,Afrunde Cost center
DocType: Purchase Invoice,End Date,Slutdato
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +93,Software Developer,Software Developer
apps/erpnext/erpnext/config/setup.py +83,"Show / Hide features like Serial Nos, POS etc.","Vis / Skjul funktioner som Serial Nos, POS mv"
apps/erpnext/erpnext/accounts/doctype/payment_tool/payment_tool.js +236,Row {0}: Payment amount can not be negative,Række {0}: Betaling beløb kan ikke være negativ
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +50,Privilege Leave,Privilege Forlad
DocType: Journal Entry,Write Off Based On,Skriv Off baseret på
DocType: Bulk Email,Message,Besked
DocType: Email Digest,Email Digest Settings,E-mail-Digest-indstillinger
DocType: Sales Invoice,Customer Address,Kunde Adresse
DocType: Custom Script,Client,Klient
DocType: Task,Review Date,Anmeldelse Dato
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +61,Total Actual,Samlede faktiske
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +164,Morticing,Stemmemaskiner
DocType: Item,Variants,Varianter
DocType: Quotation Item,Against Docname,Mod Docname
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: Journal Entry Account,Expense Claim,Expense krav
DocType: Workflow State,Search,Søg
apps/erpnext/erpnext/accounts/general_ledger.py +131,Please mention Round Off Account in Company,Henvis Round Off-konto i selskabet
DocType: Journal Entry,Accounts Receivable,Tilgodehavender
DocType: Packed Item,Parent Detail docname,Parent Detail docname
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +69,Stock Expenses,Stock Udgifter
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/setup/page/setup_wizard/install_fixtures.py +58,Probation,Kriminalforsorgen
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +23,Compaction plus sintering,Komprimering plus sintring
apps/erpnext/erpnext/selling/report/customers_not_buying_since_long_time/customers_not_buying_since_long_time.js +8,Days Since Last Order,Dage siden sidste ordre
DocType: Employee,Married,Gift
apps/erpnext/erpnext/public/js/stock_analytics.js +45,Opening,Åbning
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
apps/erpnext/erpnext/setup/doctype/company/company.py +152,Main,Main
DocType: Product Bundle,Product Bundle,Produkt Bundle
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +43,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: Salary Structure Earning,Reduce Earning for Leave Without Pay (LWP),Reducer Optjening for Leave uden løn (LWP)
apps/erpnext/erpnext/config/stock.py +53,Batch (lot) of an Item.,Batch (parti) af et element.
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +19,Shell molding,Skalstøbning
DocType: Production Plan Item,Reserved Warehouse in Sales Order / Finished Goods Warehouse,Reserveret Warehouse i kundeordre / færdigvarer Warehouse
DocType: Features Setup,Miscelleneous,Miscelleneous
apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +154,Please select Incharge Person's name,Vælg Incharge Person navn
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +399,"e.g. ""XYZ National Bank""",fx &quot;XYZ National Bank&quot;
DocType: Lead,Lead Type,Lead Type
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +149,Target warehouse is mandatory for row {0},Target lageret er obligatorisk for rækken {0}
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +201,Duplicate Serial No entered for Item {0},Duplicate Løbenummer indtastet for Item {0}
DocType: Account,Cash,Kontanter
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +67,Redrawing,Gentegning
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +62,Item: {0} does not exist in the system,Item: {0} findes ikke i systemet
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +186,No records found in the Payment table,Ingen resultater i Payment tabellen
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +168,Stock Options,Aktieoptioner
DocType: Journal Entry,Opening Entry,Åbning indtastning
DocType: Appraisal,Appraisal Template,Vurdering skabelon
DocType: Salary Slip Earning,Salary Slip Earning,Lønseddel Earning
DocType: POS Profile,Write Off Account,Skriv Off konto
apps/erpnext/erpnext/controllers/recurring_document.py +206,Next Recurring {0} will be created on {1},Næste Tilbagevendende {0} vil blive oprettet på {1}
DocType: DocType,System,System
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +471,cannot be greater than 100,må ikke være større end 100
DocType: Pricing Rule,Campaign,Kampagne
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +268,Total Debit must be equal to Total Credit. The difference is {0},Samlet Debit skal være lig med Total Credit. Forskellen er {0}
DocType: Appraisal,Select template from which you want to get the Goals,"Vælg skabelon, hvorfra du ønsker at få de mål"
DocType: Purchase Taxes and Charges,Consider Tax or Charge for,Overvej Skat eller Gebyr for
apps/erpnext/erpnext/buying/doctype/purchase_common/purchase_common.py +74,{0} must be a Purchased or Sub-Contracted Item in row {1},{0} skal være en Købt eller underentreprise element i række {1}
DocType: Lead,Request Type,Anmodning Type
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +128,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
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.js +28,Group By,Gruppér efter
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +151,Colour,Farve
DocType: BOM,Materials Required (Exploded),Nødvendige materialer (Sprængskitse)
apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +138,"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/frappe/frappe/config/setup.py +130,Printing,Udskrivning
DocType: Stock Entry,For Quantity,For Mængde
apps/erpnext/erpnext/controllers/buying_controller.py +139,Please select BOM in BOM field for Item {0},Vælg BOM i BOM vilkår for Item {0}
DocType: Warehouse,A logical Warehouse against which stock entries are made.,Et logisk varelager hvor lagerændringer foretages.
apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +66,Payable Account,Betales konto
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +183,No records found in the Invoice table,Ingen resultater i Invoice tabellen
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +36,"Can not filter based on Voucher No, if grouped by Voucher","Kan ikke filtrere baseret på blad nr, hvis grupperet efter Voucher"
DocType: Leave Type,Include holidays within leaves as leaves,Medtag helligdage inden blade som blade
DocType: Item Attribute Value,Item Attribute Value,Item Attribut Værdi
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: Production Order,Item To Manufacture,Item Til Fremstilling
DocType: Purchase Invoice,Price List Currency,Pris List Valuta
DocType: Address,Subsidiary,Datterselskab
DocType: Contact Us Settings,Address Title,Adresse Titel
DocType: Purchase Invoice Item,Qty,Antal
apps/erpnext/erpnext/stock/get_item_details.py +262,Price List not selected,Prisliste ikke valgt
DocType: Company History,Year,År
DocType: Sales Order,% of materials delivered against this Sales Order,% Af materialer leveret mod denne Sales Order
DocType: Journal Entry,Write Off,Skriv Off
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +443,All items have already been invoiced,Alle elementer er allerede blevet faktureret
DocType: Buying Settings,Purchase Receipt Required,Kvittering Nødvendig
apps/erpnext/erpnext/config/hr.py +210,Leave Management,Lad Management
DocType: BOM,Materials,Materialer
DocType: Payment Tool,Reference No,Referencenummer
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +62,Please enter Purchase Receipt first,Indtast venligst kvittering først
DocType: Sales Partner,Distributor,Distributør
apps/erpnext/erpnext/config/setup.py +37,Country wise default Address Templates,Land klogt standardadresse Skabeloner
apps/erpnext/erpnext/utilities/transaction_base.py +128,Quantity cannot be a fraction in row {0},Mængde kan ikke være en del i række {0}
DocType: Standard Reply,Owner,Ejer
DocType: Task,Expected Time (in hours),Forventet tid (i timer)
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: Project,Total Billing Amount (via Time Logs),Total Billing Beløb (via Time Logs)
apps/erpnext/erpnext/config/hr.py +155,Types of Expense Claim.,Typer af Expense krav.
DocType: Upload Attendance,Attendance From Date,Fremmøde Fra dato
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +21,Defense,Forsvar
DocType: Employee,Family Background,Familie Baggrund
DocType: Sales Order,Partly Billed,Delvist Billed
DocType: Stock Reconciliation Item,Current Valuation Rate,Aktuel Værdiansættelse Rate
DocType: About Us Settings,Website,Websted
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +43,Publishing,Publishing
DocType: Email Digest,How frequently?,Hvor ofte?
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +202,Maintenance Schedule {0} must be cancelled before cancelling this Sales Order,"Vedligeholdelsesplan {0} skal annulleres, før den annullerer denne Sales Order"
DocType: Purchase Order,% Received,% Modtaget
DocType: Workstation Working Hour,Workstation Working Hour,Workstation Working Hour
DocType: Features Setup,To track items using barcode. You will be able to enter items in Delivery Note and Sales Invoice by scanning barcode of item.,At spore elementer ved hjælp af stregkode. Du vil være i stand til at indtaste poster i følgeseddel og salgsfaktura ved at scanne stregkoden på varen.
DocType: Time Log Batch Detail,Time Log Batch Detail,Time Log Batch Detail
DocType: SMS Center,Send SMS,Send SMS
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +298,My Orders,Mine ordrer
DocType: Item,Default BOM,Standard BOM
DocType: Sales Order,To Deliver and Bill,At levere og Bill
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +53,Plant and Machinery,Anlæg og maskiner
DocType: Warehouse,Warehouse Name,Warehouse Navn
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, varerne ikke leveres via {0}"
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +410,The name of your company for which you are setting up this system.,"Navnet på din virksomhed, som du oprette dette system."
apps/erpnext/erpnext/public/js/pos/pos.js +91,Price List not found or disabled,Prisliste ikke fundet eller handicappede
apps/erpnext/erpnext/config/crm.py +48,Send mass SMS to your contacts,Send masse SMS til dine kontakter
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +382,Item table can not be blank,Item tabel kan ikke være tom
DocType: Material Request Item,Quantity and Warehouse,Mængde og Warehouse
DocType: Company,Default Receivable Account,Standard Tilgodehavende konto
apps/erpnext/erpnext/projects/doctype/time_log_batch/time_log_batch.js +28,Make Sales Invoice,Make Sales Invoice
apps/frappe/frappe/config/desk.py +7,Tools,Værktøj
DocType: Appraisal Goal,Key Responsibility Area,Key Responsibility Area
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +187,Delivery Notes {0} must be cancelled before cancelling this Sales Order,"Følgesedler {0} skal annulleres, før den annullerer denne Sales Order"
DocType: File,Lft,LFT
apps/erpnext/erpnext/setup/page/setup_wizard/default_website.py +26,This is an example website auto-generated from ERPNext,Dette er et eksempel website auto-genereret fra ERPNext
DocType: Purchase Order,To Receive,At Modtage
apps/erpnext/erpnext/config/stock.py +125,Price List master.,Pris List mester.
DocType: Quality Inspection,Quality Manager,Kvalitetschef
apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +79,Workstation is closed on the following dates as per Holiday List: {0},Workstation er lukket på følgende datoer som pr Holiday List: {0}
,Issued Items Against Production Order,Udstedte Varer Against produktionsordre
DocType: Production Planning Tool,Get Items From Sales Orders,Få elementer fra salgsordrer
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +62,Total Revenue,Total Revenue
apps/erpnext/erpnext/config/manufacturing.py +14,Bill of Material,Bill of Material
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åvarer til analyse."
DocType: Shipping Rule,Shipping Rule Conditions,Forsendelse Regel Betingelser
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +351,The First User: You,Den første bruger: Du
apps/erpnext/erpnext/accounts/report/sales_register/sales_register.py +66,Customer Id,Kunde-id
DocType: Salary Slip,Deduction,Fradrag
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.py +182,Standard Selling,Standard Selling
DocType: Packing Slip,Package Weight Details,Pakke vægt detaljer
DocType: Employee,Held On,Held On
DocType: Address,Personal,Personlig
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +143,Reason for losing,Årsag til at miste
apps/erpnext/erpnext/config/hr.py +48,Opening for a Job.,Åbning for et job.
apps/erpnext/erpnext/setup/doctype/company/company.js +41,Wrong Password,Forkert Adgangskode
DocType: Payment Reconciliation,Reconcile,Forene
DocType: Sales Invoice Item,Delivery Note,Følgeseddel
DocType: Sales Person,Name and Employee ID,Navn og Medarbejder ID
,Requested Items To Be Ordered,Anmodet Varer skal bestilles
DocType: Supplier,Supplier of Goods or Services.,Leverandør af varer eller tjenesteydelser.
apps/erpnext/erpnext/controllers/stock_controller.py +71,No accounting entries for the following warehouses,Ingen bogføring for følgende lagre
apps/erpnext/erpnext/projects/doctype/time_log_batch/time_log_batch.js +22,Click on 'Make Sales Invoice' button to create a new Sales Invoice.,Klik på &#39;Make Salg Faktura&#39; knappen for at oprette en ny Sales Invoice.
DocType: Payment Tool Detail,Against Voucher No,Mod blad nr
DocType: Async Task,System Manager,System Manager
DocType: Maintenance Visit,Completion Status,Afslutning status
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +7,Your email address,Din e-mail-adresse
apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.py +20,An Customer exists with same name,En Kunden eksisterer med samme navn
apps/erpnext/erpnext/stock/doctype/stock_uom_replace_utility/stock_uom_replace_utility.py +40,New Stock UOM is required,New Stock UOM kræves
DocType: Project,Project Type,Projekt type
DocType: Communication,Series,Series
DocType: Territory,Classification of Customers by region,Klassifikation af kunder efter region
DocType: Production Planning Tool,Filter based on item,Filter baseret på emne
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +85,Machining,Bearbejdning
DocType: Offer Letter,Offer Letter,Tilbyd Letter
DocType: Project,External,Ekstern
DocType: Workstation,Workstation Name,Workstation Navn
DocType: Employee,Emergency Phone,Emergency Phone
DocType: Journal Entry,Write Off Amount,Skriv Off Beløb
DocType: Employee,Educational Qualification,Pædagogisk Kvalifikation
DocType: DocField,Name,Navn
DocType: Workstation Working Hour,Start Time,Start Time
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +139,Item Group not mentioned in item master for item {0},Item Group ikke er nævnt i punkt master for element {0}
DocType: Item Reorder,Material Request Type,Materiale Request Type
apps/erpnext/erpnext/config/crm.py +17,Customer database.,Kundedatabase.
DocType: POS Profile,Cash/Bank Account,Kontant / Bankkonto
DocType: Sales Invoice,Packed Items,Pakket Varer
DocType: Employee,Health Concerns,Sundhedsmæssige betænkeligheder
apps/erpnext/erpnext/crm/doctype/newsletter_list/newsletter_list.js +3,View Subscribers,Se Abonnenter
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.js +458,Make Purchase Order,Make indkøbsordre
DocType: Features Setup,"Available in BOM, Delivery Note, Purchase Invoice, Production Order, Purchase Order, Purchase Receipt, Sales Invoice, Sales Order, Stock Entry, Timesheet","Fås i BOM, følgeseddel, købsfaktura, produktionsordre, Indkøbsordre, kvittering, Sales Invoice, Sales Order, Stock indtastning, Timesheet"
apps/erpnext/erpnext/setup/doctype/company/company.py +80,Stores,Butikker
DocType: Account,Balance Sheet,Balance
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +82,Account {0} does not belong to Company {1},Konto {0} tilhører ikke virksomheden {1}
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/projects/doctype/project/project_list.js +6,{0}% Complete,{0}% Complete
DocType: Stock Entry,From BOM,Fra BOM
DocType: Purchase Order Item,UOM Conversion Factor,UOM Conversion Factor
DocType: SMS Settings,"Enter static url parameters here (Eg. sender=ERPNext, username=ERPNext, password=1234 etc.)","Indtast statiske url parametre her (F.eks. Afsender = ERPNext, brugernavn = ERPNext, password = 1234 mm)"
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +116,"For {0}, only debit accounts can be linked against another credit entry",For {0} kan kun betalingskort konti knyttes mod en anden kredit post
DocType: Packing Slip,The gross weight of the package. Usually net weight + packaging material weight. (for print),Bruttovægt af pakken. Normalt nettovægt + emballagemateriale vægt. (Til print)
apps/frappe/frappe/desk/moduleview.py +61,Documents,Dokumenter
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."
DocType: Hub Settings,Seller Country,Sælger Land
DocType: Account,Old Parent,Gammel Parent
DocType: Purchase Order,Stopped,Stoppet
apps/erpnext/erpnext/hr/doctype/employee/employee.py +212,Birthday Reminder for {0},Birthday Reminder for {0}
DocType: Shipping Rule,example: Next Day Shipping,eksempel: Næste dages levering
DocType: Packing Slip,From Package No.,Fra pakken No.
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +173,Warehouse required for stock Item {0},Warehouse kræves for lager Vare {0}
DocType: Item,Show a slideshow at the top of the page,Vis et diasshow på toppen af ​​siden
apps/erpnext/erpnext/crm/doctype/newsletter/newsletter.py +136,Thank you for your interest in subscribing to our updates,Tak for din interesse i at abonnere på vores opdateringer
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +60,Nibbling,Gnave
DocType: Account,Warehouse,Warehouse
DocType: Pricing Rule,Valid From,Gyldig fra
DocType: Comment,Unsubscribed,Afmeldt
DocType: Pricing Rule,Discount Percentage,Discount Procent
apps/erpnext/erpnext/support/doctype/issue/issue.py +58,My Issues,Mine Issues
DocType: Buying Settings,Supplier Naming By,Leverandør Navngivning Af
DocType: Purchase Invoice Item,Conversion Factor,Konvertering Factor
DocType: Sales Invoice,Total Commission,Samlet Kommissionen
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +27,Accounting Entries can be made against leaf nodes. Entries against Groups are not allowed.,Bogføring kan foretages mod blad noder. Poster mod grupper er ikke tilladt.
DocType: ToDo,Medium,Medium
apps/erpnext/erpnext/stock/stock_ledger.py +405,"Purchase rate for item: {0} not found, which is required to book accounting entry (expense). Please mention item price against a buying price list.","Købskurs for vare: {0} ikke fundet, som er nødvendig for at booke regnskabsmæssig post (udgift). Nævne venligst vare pris mod en købskurs listen."
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +512,"Add users to your organization, other than yourself","Tilføj brugere til din organisation, andre end dig selv"
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +471,Stock Entry {0} is not submitted,Stock indtastning {0} er ikke indsendt
DocType: Purchase Invoice,Terms and Conditions1,Vilkår og forhold1
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +102,Sawing,Savning
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +318,{0} against Sales Order {1},{0} mod salgsordre {1}
apps/erpnext/erpnext/config/stock.py +95,Default settings for stock transactions.,Standardindstillinger for lager transaktioner.
DocType: Quality Inspection Reading,Reading 2,Reading 2
,Lead Details,Bly Detaljer
DocType: Company,Domain,Domæne
DocType: Employee,Internal Work History,Intern Arbejde Historie
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +268,Please select Category first,Vælg Kategori først
DocType: Serial No,Incoming Rate,Indgående Rate
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26,Project Id,Projekt-id
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +75,Show Stock Entries,Vis Stock Entries
DocType: Lead,Address Desc,Adresse Desc
DocType: Journal Entry Account,If Income or Expense,Hvis indtægter og omkostninger
DocType: Activity Cost,Activity Cost,Aktivitet Omkostninger
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +32,Provisional Profit / Loss (Credit),Foreløbig Profit / Loss (Credit)
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +424,Production Order {0} must be submitted,Produktionsordre {0} skal indsendes
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +36,Motion Picture & Video,Motion Picture &amp; Video
DocType: Production Planning Tool,Create Material Requests,Opret Materiale Anmodning
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +37,Budget cannot be assigned against Group Account {0},Budget kan ikke tildeles mod Group konto {0}
DocType: Expense Claim Detail,Expense Claim Detail,Expense krav Detail
DocType: Company,Default Cash Account,Standard Kontant konto
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +100,Different UOM for items will lead to incorrect (Total) Net Weight value. Make sure that Net Weight of each item is in the same UOM.,"Forskellige UOM for elementer vil føre til forkert (Total) Vægt værdi. Sørg for, at Nettovægt for hvert punkt er i den samme UOM."
DocType: Supplier Quotation Item,Material Request No,Materiale Request Nej
DocType: Time Log,Billable,Faktureres
apps/erpnext/erpnext/stock/doctype/item/item.js +188,"Weight is mentioned,\nPlease mention ""Weight UOM"" too","Vægt er nævnt, \ nVenligst nævne &quot;Weight UOM&quot; for"
DocType: Salary Structure Deduction,Reduce Deduction for Leave Without Pay (LWP),Reducer Fradrag for Leave uden løn (LWP)
apps/erpnext/erpnext/controllers/buying_controller.py +135,Supplier Warehouse mandatory for sub-contracted Purchase Receipt,Leverandør Warehouse obligatorisk for underentreprise kvittering
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +116,Burnishing,Brunering
DocType: Issue,First Responded On,Først svarede den
apps/erpnext/erpnext/templates/includes/cart.js +137,Something went wrong!,Noget gik galt!
DocType: Job Applicant,Job Opening,Job Åbning
apps/erpnext/erpnext/projects/report/daily_time_log_summary/daily_time_log_summary.py +17,To Datetime,Til datotid
DocType: Appraisal,Goals,Mål
apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.js +9,Activity Log:,Aktivitet Log:
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +148,Extra Large,Extra Large
apps/erpnext/erpnext/config/hr.py +95,"Types of employment (permanent, contract, intern etc.).","Typer af beskæftigelse (permanent, kontrakt, praktikant osv)."
DocType: Leave Control Panel,Leave blank if considered for all branches,Lad stå tomt hvis det anses for alle brancher
DocType: Item Quality Inspection Parameter,Item Quality Inspection Parameter,Item Quality Inspection Parameter
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +63,Apprentice,Lærling
DocType: POS Profile,Terms and Conditions,Betingelser
apps/frappe/frappe/public/js/frappe/form/toolbar.js +165,New {0},Ny {0}
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +157,Please enter Planned Qty for Item {0} at row {1},Indtast venligst Planned Antal for Item {0} på rækken {1}
DocType: Item,Has Serial No,Har Løbenummer
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +120,You can not enter current voucher in 'Against Journal Entry' column,Du kan ikke indtaste aktuelle kupon i &quot;Mod Kassekladde &#39;kolonne
apps/frappe/frappe/public/js/frappe/views/reports/grid_report.js +305,From Date must be before To Date,Fra dato skal være før til dato
DocType: Purchase Taxes and Charges,On Net Total,On Net Total
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.js +19,"To set this Fiscal Year as Default, click on 'Set as Default'","For at indstille dette regnskabsår som standard, skal du klikke på &#39;Vælg som standard&#39;"
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +50,Office Equipments,Kontor udstyr
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +18,Browse BOM,Gennemse BOM
apps/erpnext/erpnext/selling/doctype/customer/customer.py +181,Credit limit has been crossed for customer {0} {1}/{2},Credit grænsen er krydset for kunde {0} {1} / {2}
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +53,Television,Fjernsyn
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +169,Stopped order cannot be cancelled. Unstop to cancel.,Stoppet ordre kan ikke annulleres. Unstop at annullere.
DocType: Company,Services,Tjenester
DocType: Journal Entry,Make Difference Entry,Make Difference indtastning
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +147,Riveting,Nitning
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +47,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},Stock balance i Batch {0} vil blive negativ {1} for Item {2} på Warehouse {3}
DocType: Delivery Note,Time at which items were delivered from warehouse,"Tidspunkt, hvor varerne blev leveret fra lageret"
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +40,Others,Andre
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +152,{0} ({1}) must have role 'Leave Approver',"{0} ({1}), skal have rollen 'Godkendelse af fravær'"
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +148,Series Updated Successfully,Series opdateret
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: Expense Claim Detail,Expense Claim Type,Expense krav Type
apps/erpnext/erpnext/public/js/pos/pos.js +402,Payment cannot be made for empty cart,Betaling kan ikke ske for tomme vogn
DocType: Address,City/Town,By / Town
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +28,Blow molding,Blæsestøbning
DocType: Material Request Item,Material Request Item,Materiale Request Vare
DocType: Material Request,Material Transfer,Materiale Transfer
,Supplier Addresses and Contacts,Leverandør Adresser og kontaktpersoner
DocType: Item,Re-Order Qty,Re-prisen evt
DocType: Payment Tool,Find Invoices to Match,Find fakturaer til Match
apps/erpnext/erpnext/accounts/utils.py +195,Allocated amount can not greater than unadusted amount,Tildelte beløb kan ikke er større end unadusted beløb
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +28,Financial Services,Financial Services
,Payment Period Based On Invoice Date,Betaling Periode Baseret på Fakturadato
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +20,Spray forming,Spray danner
apps/erpnext/erpnext/config/selling.py +148,Rules for applying pricing and discount.,Regler for anvendelse af priser og rabat.
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +59,Account head {0} created,Konto head {0} oprettet
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +75,Staking,Satsningen
DocType: Account,Round Off,Afrunde
DocType: Leave Application,Leave Approver Name,Lad Godkender Navn
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +405,Financial Year Start Date,Regnskabsår Startdato
DocType: Account,Credit,Credit
DocType: Sales Invoice,Is POS,Er POS
apps/erpnext/erpnext/selling/report/territory_target_variance_item_group_wise/territory_target_variance_item_group_wise.py +57,Total Achieved,Total Opnået
apps/erpnext/erpnext/config/accounts.py +107,Default settings for accounting transactions.,Standardindstillinger regnskabsmæssige transaktioner.
DocType: Item,Customer Item Codes,Kunde Item Koder
DocType: Project Task,Project Task,Project Task
apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py +37,Can be approved by {0},Kan godkendes af {0}
DocType: Purchase Invoice,Grand Total (Company Currency),Grand Total (Company Valuta)
DocType: Purchase Invoice,Mobile No,Mobile Ingen
DocType: Account,Debit,Betalingskort
DocType: BOM Item,Scrap %,Skrot%
DocType: Payment Tool,Payment Tool,Betaling Tool
DocType: Event,Tuesday,Tirsdag
apps/erpnext/erpnext/crm/doctype/newsletter/newsletter.py +43,Scheduled to send to {0} recipients,Planlagt at sende til {0} modtagere
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +118,Electropolishing,Elektropolering
apps/erpnext/erpnext/selling/report/customers_not_buying_since_long_time/customers_not_buying_since_long_time.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
,Stock Projected Qty,Stock Forventet Antal
DocType: Supplier,Stock Manager,Stock manager
apps/erpnext/erpnext/public/js/pos/pos.js +528,Please select Price List,Vælg venligst prislisten
apps/erpnext/erpnext/accounts/utils.py +53,{0} '{1}' not in Fiscal Year {2},{0} &#39;{1}&#39; ikke i regnskabsåret {2}
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +242,"Multiple Price Rule exists with same criteria, please resolve \
			conflict by assigning priority. Price Rules: {0}","Multiple Pris Regel eksisterer med samme kriterier, skal du løse \ konflikten ved at tildele prioritet. Pris Regler: {0}"
DocType: BOM,Manufacturing User,Manufacturing Bruger
DocType: Production Planning Tool,Production Orders,Produktionsordrer
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +189,Opening Balance Equity,Åbning Balance Egenkapital
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +189,New Leave Application,Ny Leave Application
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +40,No Items to pack,Ingen varer at pakke
apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +32,Contribution %,Bidrag%
DocType: Purchase Receipt Item,Rejected Quantity,Afvist Mængde
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +111,Row #{0}: Please specify Serial No for Item {1},Row # {0}: Angiv Serial Nej for Item {1}
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +114,Expense Claim is pending approval. Only the Expense Approver can update status.,Expense krav afventer godkendelse. Kun Expense Godkender kan opdatere status.
apps/frappe/frappe/core/doctype/user/user.js +130,Loading,Loading
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/hr/doctype/upload_attendance/upload_attendance.py +105,Please select a csv file,Vælg en CSV-fil
DocType: Sales Invoice Item,Customer's Item Code,Kundens Item Code
apps/erpnext/erpnext/public/js/account_tree_grid.js +52,Closing (Cr),Lukning (Cr)
DocType: Sales Invoice,Customer Name,Customer Name
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +86,Secretary,Sekretær
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +144,Cost Updated,Omkostninger Opdateret
DocType: BOM Operation,Operation Description,Operation Beskrivelse
DocType: Sales Person,Sales Person Name,Salg Person Name
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41,Consumed,Forbrugt
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +74,Please select month and year,Vælg måned og år
DocType: Process Payroll,Select Employees,Vælg Medarbejdere
,Sales Person Target Variance Item Group-Wise,Salg Person Target Variance Item Group-Wise
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +379,Item Code required at Row No {0},Item Code kræves på Row Nej {0}
DocType: Item,Allow over delivery or receipt upto this percent,Tillad løbet levering eller modtagelse op denne procent
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: Purchase Invoice,Total Taxes and Charges (Company Currency),Total Skatter og Afgifter (Company valuta)
,Project wise Stock Tracking,Projekt klogt Stock Tracking
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +37,"Selling must be checked, if Applicable For is selected as {0}","Selling skal kontrolleres, om nødvendigt er valgt som {0}"
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +112,Hardware,Hardware
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +68,Gross Profit %,Gross Profit%
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +213,Optional. This setting will be used to filter in various transactions.,Valgfri. Denne indstilling vil blive brugt til at filtrere i forskellige transaktioner.
DocType: Features Setup,Item Batch Nos,Item Batch nr
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +44,Charges are updated in Purchase Receipt against each item,Afgifter er opdateret i kvittering mod hvert punkt
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +62,Sanctioned Amount cannot be greater than Claim Amount in Row {0}.,Sanktioneret Beløb kan ikke være større end krav Beløb i Row {0}.
DocType: Journal Entry,Bill No,Bill Ingen
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +61,Repeat Customer Revenue,Gentag Kunde Omsætning
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +323,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}
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +95,Researcher,Forsker
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +140,Valuation type charges can not marked as Inclusive,Værdiansættelse typen omkostninger ikke er markeret som Inclusive
DocType: BOM,Exploded_items,Exploded_items
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/setup/page/setup_wizard/fixtures/operations.py +76,Seaming,Falsning
apps/erpnext/erpnext/accounts/doctype/account/account.py +41,Account {0}: Parent account {1} does not exist,Konto {0}: Forældre-konto {1} findes ikke
DocType: Workstation,Wages per hour,Lønningerne i timen
apps/erpnext/erpnext/selling/report/territory_target_variance_item_group_wise/territory_target_variance_item_group_wise.py +58,Total Variance,Samlet Varians
DocType: Time Log Batch,Total Hours,Total Hours
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +494,From Purchase Receipt,Fra kvittering
apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +43,No employee found,Ingen medarbejder fundet
DocType: Account,Balance must be,Balance skal være
DocType: Issue,Raised By (Email),Rejst af (E-mail)
DocType: Supplier Quotation,Manufacturing Manager,Produktion manager
DocType: Cost Center,Cost Center,Cost center
apps/erpnext/erpnext/templates/form_grid/item_grid.html +72,Discount,Rabat
DocType: Purchase Order Item,Supplier Part Number,Leverandør Part Number
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +133,Wire Transfer,Bankoverførsel
DocType: Item,Default Warehouse,Standard Warehouse
apps/erpnext/erpnext/buying/doctype/supplier/supplier.py +88,No Permission,Ingen Tilladelse
,Invoiced Amount (Exculsive Tax),Faktureret beløb (exculsive Tax)
apps/erpnext/erpnext/selling/report/customers_not_buying_since_long_time/customers_not_buying_since_long_time.py +68,Total Order Value,Samlet ordreværdi
DocType: Opportunity,With Items,Med Varer
apps/erpnext/erpnext/crm/doctype/lead/lead.py +37,Campaign Name is required,Kampagne navn er påkrævet
DocType: DocField,Currency,Valuta
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +94,Designer,Designer
DocType: Employee,Emergency Contact,Emergency Kontakt
apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +33,Please select weekly off day,Vælg ugentlige off dag
DocType: Offer Letter Term,Offer Letter Term,Tilbyd Letter Term
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +55,Venture Capital,Venture Capital
apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +26,`Freeze Stocks Older Than` should be smaller than %d days.,`Frys lager ældre end` skal være mindre end %d dage.
DocType: Industry Type,Industry Type,Industri Type
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +155,Fused deposition modeling,Fused deposition modeling
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +37,Pricing Rules are further filtered based on quantity.,Priser Regler er yderligere filtreret baseret på mængde.
apps/erpnext/erpnext/config/manufacturing.py +56,Replace Item / BOM in all BOMs,Udskift Item / BOM i alle styklister
DocType: DocField,Description,Beskrivelse
DocType: Stock Settings,Freeze Stock Entries,Frys Stock Entries
DocType: Account,Stock Adjustment,Stock Justering
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +621,Group,Gruppe
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +138,"Serialized Item {0} cannot be updated \
					using Stock Reconciliation",Føljeton Item {0} kan ikke opdateres \ hjælp Stock Afstemning
DocType: Delivery Note,Vehicle Dispatch Date,Køretøj Dispatch Dato
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +186,Dividends Paid,Betalt udbytte
DocType: Sales Invoice Item,Available Batch Qty at Warehouse,Tilgængelig Batch Antal på Warehouse
DocType: Lead,Suggestions,Forslag
DocType: Opportunity,Your sales person who will contact the customer in future,"Dit salg person, som vil kontakte kunden i fremtiden"
DocType: ToDo,Low,Lav
DocType: Sales Partner,A third party distributor / dealer / commission agent / affiliate / reseller who sells the companies products for a commission.,"En tredjepart, distributør/forhandler/sælger/affiliate/butik der, der sælger selskabernes varer/tjenesteydelser mod provision."
DocType: Monthly Distribution,Monthly Distribution Percentages,Månedlige Distribution Procenter
,Delivery Note Trends,Følgeseddel Tendenser
apps/erpnext/erpnext/controllers/selling_controller.py +122,Commission rate cannot be greater than 100,Provisionssats kan ikke være større end 100
DocType: Purchase Receipt,Range,Range
DocType: Account,Receivable,Tilgodehavende
DocType: Purchase Invoice,Contact Details,Kontaktoplysninger
apps/frappe/frappe/desk/moduleview.py +67,Standard Reports,Standard rapporter
apps/erpnext/erpnext/controllers/status_updater.py +163,Allowance for over-{0} crossed for Item {1}.,Fradrag for over- {0} krydsede for Item {1}.
apps/erpnext/erpnext/accounts/utils.py +339,Annual,Årligt
DocType: Journal Entry,Write Off Entry,Skriv Off indtastning
apps/erpnext/erpnext/controllers/stock_controller.py +166,Expense or Difference account is mandatory for Item {0} as it impacts overall stock value,"Udgift eller Forskel konto er obligatorisk for Item {0}, da det påvirker den samlede lagerværdi"
DocType: Lead,Channel Partner,Channel Partner
DocType: Communication,Replied,Svarede
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +176,Purchse Order number required for Item {0},Purchse Ordrenummer kræves for Item {0}
DocType: Item,Lead Time in days,Lead Time i dage
DocType: Journal Entry,Debit Note,Debetnota
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +125,Vibratory finishing,Vibrerende efterbehandling
DocType: Payment Reconciliation Invoice,Invoice Type,Faktura type
apps/erpnext/erpnext/controllers/status_updater.py +140,Allowance for over-{0} crossed for Item {1},Fradrag for over- {0} krydsede for Item {1}
apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +38,Please click on 'Generate Schedule' to get schedule,Klik på &quot;Generer Schedule &#39;for at få tidsplan
DocType: Appraisal,For Employee Name,For Medarbejder Navn
apps/erpnext/erpnext/accounts/report/trial_balance_for_party/trial_balance_for_party.py +70,Totals,Totaler
apps/erpnext/erpnext/selling/doctype/campaign/campaign.js +10,View Leads,Se Leads
DocType: Item Group,Check this if you want to show in website,Markér dette hvis du ønsker at vise i website
DocType: Newsletter List Subscriber,Newsletter List Subscriber,Nyhedsbrev List Subscriber
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +156,White,Hvid
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +102,Marketing Expenses,Markedsføringsomkostninger
DocType: Journal Entry,User Remark,Bruger Bemærkning
DocType: Sales Order,Partly Delivered,Delvist Delivered
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +91,Project Manager,Projektleder
DocType: Purchase Invoice,Credit To,Credit Til
apps/frappe/frappe/public/js/frappe/list/doclistview.js +418,Customize,Tilpas
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +26,Please specify currency in Company,Angiv venligst valuta i selskabet
DocType: Purchase Invoice,Taxes and Charges Calculation,Skatter og Afgifter Beregning
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."
apps/erpnext/erpnext/selling/page/sales_analytics/sales_analytics.js +33,Customer Group / Customer,Customer Group / kunde
DocType: Naming Series,Setup Series,Opsætning Series
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +44,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/page/setup_wizard/setup_wizard.js +626,Nos,Nos
DocType: Purchase Invoice Item,Rate,Rate
apps/erpnext/erpnext/config/stock.py +79,Update additional costs to calculate landed cost of items,Opdater yderligere omkostninger til at beregne landede udgifter til poster
DocType: Sales Invoice,Get Advances Received,Få forskud
DocType: Leave Control Panel,Leave blank if considered for all designations,Lad stå tomt hvis det anses for alle betegnelser
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +627,Minute,Minut
apps/erpnext/erpnext/public/js/pos/pos.html +36,Amount Paid,Beløb betalt
DocType: Company,Phone No,Telefon Nej
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/page/setup_wizard/fixtures/operations.py +12,Full-mold casting,Fuld formstøbning
DocType: Rename Tool,Type of document to rename.,Type dokument omdøbe.
DocType: Purchase Invoice,Terms,Betingelser
apps/erpnext/erpnext/hr/doctype/employee/employee.py +111,Date Of Retirement must be greater than Date of Joining,Dato for pensionering skal være større end Dato for Sammenføjning
DocType: Process Payroll,Send Email,Send Email
apps/erpnext/erpnext/config/hr.py +140,Holiday master.,Ferie mester.
DocType: Features Setup,If you involve in manufacturing activity. Enables Item 'Is Manufactured',Hvis du inddrage i fremstillingsindustrien aktivitet. Aktiverer Item &#39;Er Fremstillet&#39;
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +13,Lost-foam casting,Lost-skum støbning
DocType: Contact Us Settings,City,By
DocType: Hub Settings,Seller Description,Sælger Beskrivelse
apps/erpnext/erpnext/controllers/accounts_controller.py +338,Warning: System will not check overbilling since amount for Item {0} in {1} is zero,"Advarsel: Systemet vil ikke tjekke overfakturering, da beløbet til konto {0} i {1} er nul"
apps/erpnext/erpnext/config/projects.py +38,Cost of various activities,Omkostninger ved forskellige aktiviteter
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +104,Broaching,Rømning
DocType: Tax Rule,Sales,Salg
DocType: Salary Structure,Salary Structure,Løn Struktur
DocType: BOM Operation,BOM Operation,BOM Operation
DocType: Warranty Claim,Resolution,Opløsning
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 Material Request Dato
apps/frappe/frappe/public/js/frappe/model/model.js +18,Created By,Lavet af
apps/erpnext/erpnext/config/hr.py +115,Salary template master.,Løn skabelon mester.
,Monthly Salary Register,Månedlig Løn Tilmeld
apps/erpnext/erpnext/controllers/trends.py +257,Project-wise data is not available for Quotation,Projekt-wise data er ikke tilgængelig for Citat
DocType: Purchase Invoice,Contact Email,Kontakt E-mail
DocType: SMS Settings,Message Parameter,Besked Parameter
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +124,Spindle finishing,Spindel efterbehandling
DocType: C-Form Invoice Detail,Invoice Date,Faktura Dato
DocType: Payment Reconciliation Invoice,Payment Reconciliation Invoice,Betaling Afstemning Faktura
apps/erpnext/erpnext/selling/doctype/quotation/quotation.js +643,Please select a value for {0} quotation_to {1},Vælg en værdi for {0} quotation_to {1}
DocType: Pricing Rule,"Higher the number, higher the priority","Højere tallet er, jo højere prioritet"
apps/erpnext/erpnext/config/accounts.py +18,Bills raised to Customers.,Regninger rejst til kunder.
DocType: Newsletter,A Lead with this email id should exist,Et emne med dette e-mail-id skal være oprettet.
DocType: Notification Control,Expense Claim Rejected Message,Expense krav Afvist Message
DocType: Time Log,Will be updated when billed.,"Vil blive opdateret, når faktureret."
apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +191,Serial No {0} is under warranty upto {1},Løbenummer {0} er under garanti op {1}
DocType: Time Log Batch,Total Billing Amount,Samlet Billing Beløb
DocType: POS Profile,Update Stock,Opdatering Stock
DocType: Manufacturing Settings,"Disables creation of time logs against Production Orders.
Operations shall not be tracked against Production Order",Deaktiverer oprettelsen af ​​tid logs mod produktionsordrer. Operationer må ikke spores mod produktionsordre
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +214,Production Order {0} must be cancelled before cancelling this Sales Order,"Produktionsordre {0} skal annulleres, før den annullerer denne Sales Order"
DocType: Serial No,Delivery Details,Levering Detaljer
DocType: Hub Settings,Sync Now,Synkroniser nu
DocType: Dropbox Backup,Daily,Daglig
apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +16,{0}: From {1},{0}: Fra {1}
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +38,Search Sub Assemblies,Søg Sub Assemblies
,Requested Items To Be Transferred,"Anmodet Varer, der skal overføres"
DocType: Features Setup,"If you have long print formats, this feature can be used to split the page to be printed on multiple pages with all headers and footers on each page","Hvis du har lange trykte formater, kan denne funktion bruges til at opdele side, der skal udskrives på flere sider med alle sidehoveder og sidefødder på hver side"
DocType: Mode of Payment,Mode of Payment,Mode Betaling
apps/erpnext/erpnext/accounts/page/financial_analytics/financial_analytics.js +52,Plot,Plot
DocType: Stock Reconciliation,Difference Amount,Forskel Beløb
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +641,Add a few sample records,Tilføj et par prøve optegnelser
apps/erpnext/erpnext/controllers/accounts_controller.py +354,"Cannot overbill for Item {0} in row {1} more than {2}. To allow overbilling, please set in Stock Settings","Kan ikke overbill for Item {0} i række {1} mere end {2}. For at tillade overfakturering, skal du indstille i Stock-indstillinger"
DocType: Item,Item Tax,Item Skat
DocType: Leave Block List,Allow Users,Tillad brugere
DocType: Cost Center,Stock User,Stock Bruger
DocType: Period Closing Voucher,Closing Account Head,Lukning konto Hoved
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +74,Human Resources,Human Resources
DocType: Delivery Note,Transporter Name,Transporter Navn
DocType: Production Order Operation,Operation completed for how many finished goods?,Operation afsluttet for hvor mange færdigvarer?
DocType: Company,Distribution,Distribution
DocType: Pricing Rule,Applicable For,Gældende For
DocType: Account,Account,Konto
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +90,Annealing,Annealing
apps/erpnext/erpnext/crm/doctype/newsletter/newsletter.py +147,Confirm Your Email,Bekræft din e-mail
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +214,{0} {1} is fully billed,{0} {1} er fuldt faktureret
DocType: Workstation,Net Hour Rate,Net Hour Rate
apps/erpnext/erpnext/config/learn.py +204,Human Resource,Menneskelige Ressourcer
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +61,Temporary Opening,Midlertidig Åbning
DocType: Production Order,Planned Operating Cost,Planlagt driftsomkostninger
DocType: Job Opening,Description of a Job Opening,Beskrivelse af et job Åbning
DocType: Country,Country,Land
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
,Amount to Deliver,"Beløb, Deliver"
apps/erpnext/erpnext/selling/report/territory_target_variance_item_group_wise/territory_target_variance_item_group_wise.py +50,Achieved,Opnået
DocType: Lead,Opportunity,Mulighed
apps/erpnext/erpnext/hr/doctype/employee/employee.py +151,Employee cannot report to himself.,Medarbejder kan ikke rapportere til ham selv.
apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +144,Please enter Maintaince Details first,Indtast venligst Maintaince Detaljer først
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +56,Series Updated,Series Opdateret
DocType: Appraisal,HR User,HR Bruger
DocType: Selling Settings,Settings for Selling Module,Indstillinger for Selling modul
DocType: Quotation Item,Against Doctype,Mod DOCTYPE
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +96,Cost Centers,Omkostninger Centers
DocType: Salary Slip Deduction,Salary Slip Deduction,Lønseddel Fradrag
DocType: Upload Attendance,Upload Attendance,Upload Fremmøde
DocType: Item,Auto re-order,Auto re-ordre
DocType: GL Entry,Voucher No,Blad nr
DocType: Opportunity,Your sales person will get a reminder on this date to contact the customer,Dit salg person vil få en påmindelse på denne dato for at kontakte kunden
DocType: Delivery Note,% of materials delivered against this Delivery Note,% Af materialer leveret mod denne følgeseddel
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +80,Cold sizing,Kolde dimensionering
DocType: Warranty Claim,Service Address,Tjeneste Adresse
DocType: Stock Settings,Notify by Email on creation of automatic Material Request,Give besked på mail om oprettelse af automatiske Materiale Request
DocType: Batch,Batch ID,Batch-id
apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +18,Reorder Qty,Genbestil Antal
apps/erpnext/erpnext/controllers/stock_controller.py +172,Expense / Difference account ({0}) must be a 'Profit or Loss' account,Udgift / Difference konto ({0}) skal være en »resultatet« konto
apps/erpnext/erpnext/crm/doctype/lead/lead.py +65,"Email id must be unique, already exists for {0}","Email id skal være unikt, der allerede eksisterer for {0}"
apps/erpnext/erpnext/config/hr.py +160,Setup incoming server for jobs email id. (e.g. jobs@example.com),Opsætning indgående server for job email id. (F.eks jobs@example.com)
DocType: Employee,External Work History,Ekstern Work History
DocType: Production Order,Planned Start Date,Planlagt startdato
DocType: Features Setup,To track any installation or commissioning related work after sales,At spore enhver installation eller idriftsættelse relateret arbejde eftersalgsservice
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +126,Sales Expenses,Salgsomkostninger
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +211,{0} {1} is not submitted,{0} {1} er ikke indsendt
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +29,Account {0} does not exists,Konto {0} findes ikke
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +119,BOM and Manufacturing Quantity are required,BOM and Manufacturing Mængde kræves
DocType: Dropbox Backup,Send Notifications To,Send meddelelser til
DocType: Employee,Mr,Hr
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +165,Crushing,Knusning
,Hub,Hub
DocType: Item Reorder,Item Reorder,Item Genbestil
apps/erpnext/erpnext/accounts/doctype/payment_tool/payment_tool.js +264,Please select {0} first,Vælg {0} først
DocType: Leave Allocation,Total Leaves Allocated,Total Blade Allokeret
DocType: Journal Entry Account,Purchase Order,Indkøbsordre
DocType: Landed Cost Voucher,Purchase Receipt Items,Kvittering Varer
apps/erpnext/erpnext/accounts/utils.py +189,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/setup/doctype/naming_series/naming_series.py +150,Please select prefix first,Vælg venligst præfiks først
apps/frappe/frappe/templates/base.html +134,Added,Tilføjet
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +50,Stock Ledger Entries and GL Entries are reposted for the selected Purchase Receipts,Stock Poster og GL Entries er reposted for de valgte Køb Kvitteringer
DocType: Employee,Salary Information,Løn Information
apps/erpnext/erpnext/stock/doctype/item/item.py +317,Default BOM ({0}) must be active for this item or its template,Standard BOM ({0}) skal være aktiv for dette element eller dens skabelon
DocType: Item,Allow Production Order,Tillad produktionsordre
DocType: Authorization Rule,Customer / Item Name,Kunde / Item Name
DocType: Features Setup,1. To maintain the customer wise item code and to make them searchable based on their code use this option,1. For at bevare kunden kloge post kode og gøre dem søgbare baseret på deres kode brug denne mulighed
DocType: Appraisal Template Goal,Appraisal Template Goal,Vurdering Template Goal
DocType: Expense Claim,Total Sanctioned Amount,Total Sanktioneret Beløb
apps/erpnext/erpnext/config/selling.py +299,Sales Order to Payment,Sales Order til Betaling
DocType: Job Applicant,Hold,Hold
DocType: Letter Head,Letter Head,Brev hoved
DocType: Item,Website Description,Website Beskrivelse
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 Item hvor &quot;Er Stock Item&quot; er &quot;Nej&quot; og &quot;Er Sales Item&quot; er &quot;Ja&quot;, og der er ingen anden Product Bundle"
DocType: Newsletter,Newsletter,Nyhedsbrev
DocType: Buying Settings,Default Buying Price List,Standard Opkøb prisliste
apps/erpnext/erpnext/accounts/utils.py +268,Journal Entries {0} are un-linked,Journaloptegnelser {0} er un-forbundet
DocType: Purchase Invoice,"Enter email id separated by commas, invoice will be mailed automatically on particular date","Indtast email id adskilt af kommaer, vil faktura blive sendt automatisk på bestemt dato"
DocType: Item,Website Warehouse,Website Warehouse
apps/erpnext/erpnext/buying/doctype/purchase_common/purchase_common.py +47,Please enter quantity for Item {0},Indtast mængde for Item {0}
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: Features Setup,Features Setup,Features Setup
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +79,Employee relieved on {0} must be set as 'Left',Medarbejder lettet på {0} skal indstilles som &quot;Left&quot;
DocType: Maintenance Visit,Breakdown,Sammenbrud
apps/erpnext/erpnext/config/manufacturing.py +13,Bill of Materials (BOM),Bill of Materials (BOM)
DocType: Report,Report Type,Rapporttype
apps/erpnext/erpnext/crm/doctype/newsletter/newsletter.py +139,Click here to verify,Klik her for at verificere
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +109,Water jet cutting,Vandstråleskæring
DocType: Installation Note Item,Installed Qty,Antal installeret
apps/erpnext/erpnext/config/hr.py +145,Block leave applications by department.,Blok orlov ansøgninger fra afdelingen.
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +126,Plating,Plating
DocType: Website Item Group,Website Item Group,Website Item Group
DocType: BOM Item,Item Description,Punkt Beskrivelse
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +40,Fixed Assets,Anlægsaktiver
apps/erpnext/erpnext/accounts/doctype/payment_tool/payment_tool.py +71,Please enter the Against Vouchers manually,Indtast Against Vouchers manuelt
apps/erpnext/erpnext/stock/doctype/item/item.py +377,Row {0}: An Reorder entry already exists for this warehouse {1},Række {0}: En Genbestil indgang findes allerede for dette lager {1}
DocType: Item,Default Buying Cost Center,Standard købsomkostninger center
DocType: Employee,Education,Uddannelse
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +197,Purchase Receipt {0} is not submitted,Kvittering {0} er ikke indsendt
DocType: User,Bio,Bio
DocType: Address,Lead Name,Bly navn
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +283,New Cost Center,Ny Cost center
DocType: Bin,Reserved Quantity,Reserveret Mængde
DocType: Attendance,Half Day,Half Day
DocType: Email Digest,For Company,For Company
DocType: Features Setup,"Field available in Delivery Note, Quotation, Sales Invoice, Sales Order","Felt fås i Delivery Note, Citat, Sales Invoice, Sales Order"
,Open Production Orders,Åbne produktionsordrer
DocType: Account,Bank,Bank
DocType: Monthly Distribution Percentage,Month,Måned
DocType: Project Task,Task ID,Opgave-id
DocType: About Us Settings,Website Manager,Website manager
DocType: SMS Settings,Static Parameters,Statiske parametre
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +495,Attach Letterhead,Vedhæft Brevpapir
,Material Requests for which Supplier Quotations are not created,Materielle Anmodning om hvilke Leverandør Citater ikke er skabt
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +39,Account {0} does not belongs to company {1},Konto {0} ikke hører til virksomheden {1}
DocType: Item,Will also apply for variants unless overrridden,"Vil også gælde for varianter, medmindre overrridden"
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +71,Update Finished Goods,Opdater færdigvarer
DocType: Dropbox Backup,Dropbox Access Allowed,Dropbox Adgang tilladt
DocType: Production Order Operation,Actual Operation Time,Faktiske Operation Time
DocType: Item Attribute,Attribute Name,Attribut Navn
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +21,Vacuum molding,Vakuum støbning
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +20,Cash In Hand,Kassebeholdning
DocType: Contact,User ID,Bruger-id
DocType: User,Last Name,Efternavn
apps/frappe/frappe/integrations/doctype/dropbox_backup/dropbox_backup.py +179,Please install dropbox python module,Du installere dropbox python-modul
DocType: Salary Slip,Net Pay,Nettoløn
DocType: Purchase Taxes and Charges,Is this Tax included in Basic Rate?,Er denne Tax inkluderet i Basic Rate?
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.
DocType: Customer,Fixed Days,Faste dage
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +51,{0} ({1}) must have role 'Expense Approver',"{0} ({1}), skal have rollen 'Godkendelse af udgifter'"
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +29,Invalid {0}: {1},Ugyldig {0}: {1}
DocType: Serial No,AMC Expiry Date,AMC Udløbsdato
DocType: Rename Tool,Rename Log,Omdøbe Log
DocType: Quality Inspection,Outgoing,Udgående
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +106,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
DocType: Hub Settings,Seller Email,Sælger Email
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +17,Email Digest:,Email Digest:
apps/erpnext/erpnext/config/projects.py +18,Project master.,Projekt mester.
apps/erpnext/erpnext/stock/doctype/item/item.py +337,{0} entered twice in Item Tax,{0} indtastet to gange i vareafgift
DocType: Workflow State,Primary,Primær
DocType: Employee,Marital Status,Civilstand
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +145,Nailing,Sømning
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +358,You will use it to Login,Du vil bruge det til login
apps/erpnext/erpnext/controllers/recurring_document.py +192,'Notification Email Addresses' not specified for recurring %s,'Notification Email Adresser' er ikke angivet for tilbagevendende %s
DocType: C-Form,Amended From,Ændret Fra
DocType: Pricing Rule,For Price List,For prisliste
apps/erpnext/erpnext/accounts/report/financial_statements.py +147,Total ({0}),I alt ({0})
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +42,New Company,Ny Company
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +68,Warning: Leave application contains following block dates,Advarsel: Lad ansøgning indeholder følgende blok datoer
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +133,Electron beam machining,Elektronstråle bearbejdning
DocType: Bank Reconciliation Detail,Posting Date,Udstationering Dato
DocType: Product Bundle,Parent Item,Parent Item
,Item-wise Sales History,Vare-wise Sales History
DocType: Contact,Enter designation of this Contact,Indtast udpegelsen af ​​denne Kontakt
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +119,Quantity for Item {0} must be less than {1},Mængde for Item {0} skal være mindre end {1}
DocType: HR Settings,Employee Settings,Medarbejder Indstillinger
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +52,Bending,Bøjning
DocType: Cost Center,Distribution Id,Distribution Id
DocType: Quotation,Quotation Lost Reason,Citat Lost Årsag
DocType: Issue,Resolution Details,Opløsning Detaljer
,Serial No Warranty Expiry,Seriel Ingen garanti Udløb
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +112,Electro-chemical grinding,Elektrokemisk slibning
DocType: Salary Slip,Leave Without Pay,Lad uden løn
DocType: SMS Settings,Enter url parameter for receiver nos,Indtast url parameter for receiver nos
DocType: System Settings,System Settings,Systemindstillinger
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +667,From Sales Order,Fra kundeordre
DocType: Address Template,Address Template,Adresse Skabelon
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +63,Removed items with no change in quantity or value.,Fjernede elementer uden nogen ændringer i mængde eller værdi.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +90,Depreciation,Afskrivninger
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +49,Customer > Customer Group > Territory,Kunde&gt; Customer Group&gt; Territory
DocType: Purchase Taxes and Charges,Valuation,Værdiansættelse
DocType: Customer,Default Price List,Standard prisliste
DocType: Purchase Invoice Item,"Tax detail table fetched from item master as a string and stored in this field.
Used for Taxes and Charges",Skat detalje tabel hentes fra post mester som en streng og opbevares i dette område. Bruges til skatter og afgifter
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +48,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/hr/doctype/employee/employee.py +25,Please setup Employee Naming System in Human Resource > HR Settings,Venligst setup Medarbejder navnesystem i Human Resource&gt; HR-indstillinger
DocType: Employee,Employment Details,Beskæftigelse Detaljer
apps/erpnext/erpnext/hub_node/page/hub/register_in_hub.html +2,Register For ERPNext Hub,Tilmeld dig ERPNext Hub
DocType: Contact Us Settings,Address Line 2,Adresse Linje 2
DocType: Purchase Receipt Item,Accepted Quantity,Accepteret Mængde
DocType: Process Payroll,Create Salary Slip,Opret lønseddel
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: Shipping Rule Condition,A condition for a Shipping Rule,Betingelse for en forsendelsesregel
DocType: Process Payroll,Submit all salary slips for the above selected criteria,Indsend alle lønsedler for de ovenfor valgte kriterier
DocType: Naming Series,Help HTML,Hjælp HTML
apps/frappe/frappe/public/js/frappe/form/footer/timeline_item.html +39,Details,Detaljer
DocType: Authorization Rule,Above Value,Over værdi
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +111,There is not enough leave balance for Leave Type {0},Der er ikke nok orlov balance for Leave Type {0}
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +213,Stock Entries already created for Production Order ,Stock Entries allerede skabt til produktionsordre
DocType: Shopping Cart Settings,Enable Shopping Cart,Aktiver Indkøbskurv
DocType: Monthly Distribution Percentage,Percentage Allocation,Procentvise fordeling
apps/erpnext/erpnext/controllers/website_list_for_contact.py +69,{0}% Delivered,{0}% Delivered
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."
DocType: Production Order,Actual End Date,Faktiske Slutdato
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +62,Please enter item details,Indtast venligst item detaljer
DocType: Accounts Settings,Check Supplier Invoice Number Uniqueness,Check Leverandør Fakturanummer Entydighed
apps/erpnext/erpnext/config/stock.py +115,Warehouses.,Pakhuse.
DocType: Quality Inspection,Incoming,Indgående
DocType: Department,Leave Block List,Lad Block List
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +97,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/manufacturing/doctype/production_order/production_order.js +200,Select Quantity,Vælg antal
apps/erpnext/erpnext/config/manufacturing.py +34,Where manufacturing operations are carried.,Hvor fremstillingsprocesser gennemføres.
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"
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +326,{0} against Bill {1} dated {2},{0} mod regning {1} ​​dateret {2}
apps/erpnext/erpnext/utilities/doctype/address_template/address_template.py +24,Default Address Template cannot be deleted,Standard Adresse Skabelon kan ikke slettes
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."
DocType: Salary Slip,Working Days,Arbejdsdage
apps/erpnext/erpnext/hr/doctype/employee/employee.py +108,Date of Joining must be greater than Date of Birth,Dato for Sammenføjning skal være større end Fødselsdato
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +43,Exchange Rate must be same as {0} {1} ({2}),Exchange Rate skal være samme som {0} {1} ({2})
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +348,Leave Blocked,Lad Blokeret
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +46,Item {0} is not a serialized Item,Vare {0} er ikke en føljeton Item
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +13,Set as Open,Sæt som Open
apps/erpnext/erpnext/crm/doctype/lead/lead.js +34,Make Quotation,Make Citat
DocType: Employee,Current Address Is,Nuværende adresse er
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js +5,Ordered,Bestilt
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +530,Accountant,Revisor
apps/erpnext/erpnext/config/hr.py +110,"Employee designation (e.g. CEO, Director etc.).","Medarbejder betegnelse (f.eks CEO, direktør osv.)"
DocType: Stock Ledger Entry,Stock Value Difference,Stock Value Forskel
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +66,Slitting,Langskæring
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +77,Research & Development,Forskning &amp; Udvikling
DocType: Item,Website Item Groups,Website varegrupper
DocType: Page,Standard,Standard
DocType: Target Detail,Target Detail,Target Detail
DocType: Quotation,Quotation To,Citat Til
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +147,Large,Large
apps/erpnext/erpnext/accounts/doctype/account/account.py +174,Child account exists for this account. You can not delete this account.,Eksisterer barn konto til denne konto. Du kan ikke slette denne konto.
DocType: Delivery Note,Transporter Info,Transporter Info
apps/erpnext/erpnext/projects/doctype/time_log/time_log.py +139,You can make a time log only against a submitted production order,Du kan lave en tid log kun mod en indsendt produktionsordre
DocType: Serial No,Delivery Document No,Levering dokument nr
DocType: Purchase Common,Purchase Common,Indkøb Common
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +581,Packing Slip,Packing Slip
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +160,Note: Item {0} entered multiple times,Bemærk: Konto {0} indtastet flere gange
DocType: Employee Education,School/University,Skole / Universitet
DocType: Purchase Order,To Bill,Til Bill
DocType: Stock Settings,Role Allowed to edit frozen stock,Rolle Tilladt at redigere frosne lager
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +27,Send Now,Send nu
DocType: Task,Actual Time (in Hours),Faktiske tid (i timer)
apps/erpnext/erpnext/projects/doctype/time_log/time_log.py +110,To Time must be greater than From Time,Til Time skal være større end From Time
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +9,Airline,Flyselskab
DocType: Delivery Note,Excise Page Number,Excise Sidetal
DocType: Delivery Note,To Warehouse,Til Warehouse
DocType: Production Planning Tool,Select Sales Orders,Vælg salgsordrer
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +129,Telephone Expenses,Telefon Udgifter
,Requested,Anmodet
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +55,Purchase Receipt must be submitted,Kvittering skal indsendes
DocType: Lead,Market Segment,Market Segment
DocType: Employee,"Here you can maintain family details like name and occupation of parent, spouse and children","Her kan du opretholde familiens detaljer som navn og besættelse af forældre, ægtefælle og børn"
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +165,Probationary Period,Prøvetid
apps/erpnext/erpnext/accounts/doctype/account/account.py +91,"Account balance already in Credit, you are not allowed to set 'Balance Must Be' as 'Debit'","Konto balance er kredit, Du har ikke lov at ændre 'Balancetype' til 'debit'"
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/controllers/status_updater.py +142,{0} must be reduced by {1} or you should increase overflow tolerance,"{0} skal reduceres med {1}, eller du bør øge overflow tolerance"
DocType: HR Settings,HR Settings,HR-indstillinger
DocType: Sales Team,Incentives,Incitamenter
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +102,Credit To account must be a Payable account,Kredit til konto skal være en Betales konto
DocType: C-Form,Total Invoiced Amount,Total Faktureret beløb
DocType: C-Form Invoice Detail,C-Form Invoice Detail,C-Form Faktura Detail
DocType: Features Setup,"Check if you need automatic recurring invoices. After submitting any sales invoice, Recurring section will be visible.","Kontroller, om du har brug for automatiske tilbagevendende fakturaer. Når du har indsendt nogen faktura, vil Tilbagevendende sektion være synlige."
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +259,You cannot credit and debit same account at the same time,Du kan ikke kreditere og debitere samme konto på samme tid
DocType: Leave Application,Leave Application,Forlad Application
apps/erpnext/erpnext/accounts/page/financial_analytics/financial_analytics.js +42,Select Fiscal Year...,Vælg regnskabsår ...
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +41,Travel,Rejser
DocType: Manufacturing Settings,Try planning operations for X days in advance.,Prøv at planlægge operationer for X dage i forvejen.
DocType: Stock Entry,Default Source Warehouse,Standardkilde Warehouse
apps/erpnext/erpnext/accounts/doctype/account/account.py +73,Root cannot be edited.,Root kan ikke redigeres.
apps/erpnext/erpnext/stock/doctype/item/item.js +181,Add / Edit Prices,Tilføj / rediger Priser
DocType: Selling Settings,Sales Order Required,Sales Order Påkrævet
DocType: Employee,Widowed,Enke
DocType: Buying Settings,Purchase Order Required,Indkøbsordre Påkrævet
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +78,Straightening,Opretning
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +51,Ageing Range 3,Ageing Range 3
DocType: Production Order,Plan material for sub-assemblies,Plan materiale til sub-enheder
DocType: Employee,Reason for Leaving,Årsag til Leaving
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +64,Coining,Opfandt
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +29,Employee {0} was on leave on {1}. Cannot mark attendance.,Medarbejder {0} var på orlov på {1}. Kan ikke markere fremmøde.
apps/erpnext/erpnext/stock/doctype/item/item.js +43,This Item is a Variant of {0} (Template). Attributes will be copied over from the template unless 'No Copy' is set,"Dette element er en Variant af {0} (skabelon). Attributter vil blive kopieret over fra skabelonen, medmindre &#39;Ingen Copy &quot;er indstillet"
DocType: BOM Replace Tool,BOM Replace Tool,BOM Erstat Værktøj
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +176,Unsecured Loans,Usikrede lån
apps/erpnext/erpnext/config/learn.py +72,Setting up Taxes,Opsætning Skatter
DocType: Sales Invoice Item,Sales Order Item,Sales Order Vare
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +171,Responsibilities,Ansvar
apps/frappe/frappe/desk/doctype/note/note_list.js +3,Notes,Noter
apps/erpnext/erpnext/config/stock.py +18,Requests for items.,Anmodning om.
DocType: Item,Minimum Order Qty,Minimum Antal
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +69,Flattening,Udfladning
DocType: Target Detail,Target  Amount,Målbeløbet
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +78,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).
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +68,Direct Expenses,Direkte udgifter
apps/erpnext/erpnext/selling/report/customers_not_buying_since_long_time/customers_not_buying_since_long_time.py +70,Last Order Amount,Sidste ordrebeløb
DocType: Company,Stock Adjustment Account,Stock Justering konto
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +104,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."
DocType: Purchase Taxes and Charges,Add or Deduct,Tilføje eller fratrække
DocType: Warranty Claim,Warranty / AMC Status,Garanti / AMC status
DocType: GL Entry,Party Type,Party Type
DocType: Purchase Receipt,Supplier Warehouse,Leverandør Warehouse
DocType: Sales Invoice,Packing List,Pakning List
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +76,Quality Management,Quality Management
DocType: Shipping Rule,Net Weight,Vægt
DocType: Issue,Support Team,Support Team
DocType: Address,Preferred Shipping Address,Foretrukne Forsendelsesadresse
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +113,"For {0}, only credit accounts can be linked against another debit entry",For {0} kan kun kredit konti knyttes mod en anden debet post
DocType: Item,Attributes,Attributter
DocType: Account,Tax,Skat
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +490,UOM coversion factor required for UOM: {0} in Item: {1},UOM coversion faktor kræves for Pakke: {0} i Konto: {1}
apps/erpnext/erpnext/controllers/selling_controller.py +163,Row {0}: Qty is mandatory,Række {0}: Antal er obligatorisk
DocType: Company,Change Abbreviation,Skift Forkortelse
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +104,Non Profit,Non Profit
DocType: Purchase Invoice,Supplier Invoice Date,Leverandør Faktura Dato
apps/erpnext/erpnext/config/stock.py +141,Main Reports,Vigtigste Reports
DocType: Delivery Note,% Installed,% Installeret
DocType: Shipping Rule,Shipping Account,Forsendelse konto
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +87,Hammering,Hamring
DocType: Features Setup,If you follow Quality Inspection. Enables Item QA Required and QA No in Purchase Receipt,Hvis du følger kvalitetskontrol. Aktiverer Item QA Nødvendig og QA Ingen i kvittering
DocType: Email Account,Email Ids,Email Ids
DocType: Features Setup,"Discount Fields will be available in Purchase Order, Purchase Receipt, Purchase Invoice","Discount Fields vil være tilgængelig i Indkøbsordre, kvittering, købsfaktura"
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."
DocType: Landed Cost Voucher,Get Items From Purchase Receipts,Få elementer fra køb Kvitteringer
DocType: Budget Detail,Budget Detail,Budget Detail
apps/erpnext/erpnext/accounts/report/financial_statements.py +16,Fiscal Year {0} not found.,Regnskabsår {0} ikke fundet.
DocType: Production Order Operation,Make Time Log,Make Time Log
DocType: Item,Will also apply for variants,Vil også gælde for varianter
DocType: Email Digest,Payables,Gæld
DocType: Pricing Rule,Customer Group,Customer Group
apps/frappe/frappe/public/js/frappe/model/model.js +492,Rename,Omdøb
apps/erpnext/erpnext/accounts/utils.py +276,Please set default value {0} in Company {1},Indstil standard værdi {0} i Company {1}
DocType: User,First Name,Fornavn
DocType: Company,Company registration numbers for your reference. Tax numbers etc.,Firma registreringsnumre til din reference. Skat numre etc.
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +72,Please enter parent account group for warehouse {0},Indtast venligst forælder konto gruppe for lager {0}
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +30,Grocery,Købmand
apps/erpnext/erpnext/accounts/party.py +25,{0}: {1} does not exists,{0}: {1} eksisterer ikke
apps/erpnext/erpnext/public/js/pos/pos.js +429,Change,Ændring
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +144,Extra Small,Extra Small
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +59,Contract,Kontrakt
apps/erpnext/erpnext/accounts/general_ledger.py +121,Debit and Credit not equal for {0} #{1}. Difference is {2}.,Debet og Credit ikke ens for {0} # {1}. Forskellen er {2}.
DocType: Pricing Rule,Discount on Price List Rate (%),Rabat på prisliste Rate (%)
DocType: Time Log,To Time,Til Time
DocType: Pricing Rule,Item Code,Item Code
DocType: Sales Invoice,Recurring,Tilbagevendende
,BOM Browser,BOM Browser
,Completed Production Orders,Afsluttede produktionsordrer
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +598,Material Request,Materiale Request
apps/erpnext/erpnext/config/projects.py +23,Time Log for tasks.,Tid Log til opgaver.
apps/erpnext/erpnext/accounts/report/bank_clearance_summary/bank_clearance_summary.py +25,Please select Bank Account,Vælg Bankkonto
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: Production Order Operation,"in Minutes
Updated via 'Time Log'",i minutter Opdateret via &#39;Time Log&#39;
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +144,Adhesive bonding,Limning
DocType: Offer Letter,Awaiting Response,Afventer svar
,Stock Ledger,Stock Ledger
DocType: POS Profile,Taxes and Charges,Skatter og Afgifter
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +74,Electroforming,Electroforming
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +96,Reference No is mandatory if you entered Reference Date,"Referencenummer er obligatorisk, hvis du har indtastet reference Dato"
DocType: Employee Leave Approver,Leave Approver,Lad Godkender
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +35,Balance Value,Balance Value
apps/erpnext/erpnext/config/stock.py +28,Shipments to customers.,Forsendelser til kunderne.
DocType: Appraisal,Total Score (Out of 5),Total Score (ud af 5)
DocType: Purchase Taxes and Charges,On Previous Row Total,På Forrige Row Total
DocType: Accounts Settings,Settings for Accounts,Indstillinger for konti
DocType: Employee,Date of Joining,Dato for Sammenføjning
DocType: BOM,With Operations,Med Operations
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +36,Tube beading,Tube beading
DocType: System Settings,Time Zone,Time Zone
DocType: Item,Inspection Required,Inspection Nødvendig
DocType: Company,Default Currency,Standard Valuta
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +549,Fetch exploded BOM (including sub-assemblies),Hent eksploderede BOM (herunder underenheder)
,Daily Time Log Summary,Daglig Time Log Summary
DocType: POS Profile,Price List,Pris List
DocType: Payment Reconciliation,Minimum Amount,Minimumsbeløb
DocType: Time Log,Batched for Billing,Batched for fakturering
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +70,Max discount allowed for item: {0} is {1}%,Max rabat tilladt for vare: {0} er {1}%
DocType: Maintenance Visit,Maintenance Type,Vedligeholdelse Type
DocType: Blog Category,Parent Website Route,Parent Website Route
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +233,BOM recursion: {0} cannot be parent or child of {2},BOM rekursion: {0} kan ikke være forælder eller barn af {2}
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +121,Add Child,Tilføj Child
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +63,Clearance Date not mentioned,Clearance Dato ikke nævnt
DocType: Production Order Operation,Production Order Operation,Produktionsordre Operation
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +41,Remove item if charges is not applicable to that item,"Fjern element, hvis afgifter ikke finder anvendelse på denne post"
DocType: Production Planning Tool,Filter based on customer,Filter baseret på kundernes
DocType: Bank Reconciliation,Update Clearance Date,Opdatering Clearance Dato
apps/erpnext/erpnext/config/selling.py +163,Track Leads by Industry Type.,Spor fører af Industry Type.
apps/frappe/frappe/utils/__init__.py +79,{0} is not a valid email id,{0} er ikke en gyldig e-mail-id
,Item-wise Purchase Register,Vare-wise Purchase Tilmeld
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +135,Laser cutting,Laserskæring
,SO Qty,SO Antal
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +39,Online Auctions,Online Auktioner
DocType: Payment Reconciliation,Receivable / Payable Account,Tilgodehavende / Betales konto
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +209,Serial No {0} does not belong to Item {1},Løbenummer {0} ikke hører til Vare {1}
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +72,To Do List,To Do List
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +13,Please Delivery Note first,Venligst følgeseddel først
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +520,Posting date and posting time is mandatory,Udstationering dato og udstationering tid er obligatorisk
apps/erpnext/erpnext/setup/doctype/company/company.js +24,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: DocField,Column Break,Kolonne Break
DocType: Project,Gross Margin,Gross Margin
DocType: Purchase Order Item Supplied,BOM Detail No,BOM Detail Nej
apps/erpnext/erpnext/controllers/recurring_document.py +127,New {0}: #{1},Ny {0}: # {1}
DocType: Attendance,HR Manager,HR Manager
DocType: Employee Leave Approver,Users who can approve a specific employee's leave applications,"Brugere, der kan godkende en bestemt medarbejders orlov applikationer"
DocType: DocField,Attach Image,Vedhæft billede
,Delivered Items To Be Billed,Leverede varer at blive faktureret
,Item-wise Sales Register,Vare-wise Sales Register
DocType: Warranty Claim,From Company,Fra Company
DocType: SMS Center,Total Characters,Total tegn
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +44,Ageing Range 2,Ageing Range 2
apps/erpnext/erpnext/accounts/page/financial_analytics/financial_analytics.js +20,PL or BS,PL eller BS
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +550,e.g. VAT,fx moms
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +59,Perforating,Perforering
DocType: Sales Invoice,Rounded Total (Company Currency),Afrundet alt (Company Valuta)
DocType: Expense Claim,Expense Approver,Expense Godkender
DocType: Packing Slip,Net Weight UOM,Nettovægt UOM
apps/erpnext/erpnext/config/selling.py +33,All Addresses.,Alle adresser.
DocType: Maintenance Schedule Item,Half Yearly,Halvdelen Årlig
apps/erpnext/erpnext/hr/doctype/employee/employee.py +141,User {0} is already assigned to Employee {1},Bruger {0} er allerede tildelt Medarbejder {1}
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +330, (Half Day),(Halv dag)
DocType: Bank Reconciliation,Include Reconciled Entries,Medtag Afstemt Angivelser
DocType: Employee,Better Prospects,Bedre udsigter
apps/erpnext/erpnext/crm/doctype/newsletter/newsletter.py +78,Please save the Newsletter before sending,Gem nyhedsbrevet før afsendelse
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +24,Duplicate Entry. Please check Authorization Rule {0},Duplicate indtastning. Forhør Authorization Rule {0}
DocType: Quality Inspection,Delivery Note No,Levering Note Nej
apps/erpnext/erpnext/projects/doctype/time_log/time_log.py +221,Completed Qty cannot be more than {0} for operation {1},Afsluttet Antal kan ikke være mere end {0} til drift {1}
DocType: Report,Disabled,Handicappet
DocType: Purchase Invoice Item,Price List Rate (Company Currency),Prisliste Rate (Company Valuta)
DocType: GL Entry,Is Opening,Er Åbning
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."
DocType: Payment Reconciliation,Payment Reconciliation,Betaling Afstemning
DocType: Quality Inspection Reading,Reading 1,Læsning 1
apps/erpnext/erpnext/config/buying.py +18,Request for purchase.,Anmodning om køb.
DocType: Journal Entry,Contra Entry,Contra indtastning
apps/erpnext/erpnext/stock/doctype/item/item.py +532,Item {0} has reached its end of life on {1},Vare {0} har nået slutningen af ​​sin levetid på {1}
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"
DocType: Manufacturing Settings,Time Between Operations (in mins),Time Between Operations (i minutter)
DocType: Leave Allocation,Leave Allocation,Lad Tildeling
DocType: Tax Rule,Purchase,Købe
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +33,Shrink fitting,Shrink fitting
DocType: Account,Income Account,Indkomst konto
DocType: Stock Entry,Including items for sub assemblies,Herunder elementer til sub forsamlinger
DocType: Packing Slip,Identification of the package for the delivery (for print),Identifikation af emballagen for levering (til print)
DocType: Employee,Feedback,Feedback
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +57,'To Case No.' cannot be less than 'From Case No.','Til sag nr.' kan ikke være mindre end 'Fra sag nr.'
DocType: Serial No,Creation Document No,Creation dokument nr
DocType: Account,Account Name,Kontonavn
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +101,Tapping,Aflytning
DocType: Earning Type,Earning Type,Optjening Type
DocType: Production Order Operation,Pending,Afventer
DocType: Pricing Rule,Pricing Rule,Prisfastsættelse Rule
DocType: Customer,Sales Team Details,Salg Team Detaljer
DocType: Sales Partner,Address & Contacts,Adresse &amp; Contacts
,Stock Balance,Stock Balance
DocType: Lead,Converted,Konverteret
DocType: Supplier,Supplier Details,Leverandør Detaljer
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +78,Legal,Juridisk
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 skat skabelon, der kan anvendes på alle købstransaktioner. Denne skabelon kan indeholde liste over skatte- hoveder og også andre bekostning 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. 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: Currency Exchange,To Currency,Til Valuta
DocType: Newsletter,Newsletter Manager,Nyhedsbrev manager
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +34,Balance Qty,Balance Antal
DocType: Material Request Item,For Warehouse,For Warehouse
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +362,Attach Your Picture,Vedhæft dit billede
apps/frappe/frappe/model/naming.py +40,{0} is required,{0} er påkrævet
DocType: Purchase Invoice Item,Item Tax Amount,Item Skat Beløb
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/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}"
apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +27,Closing Account {0} must be of type 'Liability',Lukning Konto {0} skal være af typen &#39;ansvar&#39;
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +693,All items have already been transferred for this Production Order.,Alle elementer er allerede blevet overført til denne produktionsordre.
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +383,Cost Center is required in row {0} in Taxes table for type {1},Cost Center kræves i række {0} i Skatter tabellen for type {1}
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +7,Aerospace,Aerospace
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +37,Ageing Range 1,Ageing Range 1
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +156,Laminated object manufacturing,Lamineret objekt fremstillingsvirksomhed
DocType: BOM,Raw Material Cost,Raw Material Omkostninger
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41,Lead Time Days,Lead Time dage
apps/erpnext/erpnext/crm/doctype/lead/lead.js +32,Create Opportunity,Opret Opportunity
DocType: DocField,Default,Standard
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +174,Production order number is mandatory for stock entry purpose manufacture,Produktion ordrenummer er obligatorisk for lager post fremstilling formål
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +68,Please select Party Type first,Vælg Party Type først
DocType: Dropbox Backup,Send Backups to Dropbox,Send Backups til Dropbox
DocType: Address,Preferred Billing Address,Foretrukne Faktureringsadresse
DocType: Journal Entry Account,Account Balance,Kontosaldo
DocType: Shopping Cart Settings,Default settings for Shopping Cart,Standardindstillinger for Indkøbskurv
DocType: Payment Reconciliation Payment,Payment Reconciliation Payment,Betaling Afstemning Betaling
DocType: Delivery Note,Billing Address Name,Fakturering Adresse Navn
DocType: Page,Title,Titel
DocType: Company,Default Values,Standardværdier
DocType: Opportunity,Opportunity Date,Opportunity Dato
,Item Prices,Item Priser
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +150,Row # ,Row #
,Purchase Invoice Trends,Købsfaktura Trends
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +47,Furniture and Fixture,Møbler og Fixture
DocType: Item,Copy From Item Group,Kopier fra Item Group
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +128,Superfinishing,Superfinishing
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +94,Please specify either Quantity or Valuation Rate or both,Angiv venligst enten mængde eller Værdiansættelse Rate eller begge
DocType: SMS Log,Sender Name,Sender Name
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +158,Please create Customer from Lead {0},Opret Kunden fra Lead {0}
DocType: Sales Order,To Deliver,Til at levere
DocType: Sales Invoice Item,Quantity,Mængde
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +43,Reorder Level,Genbestil Level
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +64,Avg. Buying Rate,Gns. Køb Rate
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +175,Secured Loans,Sikrede lån
DocType: Employee Education,Employee Education,Medarbejder Uddannelse
apps/erpnext/erpnext/config/learn.py +167,Material Request to Purchase Order,Materiale Anmodning om at Indkøbsordre
,Items To Be Requested,Varer skal ansøges
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +82,Create Quotation,Opret Citat
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +168,Against Journal Entry {0} is already adjusted against some other voucher,Mod Kassekladde {0} er allerede justeret mod en anden kupon
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 setup for Serial nr. Check Item mester
DocType: Purchase Order,The date on which recurring order will be stop,"Den dato, hvor tilbagevendende ordre vil blive stoppe"
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +145,Dr,Dr
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: 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 Invoice,Notification Email Address,Meddelelse E-mailadresse
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +564,List a few of your customers. They could be organizations or individuals.,Nævne et par af dine kunder. De kunne være organisationer eller enkeltpersoner.
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +84,Invalid quantity specified for item {0}. Quantity should be greater than 0.,Ugyldig mængde angivet for element {0}. Mængde bør være større end 0.
DocType: Serial No,Warranty / AMC Details,Garanti / AMC Detaljer
DocType: Notification Control,Expense Claim Approved Message,Expense krav Godkendt Message
,Sales Person-wise Transaction Summary,Salg Person-wise Transaktion Summary
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +83,Curling,Curling
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +107,Double housing,Dobbelt hus
DocType: Activity Cost,Activity Type,Aktivitet Type
apps/erpnext/erpnext/config/hr.py +78,Allocate leaves for the year.,Afsætte blade for året.
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +369,Cash or Bank Account is mandatory for making payment entry,Kontant eller bankkonto er obligatorisk for betalingen post
DocType: Journal Entry,Difference (Dr - Cr),Difference (Dr - Cr)
apps/erpnext/erpnext/config/stock.py +84,Change UOM for an Item.,Skift UOM for et element.
DocType: Packing Slip,"Generate packing slips for packages to be delivered. Used to notify package number, package contents and its weight.","Generer pakkesedler for pakker, der skal leveres. Bruges til at anmelde pakke nummer, pakkens indhold og dens vægt."
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +347,Quantity in row {0} ({1}) must be same as manufactured quantity {2},"Mængde i række {0} ({1}), skal være det samme som fremstillede mængde {2}"
DocType: Production Order,Work-in-Progress Warehouse,Work-in-Progress Warehouse
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +86,Please select Charge Type first,Vælg Charge Type først
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +542,"List your tax heads (e.g. VAT, Customs etc; they should have unique names) and their standard rates. This will create a standard template, which you can edit and add more later.","Liste dine skattemæssige hoveder (f.eks moms, Told osv de skal have entydige navne) og deres faste satser. Dette vil skabe en standard skabelon, som du kan redigere og tilføje mere senere."
apps/erpnext/erpnext/crm/doctype/newsletter/newsletter.py +166,Confirmed,Bekræftet
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +38,Item {0} must be Sales Item,Vare {0} skal være Sales Item
apps/erpnext/erpnext/stock/doctype/item/item.py +358,"As there are existing stock transactions for this item, \
							you can not change the values of 'Has Serial No', 'Has Batch No', 'Is Stock Item' and 'Valuation Method'","Da der er eksisterende lagertransaktioner til denne vare, \ du ikke kan ændre værdierne af &quot;Har Serial Nej &#39;,&#39; Har Batch Nej &#39;,&#39; Er Stock Item&quot; og &quot;værdiansættelsesmetode &#39;"
DocType: Journal Entry,Print Heading,Print Overskrift
apps/erpnext/erpnext/config/hr.py +130,Allocate leaves for a period.,Afsætte blade i en periode.
apps/frappe/frappe/desk/query_report.py +136,Total,Total
DocType: Serial No,Maintenance Status,Vedligeholdelse status
apps/frappe/frappe/integrations/doctype/dropbox_backup/dropbox_backup.js +12,Please specify,Angiv venligst
DocType: Dropbox Backup,Weekly,Ugentlig
apps/erpnext/erpnext/buying/doctype/purchase_common/purchase_common.py +69,Warehouse is mandatory for stock Item {0} in row {1},Warehouse er obligatorisk for lager Vare {0} i række {1}
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +42,Cross-rolling,Cross-rulning
DocType: Rename Tool,"Attach .csv file with two columns, one for the old name and one for the new name","Vedhæfte .csv fil med to kolonner, en for det gamle navn og et til det nye navn"
DocType: Item,Maintain Stock,Vedligehold Stock
apps/erpnext/erpnext/accounts/doctype/account/account.py +155,"Stock entries exist against warehouse {0}, hence you cannot re-assign or modify Warehouse","Lagertilgang eksisterer mod lageret {0}, og derfor kan du ikke re-tildele eller ændre Warehouse"
DocType: Account,Asset,Asset
DocType: Salary Slip,Earnings,Indtjening
DocType: Sales Invoice,Against Income Account,Mod Indkomst konto
DocType: Selling Settings,Default Territory,Standard Territory
DocType: Purchase Order,Start date of current order's period,Startdato for nuværende ordres periode
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +72,disabled user,handicappet bruger
DocType: Maintenance Visit,Purposes,Formål
DocType: Contact,Is Primary Contact,Er Primær Kontaktperson
DocType: Maintenance Visit,Fully Completed,Fuldt Afsluttet
DocType: Address,Office,Kontor
DocType: Attendance,Leave Type,Forlad Type
DocType: Purchase Invoice,Against Expense Account,Mod udgiftskonto
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +31,Income Tax,Indkomstskat
DocType: Issue,Content Type,Indholdstype
DocType: Salary Slip,Total in words,I alt i ord
DocType: Purchase Order,"Enter email id separated by commas, order will be mailed automatically on particular date","Indtast email id adskilt af kommaer, vil ordren blive sendt automatisk på bestemt dato"
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +8,Item 1,Punkt 1
DocType: User,Enabled,Aktiveret
DocType: Warehouse,Warehouse Detail,Warehouse Detail
